diff --git a/Cargo.lock b/Cargo.lock index 4be7e801e..82e60ac38 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10400,6 +10400,7 @@ dependencies = [ "async-trait", "axum", "bytes", + "chrono", "futures", "reqwest 0.12.28", "serde", diff --git a/crates/temps-agents/src/ai_cli/catalog.rs b/crates/temps-agents/src/ai_cli/catalog.rs index 13af5e071..d2ae63ab4 100644 --- a/crates/temps-agents/src/ai_cli/catalog.rs +++ b/crates/temps-agents/src/ai_cli/catalog.rs @@ -99,11 +99,11 @@ pub struct ProviderCatalogEntry { /// Auth flavors this provider supports, in display order. The first entry /// is the recommended default for new installs. pub auth_flavors: &'static [AuthFlavor], - /// Model identifiers this provider accepts, in display order. The first - /// entry is the recommended default. Empty when the provider doesn't - /// expose model selection (e.g. OpenCode delegates model choice to its - /// own per-session config). The settings UI renders these in the model - /// dropdown for the *active* provider only. + /// Verified provider-native model identifiers that remain safe to offer + /// when live harness discovery is unavailable, in display order. The + /// first entry is the recommended default. Keep this empty when the + /// harness owns an account-aware catalog: callers must not invent model + /// identifiers when its metadata probe fails. pub models: &'static [&'static str], /// Provider-native modes translated into the common capability contract. /// Authorization remains enforced by Temps' Tool Broker; these values only @@ -171,16 +171,10 @@ pub const PROVIDER_CATALOG: &[ProviderCatalogEntry] = &[ seed_path_rel: "", }, ], - // Bootstrap fallback when live CLI discovery is unavailable. - models: &[ - "sonnet", - "opus", - "haiku", - "claude-sonnet-5", - "claude-opus-5", - "claude-fable-5", - "claude-haiku-4-5", - ], + // Claude Code's control initialization response is the only source of + // selectable models. Its account-aware aliases and concrete versions + // change independently of Temps, so a failed probe must stay empty. + models: &[], permission_modes: &[ ProviderOption { id: "default", @@ -397,6 +391,15 @@ mod tests { assert_eq!(claude.default_flavor().id, "subscription"); } + #[test] + fn claude_models_are_never_synthesized_by_the_static_catalog() { + let claude = find_provider("claude_cli").expect("claude_cli in catalog"); + assert!( + claude.models.is_empty(), + "Claude model choices must come from the installed harness" + ); + } + #[test] fn claude_permission_labels_explain_runtime_behavior() { let claude = find_provider("claude_cli").expect("claude_cli in catalog"); diff --git a/crates/temps-agents/src/ai_cli/claude.rs b/crates/temps-agents/src/ai_cli/claude.rs index 04247d2ba..3715f2622 100644 --- a/crates/temps-agents/src/ai_cli/claude.rs +++ b/crates/temps-agents/src/ai_cli/claude.rs @@ -36,6 +36,25 @@ fn cancellation_safe_command(program: &str) -> Command { command } +fn model_discovery_command() -> Command { + let mut command = cancellation_safe_command("claude"); + command.args([ + "--print", + "--output-format", + "stream-json", + "--verbose", + "--input-format", + "stream-json", + "--tools", + "", + // Capability discovery must not execute the operator's user, + // project, or local SessionStart hooks. Managed account policy and + // the authenticated model list remain available. + "--setting-sources=", + ]); + command +} + async fn configure_chat_mcp(cmd: &mut Command, config: &AiRunConfig) -> Result<(), AgentError> { // A non-interactive turn must never inherit Claude Code's host // shell/filesystem tools. Interactive turns intentionally keep Claude's @@ -93,104 +112,117 @@ pub struct ClaudeModelInfo { pub supports_auto_mode: bool, } -/// Turn Claude's resolved model identifier into the versioned label users see -/// in Claude Code. The selectable `value` is intentionally often a moving -/// alias (`sonnet`, `haiku`, `default`), while `resolvedModel` carries the -/// concrete version selected for the authenticated account. -fn resolved_model_display_name(resolved_model: &str) -> Option { - let resolved_model = resolved_model.strip_prefix("claude-")?; - let (model_slug, context) = resolved_model - .strip_suffix(']') - .and_then(|without_bracket| without_bracket.rsplit_once('[')) - .map_or((resolved_model, None), |(model, context)| { - (model, Some(context)) - }); - let parts = model_slug.split('-').collect::>(); - let (family, version_parts) = if parts.first()?.chars().all(|c| c.is_ascii_digit()) { - let family_index = parts - .iter() - .position(|part| !part.chars().all(|c| c.is_ascii_digit()))?; - (parts[family_index], &parts[..family_index]) - } else { - let version_end = parts[1..] - .iter() - .position(|part| part.len() == 8 && part.chars().all(|c| c.is_ascii_digit())) - .map(|index| index + 1) - .unwrap_or(parts.len()); - (parts[0], &parts[1..version_end]) - }; - let version = version_parts - .iter() - .take_while(|part| part.chars().all(|c| c.is_ascii_digit())) - .copied() - .collect::>() - .join("."); - if version.is_empty() { - return None; - } - let mut family_chars = family.chars(); - let family = family_chars - .next() - .map(|first| first.to_uppercase().collect::() + family_chars.as_str())?; - let mut label = format!("{family} {version}"); - if let Some(context) = context { - label.push_str(&format!(" ({} context)", context.to_ascii_uppercase())); - } - Some(label) -} - fn model_display_name(model: &serde_json::Value, id: &str) -> String { - let fallback = model + model .get("displayName") .and_then(serde_json::Value::as_str) - .unwrap_or(id); - let resolved = model - .get("resolvedModel") - .and_then(serde_json::Value::as_str) - .and_then(resolved_model_display_name); - match (id, resolved) { - // The CLI needs the moving `default` alias as its value, but that is an - // implementation detail rather than a useful model label. Show the - // concrete account-resolved model in the composer. - ("default", Some(resolved)) => resolved, - (_, Some(resolved)) => resolved, - (_, None) => fallback.to_string(), - } + .unwrap_or(id) + .to_string() } fn parse_model_initialize_response(value: &serde_json::Value) -> Vec { - value + let models = value .pointer("/response/response/models") .and_then(serde_json::Value::as_array) - .into_iter() - .flatten() + .map(Vec::as_slice) + .unwrap_or_default(); + let default_resolved = models + .iter() + .find(|model| model.get("value").and_then(serde_json::Value::as_str) == Some("default")) + .and_then(|model| model.get("resolvedModel")) + .and_then(serde_json::Value::as_str); + let mut parsed = models + .iter() + // `default` is an internal sentinel. The UI already has an explicit + // provider-default choice, so exposing it as a second model is both + // redundant and different from temps-agent-runtime's catalog. + .filter(|model| model.get("value").and_then(serde_json::Value::as_str) != Some("default")) .filter_map(|model| { let id = model.get("value")?.as_str()?.to_string(); - Some(ClaudeModelInfo { - name: model_display_name(model, &id), - description: model - .get("description") + let is_default = default_resolved.is_some() + && model + .get("resolvedModel") .and_then(serde_json::Value::as_str) - .unwrap_or_default() - .to_string(), - effort_levels: model - .get("supportedEffortLevels") - .and_then(serde_json::Value::as_array) - .into_iter() - .flatten() - .filter_map(serde_json::Value::as_str) - .map(str::to_string) - .collect(), - supports_adaptive_thinking: model - .get("supportsAdaptiveThinking") - .and_then(serde_json::Value::as_bool) - .unwrap_or(false), - supports_auto_mode: model - .get("supportsAutoMode") - .and_then(serde_json::Value::as_bool) - .unwrap_or(false), - id, - }) + == default_resolved; + Some(( + is_default, + ClaudeModelInfo { + name: model_display_name(model, &id), + description: model + .get("description") + .and_then(serde_json::Value::as_str) + .unwrap_or_default() + .to_string(), + effort_levels: model + .get("supportedEffortLevels") + .and_then(serde_json::Value::as_array) + .into_iter() + .flatten() + .filter_map(serde_json::Value::as_str) + .map(str::to_string) + .collect(), + supports_adaptive_thinking: model + .get("supportsAdaptiveThinking") + .and_then(serde_json::Value::as_bool) + .unwrap_or(false), + supports_auto_mode: model + .get("supportsAutoMode") + .and_then(serde_json::Value::as_bool) + .unwrap_or(false), + id, + }, + )) + }) + .collect::>(); + parsed.sort_by_key(|(is_default, _)| !*is_default); + parsed.into_iter().map(|(_, model)| model).collect() +} + +/// Parse the SDK initialization response emitted by Claude Code into the +/// provider-neutral model contract. Sandbox-backed discovery uses the same +/// parser as host discovery so selectors and turn validation cannot drift. +pub fn parse_model_capabilities_from_initialize_output( + output: &str, +) -> Vec { + output + .lines() + .filter_map(|line| serde_json::from_str::(line).ok()) + .find(|value| { + value + .pointer("/response/request_id") + .and_then(serde_json::Value::as_str) + == Some("temps-models") + }) + .map(|value| model_capabilities(parse_model_initialize_response(&value))) + .unwrap_or_default() +} + +fn model_capabilities(models: Vec) -> Vec { + models + .into_iter() + .map(|model| { + let has_reasoning = !model.effort_levels.is_empty() || model.supports_adaptive_thinking; + let mut reasoning_options = if has_reasoning { + vec!["off".to_string()] + } else { + Vec::new() + }; + reasoning_options.extend(model.effort_levels.iter().cloned()); + if model.supports_adaptive_thinking { + reasoning_options.push("auto".to_string()); + } + let default_reasoning_option = model + .effort_levels + .iter() + .find(|effort| effort.as_str() == "medium") + .or_else(|| model.effort_levels.first()) + .cloned(); + super::AiCliModelCapability { + id: model.id, + name: model.name, + reasoning_options, + default_reasoning_option, + } }) .collect() } @@ -202,20 +234,8 @@ pub async fn discover_models() -> Vec { use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader}; let probe = async { - let mut command = cancellation_safe_command("claude"); + let mut command = model_discovery_command(); command - .args([ - "--output-format", - "stream-json", - "--verbose", - "--input-format", - "stream-json", - // Capability discovery must not execute the operator's user, - // project, or local SessionStart hooks. Managed account policy - // and the authenticated model list remain available. - "--setting-sources", - "", - ]) .stdin(Stdio::piped()) .stdout(Stdio::piped()) .stderr(Stdio::null()) @@ -385,35 +405,7 @@ impl AiCliProvider for ClaudeCliProvider { } async fn discover_model_capabilities(&self) -> Vec { - discover_models() - .await - .into_iter() - .map(|model| { - let has_reasoning = - !model.effort_levels.is_empty() || model.supports_adaptive_thinking; - let mut reasoning_options = if has_reasoning { - vec!["off".to_string()] - } else { - Vec::new() - }; - reasoning_options.extend(model.effort_levels.iter().cloned()); - if model.supports_adaptive_thinking { - reasoning_options.push("auto".to_string()); - } - let default_reasoning_option = model - .effort_levels - .iter() - .find(|effort| effort.as_str() == "medium") - .or_else(|| model.effort_levels.first()) - .cloned(); - super::AiCliModelCapability { - id: model.id, - name: model.name, - reasoning_options, - default_reasoning_option, - } - }) - .collect() + model_capabilities(discover_models().await) } fn extract_assistant_text(&self, line: &str) -> Option { @@ -1492,6 +1484,22 @@ pub fn dropped_tool_use_name(line: &str) -> Option { mod tests { use super::*; + #[test] + fn model_discovery_uses_claudes_metadata_only_initialization_mode() { + let command = model_discovery_command(); + let arguments = command + .as_std() + .get_args() + .map(|argument| argument.to_string_lossy().into_owned()) + .collect::>(); + + assert!(arguments.iter().any(|argument| argument == "--print")); + assert!(arguments.windows(2).any(|pair| pair == ["--tools", ""])); + assert!(arguments + .iter() + .any(|argument| argument == "--setting-sources=")); + } + #[test] fn parses_account_aware_models_and_effort_capabilities() { let response = serde_json::json!({ @@ -1529,31 +1537,18 @@ mod tests { }); let models = parse_model_initialize_response(&response); - assert_eq!(models.len(), 3); - assert_eq!(models[0].id, "default"); - assert_eq!(models[0].name, "Opus 5 (1M context)"); - assert_eq!(models[1].id, "opus[1m]"); - assert_eq!(models[1].name, "Opus 5 (1M context)"); + assert_eq!(models.len(), 2); + assert_eq!(models[0].id, "opus[1m]"); + assert_eq!(models[0].name, "Opus (1M context)"); assert_eq!( - models[1].effort_levels, + models[0].effort_levels, ["low", "medium", "high", "xhigh", "max"] ); - assert!(models[1].supports_adaptive_thinking); - assert!(models[1].supports_auto_mode); - assert_eq!(models[2].name, "Haiku 4.5"); - assert!(models[2].effort_levels.is_empty()); - } - - #[test] - fn formats_both_current_and_legacy_resolved_claude_model_ids() { - assert_eq!( - resolved_model_display_name("claude-sonnet-5").as_deref(), - Some("Sonnet 5") - ); - assert_eq!( - resolved_model_display_name("claude-3-7-sonnet-20250219").as_deref(), - Some("Sonnet 3.7") - ); + assert!(models[0].supports_adaptive_thinking); + assert!(models[0].supports_auto_mode); + assert_eq!(models[1].id, "haiku"); + assert_eq!(models[1].name, "Haiku"); + assert!(models[1].effort_levels.is_empty()); } fn thinking_args(level: &str) -> Vec { diff --git a/crates/temps-agents/src/ai_cli/mod.rs b/crates/temps-agents/src/ai_cli/mod.rs index 1bd9df690..af76e88d5 100644 --- a/crates/temps-agents/src/ai_cli/mod.rs +++ b/crates/temps-agents/src/ai_cli/mod.rs @@ -186,7 +186,7 @@ pub enum NativeToolEvent { pub struct AiCliModelSnapshot { pub models: Vec, pub refreshed_at: chrono::DateTime, - pub source: &'static str, + pub source: temps_ai::ModelCatalogSource, } #[derive(Clone)] @@ -323,7 +323,7 @@ pub async fn discover_model_capabilities_cached( return AiCliModelSnapshot { models: cached.models.clone(), refreshed_at: cached.refreshed_at, - source: "cache", + source: temps_ai::ModelCatalogSource::Cache, }; } } @@ -334,13 +334,13 @@ pub async fn discover_model_capabilities_cached( return AiCliModelSnapshot { models: cached.models, refreshed_at: cached.refreshed_at, - source: "stale_cache", + source: temps_ai::ModelCatalogSource::StaleCache, }; } return AiCliModelSnapshot { models: Vec::new(), refreshed_at: chrono::Utc::now(), - source: "unavailable", + source: temps_ai::ModelCatalogSource::Bootstrap, }; } @@ -357,7 +357,7 @@ pub async fn discover_model_capabilities_cached( AiCliModelSnapshot { models: discovered, refreshed_at, - source: "live", + source: temps_ai::ModelCatalogSource::Live, } } @@ -377,9 +377,9 @@ pub async fn cached_model_capabilities( .cloned() .filter(|cached| cached.identity == identity)?; let source = if cached.expires_at > Instant::now() { - "cache" + temps_ai::ModelCatalogSource::Cache } else { - "stale_cache" + temps_ai::ModelCatalogSource::StaleCache }; Some(AiCliModelSnapshot { models: cached.models, @@ -861,7 +861,7 @@ mod tests { let snapshot = cached_model_capabilities(provider_id, identity) .await .expect("cached model snapshot"); - assert_eq!(snapshot.source, "cache"); + assert_eq!(snapshot.source, temps_ai::ModelCatalogSource::Cache); assert_eq!(snapshot.models[0].id, "model-1"); assert_eq!(snapshot.refreshed_at, refreshed_at); assert!(cached_model_capabilities(provider_id, "different-user") @@ -885,6 +885,15 @@ mod tests { .any(|model| model.id == "gpt-5.6-terra")); } + #[test] + fn empty_claude_discovery_does_not_invent_models() { + let capabilities = provider_capabilities_from_models("claude_cli", Vec::new()) + .expect("Claude capability contract"); + + assert!(capabilities.models.is_empty()); + assert!(capabilities.default_model_id.is_none()); + } + #[test] fn discovered_models_keep_provider_reasoning_metadata() { let capabilities = provider_capabilities_from_models( diff --git a/crates/temps-agents/src/handlers/ai_providers.rs b/crates/temps-agents/src/handlers/ai_providers.rs index 771131709..88adb5dd0 100644 --- a/crates/temps-agents/src/handlers/ai_providers.rs +++ b/crates/temps-agents/src/handlers/ai_providers.rs @@ -20,22 +20,29 @@ use axum::{ extract::{Path, Query, State}, + http::StatusCode, response::IntoResponse, routing::{get, patch, post}, - Json, Router, + Extension, Json, Router, }; -use futures::future::join_all; use sea_orm::{ActiveModelTrait, EntityTrait, Set}; use serde::{Deserialize, Serialize}; -use std::{sync::Arc, time::Duration}; +use std::sync::Arc; use utoipa::{IntoParams, ToSchema}; -use temps_auth::{permission_guard, RequireAuth}; -use temps_core::problemdetails::Problem; +use temps_auth::{permission_guard, Permission, RequireAuth}; +use temps_core::audit::{AuditContext, AuditOperation}; +use temps_core::problemdetails::{self, Problem}; +use temps_core::RequestMetadata; -use crate::ai_cli::catalog::{find_provider, CredentialFormat, PROVIDER_CATALOG}; +use crate::ai_cli::catalog::{ + find_provider, CredentialFormat, HostAccessRequirement, PROVIDER_CATALOG, +}; use crate::error::AgentError; use crate::handlers::AppState; +use crate::services::provider_credential_service::{ + discover_local_credential, discover_local_credential_summary, LocalCredentialSummary, +}; // ── DTOs ────────────────────────────────────────────────────────────────────── @@ -115,8 +122,8 @@ pub struct ProviderCatalogDto { pub host_auth_method: Option, /// Installed CLI version used as part of the model-cache identity. pub host_version: Option, - /// `live`, `cache`, `stale_cache`, or `bootstrap`. - pub model_source: String, + /// Whether the catalog is live, cached, stale, or a bootstrap fallback. + pub model_source: temps_ai::ModelCatalogSource, /// Time of the last successful account-aware CLI model discovery. pub models_refreshed_at: Option, /// Explains why `host_authenticated` is false (not installed vs. @@ -128,6 +135,9 @@ pub struct ProviderCatalogDto { pub workspace_ready: bool, /// Actionable explanation when `workspace_ready` is false. pub workspace_readiness_hint: Option, + /// Importable credential already used by this host's CLI, if one can be + /// copied directly into encrypted Temps settings. Contains metadata only. + pub local_credential: Option, } #[derive(Debug, Serialize, ToSchema)] @@ -146,11 +156,6 @@ pub struct ListAiProvidersQuery { /// first paint; an authenticated refresh follows in the background. #[serde(default)] pub catalog_only: bool, - /// Run account-aware model discovery before returning. Normal catalog - /// reads intentionally use cached/bootstrap models so chat first paint is - /// not held hostage by provider CLIs that can take 10-15 seconds. - #[serde(default)] - pub refresh_models: bool, } #[derive(Debug, Deserialize, ToSchema)] @@ -170,11 +175,114 @@ pub struct SaveCredentialResponse { pub auth_type: String, } +/// Metadata about a credential that Temps can import from the server process +/// user's existing CLI login. This never includes a path or credential value. +#[derive(Debug, Clone, Serialize, ToSchema)] +pub struct LocalCredentialDto { + pub auth_type: String, + /// Stable machine-readable source: `environment` or `host_auth_store`. + pub source: String, + pub label: String, +} + +#[derive(Debug, Serialize, ToSchema)] +pub struct ImportLocalCredentialResponse { + pub saved: bool, + pub provider_id: String, + pub auth_type: String, + pub source: String, + pub workspace_ready: bool, +} + #[derive(Debug, Serialize, ToSchema)] pub struct ActivateProviderResponse { pub default_provider: String, } +#[derive(Debug, Serialize, ToSchema)] +pub struct RefreshProviderModelsResponse { + pub provider_id: String, + pub runtime_models: Vec, + pub default_runtime_model_id: Option, + pub model_source: temps_ai::ModelCatalogSource, + pub models_refreshed_at: Option, +} + +fn uses_workspace_model_discovery( + provider: &crate::ai_cli::catalog::ProviderCatalogEntry, + config: &temps_core::ProviderConfig, +) -> bool { + provider.workspace_chat_supported && config.credentials_encrypted.is_some() +} + +fn should_discover_local_credentials(catalog_only: bool, is_system_admin: bool) -> bool { + !catalog_only && is_system_admin +} + +#[derive(Debug, Clone, Serialize)] +struct ProviderModelsRefreshedAudit { + context: AuditContext, + provider_id: String, + model_count: usize, + model_source: temps_ai::ModelCatalogSource, +} + +#[derive(Debug, Clone, Serialize)] +struct ProviderCredentialSavedAudit { + context: AuditContext, + provider_id: String, + auth_type: String, + source: String, +} + +impl AuditOperation for ProviderCredentialSavedAudit { + fn operation_type(&self) -> String { + "AI_PROVIDER_CREDENTIAL_SAVED".to_string() + } + + fn user_id(&self) -> Option { + Some(self.context.user_id) + } + + fn ip_address(&self) -> Option { + self.context.ip_address.clone() + } + + fn user_agent(&self) -> &str { + &self.context.user_agent + } + + fn serialize(&self) -> temps_core::anyhow::Result { + serde_json::to_string(self).map_err(|error| { + temps_core::anyhow::anyhow!("failed to serialize provider credential audit: {error}") + }) + } +} + +impl AuditOperation for ProviderModelsRefreshedAudit { + fn operation_type(&self) -> String { + "AI_PROVIDER_MODELS_REFRESHED".to_string() + } + + fn user_id(&self) -> Option { + Some(self.context.user_id) + } + + fn ip_address(&self) -> Option { + self.context.ip_address.clone() + } + + fn user_agent(&self) -> &str { + &self.context.user_agent + } + + fn serialize(&self) -> temps_core::anyhow::Result { + serde_json::to_string(self).map_err(|error| { + temps_core::anyhow::anyhow!("failed to serialize model refresh audit: {error}") + }) + } +} + /// Body for `PATCH /settings/ai-providers/{provider_id}` — updates /// provider-scoped settings (just the default model for now) without /// touching the credential. Keeping credentials out of this shape means @@ -231,10 +339,18 @@ pub fn routes() -> Router> { "/settings/ai-providers/{provider_id}/credential", post(save_ai_provider_credential), ) + .route( + "/settings/ai-providers/{provider_id}/credential/import-local", + post(import_local_ai_provider_credential), + ) .route( "/settings/ai-providers/{provider_id}/activate", post(activate_ai_provider), ) + .route( + "/settings/ai-providers/{provider_id}/models/refresh", + post(refresh_ai_provider_models), + ) } // ── Handlers ────────────────────────────────────────────────────────────────── @@ -266,12 +382,50 @@ pub async fn list_ai_providers( load_agent_sandbox(&app_state).await? }; - let providers = join_all(PROVIDER_CATALOG.iter().map(|entry| { - provider_catalog_dto( - entry, - sandbox.provider_config(entry.id), - query.refresh_models, - ) + let ai_service = app_state.ai_service.clone(); + let principal_id = auth.user_id(); + let can_discover_local_credentials = auth.has_permission(&Permission::SystemAdmin); + let providers = futures::future::join_all(PROVIDER_CATALOG.iter().map(|entry| { + let provider_config = sandbox.provider_config(entry.id); + let ai_service = ai_service.clone(); + async move { + let local_credential = if !should_discover_local_credentials( + query.catalog_only, + can_discover_local_credentials, + ) { + None + } else { + match discover_local_credential_summary(entry).await { + Ok(credential) => credential, + Err(error) => { + tracing::warn!( + provider_id = entry.id, + %error, + "could not inspect local AI provider credential" + ); + None + } + } + }; + let workspace_snapshot = if entry.workspace_chat_supported + && provider_config.credentials_encrypted.is_some() + { + match ai_service { + Some(service) => service + .capabilities_snapshot_for_principal( + Some(entry.id), + principal_id, + temps_ai::RefreshPolicy::Cached, + ) + .await + .ok(), + None => None, + } + } else { + None + }; + provider_catalog_dto(entry, provider_config, workspace_snapshot, local_credential).await + } })) .await; @@ -281,12 +435,157 @@ pub async fn list_ai_providers( })) } -const PROVIDER_STATUS_TIMEOUT: Duration = Duration::from_secs(5); +/// Refresh exactly one provider's account-aware model inventory. This is an +/// explicit operation because it starts a CLI process (and, for Claude +/// workspaces, creates or wakes the user's persistent sandbox). Authorization +/// therefore matches the provider's chat execution requirement instead of +/// requiring unrelated settings mutation access. The AI service applies a +/// provider-scoped single-flight and cooldown before doing that work. +#[utoipa::path( + tag = "Agents", + post, + path = "/settings/ai-providers/{provider_id}/models/refresh", + params(("provider_id" = String, Path, description = "AI provider ID")), + responses( + (status = 200, body = RefreshProviderModelsResponse), + (status = 400, description = "Unknown provider"), + (status = 401, description = "Unauthorized"), + (status = 403, description = "Provider execution permission required"), + (status = 503, description = "Provider model discovery unavailable"), + ), + security(("bearer_auth" = [])) +)] +pub async fn refresh_ai_provider_models( + RequireAuth(auth): RequireAuth, + State(app_state): State>, + Extension(metadata): Extension, + Path(provider_id): Path, +) -> Result { + let provider = find_provider(&provider_id).ok_or_else(|| { + Problem::from(AgentError::Validation { + message: format!("Unknown AI provider '{provider_id}'"), + }) + })?; + ensure_provider_runtime_permission(&auth, provider)?; + let ai_service = app_state.ai_service.as_ref().ok_or_else(|| { + problemdetails::new(StatusCode::SERVICE_UNAVAILABLE) + .with_title("AI provider refresh unavailable") + .with_detail("The AI provider service is not configured on this Temps instance.") + })?; + let sandbox = load_agent_sandbox(&app_state).await?; + let provider_config = sandbox.provider_config(&provider_id); + let workspace_discovery = uses_workspace_model_discovery(provider, &provider_config); + if workspace_discovery { + ensure_workspace_model_discovery_permission(&auth)?; + } + let snapshot_result = if workspace_discovery { + ai_service + .capabilities_snapshot_for_principal( + Some(&provider_id), + auth.user_id(), + temps_ai::RefreshPolicy::Refresh, + ) + .await + } else { + ai_service + .capabilities_snapshot_for(Some(&provider_id), temps_ai::RefreshPolicy::Refresh) + .await + }; + let snapshot = snapshot_result.map_err(|error| { + let (error_kind, error_purpose) = match &error { + temps_ai::AiError::NotAvailable => ("not_available", None), + temps_ai::AiError::NoModel { purpose } => ("no_model", Some(purpose.as_str())), + temps_ai::AiError::Provider { purpose, .. } => ("provider", Some(purpose.as_str())), + }; + tracing::warn!( + provider_id, + user_id = auth.user_id(), + workspace_discovery, + error_kind, + error_purpose, + "AI provider model refresh failed" + ); + let detail = provider_model_refresh_error_detail( + provider, + &provider_id, + workspace_discovery, + &error, + ); + problemdetails::new(StatusCode::SERVICE_UNAVAILABLE) + .with_title("Could not refresh provider models") + .with_detail(detail) + })?; + let response = RefreshProviderModelsResponse { + provider_id: provider_id.clone(), + default_runtime_model_id: snapshot.capabilities.default_model_id.clone(), + runtime_models: snapshot.capabilities.models, + model_source: snapshot.model_source, + models_refreshed_at: snapshot.models_refreshed_at, + }; + if let Err(error) = app_state + .audit_service + .create_audit_log(&ProviderModelsRefreshedAudit { + context: AuditContext { + user_id: auth.user_id(), + ip_address: Some(metadata.ip_address.clone()), + user_agent: metadata.user_agent.clone(), + }, + provider_id, + model_count: response.runtime_models.len(), + model_source: response.model_source, + }) + .await + { + tracing::error!(%error, "failed to write AI provider model refresh audit log"); + } + Ok(Json(response)) +} + +fn ensure_provider_runtime_permission( + auth: &temps_auth::AuthContext, + provider: &crate::ai_cli::catalog::ProviderCatalogEntry, +) -> Result<(), Problem> { + match provider.host_access_requirement { + HostAccessRequirement::AiGatewayWrite => permission_guard!(auth, AiGatewayWrite), + HostAccessRequirement::SystemAdmin => permission_guard!(auth, SystemAdmin), + } + Ok(()) +} + +fn ensure_workspace_model_discovery_permission( + auth: &temps_auth::AuthContext, +) -> Result<(), Problem> { + permission_guard!(auth, SandboxesWrite); + permission_guard!(auth, SandboxesExec); + Ok(()) +} + +fn provider_model_refresh_error_detail( + provider: &crate::ai_cli::catalog::ProviderCatalogEntry, + provider_id: &str, + workspace_discovery: bool, + error: &temps_ai::AiError, +) -> String { + if matches!(error, temps_ai::AiError::NotAvailable) { + return format!( + "{} is not installed and authenticated on the Temps host. Use the install and authentication commands shown above, then retry.", + provider.name + ); + } + if workspace_discovery { + return format!( + "Temps could not start or inspect your persistent workspace, so {} models could not be resolved. Retry after the workspace is available; if it remains unavailable, contact your Temps administrator.", + provider.name + ); + } + format!("Temps could not refresh the model inventory for '{provider_id}'. Check the provider authentication and retry.") +} async fn provider_catalog_dto( entry: &'static crate::ai_cli::catalog::ProviderCatalogEntry, provider_cfg: temps_core::ProviderConfig, - refresh_models: bool, + workspace_snapshot: Option, + local_credential: Option, ) -> ProviderCatalogDto { let credential_saved = provider_cfg.credentials_encrypted.is_some(); let current_auth_type = if credential_saved { @@ -304,19 +603,49 @@ async fn provider_catalog_dto( discovered_source, models_refreshed_at, ) = match crate::ai_cli::create_provider(entry.id) { - Some(provider) => { - let status = if refresh_models { - crate::ai_cli::get_status_cached(provider.as_ref(), true, PROVIDER_STATUS_TIMEOUT) - .await - } else { - crate::ai_cli::cached_status(entry.id).await - }; - let Some(status) = status else { - return provider_catalog_dto_from_runtime( - entry, - provider_cfg, - credential_saved, - current_auth_type, + Some(_provider) => { + let status = crate::ai_cli::cached_status(entry.id).await; + match status { + Some(status) => { + let authenticated = status.installed && status.authenticated; + let version = status.version.clone(); + let identity = format!( + "{}|{}|{}|{}", + version.as_deref().unwrap_or("unknown"), + status.auth_method.as_deref().unwrap_or("unknown"), + status.email.as_deref().unwrap_or("unknown"), + status.subscription_type.as_deref().unwrap_or("unknown") + ); + let snapshot = if !status.installed { + None + } else { + crate::ai_cli::cached_model_capabilities(entry.id, &identity).await + }; + let models = snapshot + .as_ref() + .map(|snapshot| snapshot.models.clone()) + .unwrap_or_default(); + ( + authenticated, + status.auth_method, + if authenticated { + None + } else { + status.setup_hint + }, + version, + models, + snapshot + .as_ref() + .map(|snapshot| snapshot.source) + .unwrap_or(temps_ai::ModelCatalogSource::Bootstrap), + snapshot.as_ref().and_then(|snapshot| { + (!snapshot.models.is_empty()) + .then(|| snapshot.refreshed_at.to_rfc3339()) + }), + ) + } + None => ( false, None, Some( @@ -324,59 +653,22 @@ async fn provider_catalog_dto( ), None, Vec::new(), - "bootstrap", + temps_ai::ModelCatalogSource::Bootstrap, None, - ); - }; - let authenticated = status.installed && status.authenticated; - let version = status.version.clone(); - let identity = format!( - "{}|{}|{}|{}", - version.as_deref().unwrap_or("unknown"), - status.auth_method.as_deref().unwrap_or("unknown"), - status.email.as_deref().unwrap_or("unknown"), - status.subscription_type.as_deref().unwrap_or("unknown") - ); - let snapshot = if !status.installed { - None - } else if refresh_models { - Some( - crate::ai_cli::discover_model_capabilities_cached( - provider.as_ref(), - identity, - true, - ) - .await, - ) - } else { - crate::ai_cli::cached_model_capabilities(entry.id, &identity).await - }; - let models = snapshot - .as_ref() - .map(|snapshot| snapshot.models.clone()) - .unwrap_or_default(); - ( - authenticated, - status.auth_method, - if authenticated { - None - } else { - status.setup_hint - }, - version, - models, - snapshot - .as_ref() - .map(|snapshot| snapshot.source) - .unwrap_or("unavailable"), - snapshot.as_ref().and_then(|snapshot| { - (!snapshot.models.is_empty()).then(|| snapshot.refreshed_at.to_rfc3339()) - }), - ) + ), + } } - None => (false, None, None, None, Vec::new(), "unavailable", None), + None => ( + false, + None, + None, + None, + Vec::new(), + temps_ai::ModelCatalogSource::Bootstrap, + None, + ), }; - provider_catalog_dto_from_runtime( + let mut dto = provider_catalog_dto_from_runtime( entry, provider_cfg, credential_saved, @@ -388,7 +680,25 @@ async fn provider_catalog_dto( discovered_models, discovered_source, models_refreshed_at, - ) + local_credential, + ); + if let Some(snapshot) = workspace_snapshot { + dto.models = snapshot + .capabilities + .models + .iter() + .map(|model| model.id.clone()) + .collect(); + dto.runtime_models = snapshot.capabilities.models; + dto.default_runtime_model_id = dto + .default_model + .clone() + .filter(|saved| dto.models.iter().any(|model| model == saved)) + .or(snapshot.capabilities.default_model_id); + dto.model_source = snapshot.model_source; + dto.models_refreshed_at = snapshot.models_refreshed_at; + } + dto } #[allow(clippy::too_many_arguments)] @@ -402,8 +712,9 @@ fn provider_catalog_dto_from_runtime( host_auth_hint: Option, host_version: Option, discovered_models: Vec, - discovered_source: &str, + discovered_source: temps_ai::ModelCatalogSource, models_refreshed_at: Option, + local_credential: Option, ) -> ProviderCatalogDto { let workspace_ready = entry.workspace_chat_supported && credential_saved; let workspace_readiness_hint = if workspace_ready { @@ -422,7 +733,7 @@ fn provider_catalog_dto_from_runtime( let (runtime_models, model_source) = if discovered_models.is_empty() { ( bootstrap_runtime_models(entry.models), - "bootstrap".to_string(), + temps_ai::ModelCatalogSource::Bootstrap, ) } else { ( @@ -430,7 +741,7 @@ fn provider_catalog_dto_from_runtime( .into_iter() .map(runtime_model_capability) .collect(), - discovered_source.to_string(), + discovered_source, ) }; let models = runtime_models @@ -498,6 +809,11 @@ fn provider_catalog_dto_from_runtime( host_auth_hint, workspace_ready, workspace_readiness_hint, + local_credential: local_credential.map(|credential| LocalCredentialDto { + auth_type: credential.auth_type, + source: credential.source.as_str().to_string(), + label: credential.source.label().to_string(), + }), } } @@ -524,6 +840,7 @@ fn provider_catalog_dto_from_runtime( pub async fn save_ai_provider_credential( RequireAuth(auth): RequireAuth, State(app_state): State>, + Extension(metadata): Extension, Path(provider_id): Path, Json(request): Json, ) -> Result { @@ -568,6 +885,21 @@ pub async fn save_ai_provider_credential( ) .await .map_err(Problem::from)?; + if let Some(ai_service) = &app_state.ai_service { + ai_service + .invalidate_capabilities_for(Some(&provider_id)) + .await; + } + + write_provider_credential_audit( + &app_state, + &auth, + &metadata, + &provider_id, + &request.auth_type, + "manual", + ) + .await; Ok(Json(SaveCredentialResponse { saved: true, @@ -576,6 +908,126 @@ pub async fn save_ai_provider_credential( })) } +/// Import the credential already used by this provider's CLI on the Temps +/// host. Discovery and encryption happen entirely server-side; the plaintext +/// credential is never serialized into the response or browser state. +#[utoipa::path( + tag = "Agents", + post, + path = "/settings/ai-providers/{provider_id}/credential/import-local", + params(("provider_id" = String, Path, description = "AI provider ID")), + responses( + (status = 200, body = ImportLocalCredentialResponse), + (status = 400, description = "Unknown provider or invalid local credential"), + (status = 401, description = "Unauthorized"), + (status = 403, description = "System administrator permission required"), + (status = 404, description = "No importable local credential found"), + ), + security(("bearer_auth" = [])) +)] +pub async fn import_local_ai_provider_credential( + RequireAuth(auth): RequireAuth, + State(app_state): State>, + Extension(metadata): Extension, + Path(provider_id): Path, +) -> Result { + permission_guard!(auth, SettingsWrite); + permission_guard!(auth, SystemAdmin); + + let provider = find_provider(&provider_id).ok_or_else(|| { + Problem::from(AgentError::Validation { + message: format!("Unknown AI provider '{provider_id}'"), + }) + })?; + let discovered = discover_local_credential(provider) + .await + .map_err(|error| { + problemdetails::new(StatusCode::BAD_REQUEST) + .with_title("Local AI credential could not be imported") + .with_detail(error.to_string()) + })? + .ok_or_else(|| { + problemdetails::new(StatusCode::NOT_FOUND) + .with_title("No local AI credential found") + .with_detail(format!( + "Temps could not find an importable {} credential for the operating-system user running this server. Authenticate the host CLI or save a credential manually.", + provider.name + )) + })?; + + let encrypted = app_state + .encryption_service + .encrypt_string(&discovered.credential) + .map_err(|error| { + Problem::from(AgentError::EncryptionError { + message: format!( + "Failed to encrypt imported credential for provider '{provider_id}': {error}" + ), + }) + })?; + persist_provider_credential_and_invalidate( + app_state.db.as_ref(), + app_state.platform_config_service.as_ref(), + &provider_id, + &discovered.auth_type, + encrypted, + ) + .await + .map_err(Problem::from)?; + if let Some(ai_service) = &app_state.ai_service { + ai_service + .invalidate_capabilities_for(Some(&provider_id)) + .await; + } + write_provider_credential_audit( + &app_state, + &auth, + &metadata, + &provider_id, + &discovered.auth_type, + discovered.source.as_str(), + ) + .await; + + Ok(Json(ImportLocalCredentialResponse { + saved: true, + provider_id, + auth_type: discovered.auth_type, + source: discovered.source.as_str().to_string(), + workspace_ready: provider.workspace_chat_supported, + })) +} + +async fn write_provider_credential_audit( + app_state: &Arc, + auth: &temps_auth::AuthContext, + metadata: &RequestMetadata, + provider_id: &str, + auth_type: &str, + source: &str, +) { + if let Err(error) = app_state + .audit_service + .create_audit_log(&ProviderCredentialSavedAudit { + context: AuditContext { + user_id: auth.user_id(), + ip_address: Some(metadata.ip_address.clone()), + user_agent: metadata.user_agent.clone(), + }, + provider_id: provider_id.to_string(), + auth_type: auth_type.to_string(), + source: source.to_string(), + }) + .await + { + tracing::error!( + provider_id, + %error, + "failed to write AI provider credential audit log" + ); + } +} + /// Persist a provider credential and make the successful write a strict cache /// freshness boundary. Keeping both operations in one function prevents a /// future handler edit from accidentally restoring the old-token-for-one-turn @@ -1041,18 +1493,24 @@ mod tests { } #[test] - fn provider_catalog_reads_do_not_refresh_models_by_default() { + fn provider_catalog_reads_never_accept_a_process_spawning_refresh_flag() { let query = serde_json::from_value::(serde_json::json!({})) .expect("default query"); - assert!(!query.refresh_models); assert!(!query.catalog_only); - let refresh = serde_json::from_value::( + let ignored_legacy_refresh = serde_json::from_value::( serde_json::json!({ "refresh_models": true, "catalog_only": true }), ) - .expect("refresh query"); - assert!(refresh.refresh_models); - assert!(refresh.catalog_only); + .expect("unknown query fields are harmless"); + assert!(ignored_legacy_refresh.catalog_only); + } + + #[test] + fn local_credential_discovery_requires_a_full_admin_catalog_request() { + assert!(should_discover_local_credentials(false, true)); + assert!(!should_discover_local_credentials(true, true)); + assert!(!should_discover_local_credentials(false, false)); + assert!(!should_discover_local_credentials(true, false)); } #[tokio::test] @@ -1150,6 +1608,187 @@ mod tests { assert_eq!(models[0].name, "Sonnet"); } + #[test] + fn cold_claude_catalog_does_not_advertise_unverified_models() { + let claude = + crate::ai_cli::catalog::find_provider("claude_cli").expect("Claude catalog entry"); + let dto = provider_catalog_dto_from_runtime( + claude, + temps_core::ProviderConfig::default(), + true, + Some("subscription".to_string()), + false, + None, + None, + None, + Vec::new(), + temps_ai::ModelCatalogSource::Bootstrap, + None, + None, + ); + + assert!(dto.models.is_empty()); + assert!(dto.runtime_models.is_empty()); + assert!(dto.default_runtime_model_id.is_none()); + } + + #[tokio::test] + async fn workspace_models_overlay_a_cold_host_status_cache() { + crate::ai_cli::invalidate_status_cache().await; + let claude = + crate::ai_cli::catalog::find_provider("claude_cli").expect("Claude catalog entry"); + let provider_config = temps_core::ProviderConfig { + auth_type: "subscription".to_string(), + credentials_encrypted: Some("encrypted-token".to_string()), + ..Default::default() + }; + let capabilities = crate::ai_cli::provider_capabilities_from_models( + "claude_cli", + vec![crate::ai_cli::AiCliModelCapability { + id: "account-model".to_string(), + name: "Account model".to_string(), + reasoning_options: Vec::new(), + default_reasoning_option: None, + }], + ) + .expect("Claude capability contract"); + + let dto = provider_catalog_dto( + claude, + provider_config, + Some(temps_ai::ProviderCapabilitiesSnapshot { + capabilities, + model_source: temps_ai::ModelCatalogSource::Live, + models_refreshed_at: Some("2026-09-08T00:00:00Z".to_string()), + }), + None, + ) + .await; + + assert_eq!(dto.model_source, temps_ai::ModelCatalogSource::Live); + assert_eq!(dto.models, vec!["account-model"]); + assert_eq!( + dto.models_refreshed_at.as_deref(), + Some("2026-09-08T00:00:00Z") + ); + } + + #[test] + fn claude_refresh_uses_host_without_a_saved_workspace_credential() { + let claude = + crate::ai_cli::catalog::find_provider("claude_cli").expect("Claude catalog entry"); + assert!(!uses_workspace_model_discovery( + claude, + &temps_core::ProviderConfig::default() + )); + + let configured = temps_core::ProviderConfig { + credentials_encrypted: Some("encrypted-token".to_string()), + ..temps_core::ProviderConfig::default() + }; + assert!(uses_workspace_model_discovery(claude, &configured)); + + let codex = + crate::ai_cli::catalog::find_provider("codex_cli").expect("Codex catalog entry"); + assert!(!uses_workspace_model_discovery(codex, &configured)); + } + + #[test] + fn model_refresh_uses_the_same_permission_as_provider_execution() { + let now = chrono::Utc::now(); + let user = temps_entities::users::Model { + id: 42, + name: "Harness User".to_string(), + email: "harness-user@example.com".to_string(), + password_hash: None, + email_verified: true, + email_verification_token: None, + email_verification_expires: None, + password_reset_token: None, + password_reset_expires: None, + must_change_password: false, + deleted_at: None, + mfa_secret: None, + mfa_enabled: false, + mfa_recovery_codes: None, + oidc_subject: None, + oidc_provider_id: None, + created_at: now, + updated_at: now, + }; + let auth = |permissions| { + temps_auth::AuthContext::new_api_key( + user.clone(), + None, + Some(permissions), + "provider-refresh-test".to_string(), + 1, + ) + }; + let claude = find_provider("claude_cli").expect("Claude catalog entry"); + let codex = find_provider("codex_cli").expect("Codex catalog entry"); + + assert!(ensure_provider_runtime_permission( + &auth(vec![Permission::AiGatewayWrite]), + claude + ) + .is_ok()); + assert!( + ensure_provider_runtime_permission(&auth(vec![Permission::SettingsRead]), claude) + .is_err() + ); + assert!( + ensure_provider_runtime_permission(&auth(vec![Permission::SystemAdmin]), codex).is_ok() + ); + assert!( + ensure_provider_runtime_permission(&auth(vec![Permission::AiGatewayWrite]), codex) + .is_err() + ); + assert!(ensure_workspace_model_discovery_permission(&auth(vec![ + Permission::SandboxesWrite, + Permission::SandboxesExec, + ])) + .is_ok()); + assert!(ensure_workspace_model_discovery_permission(&auth(vec![ + Permission::SandboxesWrite, + ])) + .is_err()); + } + + #[test] + fn workspace_refresh_errors_do_not_expose_sandbox_internals() { + let claude = + crate::ai_cli::catalog::find_provider("claude_cli").expect("Claude catalog entry"); + let raw_error = temps_ai::AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: "create application network 'private-name': all predefined address pools have been fully subnetted" + .to_string(), + }; + + let detail = provider_model_refresh_error_detail(claude, "claude_cli", true, &raw_error); + + assert!(detail.contains("persistent workspace")); + assert!(detail.contains("Claude Code models")); + assert!(!detail.contains("private-name")); + assert!(!detail.contains("address pools")); + } + + #[test] + fn host_refresh_errors_keep_provider_context_without_raw_cli_output() { + let claude = + crate::ai_cli::catalog::find_provider("claude_cli").expect("Claude catalog entry"); + let raw_error = temps_ai::AiError::Provider { + purpose: "provider.capabilities".to_string(), + reason: "authorization: Bearer secret-value".to_string(), + }; + + let detail = provider_model_refresh_error_detail(claude, "claude_cli", false, &raw_error); + + assert!(detail.contains("claude_cli")); + assert!(!detail.contains("secret-value")); + assert!(!detail.contains("Bearer")); + } + #[test] fn workspace_readiness_requires_a_supported_relay_and_saved_credential() { let claude = @@ -1164,7 +1803,8 @@ mod tests { Some("Host authentication is not used by workspaces.".to_string()), None, Vec::new(), - "bootstrap", + temps_ai::ModelCatalogSource::Bootstrap, + None, None, ); assert!(configured.workspace_ready); @@ -1180,7 +1820,8 @@ mod tests { None, Some("1.0.0".to_string()), Vec::new(), - "bootstrap", + temps_ai::ModelCatalogSource::Bootstrap, + None, None, ); assert!(!host_only.workspace_ready); @@ -1201,7 +1842,8 @@ mod tests { None, Some("1.0.0".to_string()), Vec::new(), - "bootstrap", + temps_ai::ModelCatalogSource::Bootstrap, + None, None, ); assert!(!codex_configured.workspace_ready); diff --git a/crates/temps-agents/src/handlers/mod.rs b/crates/temps-agents/src/handlers/mod.rs index b6ba7a72c..08f3c3503 100644 --- a/crates/temps-agents/src/handlers/mod.rs +++ b/crates/temps-agents/src/handlers/mod.rs @@ -121,8 +121,10 @@ use crate::services::secret_service::SecretService; // AI providers ai_providers::list_ai_providers, ai_providers::save_ai_provider_credential, + ai_providers::import_local_ai_provider_credential, ai_providers::activate_ai_provider, ai_providers::update_ai_provider, + ai_providers::refresh_ai_provider_models, ), components(schemas( // Agent config @@ -189,9 +191,13 @@ use crate::services::secret_service::SecretService; ai_providers::ProviderCatalogResponse, ai_providers::SaveCredentialRequest, ai_providers::SaveCredentialResponse, + ai_providers::LocalCredentialDto, + ai_providers::ImportLocalCredentialResponse, ai_providers::ActivateProviderResponse, ai_providers::UpdateProviderRequest, ai_providers::UpdateProviderResponse, + ai_providers::RefreshProviderModelsResponse, + temps_ai::ModelCatalogSource, )), tags( (name = "Agents", description = "Autonomous AI agents, autofixer (interactive AI debugging), skills/MCP definitions, and preview gateway management.") @@ -219,6 +225,9 @@ pub struct AppState { pub telemetry: Arc, /// Optional checker for team-based project access (human sessions only). pub project_access_checker: Option>, + /// Late-bound normalized AI registry. Model refresh uses this service so + /// it observes the same credential/environment as the next workspace turn. + pub ai_service: Option>, } pub fn configure_routes() -> Router> { diff --git a/crates/temps-agents/src/handlers/trigger.rs b/crates/temps-agents/src/handlers/trigger.rs index 66f0ffcf6..464f1589e 100644 --- a/crates/temps-agents/src/handlers/trigger.rs +++ b/crates/temps-agents/src/handlers/trigger.rs @@ -944,6 +944,18 @@ pub struct SaveAgentTokenResponse { pub saved: bool, } +async fn invalidate_legacy_agent_token_caches( + platform_config_service: &temps_config::ConfigService, + ai_service: Option<&Arc>, +) { + platform_config_service.invalidate_settings_cache().await; + if let Some(ai_service) = ai_service { + ai_service + .invalidate_capabilities_for(Some("claude_cli")) + .await; + } +} + /// Save an encrypted AI provider token for use in sandbox containers. #[utoipa::path( tag = "Agents", @@ -1006,12 +1018,78 @@ pub async fn save_agent_token( .await .map_err(|e| Problem::from(AgentError::Database(e)))?; + // Legacy settings still feed `provider_config("claude_cli")`. Make this + // writer the same hard freshness boundary as the provider-specific route + // so the next turn cannot reuse the old decrypted token or model catalog. + invalidate_legacy_agent_token_caches( + app_state.platform_config_service.as_ref(), + app_state.ai_service.as_ref(), + ) + .await; + Ok(Json(SaveAgentTokenResponse { saved: true })) } #[cfg(test)] -mod webhook_token_tests { - use super::constant_time_eq; +mod tests { + use super::{constant_time_eq, invalidate_legacy_agent_token_caches}; + use async_trait::async_trait; + use futures::stream; + use sea_orm::{DatabaseBackend, MockDatabase}; + use std::sync::{ + atomic::{AtomicBool, Ordering}, + Arc, + }; + use temps_ai::{AiError, AiRequest, AiResponse, AiService, ChatTurnRequest, TokenStream}; + use temps_config::ServerConfig; + use temps_core::AppSettings; + + struct InvalidationTrackingAiService { + invalidated: Arc, + } + + #[async_trait] + impl AiService for InvalidationTrackingAiService { + async fn is_available(&self) -> bool { + false + } + + async fn invalidate_capabilities_for(&self, provider: Option<&str>) { + assert_eq!(provider, Some("claude_cli")); + self.invalidated.store(true, Ordering::SeqCst); + } + + async fn complete(&self, _request: AiRequest) -> Result { + Err(AiError::NotAvailable) + } + + async fn chat_stream(&self, _request: ChatTurnRequest) -> Result { + Ok(Box::pin(stream::empty())) + } + } + + fn settings_row(default_provider: &str) -> temps_entities::settings::Model { + let mut settings = AppSettings::default(); + settings.agent_sandbox.default_provider = default_provider.to_string(); + temps_entities::settings::Model { + id: 1, + data: settings.to_json(), + created_at: chrono::Utc::now(), + updated_at: chrono::Utc::now(), + } + } + + fn test_server_config() -> Arc { + Arc::new( + ServerConfig::new( + "127.0.0.1:3000".to_string(), + "postgresql://test".to_string(), + None, + Some("127.0.0.1:8000".to_string()), + ) + .expect("valid test server config"), + ) + } #[test] fn accepts_matching_tokens() { @@ -1042,6 +1120,37 @@ mod webhook_token_tests { fn empty_tokens_are_equal() { assert!(constant_time_eq(b"", b"")); } + + #[tokio::test] + async fn legacy_token_change_invalidates_settings_and_model_caches() { + let db = Arc::new( + MockDatabase::new(DatabaseBackend::Postgres) + .append_query_results([ + [settings_row("old-provider")], + [settings_row("new-provider")], + ]) + .into_connection(), + ); + let config_service = temps_config::ConfigService::new(test_server_config(), db.clone()); + let cached = config_service + .get_settings() + .await + .expect("prime settings cache"); + assert_eq!(cached.agent_sandbox.default_provider, "old-provider"); + + let invalidated = Arc::new(AtomicBool::new(false)); + let ai_service: Arc = Arc::new(InvalidationTrackingAiService { + invalidated: invalidated.clone(), + }); + invalidate_legacy_agent_token_caches(&config_service, Some(&ai_service)).await; + + assert!(invalidated.load(Ordering::SeqCst)); + let refreshed = config_service + .get_settings() + .await + .expect("settings cache was invalidated"); + assert_eq!(refreshed.agent_sandbox.default_provider, "new-provider"); + } } // `list_available_models` was retired in favour of the per-provider diff --git a/crates/temps-agents/src/plugin.rs b/crates/temps-agents/src/plugin.rs index 07259db43..6ce7b3a76 100644 --- a/crates/temps-agents/src/plugin.rs +++ b/crates/temps-agents/src/plugin.rs @@ -699,6 +699,7 @@ impl TempsPlugin for AgentsPlugin { .get_service::() .unwrap_or_else(|| Arc::new(temps_core::NoopTelemetryReporter)), project_access_checker: None, + ai_service: None, }); context.register_plugin_state("agents", app_state); @@ -757,6 +758,7 @@ impl TempsPlugin for AgentsPlugin { // regardless of plugin load order. let old = context.get_plugin_state::("agents")?; let project_access_checker = context.get_service::(); + let ai_service = context.get_service::(); let app_state = Arc::new(AppState { db: old.db.clone(), encryption_service: old.encryption_service.clone(), @@ -771,6 +773,7 @@ impl TempsPlugin for AgentsPlugin { platform_config_service: old.platform_config_service.clone(), telemetry: old.telemetry.clone(), project_access_checker, + ai_service, }); let router = crate::handlers::configure_routes().with_state(app_state); diff --git a/crates/temps-agents/src/sandbox/local.rs b/crates/temps-agents/src/sandbox/local.rs index e8159ecd0..e608eceee 100644 --- a/crates/temps-agents/src/sandbox/local.rs +++ b/crates/temps-agents/src/sandbox/local.rs @@ -61,7 +61,8 @@ impl SandboxProvider for LocalSandboxProvider { .args(&cmd[1..]) .current_dir(&handle.work_dir) .stdout(Stdio::piped()) - .stderr(Stdio::piped()); + .stderr(Stdio::piped()) + .kill_on_drop(true); for (key, value) in &env { command.env(key, value); diff --git a/crates/temps-agents/src/sandbox/mod.rs b/crates/temps-agents/src/sandbox/mod.rs index acf0c57eb..75c330f29 100644 --- a/crates/temps-agents/src/sandbox/mod.rs +++ b/crates/temps-agents/src/sandbox/mod.rs @@ -551,6 +551,134 @@ pub trait SandboxProvider: Send + Sync { signal: KillSignal, ) -> Result<(), AgentError>; + /// Strictly fence matching process trees before adopting compute from a + /// previous control-plane generation. + /// + /// Unlike [`SandboxProvider::kill_processes`], this operation is not + /// best-effort. It freezes matching roots, discovers and freezes their + /// descendants, sends SIGTERM, escalates survivors to SIGKILL, and only + /// succeeds after every recorded PID is absent. Provider exec failures, + /// timeouts, and surviving processes are errors so callers can fail + /// closed instead of running a second harness in the same workspace. + async fn fence_process_trees( + &self, + handle: &SandboxHandle, + patterns: &[&str], + ) -> Result<(), AgentError> { + const FENCE_SCRIPT: &str = r#" +set -eu + +roots="" +self_pid=$$ +for pattern in "$@"; do + set +e + matches=$(pgrep -f "$pattern" 2>/dev/null) + match_status=$? + set -e + [ "$match_status" -le 1 ] || exit 71 + for pid in $matches; do + [ "$pid" = "$self_pid" ] && continue + case " $roots " in + *" $pid "*) ;; + *) roots="$roots $pid" ;; + esac + done +done + +[ -n "$roots" ] || exit 0 + +# Freeze roots before walking the tree so a stale harness cannot keep +# spawning children while the fence is being established. +kill -STOP $roots 2>/dev/null || true +targets="$roots" +frontier="$roots" +while [ -n "$frontier" ]; do + next="" + process_table=$(ps -eo pid=,ppid=) + for parent in $frontier; do + for child in $(printf '%s\n' "$process_table" | awk -v parent="$parent" '$2 == parent { print $1 }'); do + case " $targets " in + *" $child "*) ;; + *) + kill -STOP "$child" 2>/dev/null || true + targets="$targets $child" + next="$next $child" + ;; + esac + done + done + frontier="$next" +done + +# SIGTERM is queued while the processes are stopped. SIGCONT lets graceful +# handlers run; processes that ignore TERM are killed after the deadline. +kill -TERM $targets 2>/dev/null || true +kill -CONT $targets 2>/dev/null || true + +is_running() { + state=$(ps -o stat= -p "$1" 2>/dev/null || true) + case "$state" in + ""|Z*) return 1 ;; + *) return 0 ;; + esac +} + +attempt=0 +remaining="$targets" +while [ "$attempt" -lt 30 ]; do + remaining="" + for pid in $targets; do + if is_running "$pid"; then + remaining="$remaining $pid" + fi + done + [ -n "$remaining" ] || exit 0 + attempt=$((attempt + 1)) + sleep 0.1 +done + +kill -KILL $remaining 2>/dev/null || true +sleep 0.1 +for pid in $remaining; do + if is_running "$pid"; then + exit 70 + fi +done +"#; + + let mut command = vec![ + "sh".to_string(), + "-c".to_string(), + FENCE_SCRIPT.to_string(), + "temps-process-fence".to_string(), + ]; + command.extend(patterns.iter().map(|pattern| (*pattern).to_string())); + + let result = tokio::time::timeout( + Duration::from_secs(10), + self.exec(handle, command, HashMap::new(), None), + ) + .await + .map_err(|_| AgentError::SandboxExecFailed { + run_id: 0, + sandbox_id: handle.sandbox_id.clone(), + reason: "verified process fencing timed out".to_string(), + })??; + + if result.exit_code != 0 { + return Err(AgentError::SandboxExecFailed { + run_id: 0, + sandbox_id: handle.sandbox_id.clone(), + reason: format!( + "verified process fencing failed with exit code {}", + result.exit_code + ), + }); + } + + Ok(()) + } + /// Destroy sandbox and clean up its container. /// /// When `purge_volumes` is true, the provider also removes any per-run @@ -816,6 +944,8 @@ pub trait SandboxProvider: Send + Sync { #[cfg(test)] mod tests { use super::*; + use tokio::io::{AsyncBufReadExt, BufReader}; + use tokio::process::Command; #[test] fn kill_signal_term_is_15() { @@ -860,4 +990,94 @@ mod tests { "http://control-plane.test:8080/api/ai/sandbox-models" ); } + + #[tokio::test] + async fn strict_fence_kills_a_term_resistant_process_tree() { + let marker = format!("temps-fence-test-{}", std::process::id()); + let child_marker = format!("{marker}-child"); + let root_marker = format!("{marker}-root"); + let script = format!( + "trap '' TERM; sh -c 'trap \"\" TERM; while :; do sleep 1; done' {child_marker} & echo $!; while :; do sleep 1; done" + ); + let mut root = Command::new("sh") + .arg("-c") + .arg(script) + .arg(&root_marker) + .stdout(std::process::Stdio::piped()) + .kill_on_drop(true) + .spawn() + .expect("spawn TERM-resistant process tree"); + let root_pid = root.id().expect("root process id"); + let child_pid: u32 = BufReader::new(root.stdout.take().expect("child pid pipe")) + .lines() + .next_line() + .await + .expect("read child pid") + .expect("child pid line") + .parse() + .expect("numeric child pid"); + + let probe = Command::new("pgrep") + .args(["-f", &format!("{root_marker}$")]) + .output() + .await + .expect("run process discovery probe"); + if !probe.status.success() { + unsafe { + libc::kill(root_pid as i32, libc::SIGKILL); + libc::kill(child_pid as i32, libc::SIGKILL); + } + let _ = root.wait().await; + eprintln!("skipping strict fence process-tree test: process discovery unavailable"); + return; + } + + let handle = SandboxHandle { + sandbox_id: marker.clone(), + sandbox_name: marker.clone(), + work_dir: std::env::current_dir().expect("current directory"), + backend: SandboxBackend::Local, + image: String::new(), + }; + let provider = local::LocalSandboxProvider::new(); + let fence_result = provider + .fence_process_trees(&handle, &[&format!("{root_marker}$")]) + .await; + + if fence_result.is_err() { + // Test cleanup must not leave an intentionally TERM-resistant + // process behind when an assertion fails. + unsafe { + libc::kill(root_pid as i32, libc::SIGKILL); + libc::kill(child_pid as i32, libc::SIGKILL); + } + } + + let root_wait = tokio::time::timeout(Duration::from_secs(1), root.wait()).await; + if root_wait.is_err() { + unsafe { + libc::kill(root_pid as i32, libc::SIGKILL); + libc::kill(child_pid as i32, libc::SIGKILL); + } + } + let root_status = match root_wait { + Ok(status) => status.expect("wait for root process"), + Err(error) => { + let _ = root.wait().await; + panic!("root process must exit: {error}") + } + }; + fence_result.expect("verified fence must escalate TERM-resistant processes"); + assert!(!root_status.success()); + let child_state = Command::new("ps") + .args(["-o", "stat=", "-p", &child_pid.to_string()]) + .output() + .await + .expect("inspect child state"); + let state = String::from_utf8_lossy(&child_state.stdout); + assert!( + state.trim().is_empty() || state.trim_start().starts_with('Z'), + "child process remained active with state {state:?}" + ); + } } diff --git a/crates/temps-agents/src/services/mod.rs b/crates/temps-agents/src/services/mod.rs index 5784bf351..92ecf896d 100644 --- a/crates/temps-agents/src/services/mod.rs +++ b/crates/temps-agents/src/services/mod.rs @@ -7,6 +7,7 @@ pub mod cron_scheduler; pub mod definition_service; pub mod executor; pub mod prompt_builder; +pub mod provider_credential_service; pub mod run_service; pub mod sandbox_injector; pub mod sandbox_registry; diff --git a/crates/temps-agents/src/services/provider_credential_service.rs b/crates/temps-agents/src/services/provider_credential_service.rs new file mode 100644 index 000000000..20d6ea0a4 --- /dev/null +++ b/crates/temps-agents/src/services/provider_credential_service.rs @@ -0,0 +1,628 @@ +// SPDX-FileCopyrightText: 2024-2026 Temps Contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 + +//! Discovers credentials already used by AI harnesses on the Temps host. +//! +//! Discovery is deliberately limited to provider-owned environment variables +//! and fixed files below the server process user's home/config directories. +//! Callers receive credential bytes only in-process; HTTP responses must expose +//! [`LocalCredentialSummary`] rather than [`DiscoveredLocalCredential`]. + +use std::path::{Path, PathBuf}; +#[cfg(target_os = "macos")] +use std::time::Duration; + +use serde_json::Value; +use thiserror::Error; +use tokio::io::AsyncReadExt; + +use crate::ai_cli::catalog::{CredentialFormat, ProviderCatalogEntry}; + +const MAX_LOCAL_CREDENTIAL_BYTES: u64 = 1024 * 1024; +#[cfg(target_os = "macos")] +const CLAUDE_KEYCHAIN_SERVICE: &str = "Claude Code-credentials"; +#[cfg(target_os = "macos")] +const KEYCHAIN_READ_TIMEOUT: Duration = Duration::from_secs(5); +#[cfg(target_os = "macos")] +const KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE: i32 = 44; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum LocalCredentialSourceKind { + Environment, + HostAuthStore, +} + +impl LocalCredentialSourceKind { + pub fn as_str(self) -> &'static str { + match self { + Self::Environment => "environment", + Self::HostAuthStore => "host_auth_store", + } + } + + pub fn label(self) -> &'static str { + match self { + Self::Environment => "Temps server environment", + Self::HostAuthStore => "Authenticated host CLI", + } + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct LocalCredentialSummary { + pub auth_type: String, + pub source: LocalCredentialSourceKind, +} + +pub struct DiscoveredLocalCredential { + pub auth_type: String, + pub source: LocalCredentialSourceKind, + pub credential: String, +} + +impl DiscoveredLocalCredential { + pub fn summary(&self) -> LocalCredentialSummary { + LocalCredentialSummary { + auth_type: self.auth_type.clone(), + source: self.source, + } + } +} + +#[derive(Debug, Error)] +pub enum LocalCredentialError { + #[error("provider '{provider_id}' is not supported for local credential discovery")] + UnsupportedProvider { provider_id: String }, + #[error("could not inspect the local {provider_id} credential store: {reason}")] + InspectFailed { provider_id: String, reason: String }, + #[error("the local {provider_id} credential store is larger than {max_bytes} bytes")] + CredentialTooLarge { provider_id: String, max_bytes: u64 }, + #[error("the local {provider_id} credential store is not valid JSON: {reason}")] + InvalidCredentialFile { provider_id: String, reason: String }, + #[error("the local {provider_id} credential store does not contain a usable credential")] + CredentialMissing { provider_id: String }, +} + +/// Find an importable local credential without exposing where it lives. +/// +/// Provider order is intentional: explicit process environment wins over a +/// host auth store because it is how the operator configured the Temps +/// service itself. Provider-specific ordering then follows the least +/// surprising locally configured credential for that CLI. +pub async fn discover_local_credential( + provider: &ProviderCatalogEntry, +) -> Result, LocalCredentialError> { + match provider.id { + "claude_cli" => discover_claude_credential(provider).await, + "codex_cli" => discover_codex_credential(provider).await, + "opencode" => discover_opencode_credential(provider).await, + provider_id => Err(LocalCredentialError::UnsupportedProvider { + provider_id: provider_id.to_string(), + }), + } +} + +/// Report whether an importable credential exists without returning the +/// credential to the caller. On macOS this deliberately probes only Keychain +/// item metadata, so rendering the settings page does not repeatedly request +/// access to the secret. +pub async fn discover_local_credential_summary( + provider: &ProviderCatalogEntry, +) -> Result, LocalCredentialError> { + match provider.id { + "claude_cli" => { + if non_empty_env("CLAUDE_CODE_OAUTH_TOKEN").is_some() { + return Ok(Some(LocalCredentialSummary { + auth_type: "subscription".to_string(), + source: LocalCredentialSourceKind::Environment, + })); + } + if credential_from_flavor_environment(provider, "api_key").is_some() { + return Ok(Some(LocalCredentialSummary { + auth_type: "api_key".to_string(), + source: LocalCredentialSourceKind::Environment, + })); + } + #[cfg(target_os = "macos")] + if claude_keychain_item_exists(provider.id).await? { + return Ok(Some(LocalCredentialSummary { + auth_type: "subscription".to_string(), + source: LocalCredentialSourceKind::HostAuthStore, + })); + } + if let Some(path) = claude_credential_path() { + if credential_file_exists(provider.id, &path).await? { + return Ok(Some(LocalCredentialSummary { + auth_type: "subscription".to_string(), + source: LocalCredentialSourceKind::HostAuthStore, + })); + } + } + Ok(None) + } + "codex_cli" => { + if credential_from_flavor_environment(provider, "api_key").is_some() { + return Ok(Some(LocalCredentialSummary { + auth_type: "api_key".to_string(), + source: LocalCredentialSourceKind::Environment, + })); + } + let Some(path) = codex_credential_path() else { + return Ok(None); + }; + credential_file_exists(provider.id, &path) + .await + .map(|exists| { + exists.then(|| LocalCredentialSummary { + auth_type: "subscription".to_string(), + source: LocalCredentialSourceKind::HostAuthStore, + }) + }) + } + "opencode" => { + let Some(path) = opencode_credential_path() else { + return Ok(None); + }; + credential_file_exists(provider.id, &path) + .await + .map(|exists| { + exists.then(|| LocalCredentialSummary { + auth_type: "config_file".to_string(), + source: LocalCredentialSourceKind::HostAuthStore, + }) + }) + } + provider_id => Err(LocalCredentialError::UnsupportedProvider { + provider_id: provider_id.to_string(), + }), + } +} + +async fn discover_claude_credential( + provider: &ProviderCatalogEntry, +) -> Result, LocalCredentialError> { + if let Some(credential) = non_empty_env("CLAUDE_CODE_OAUTH_TOKEN") { + return Ok(Some(DiscoveredLocalCredential { + auth_type: "subscription".to_string(), + source: LocalCredentialSourceKind::Environment, + credential, + })); + } + if let Some(credential) = credential_from_flavor_environment(provider, "api_key") { + return Ok(Some(credential)); + } + + #[cfg(target_os = "macos")] + if let Some(body) = read_claude_keychain(provider.id).await? { + return parse_claude_credential_store(provider.id, &body).map(Some); + } + + if let Some(path) = claude_credential_path() { + if let Some(body) = read_optional_credential_file(provider.id, &path).await? { + return parse_claude_credential_store(provider.id, &body).map(Some); + } + } + + Ok(None) +} + +fn parse_claude_credential_store( + provider_id: &str, + body: &str, +) -> Result { + let value: Value = serde_json::from_str(body).map_err(|error| { + LocalCredentialError::InvalidCredentialFile { + provider_id: provider_id.to_string(), + reason: error.to_string(), + } + })?; + let credential = value + .pointer("/claudeAiOauth/accessToken") + .and_then(Value::as_str) + .map(str::trim) + .filter(|value| !value.is_empty()) + .ok_or_else(|| LocalCredentialError::CredentialMissing { + provider_id: provider_id.to_string(), + })?; + Ok(DiscoveredLocalCredential { + auth_type: "subscription".to_string(), + source: LocalCredentialSourceKind::HostAuthStore, + credential: credential.to_string(), + }) +} + +#[cfg(target_os = "macos")] +async fn read_claude_keychain(provider_id: &str) -> Result, LocalCredentialError> { + let output = run_claude_keychain_lookup(provider_id, true).await?; + + if !output.status.success() { + return keychain_lookup_failure(provider_id, output.status).map(|()| None); + } + if output.stdout.len() as u64 > MAX_LOCAL_CREDENTIAL_BYTES { + return Err(LocalCredentialError::CredentialTooLarge { + provider_id: provider_id.to_string(), + max_bytes: MAX_LOCAL_CREDENTIAL_BYTES, + }); + } + let body = String::from_utf8(output.stdout).map_err(|error| { + LocalCredentialError::InvalidCredentialFile { + provider_id: provider_id.to_string(), + reason: format!("credential data is not UTF-8: {error}"), + } + })?; + if body.trim().is_empty() { + return Err(LocalCredentialError::CredentialMissing { + provider_id: provider_id.to_string(), + }); + } + Ok(Some(body)) +} + +#[cfg(target_os = "macos")] +async fn claude_keychain_item_exists(provider_id: &str) -> Result { + let output = run_claude_keychain_lookup(provider_id, false).await?; + if output.status.success() { + Ok(true) + } else { + keychain_lookup_failure(provider_id, output.status).map(|()| false) + } +} + +#[cfg(target_os = "macos")] +fn keychain_lookup_failure( + provider_id: &str, + status: std::process::ExitStatus, +) -> Result<(), LocalCredentialError> { + if status.code() == Some(KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE) { + Ok(()) + } else { + Err(LocalCredentialError::InspectFailed { + provider_id: provider_id.to_string(), + reason: "macOS did not allow Temps to inspect the Claude Code login".to_string(), + }) + } +} + +#[cfg(target_os = "macos")] +async fn run_claude_keychain_lookup( + provider_id: &str, + reveal_secret: bool, +) -> Result { + let mut command = tokio::process::Command::new("/usr/bin/security"); + command.args(["find-generic-password", "-s", CLAUDE_KEYCHAIN_SERVICE]); + if let Some(account) = non_empty_env("USER") { + command.args(["-a", &account]); + } + if reveal_secret { + command.arg("-w"); + } else { + command.stdout(std::process::Stdio::null()); + } + command.kill_on_drop(true); + command.stdin(std::process::Stdio::null()); + command.stderr(std::process::Stdio::null()); + + tokio::time::timeout(KEYCHAIN_READ_TIMEOUT, command.output()) + .await + .map_err(|_| LocalCredentialError::InspectFailed { + provider_id: provider_id.to_string(), + reason: "the macOS Keychain lookup timed out".to_string(), + })? + .map_err(|error| LocalCredentialError::InspectFailed { + provider_id: provider_id.to_string(), + reason: format!("the macOS Keychain lookup could not start: {error}"), + }) +} + +async fn discover_codex_credential( + provider: &ProviderCatalogEntry, +) -> Result, LocalCredentialError> { + if let Some(credential) = credential_from_flavor_environment(provider, "api_key") { + return Ok(Some(credential)); + } + let Some(path) = codex_credential_path() else { + return Ok(None); + }; + discover_config_file(provider, "subscription", &path).await +} + +async fn discover_opencode_credential( + provider: &ProviderCatalogEntry, +) -> Result, LocalCredentialError> { + let Some(path) = opencode_credential_path() else { + return Ok(None); + }; + discover_config_file(provider, "config_file", &path).await +} + +fn credential_from_flavor_environment( + provider: &ProviderCatalogEntry, + auth_type: &str, +) -> Option { + let flavor = provider.flavor(auth_type)?; + if !matches!(flavor.format, CredentialFormat::ApiKey) { + return None; + } + non_empty_env(flavor.env_var).map(|credential| DiscoveredLocalCredential { + auth_type: auth_type.to_string(), + source: LocalCredentialSourceKind::Environment, + credential, + }) +} + +async fn discover_config_file( + provider: &ProviderCatalogEntry, + auth_type: &str, + path: &Path, +) -> Result, LocalCredentialError> { + let Some(body) = read_optional_credential_file(provider.id, path).await? else { + return Ok(None); + }; + let parsed: Value = serde_json::from_str(&body).map_err(|error| { + LocalCredentialError::InvalidCredentialFile { + provider_id: provider.id.to_string(), + reason: error.to_string(), + } + })?; + if !parsed.is_object() { + return Err(LocalCredentialError::InvalidCredentialFile { + provider_id: provider.id.to_string(), + reason: "expected a JSON object".to_string(), + }); + } + Ok(Some(DiscoveredLocalCredential { + auth_type: auth_type.to_string(), + source: LocalCredentialSourceKind::HostAuthStore, + credential: body, + })) +} + +async fn read_optional_credential_file( + provider_id: &str, + path: &Path, +) -> Result, LocalCredentialError> { + let Some((file, _metadata)) = open_optional_credential_file(provider_id, path).await? else { + return Ok(None); + }; + let mut bytes = Vec::new(); + file.take(MAX_LOCAL_CREDENTIAL_BYTES + 1) + .read_to_end(&mut bytes) + .await + .map_err(|error| LocalCredentialError::InspectFailed { + provider_id: provider_id.to_string(), + reason: error.to_string(), + })?; + if bytes.len() as u64 > MAX_LOCAL_CREDENTIAL_BYTES { + return Err(LocalCredentialError::CredentialTooLarge { + provider_id: provider_id.to_string(), + max_bytes: MAX_LOCAL_CREDENTIAL_BYTES, + }); + } + let body = + String::from_utf8(bytes).map_err(|error| LocalCredentialError::InvalidCredentialFile { + provider_id: provider_id.to_string(), + reason: format!("credential data is not UTF-8: {error}"), + })?; + if body.trim().is_empty() { + return Err(LocalCredentialError::CredentialMissing { + provider_id: provider_id.to_string(), + }); + } + Ok(Some(body)) +} + +async fn open_optional_credential_file( + provider_id: &str, + path: &Path, +) -> Result, LocalCredentialError> { + let mut options = tokio::fs::OpenOptions::new(); + options.read(true); + #[cfg(unix)] + options.custom_flags(libc::O_NOFOLLOW); + + let file = match options.open(path).await { + Ok(file) => file, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None), + Err(error) => { + return Err(LocalCredentialError::InspectFailed { + provider_id: provider_id.to_string(), + reason: error.to_string(), + }) + } + }; + let metadata = file + .metadata() + .await + .map_err(|error| LocalCredentialError::InspectFailed { + provider_id: provider_id.to_string(), + reason: error.to_string(), + })?; + if !metadata.is_file() { + return Err(LocalCredentialError::InspectFailed { + provider_id: provider_id.to_string(), + reason: "the configured credential path is not a regular file".to_string(), + }); + } + if metadata.len() > MAX_LOCAL_CREDENTIAL_BYTES { + return Err(LocalCredentialError::CredentialTooLarge { + provider_id: provider_id.to_string(), + max_bytes: MAX_LOCAL_CREDENTIAL_BYTES, + }); + } + Ok(Some((file, metadata))) +} + +async fn credential_file_exists( + provider_id: &str, + path: &Path, +) -> Result { + Ok(open_optional_credential_file(provider_id, path) + .await? + .is_some_and(|(_, metadata)| metadata.len() > 0)) +} + +fn non_empty_env(name: &str) -> Option { + std::env::var(name) + .ok() + .map(|value| value.trim().to_string()) + .filter(|value| !value.is_empty()) +} + +fn home_dir() -> Option { + std::env::var_os("HOME") + .filter(|value| !value.is_empty()) + .map(PathBuf::from) +} + +fn claude_credential_path() -> Option { + std::env::var_os("CLAUDE_CONFIG_DIR") + .filter(|value| !value.is_empty()) + .map(PathBuf::from) + .or_else(|| home_dir().map(|home| home.join(".claude"))) + .map(|directory| directory.join(".credentials.json")) +} + +fn codex_credential_path() -> Option { + std::env::var_os("CODEX_HOME") + .filter(|value| !value.is_empty()) + .map(PathBuf::from) + .or_else(|| home_dir().map(|home| home.join(".codex"))) + .map(|directory| directory.join("auth.json")) +} + +fn opencode_credential_path() -> Option { + std::env::var_os("XDG_DATA_HOME") + .filter(|value| !value.is_empty()) + .map(PathBuf::from) + .or_else(|| home_dir().map(|home| home.join(".local/share"))) + .map(|directory| directory.join("opencode/auth.json")) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn provider(id: &str) -> &'static ProviderCatalogEntry { + crate::ai_cli::catalog::find_provider(id).expect("provider in catalog") + } + + #[tokio::test] + async fn config_file_discovery_rejects_non_json_without_leaking_body() { + let directory = tempfile::tempdir().expect("temporary credential directory"); + let path = directory.path().join("auth.json"); + tokio::fs::write(&path, "not-json-secret") + .await + .expect("write credential fixture"); + + let error = discover_config_file(provider("codex_cli"), "subscription", &path) + .await + .err() + .expect("invalid credential file"); + let message = error.to_string(); + assert!(message.contains("not valid JSON")); + assert!(!message.contains("not-json-secret")); + } + + #[test] + fn claude_store_extracts_only_the_access_token() { + let discovered = parse_claude_credential_store( + "claude_cli", + r#"{"claudeAiOauth":{"accessToken":"oauth-secret","refreshToken":"refresh-secret"}}"#, + ) + .expect("valid Claude credential store"); + + assert_eq!(discovered.auth_type, "subscription"); + assert_eq!(discovered.credential, "oauth-secret"); + assert!(!discovered.credential.contains("refresh-secret")); + } + + #[test] + fn claude_store_errors_do_not_include_the_secret_body() { + let error = parse_claude_credential_store("claude_cli", "not-json-secret") + .err() + .expect("invalid Claude credential store"); + + assert!(!error.to_string().contains("not-json-secret")); + } + + #[tokio::test] + async fn config_file_discovery_returns_secret_only_in_process() { + let directory = tempfile::tempdir().expect("temporary credential directory"); + let path = directory.path().join("auth.json"); + tokio::fs::write(&path, r#"{"tokens":{"access_token":"test-secret"}}"#) + .await + .expect("write credential fixture"); + + let discovered = discover_config_file(provider("codex_cli"), "subscription", &path) + .await + .expect("valid credential store") + .expect("credential discovered"); + assert_eq!(discovered.auth_type, "subscription"); + assert_eq!(discovered.source, LocalCredentialSourceKind::HostAuthStore); + assert!(discovered.credential.contains("test-secret")); + assert_eq!( + discovered.summary().source.label(), + "Authenticated host CLI" + ); + } + + #[tokio::test] + async fn missing_config_file_is_not_an_error() { + let directory = tempfile::tempdir().expect("temporary credential directory"); + let missing = directory.path().join("missing.json"); + assert!( + discover_config_file(provider("opencode"), "config_file", &missing) + .await + .expect("missing files are ordinary discovery misses") + .is_none() + ); + } + + #[tokio::test] + async fn oversized_config_file_is_rejected_before_reading() { + let directory = tempfile::tempdir().expect("temporary credential directory"); + let path = directory.path().join("auth.json"); + let file = std::fs::File::create(&path).expect("create credential fixture"); + file.set_len(MAX_LOCAL_CREDENTIAL_BYTES + 1) + .expect("grow credential fixture"); + + assert!(matches!( + discover_config_file(provider("opencode"), "config_file", &path).await, + Err(LocalCredentialError::CredentialTooLarge { .. }) + )); + } + + #[cfg(unix)] + #[tokio::test] + async fn credential_discovery_rejects_symbolic_links() { + let directory = tempfile::tempdir().expect("temporary credential directory"); + let target = directory.path().join("real-auth.json"); + let link = directory.path().join("auth.json"); + tokio::fs::write(&target, r#"{"token":"secret"}"#) + .await + .expect("write credential fixture"); + std::os::unix::fs::symlink(&target, &link).expect("create credential symlink"); + + assert!(matches!( + discover_config_file(provider("opencode"), "config_file", &link).await, + Err(LocalCredentialError::InspectFailed { .. }) + )); + } + + #[tokio::test] + async fn summary_probe_checks_file_metadata_without_parsing_secrets() { + let directory = tempfile::tempdir().expect("temporary credential directory"); + let path = directory.path().join("auth.json"); + tokio::fs::write(&path, "not-json-secret") + .await + .expect("write credential fixture"); + + assert!(credential_file_exists("codex_cli", &path) + .await + .expect("metadata probe")); + assert!(matches!( + discover_config_file(provider("codex_cli"), "subscription", &path).await, + Err(LocalCredentialError::InvalidCredentialFile { .. }) + )); + } +} diff --git a/crates/temps-ai-agent-cli/Cargo.toml b/crates/temps-ai-agent-cli/Cargo.toml index f5e754434..f1504af94 100644 --- a/crates/temps-ai-agent-cli/Cargo.toml +++ b/crates/temps-ai-agent-cli/Cargo.toml @@ -27,6 +27,7 @@ subtle = "2.6" reqwest = { workspace = true } thiserror = { workspace = true } bytes = { workspace = true } +chrono = { workspace = true } [dev-dependencies] serde_json = { workspace = true } diff --git a/crates/temps-ai-agent-cli/src/dispatch.rs b/crates/temps-ai-agent-cli/src/dispatch.rs index 466876559..e522e0334 100644 --- a/crates/temps-ai-agent-cli/src/dispatch.rs +++ b/crates/temps-ai-agent-cli/src/dispatch.rs @@ -181,6 +181,51 @@ impl AiService for AiProviderRegistry { service.capabilities_for(provider, refresh).await } + async fn capabilities_snapshot_for_principal( + &self, + provider: Option<&str>, + principal_id: i32, + refresh: RefreshPolicy, + ) -> Result { + let service = self + .routed(provider) + .await + .ok_or_else(|| AiError::Provider { + purpose: "provider.capabilities".to_string(), + reason: format!( + "pinned provider '{}' is unavailable", + provider.unwrap_or("unknown") + ), + })?; + service + .capabilities_snapshot_for_principal(provider, principal_id, refresh) + .await + } + + async fn capabilities_snapshot_for( + &self, + provider: Option<&str>, + refresh: RefreshPolicy, + ) -> Result { + let service = self + .routed(provider) + .await + .ok_or_else(|| AiError::Provider { + purpose: "provider.capabilities".to_string(), + reason: format!( + "pinned provider '{}' is unavailable", + provider.unwrap_or("unknown") + ), + })?; + service.capabilities_snapshot_for(provider, refresh).await + } + + async fn invalidate_capabilities_for(&self, provider: Option<&str>) { + if let Some(service) = self.routed(provider).await { + service.invalidate_capabilities_for(provider).await; + } + } + async fn complete(&self, mut request: AiRequest) -> Result { self.apply_summary_defaults(&mut request).await?; let service = self diff --git a/crates/temps-ai-agent-cli/src/lib.rs b/crates/temps-ai-agent-cli/src/lib.rs index c01181f6f..45ea102b1 100644 --- a/crates/temps-ai-agent-cli/src/lib.rs +++ b/crates/temps-ai-agent-cli/src/lib.rs @@ -26,4 +26,8 @@ pub use dispatch::{ pub use model_relay::{ sandbox_model_relay_routes, SandboxHarnessCredentials, SandboxModelRelayService, }; -pub use service::{AgentCliAiService, SandboxCredentialResolver, ScopedMcpBridge}; +pub use service::{ + AgentCliAiService, ResolvedSandboxWorkspace, SandboxCredentialResolver, + SandboxWorkspaceResolver, SandboxWorkspaceResolverSlot, SandboxWorkspaceStopper, + ScopedMcpBridge, +}; diff --git a/crates/temps-ai-agent-cli/src/service.rs b/crates/temps-ai-agent-cli/src/service.rs index bc88ea6e7..6aed54eb4 100644 --- a/crates/temps-ai-agent-cli/src/service.rs +++ b/crates/temps-ai-agent-cli/src/service.rs @@ -6,7 +6,7 @@ use std::collections::HashMap; use std::path::{Path, PathBuf}; -use std::sync::{Arc, Mutex}; +use std::sync::{Arc, Mutex, OnceLock}; use std::time::{Duration, Instant}; use async_trait::async_trait; @@ -15,9 +15,10 @@ use futures::future::BoxFuture; use tokio::sync::Semaphore; use temps_agents::ai_cli::{ - cached_model_capabilities, discover_model_capabilities_cached, extract_session_metadata, - get_status_cached, provider_capabilities_from_models, scrub_and_bound, scrub_secrets, - AiCliProvider, AiRunConfig, OnEventCallback, PermissionBridge, ProviderSessionMetadata, + cached_model_capabilities, cached_status, discover_model_capabilities_cached, + extract_session_metadata, get_status_cached, provider_capabilities_from_models, + scrub_and_bound, scrub_secrets, AiCliProvider, AiRunConfig, OnEventCallback, PermissionBridge, + ProviderSessionMetadata, }; use temps_agents::error::AgentError; use temps_agents::sandbox::{SandboxCreateConfig, SandboxProvider}; @@ -62,6 +63,39 @@ fn build_bridge_router(path: &str, state: McpBridgeState) -> axum::Router { } const PROVIDER_STATUS_TIMEOUT: Duration = Duration::from_secs(5); +const WORKSPACE_MODEL_CACHE_TTL: Duration = Duration::from_secs(5 * 60); +const WORKSPACE_MODEL_REFRESH_COOLDOWN: Duration = Duration::from_secs(15); +const WORKSPACE_MODEL_DISCOVERY_TIMEOUT: Duration = Duration::from_secs(20); +const WORKSPACE_MODEL_REFRESH_TIMEOUT: Duration = Duration::from_secs(2 * 60); + +#[derive(Clone)] +struct WorkspaceModelSnapshot { + capabilities: temps_ai::ProviderCapabilities, + refreshed_at: chrono::DateTime, + expires_at: Instant, +} + +#[derive(Default)] +struct WorkspaceModelState { + snapshot: Option, + last_completed_at: Option, +} + +#[derive(Default)] +struct HostModelRefreshState { + last_completed_at: Option, +} + +fn should_reuse_completed_refresh( + last_completed_at: Option, + requested_at: Instant, + now: Instant, +) -> bool { + last_completed_at.is_some_and(|completed| { + completed >= requested_at + || now.saturating_duration_since(completed) < WORKSPACE_MODEL_REFRESH_COOLDOWN + }) +} type NativeToolCalls = Arc>>; @@ -609,6 +643,11 @@ pub struct AgentCliAiService { /// Host-side provider relay. The sandbox receives only its short-lived /// capability; real provider credentials never cross the boundary. sandbox_model_relay: Option>, + /// Resolves and wakes the authenticated principal's durable global + /// workspace. Model discovery must use the same sandbox users see and use + /// for chat; a hidden disposable sandbox can consume quota while leaving + /// the real workspace unavailable. + sandbox_workspace_resolver: Option, /// Handles recovered by this runtime. Recovering a Docker sandbox also /// performs recursive ownership repair for legacy/root-owned workspaces; /// repeating that on every chat message can walk a large node_modules tree @@ -622,6 +661,67 @@ pub struct AgentCliAiService { /// service's configurable turn deadline, so they must not inherit the /// short host-CLI completion timeout used for gateway-adjacent jobs. sandbox_timeout: Option, + /// Account-aware model inventories discovered through the same saved + /// credential relay used by persistent workspace turns. Entries are keyed + /// by principal so a future principal-specific credential resolver cannot + /// accidentally reuse another principal's authoritative catalog. This + /// cache is intentionally separate from ambient host-CLI discovery. + workspace_models: Arc>>, + /// Principal-scoped single-flight gates kept separate from + /// `workspace_models` so one slow workspace never blocks another user's + /// model refresh. + workspace_model_refreshes: Arc>>>>, + /// Credential replacement takes the write side; discoveries hold the read + /// side. This keeps invalidation a hard freshness boundary while allowing + /// different principals to refresh concurrently. + workspace_model_refresh_barrier: Arc>, + /// Serializes explicit host-CLI model refreshes and applies the same + /// cooldown as workspace discovery. Status/model caches alone do not stop + /// queued force-refresh callers from spawning the CLI one after another. + host_model_refresh: Arc>, +} + +pub type SandboxWorkspaceResolver = + Arc BoxFuture<'static, Result> + Send + Sync>; +pub type SandboxWorkspaceStopper = + Arc BoxFuture<'static, Result<(), AiError>> + Send + Sync>; + +#[derive(Clone)] +pub struct ResolvedSandboxWorkspace { + pub workspace: temps_ai::HarnessWorkspace, + pub handle: temps_agents::sandbox::SandboxHandle, + pub stop: SandboxWorkspaceStopper, +} + +/// Late-bound seam between the provider registry and AI chat's durable +/// workspace services. The gateway constructs provider services before the +/// chat plugin registers its workspace service, so every service holds this +/// shared slot and the chat plugin fills it exactly once during registration. +#[derive(Clone, Default)] +pub struct SandboxWorkspaceResolverSlot { + resolver: Arc>, +} + +impl SandboxWorkspaceResolverSlot { + pub fn new() -> Self { + Self::default() + } + + pub fn set(&self, resolver: SandboxWorkspaceResolver) -> bool { + self.resolver.set(resolver).is_ok() + } + + pub fn is_configured(&self) -> bool { + self.resolver.get().is_some() + } + + async fn resolve(&self, principal_id: i32) -> Result { + let resolver = self.resolver.get().ok_or_else(|| AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: "the persistent global workspace service is not configured".to_string(), + })?; + resolver(principal_id).await + } } /// If a server-owned turn is aborted while Docker exec is still active, stop @@ -637,6 +737,7 @@ struct StopSandboxOnDrop { sandbox_slot: Arc, global_permit: Option, sandbox_permit: Option, + managed_stop: Option, } impl StopSandboxOnDrop { @@ -654,17 +755,23 @@ impl StopSandboxOnDrop { .lock() .unwrap_or_else(std::sync::PoisonError::into_inner) .remove(&self.sandbox_label); - match self.provider.stop(&self.handle).await { - Ok(()) => {} - Err(error) => { - self.sandbox_slot.close(); - tracing::error!( - sandbox_label = self.sandbox_label, - sandbox_id = %self.handle.sandbox_id, - %error, - "failed to stop a timed-out application harness sandbox; quarantined it from future turns" - ); - } + let stop_error = if let Some(stop) = &self.managed_stop { + stop().await.err().map(|error| error.to_string()) + } else { + self.provider + .stop(&self.handle) + .await + .err() + .map(|error| error.to_string()) + }; + if let Some(error) = stop_error { + self.sandbox_slot.close(); + tracing::error!( + sandbox_label = self.sandbox_label, + sandbox_id = %self.handle.sandbox_id, + %error, + "failed to stop a timed-out application harness sandbox; quarantined it from future turns" + ); } self.armed = false; self.global_permit.take(); @@ -687,9 +794,19 @@ impl Drop for StopSandboxOnDrop { let sandbox_slot = self.sandbox_slot.clone(); let global_permit = self.global_permit.take(); let sandbox_permit = self.sandbox_permit.take(); + let managed_stop = self.managed_stop.clone(); if let Ok(runtime) = tokio::runtime::Handle::try_current() { runtime.spawn(async move { - if let Err(error) = provider.stop(&handle).await { + let stop_error = if let Some(stop) = managed_stop { + stop().await.err().map(|error| error.to_string()) + } else { + provider + .stop(&handle) + .await + .err() + .map(|error| error.to_string()) + }; + if let Some(error) = stop_error { sandbox_slot.close(); tracing::error!( sandbox_label, @@ -711,6 +828,21 @@ impl Drop for StopSandboxOnDrop { } } +fn workspace_model_discovery_command() -> Vec { + vec![ + "sh".to_string(), + "-lc".to_string(), + concat!( + "printf '%s\\n' '", + "{\"request_id\":\"temps-models\",\"type\":\"control_request\",", + "\"request\":{\"subtype\":\"initialize\"}}", + "' | claude --print --output-format stream-json --verbose ", + "--input-format stream-json --tools '' --setting-sources=" + ) + .to_string(), + ] +} + impl AgentCliAiService { /// Create a new service. /// @@ -743,9 +875,14 @@ impl AgentCliAiService { sandbox_workspace_root: None, sandbox_credentials: None, sandbox_model_relay: None, + sandbox_workspace_resolver: None, sandbox_handles: Arc::new(Mutex::new(HashMap::new())), sandbox_slots: Arc::new(Mutex::new(HashMap::new())), sandbox_timeout: None, + workspace_models: Arc::new(tokio::sync::Mutex::new(HashMap::new())), + workspace_model_refreshes: Arc::new(tokio::sync::Mutex::new(HashMap::new())), + workspace_model_refresh_barrier: Arc::new(tokio::sync::RwLock::new(())), + host_model_refresh: Arc::new(tokio::sync::Mutex::new(HostModelRefreshState::default())), } } @@ -758,11 +895,13 @@ impl AgentCliAiService { sandbox_workspace_root: PathBuf, sandbox_credentials: SandboxCredentialResolver, sandbox_model_relay: Arc, + sandbox_workspace_resolver: SandboxWorkspaceResolverSlot, ) -> Self { self.sandbox_provider = Some(sandbox_provider); self.sandbox_workspace_root = Some(sandbox_workspace_root); self.sandbox_credentials = Some(sandbox_credentials); self.sandbox_model_relay = Some(sandbox_model_relay); + self.sandbox_workspace_resolver = Some(sandbox_workspace_resolver); self.sandbox_timeout = Some(Duration::from_secs(15 * 60)); self } @@ -918,6 +1057,363 @@ impl AgentCliAiService { Ok(handle) } + fn workspace_capabilities_from_models( + &self, + models: Vec, + ) -> Result { + let mut capabilities = provider_capabilities_from_models(self.provider.name(), models) + .ok_or_else(|| AiError::Provider { + purpose: "provider.capabilities".to_string(), + reason: format!( + "provider '{}' has no registered capability contract", + self.provider.name() + ), + })?; + capabilities.auth_source = temps_ai::ProviderAuthSource::ConfiguredKey; + Ok(capabilities) + } + + fn bootstrap_workspace_capabilities( + &self, + ) -> Result { + Ok(temps_ai::ProviderCapabilitiesSnapshot { + capabilities: self.workspace_capabilities_from_models(Vec::new())?, + model_source: temps_ai::ModelCatalogSource::Bootstrap, + models_refreshed_at: None, + }) + } + + async fn cached_workspace_capabilities( + &self, + principal_id: i32, + ) -> Result { + let states = self.workspace_models.lock().await; + let Some(snapshot) = states + .get(&principal_id) + .and_then(|state| state.snapshot.as_ref()) + else { + drop(states); + return self.bootstrap_workspace_capabilities(); + }; + Ok(Self::workspace_cached_snapshot(snapshot)) + } + + fn workspace_cached_snapshot( + snapshot: &WorkspaceModelSnapshot, + ) -> temps_ai::ProviderCapabilitiesSnapshot { + temps_ai::ProviderCapabilitiesSnapshot { + capabilities: snapshot.capabilities.clone(), + model_source: if snapshot.expires_at > Instant::now() { + temps_ai::ModelCatalogSource::Cache + } else { + temps_ai::ModelCatalogSource::StaleCache + }, + models_refreshed_at: Some(snapshot.refreshed_at.to_rfc3339()), + } + } + + async fn discover_workspace_capabilities( + &self, + principal_id: i32, + ) -> Result { + if self.provider.name() != "claude_cli" { + return Err(AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: format!( + "workspace model discovery is not implemented for '{}'", + self.provider.name() + ), + }); + } + + // The principal gate provides a real single-flight without making an + // unrelated user's slow sandbox block this refresh. The read barrier + // prevents a credential replacement from racing the probe. + let requested_at = Instant::now(); + let _credential_guard = self.workspace_model_refresh_barrier.read().await; + let refresh_slot = { + let mut refreshes = self.workspace_model_refreshes.lock().await; + refreshes + .entry(principal_id) + .or_insert_with(|| Arc::new(tokio::sync::Mutex::new(()))) + .clone() + }; + let _refresh_guard = refresh_slot.lock().await; + let states = self.workspace_models.lock().await; + if let Some(state) = states.get(&principal_id) { + if should_reuse_completed_refresh(state.last_completed_at, requested_at, Instant::now()) + { + if let Some(snapshot) = state.snapshot.as_ref() { + return Ok(Self::workspace_cached_snapshot(snapshot)); + } + return Err(AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: "workspace model discovery was attempted recently; wait a few seconds before retrying" + .to_string(), + }); + } + } + drop(states); + + let result = tokio::time::timeout( + WORKSPACE_MODEL_REFRESH_TIMEOUT, + self.run_workspace_model_discovery(principal_id), + ) + .await + .unwrap_or_else(|_| { + Err(AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: "starting the workspace and resolving models timed out".to_string(), + }) + }); + let mut states = self.workspace_models.lock().await; + let state = states.entry(principal_id).or_default(); + state.last_completed_at = Some(Instant::now()); + match result { + Ok(capabilities) => { + let refreshed_at = chrono::Utc::now(); + state.snapshot = Some(WorkspaceModelSnapshot { + capabilities: capabilities.clone(), + refreshed_at, + expires_at: Instant::now() + WORKSPACE_MODEL_CACHE_TTL, + }); + Ok(temps_ai::ProviderCapabilitiesSnapshot { + capabilities, + model_source: temps_ai::ModelCatalogSource::Live, + models_refreshed_at: Some(refreshed_at.to_rfc3339()), + }) + } + Err(error) => { + if let Some(snapshot) = state.snapshot.as_ref() { + Ok(temps_ai::ProviderCapabilitiesSnapshot { + capabilities: snapshot.capabilities.clone(), + model_source: temps_ai::ModelCatalogSource::StaleCache, + models_refreshed_at: Some(snapshot.refreshed_at.to_rfc3339()), + }) + } else { + Err(error) + } + } + } + } + + async fn run_workspace_model_discovery( + &self, + principal_id: i32, + ) -> Result { + let sandbox_provider = self + .sandbox_provider + .as_ref() + .ok_or_else(|| AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: "Temps sandbox execution is not configured for workspace model discovery" + .to_string(), + })?; + let resolved = self + .sandbox_workspace_resolver + .as_ref() + .ok_or_else(|| AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: "the persistent global workspace resolver is not configured".to_string(), + })? + .resolve(principal_id) + .await?; + let workspace = resolved.workspace; + self.validate_sandbox_workspace(&workspace)?; + let sandbox_slot = self.sandbox_slot(&workspace.sandbox_label); + let sandbox_permit = sandbox_slot + .clone() + .try_acquire_owned() + .map_err(|_| AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: "the persistent global workspace is busy with another harness operation; retry after it finishes" + .to_string(), + })?; + let handle = resolved.handle; + let managed_stop = resolved.stop; + self.cache_sandbox_handle(workspace.sandbox_label.clone(), handle.clone()); + + async { + let credentials = self + .sandbox_credentials + .as_ref() + .ok_or_else(|| AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: "workspace credentials are not configured".to_string(), + })?(self.provider.name()) + .await?; + let relay_service = self + .sandbox_model_relay + .as_ref() + .ok_or_else(|| AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: "workspace model relay is not configured".to_string(), + })?; + let relay_base_url = sandbox_provider + .model_relay_base_url(&handle, &credentials.internal_api_url) + .await + .map_err(|error| map_agent_error("provider.capabilities.workspace", error))?; + let (relay, _relay_guard) = relay_service.register( + self.provider.name(), + principal_id, + None, + credentials, + &relay_base_url, + WORKSPACE_MODEL_DISCOVERY_TIMEOUT + Duration::from_secs(5), + )?; + let mut environment = HashMap::new(); + configure_sandbox_model_relay(self.provider.name(), &mut environment, &relay)?; + let command = workspace_model_discovery_command(); + let mut stop_on_drop = StopSandboxOnDrop { + armed: true, + provider: sandbox_provider.clone(), + handle: handle.clone(), + handles: self.sandbox_handles.clone(), + sandbox_label: workspace.sandbox_label.clone(), + sandbox_slot, + global_permit: None, + sandbox_permit: Some(sandbox_permit), + managed_stop: Some(managed_stop), + }; + let execution = match tokio::time::timeout( + WORKSPACE_MODEL_DISCOVERY_TIMEOUT, + sandbox_provider.exec(&handle, command, environment, None), + ) + .await + { + Ok(Ok(execution)) => { + stop_on_drop.disarm(); + execution + } + Ok(Err(error)) => { + let error = map_agent_error("provider.capabilities.workspace", error); + stop_on_drop.stop_now().await; + return Err(error); + } + Err(_) => { + stop_on_drop.stop_now().await; + return Err(AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: "workspace model discovery timed out".to_string(), + }); + } + }; + if execution.exit_code != 0 { + return Err(AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: format!( + "the {} CLI could not report models (exit code {})", + self.provider.name(), + execution.exit_code + ), + }); + } + let models = temps_agents::ai_cli::claude::parse_model_capabilities_from_initialize_output( + &execution.stdout, + ); + if models.is_empty() { + return Err(AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: "Claude Code returned no selectable models for the saved workspace credential" + .to_string(), + }); + } + self.workspace_capabilities_from_models(models) + } + .await + } + + async fn cached_host_capabilities_snapshot( + &self, + ) -> Result { + self.host_capabilities_snapshot_inner(false).await + } + + async fn host_capabilities_snapshot( + &self, + refresh: temps_ai::RefreshPolicy, + ) -> Result { + if refresh == temps_ai::RefreshPolicy::Cached { + return self.cached_host_capabilities_snapshot().await; + } + + // Keep the guard for the complete status + model probe. A caller that + // queued behind a live refresh sees the populated cache instead of + // launching the provider CLI again. + let requested_at = Instant::now(); + let mut refresh_state = self.host_model_refresh.lock().await; + if should_reuse_completed_refresh( + refresh_state.last_completed_at, + requested_at, + Instant::now(), + ) { + return self.cached_host_capabilities_snapshot().await; + } + let result = self.host_capabilities_snapshot_inner(true).await; + refresh_state.last_completed_at = Some(Instant::now()); + result + } + + async fn host_capabilities_snapshot_inner( + &self, + refresh_live: bool, + ) -> Result { + let status = if refresh_live { + get_status_cached(self.provider.as_ref(), true, PROVIDER_STATUS_TIMEOUT).await + } else { + cached_status(self.provider.name()).await + }; + let Some(status) = status else { + return Ok(temps_ai::ProviderCapabilitiesSnapshot { + capabilities: provider_capabilities_from_models(self.provider.name(), Vec::new()) + .ok_or_else(|| AiError::Provider { + purpose: "provider.capabilities".to_string(), + reason: format!( + "provider '{}' has no registered capability contract", + self.provider.name() + ), + })?, + model_source: temps_ai::ModelCatalogSource::Bootstrap, + models_refreshed_at: None, + }); + }; + if !status.installed || !status.authenticated { + return Err(AiError::NotAvailable); + } + let identity = format!( + "{}|{}|{}|{}", + status.version.as_deref().unwrap_or("unknown"), + status.auth_method.as_deref().unwrap_or("unknown"), + status.email.as_deref().unwrap_or("unknown"), + status.subscription_type.as_deref().unwrap_or("unknown") + ); + let snapshot = if refresh_live { + Some(discover_model_capabilities_cached(self.provider.as_ref(), identity, true).await) + } else { + cached_model_capabilities(self.provider.name(), &identity).await + }; + let (models, model_source, refreshed_at) = match snapshot { + Some(snapshot) if !snapshot.models.is_empty() => ( + snapshot.models, + snapshot.source, + Some(snapshot.refreshed_at.to_rfc3339()), + ), + _ => (Vec::new(), temps_ai::ModelCatalogSource::Bootstrap, None), + }; + Ok(temps_ai::ProviderCapabilitiesSnapshot { + capabilities: provider_capabilities_from_models(self.provider.name(), models) + .ok_or_else(|| AiError::Provider { + purpose: "provider.capabilities".to_string(), + reason: format!( + "provider '{}' has no registered capability contract", + self.provider.name() + ), + })?, + model_source, + models_refreshed_at: refreshed_at, + }) + } + async fn sandbox_chat_stream_turn( &self, request: ChatTurnRequest, @@ -1192,6 +1688,7 @@ impl AgentCliAiService { sandbox_slot, global_permit: Some(permit), sandbox_permit: Some(sandbox_permit), + managed_stop: None, }; tracing::info!( component = "ai_turn_timing", @@ -1780,55 +2277,54 @@ impl AiService for AgentCliAiService { _provider: Option<&str>, refresh: temps_ai::RefreshPolicy, ) -> Result { - let refresh_live = refresh == temps_ai::RefreshPolicy::Refresh; - let status = get_status_cached( - self.provider.as_ref(), - refresh_live, - PROVIDER_STATUS_TIMEOUT, - ) - .await; - let host_ready = status - .as_ref() - .is_some_and(|status| status.installed && status.authenticated); - if !host_ready - && (self.provider.name() != "claude_cli" - || self.sandbox_provider.is_none() + self.host_capabilities_snapshot(refresh) + .await + .map(|snapshot| snapshot.capabilities) + } + + async fn capabilities_snapshot_for( + &self, + _provider: Option<&str>, + refresh: temps_ai::RefreshPolicy, + ) -> Result { + self.host_capabilities_snapshot(refresh).await + } + + async fn capabilities_snapshot_for_principal( + &self, + _provider: Option<&str>, + principal_id: i32, + refresh: temps_ai::RefreshPolicy, + ) -> Result { + if self.provider.name() == "claude_cli" { + if refresh == temps_ai::RefreshPolicy::Cached { + return self.cached_workspace_capabilities(principal_id).await; + } + if self.sandbox_provider.is_none() || self.sandbox_credentials.is_none() - || self.sandbox_model_relay.is_none()) - { - return Err(AiError::NotAvailable); - } - let identity = status - .as_ref() - .map(|status| { - format!( - "{}|{}|{}|{}", - status.version.as_deref().unwrap_or("unknown"), - status.auth_method.as_deref().unwrap_or("unknown"), - status.email.as_deref().unwrap_or("unknown"), - status.subscription_type.as_deref().unwrap_or("unknown") - ) - }) - .unwrap_or_else(|| "unknown|unknown|unknown|unknown".to_string()); - let models = if refresh_live { - discover_model_capabilities_cached(self.provider.as_ref(), identity, true) - .await - .models - } else { - cached_model_capabilities(self.provider.name(), &identity) - .await - .map(|snapshot| snapshot.models) - .unwrap_or_default() - }; - provider_capabilities_from_models(self.provider.name(), models).ok_or_else(|| { - AiError::Provider { - purpose: "provider.capabilities".to_string(), - reason: format!( - "provider '{}' has no registered capability contract", - self.provider.name() - ), + || self.sandbox_model_relay.is_none() + || self + .sandbox_workspace_resolver + .as_ref() + .is_none_or(|resolver| !resolver.is_configured()) + { + return Err(AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: "secure workspace model discovery is unavailable because the persistent sandbox workspace is not configured" + .to_string(), + }); } - }) + return self.discover_workspace_capabilities(principal_id).await; + } + self.host_capabilities_snapshot(refresh).await + } + + async fn invalidate_capabilities_for(&self, _provider: Option<&str>) { + // Credential replacement is a hard freshness boundary. Wait for an + // old-credential discovery already in flight, then clear anything it + // published before allowing the save request to return. + let _refresh_guard = self.workspace_model_refresh_barrier.write().await; + self.workspace_models.lock().await.clear(); } /// CLI chat exposes scoped tools through a per-turn loopback MCP bridge. @@ -2265,6 +2761,359 @@ mod tests { use temps_ai::streaming::ChatTool; use temps_ai::AiRequest; + #[test] + fn workspace_model_discovery_matches_the_runtime_metadata_probe() { + let command = workspace_model_discovery_command(); + let script = command.get(2).expect("shell discovery script"); + + assert!(script.contains("claude --print")); + assert!(script.contains("--tools ''")); + assert!(script.contains("--setting-sources=")); + assert!(script.contains("\"subtype\":\"initialize\"")); + } + + #[tokio::test] + async fn workspace_resolver_is_late_bound_and_principal_scoped() { + let slot = SandboxWorkspaceResolverSlot::new(); + assert!(!slot.is_configured()); + let resolved_principal = Arc::new(AtomicUsize::new(0)); + let observed_principal = resolved_principal.clone(); + assert!(slot.set(Arc::new(move |principal_id| { + let observed_principal = observed_principal.clone(); + Box::pin(async move { + observed_principal.store(principal_id as usize, Ordering::SeqCst); + Ok(ResolvedSandboxWorkspace { + workspace: temps_ai::HarnessWorkspace { + sandbox_label: format!("workspace-{principal_id}"), + host_work_dir: PathBuf::from(format!( + "/managed/global-user-{principal_id}" + )), + }, + handle: temps_agents::sandbox::SandboxHandle { + sandbox_id: format!("sandbox-{principal_id}"), + sandbox_name: format!("workspace-{principal_id}"), + work_dir: PathBuf::from("/home/temps/workspace"), + backend: temps_agents::sandbox::SandboxBackend::Docker, + image: "test-image".to_string(), + }, + stop: Arc::new(|| Box::pin(async { Ok(()) })), + }) + }) + }))); + + let resolved = slot.resolve(42).await.expect("persistent workspace"); + + assert_eq!(resolved_principal.load(Ordering::SeqCst), 42); + assert_eq!(resolved.workspace.sandbox_label, "workspace-42"); + assert_eq!( + resolved.workspace.host_work_dir, + PathBuf::from("/managed/global-user-42") + ); + assert!(!slot.set(Arc::new(|_| Box::pin(async { Err(AiError::NotAvailable) })))); + } + + fn test_sandbox_handle() -> temps_agents::sandbox::SandboxHandle { + temps_agents::sandbox::SandboxHandle { + sandbox_id: "sandbox-model-discovery".to_string(), + sandbox_name: "workspace-model-discovery".to_string(), + work_dir: PathBuf::from("/tmp/workspace-model-discovery"), + backend: temps_agents::sandbox::SandboxBackend::Local, + image: "test-image".to_string(), + } + } + + struct RecordingModelDiscoverySandbox { + exec_calls: Arc, + lifecycle_calls: Arc, + } + + #[async_trait::async_trait] + impl SandboxProvider for RecordingModelDiscoverySandbox { + async fn create( + &self, + _config: SandboxCreateConfig, + ) -> Result { + self.lifecycle_calls.fetch_add(1, Ordering::SeqCst); + Err(AgentError::SandboxExecFailed { + run_id: 0, + sandbox_id: "unexpected-create".to_string(), + reason: "model discovery must adopt the managed handle".to_string(), + }) + } + + async fn exec( + &self, + _handle: &temps_agents::sandbox::SandboxHandle, + command: Vec, + environment: HashMap, + _on_output: Option, + ) -> Result { + self.exec_calls.fetch_add(1, Ordering::SeqCst); + assert_eq!(command.first().map(String::as_str), Some("sh")); + assert!(environment.contains_key("ANTHROPIC_BASE_URL")); + assert!(environment.contains_key("ANTHROPIC_AUTH_TOKEN")); + let response = serde_json::json!({ + "type": "control_response", + "response": { + "request_id": "temps-models", + "response": { + "models": [{ + "value": "sonnet", + "resolvedModel": "claude-sonnet-current", + "displayName": "Sonnet", + "description": "Account-aware Sonnet", + "supportedEffortLevels": ["low", "medium", "high"] + }] + } + } + }); + Ok(temps_agents::sandbox::SandboxExecResult { + exit_code: 0, + stdout: format!("{response}\n"), + stderr: String::new(), + }) + } + + async fn is_alive( + &self, + _handle: &temps_agents::sandbox::SandboxHandle, + ) -> Result { + Ok(true) + } + + async fn write_file( + &self, + _handle: &temps_agents::sandbox::SandboxHandle, + _path: &str, + _contents: &[u8], + _mode: u32, + ) -> Result<(), AgentError> { + Ok(()) + } + + async fn read_file( + &self, + _handle: &temps_agents::sandbox::SandboxHandle, + _path: &str, + ) -> Result, AgentError> { + Ok(Vec::new()) + } + + async fn write_directory( + &self, + _handle: &temps_agents::sandbox::SandboxHandle, + _local_dir: &Path, + _target_path: &str, + ) -> Result<(), AgentError> { + Ok(()) + } + + async fn kill_processes( + &self, + _handle: &temps_agents::sandbox::SandboxHandle, + _pattern: &str, + _signal: temps_agents::sandbox::KillSignal, + ) -> Result<(), AgentError> { + Ok(()) + } + + async fn destroy( + &self, + _handle: &temps_agents::sandbox::SandboxHandle, + _purge_volumes: bool, + ) -> Result<(), AgentError> { + self.lifecycle_calls.fetch_add(1, Ordering::SeqCst); + Ok(()) + } + + async fn stop( + &self, + _handle: &temps_agents::sandbox::SandboxHandle, + ) -> Result<(), AgentError> { + self.lifecycle_calls.fetch_add(1, Ordering::SeqCst); + Ok(()) + } + + async fn start( + &self, + _handle: &temps_agents::sandbox::SandboxHandle, + ) -> Result<(), AgentError> { + self.lifecycle_calls.fetch_add(1, Ordering::SeqCst); + Ok(()) + } + + async fn recover( + &self, + _run_id: i32, + ) -> Result, AgentError> { + self.lifecycle_calls.fetch_add(1, Ordering::SeqCst); + Ok(None) + } + + fn name(&self) -> &str { + "recording-model-discovery" + } + + async fn is_available(&self) -> bool { + true + } + + async fn image_status(&self) -> Result<(bool, String), AgentError> { + Ok((true, "test-image".to_string())) + } + + async fn rebuild_image(&self) -> Result { + self.lifecycle_calls.fetch_add(1, Ordering::SeqCst); + Ok("test-image".to_string()) + } + } + + #[tokio::test] + async fn successful_workspace_discovery_adopts_the_live_handle_without_restarting_it() { + let scratch = tempfile::tempdir().expect("scratch directory"); + let workspace_root = scratch.path().join("ai-applications"); + let workspace_path = workspace_root.join("global-user-42"); + std::fs::create_dir_all(&workspace_path).expect("managed workspace path"); + let handle = test_sandbox_handle(); + let resolver = SandboxWorkspaceResolverSlot::new(); + let resolver_handle = handle.clone(); + assert!(resolver.set(Arc::new(move |principal_id| { + let handle = resolver_handle.clone(); + let workspace_path = workspace_path.clone(); + Box::pin(async move { + assert_eq!(principal_id, 42); + Ok(ResolvedSandboxWorkspace { + workspace: temps_ai::HarnessWorkspace { + sandbox_label: handle.sandbox_name.clone(), + host_work_dir: workspace_path, + }, + handle, + stop: Arc::new(|| Box::pin(async { Ok(()) })), + }) + }) + }))); + let exec_calls = Arc::new(AtomicUsize::new(0)); + let lifecycle_calls = Arc::new(AtomicUsize::new(0)); + let sandbox: Arc = Arc::new(RecordingModelDiscoverySandbox { + exec_calls: exec_calls.clone(), + lifecycle_calls: lifecycle_calls.clone(), + }); + let credentials: SandboxCredentialResolver = Arc::new(|provider_id| { + assert_eq!(provider_id, "claude_cli"); + Box::pin(async { + Ok(SandboxHarnessCredentials::claude_oauth_token( + "test-oauth-token", + "http://model-relay.internal", + )) + }) + }); + let service = AgentCliAiService::new( + Arc::new(CountingClaudeProvider { + status_calls: Arc::new(AtomicUsize::new(0)), + discovery_calls: Arc::new(AtomicUsize::new(0)), + }), + scratch.path().join("cli-scratch"), + Duration::from_secs(30), + 1, + ) + .with_temps_sandbox( + sandbox, + workspace_root, + credentials, + Arc::new(SandboxModelRelayService::new().expect("model relay")), + resolver, + ); + + let snapshot = service + .discover_workspace_capabilities(42) + .await + .expect("account-aware workspace models"); + + assert_eq!(snapshot.model_source, temps_ai::ModelCatalogSource::Live); + assert_eq!(snapshot.capabilities.models[0].id, "sonnet"); + assert_eq!(exec_calls.load(Ordering::SeqCst), 1); + assert_eq!( + lifecycle_calls.load(Ordering::SeqCst), + 0, + "successful discovery must not create, recover, restart, stop, or destroy managed compute" + ); + } + + #[tokio::test] + async fn interrupted_workspace_discovery_uses_the_managed_lifecycle_stopper() { + let managed_stop_calls = Arc::new(AtomicUsize::new(0)); + let observed_calls = managed_stop_calls.clone(); + let managed_stop: SandboxWorkspaceStopper = Arc::new(move || { + let observed_calls = observed_calls.clone(); + Box::pin(async move { + observed_calls.fetch_add(1, Ordering::SeqCst); + Ok(()) + }) + }); + let handle = test_sandbox_handle(); + let handles = Arc::new(Mutex::new(HashMap::from([( + handle.sandbox_name.clone(), + handle.clone(), + )]))); + let guard = StopSandboxOnDrop { + armed: true, + provider: Arc::new(temps_agents::sandbox::local::LocalSandboxProvider::new()), + handle, + handles: handles.clone(), + sandbox_label: "workspace-model-discovery".to_string(), + sandbox_slot: Arc::new(Semaphore::new(1)), + global_permit: None, + sandbox_permit: None, + managed_stop: Some(managed_stop), + }; + + drop(guard); + tokio::time::timeout(Duration::from_secs(1), async { + while managed_stop_calls.load(Ordering::SeqCst) == 0 { + tokio::task::yield_now().await; + } + }) + .await + .expect("managed cancellation cleanup"); + + assert_eq!(managed_stop_calls.load(Ordering::SeqCst), 1); + assert!(handles + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .is_empty()); + } + + #[tokio::test] + async fn completed_workspace_discovery_does_not_stop_the_workspace() { + let managed_stop_calls = Arc::new(AtomicUsize::new(0)); + let observed_calls = managed_stop_calls.clone(); + let managed_stop: SandboxWorkspaceStopper = Arc::new(move || { + let observed_calls = observed_calls.clone(); + Box::pin(async move { + observed_calls.fetch_add(1, Ordering::SeqCst); + Ok(()) + }) + }); + let handle = test_sandbox_handle(); + let mut guard = StopSandboxOnDrop { + armed: true, + provider: Arc::new(temps_agents::sandbox::local::LocalSandboxProvider::new()), + handle, + handles: Arc::new(Mutex::new(HashMap::new())), + sandbox_label: "workspace-model-discovery".to_string(), + sandbox_slot: Arc::new(Semaphore::new(1)), + global_permit: None, + sandbox_permit: None, + managed_stop: Some(managed_stop), + }; + + guard.disarm(); + drop(guard); + tokio::task::yield_now().await; + + assert_eq!(managed_stop_calls.load(Ordering::SeqCst), 0); + } + // ----------------------------------------------------------------------- // Mock provider helpers // ----------------------------------------------------------------------- @@ -2424,6 +3273,45 @@ mod tests { called: Arc, } + struct CountingClaudeProvider { + status_calls: Arc, + discovery_calls: Arc, + } + + #[async_trait] + impl AiCliProvider for CountingClaudeProvider { + fn name(&self) -> &str { + "claude_cli" + } + + async fn check_installed(&self) -> bool { + true + } + + async fn get_status(&self) -> AiCliStatus { + self.status_calls.fetch_add(1, Ordering::SeqCst); + available_status() + } + + async fn discover_model_capabilities( + &self, + ) -> Vec { + self.discovery_calls.fetch_add(1, Ordering::SeqCst); + Vec::new() + } + + async fn run(&self, _config: AiRunConfig) -> Result { + Ok(fixed_result("", None)) + } + + async fn continue_conversation( + &self, + config: AiRunConfig, + ) -> Result { + self.run(config).await + } + } + #[async_trait] impl AiCliProvider for MockProvider { fn name(&self) -> &str { @@ -2953,6 +3841,282 @@ mod tests { ); } + #[tokio::test] + async fn cached_capabilities_never_probe_the_cli_on_a_cold_cache() { + invalidate_status_cache().await; + temps_agents::ai_cli::invalidate_model_discovery_cache().await; + let status_calls = Arc::new(AtomicUsize::new(0)); + let discovery_calls = Arc::new(AtomicUsize::new(0)); + let scratch = tempfile::tempdir().expect("scratch directory"); + let service = AgentCliAiService::new( + Arc::new(CountingClaudeProvider { + status_calls: status_calls.clone(), + discovery_calls: discovery_calls.clone(), + }), + scratch.path().to_owned(), + Duration::from_secs(30), + 1, + ); + + let snapshot = service + .capabilities_snapshot_for_principal( + Some("claude_cli"), + 7, + temps_ai::RefreshPolicy::Cached, + ) + .await + .expect("bootstrap capabilities remain available"); + + assert_eq!( + snapshot.model_source, + temps_ai::ModelCatalogSource::Bootstrap + ); + assert_eq!(status_calls.load(Ordering::SeqCst), 0); + assert_eq!(discovery_calls.load(Ordering::SeqCst), 0); + } + + #[tokio::test] + async fn concurrent_host_refreshes_share_one_cli_probe() { + invalidate_status_cache().await; + temps_agents::ai_cli::invalidate_model_discovery_cache().await; + let status_calls = Arc::new(AtomicUsize::new(0)); + let discovery_calls = Arc::new(AtomicUsize::new(0)); + let scratch = tempfile::tempdir().expect("scratch directory"); + let service = AgentCliAiService::new( + Arc::new(CountingClaudeProvider { + status_calls: status_calls.clone(), + discovery_calls: discovery_calls.clone(), + }), + scratch.path().to_owned(), + Duration::from_secs(30), + 1, + ); + + let (first, second) = tokio::join!( + service.host_capabilities_snapshot(temps_ai::RefreshPolicy::Refresh), + service.host_capabilities_snapshot(temps_ai::RefreshPolicy::Refresh), + ); + + first.expect("first refresh"); + second.expect("second refresh reuses the populated cache"); + assert_eq!(status_calls.load(Ordering::SeqCst), 1); + assert_eq!(discovery_calls.load(Ordering::SeqCst), 1); + } + + #[tokio::test] + async fn workspace_cache_reads_do_not_wait_for_a_live_refresh() { + let scratch = tempfile::tempdir().expect("scratch directory"); + let service = AgentCliAiService::new( + Arc::new(CountingClaudeProvider { + status_calls: Arc::new(AtomicUsize::new(0)), + discovery_calls: Arc::new(AtomicUsize::new(0)), + }), + scratch.path().to_owned(), + Duration::from_secs(30), + 1, + ); + let refresh_slot = Arc::new(tokio::sync::Mutex::new(())); + service + .workspace_model_refreshes + .lock() + .await + .insert(7, refresh_slot.clone()); + let _refresh_in_flight = refresh_slot.lock().await; + + let snapshot = tokio::time::timeout( + Duration::from_millis(100), + service.cached_workspace_capabilities(7), + ) + .await + .expect("cache-only reads must not share the long-running refresh lock") + .expect("bootstrap snapshot"); + + assert_eq!( + snapshot.model_source, + temps_ai::ModelCatalogSource::Bootstrap + ); + } + + #[tokio::test] + async fn workspace_model_cache_never_crosses_principals() { + let scratch = tempfile::tempdir().expect("scratch directory"); + let service = AgentCliAiService::new( + Arc::new(CountingClaudeProvider { + status_calls: Arc::new(AtomicUsize::new(0)), + discovery_calls: Arc::new(AtomicUsize::new(0)), + }), + scratch.path().to_owned(), + Duration::from_secs(30), + 1, + ); + let capabilities = provider_capabilities_from_models( + "claude_cli", + vec![temps_agents::ai_cli::AiCliModelCapability { + id: "principal-seven-model".to_string(), + name: "Principal seven model".to_string(), + reasoning_options: Vec::new(), + default_reasoning_option: None, + }], + ) + .expect("Claude capability contract"); + service.workspace_models.lock().await.insert( + 7, + WorkspaceModelState { + snapshot: Some(WorkspaceModelSnapshot { + capabilities, + refreshed_at: chrono::Utc::now(), + expires_at: Instant::now() + WORKSPACE_MODEL_CACHE_TTL, + }), + last_completed_at: Some(Instant::now()), + }, + ); + + let owner = service + .cached_workspace_capabilities(7) + .await + .expect("owner cache"); + let other = service + .cached_workspace_capabilities(8) + .await + .expect("other principal bootstrap"); + + assert_eq!(owner.model_source, temps_ai::ModelCatalogSource::Cache); + assert_eq!(owner.capabilities.models[0].id, "principal-seven-model"); + assert_eq!(other.model_source, temps_ai::ModelCatalogSource::Bootstrap); + assert!(other.capabilities.models.is_empty()); + assert!(other.capabilities.default_model_id.is_none()); + } + + #[tokio::test] + async fn workspace_capabilities_never_fall_back_to_host_credentials() { + let scratch = tempfile::tempdir().expect("scratch directory"); + let service = AgentCliAiService::new( + Arc::new(CountingClaudeProvider { + status_calls: Arc::new(AtomicUsize::new(0)), + discovery_calls: Arc::new(AtomicUsize::new(0)), + }), + scratch.path().to_owned(), + Duration::from_secs(30), + 1, + ); + + let error = service + .capabilities_snapshot_for_principal( + Some("claude_cli"), + 7, + temps_ai::RefreshPolicy::Refresh, + ) + .await + .expect_err("workspace discovery must fail closed without a secure relay"); + + assert!(matches!( + error, + AiError::Provider { purpose, reason } + if purpose == "provider.capabilities.workspace" + && reason.contains("persistent sandbox workspace is not configured") + )); + } + + #[test] + fn queued_refresh_reuses_a_probe_completed_after_it_was_requested() { + let requested_at = Instant::now(); + let completed_at = requested_at + WORKSPACE_MODEL_DISCOVERY_TIMEOUT; + + assert!(should_reuse_completed_refresh( + Some(completed_at), + requested_at, + completed_at + Duration::from_secs(1), + )); + } + + #[tokio::test] + async fn cooldown_never_promotes_an_expired_workspace_snapshot() { + let scratch = tempfile::tempdir().expect("scratch directory"); + let service = AgentCliAiService::new( + Arc::new(CountingClaudeProvider { + status_calls: Arc::new(AtomicUsize::new(0)), + discovery_calls: Arc::new(AtomicUsize::new(0)), + }), + scratch.path().to_owned(), + Duration::from_secs(30), + 1, + ); + let capabilities = provider_capabilities_from_models( + "claude_cli", + vec![temps_agents::ai_cli::AiCliModelCapability { + id: "account-model".to_string(), + name: "Account model".to_string(), + reasoning_options: Vec::new(), + default_reasoning_option: None, + }], + ) + .expect("Claude capability contract"); + { + let mut states = service.workspace_models.lock().await; + let state = states.entry(7).or_default(); + state.snapshot = Some(WorkspaceModelSnapshot { + capabilities, + refreshed_at: chrono::Utc::now(), + expires_at: Instant::now() - Duration::from_secs(1), + }); + state.last_completed_at = Some(Instant::now()); + } + + let snapshot = service + .discover_workspace_capabilities(7) + .await + .expect("cooldown reuses the existing snapshot"); + + assert_eq!( + snapshot.model_source, + temps_ai::ModelCatalogSource::StaleCache, + "an expired inventory must remain non-authoritative during cooldown" + ); + } + + #[tokio::test] + async fn credential_invalidation_clears_an_in_flight_refresh_result() { + let scratch = tempfile::tempdir().expect("scratch directory"); + let service = Arc::new(AgentCliAiService::new( + Arc::new(CountingClaudeProvider { + status_calls: Arc::new(AtomicUsize::new(0)), + discovery_calls: Arc::new(AtomicUsize::new(0)), + }), + scratch.path().to_owned(), + Duration::from_secs(30), + 1, + )); + let refresh_guard = service.workspace_model_refresh_barrier.read().await; + let invalidation_service = Arc::clone(&service); + let invalidation = tokio::spawn(async move { + invalidation_service + .invalidate_capabilities_for(Some("claude_cli")) + .await; + }); + tokio::task::yield_now().await; + assert!( + !invalidation.is_finished(), + "credential invalidation must wait for an old refresh to finish" + ); + + { + let mut states = service.workspace_models.lock().await; + let state = states.entry(7).or_default(); + state.snapshot = Some(WorkspaceModelSnapshot { + capabilities: provider_capabilities_from_models("claude_cli", Vec::new()) + .expect("Claude capability contract"), + refreshed_at: chrono::Utc::now(), + expires_at: Instant::now() + WORKSPACE_MODEL_CACHE_TTL, + }); + state.last_completed_at = Some(Instant::now()); + } + drop(refresh_guard); + invalidation.await.expect("invalidation task"); + + let states = service.workspace_models.lock().await; + assert!(states.is_empty()); + } + fn test_mcp_state() -> ( McpBridgeState, tokio::sync::mpsc::Receiver>, diff --git a/crates/temps-ai-chat/src/handlers.rs b/crates/temps-ai-chat/src/handlers.rs index 56892d82d..cf711dd21 100644 --- a/crates/temps-ai-chat/src/handlers.rs +++ b/crates/temps-ai-chat/src/handlers.rs @@ -2669,7 +2669,13 @@ pub async fn unlink_application_project( if let Some(summary) = sandboxes .application_workspace_summary(auth.user_id(), &application_public_id) .await - .map_err(Problem::from)? + .map_err(|error| { + application_workspace_provider_problem( + error, + &application_public_id, + "inspect before unlink", + ) + })? .filter(|summary| workspace_may_retain_data_plane(&summary.status)) { // Stop compute before moving its source tree. This closes both the @@ -2677,7 +2683,13 @@ pub async fn unlink_application_project( sandboxes .pause_sandbox(&summary.public_id, auth.user_id()) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem( + error, + &application_public_id, + "pause before unlink", + ) + })?; paused_sandbox = Some(summary.public_id); } } @@ -2772,11 +2784,23 @@ pub async fn unlink_application_project( &remaining_project_ids, ) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem( + error, + &application_public_id, + "synchronize data network after unlink", + ) + })?; sandboxes .resume_sandbox(sandbox_id, auth.user_id()) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem( + error, + &application_public_id, + "resume after unlink", + ) + })?; } state .audit(&ApplicationTopologyChangedAudit { @@ -2904,12 +2928,24 @@ pub async fn archive_application( if let Some(summary) = sandboxes .application_workspace_summary(auth.user_id(), &application_public_id) .await - .map_err(Problem::from)? + .map_err(|error| { + application_workspace_provider_problem( + error, + &application_public_id, + "inspect before archive", + ) + })? { sandboxes .pause_sandbox(&summary.public_id, auth.user_id()) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem( + error, + &application_public_id, + "pause before archive", + ) + })?; paused_sandbox = Some(summary.public_id); } } @@ -3903,6 +3939,154 @@ fn workspace_path(repository: &str, path: &str) -> String { } } +fn application_workspace_failure_detail( + error: &temps_sandbox::error::SandboxError, +) -> &'static str { + use temps_sandbox::error::SandboxError; + + match error { + SandboxError::CreateFailed { reason, .. } => { + let reason = reason.to_ascii_lowercase(); + if reason.contains("fully subnetted") + || reason.contains("address pool") + || reason.contains("non-overlapping ipv4") + { + "This Temps host has no private sandbox network capacity available. Contact your Temps administrator, then try again." + } else if reason.contains("gateway_mode_ipv4") + || reason.contains("unknown gateway mode") + { + "The sandbox runtime on this Temps host is incompatible with secure workspace networking. Contact your Temps administrator, then try again." + } else { + "Temps could not start workspace compute. Try again; if it continues, contact your Temps administrator." + } + } + SandboxError::Unavailable { .. } => { + "The sandbox runtime is unavailable on this Temps host. Contact your Temps administrator, then try again." + } + SandboxError::Timeout { .. } => { + "The workspace did not become ready before the startup timeout. Try again; if it continues, contact your Temps administrator." + } + SandboxError::InvalidState { .. } => { + "The workspace cannot resume from its current state. Rebuild it, or contact your Temps administrator." + } + SandboxError::RuntimeEnvironmentNotFound { .. } => { + "A linked project has no active environment, so Temps could not prepare workspace services. Activate the environment, then try again." + } + SandboxError::RuntimeCredentialsFailed { .. } => { + "Temps could not prepare credentials for a linked workspace service. Check the service configuration, then try again." + } + SandboxError::RuntimeVariableConflict { .. } => { + "Linked services expose conflicting runtime variable names. Resolve the service configuration, then try again." + } + _ => { + "Temps could not prepare the persistent application workspace. Try again; if it continues, contact your Temps administrator." + } + } +} + +fn application_workspace_failure_problem(error: &temps_sandbox::error::SandboxError) -> Problem { + use temps_sandbox::error::SandboxError; + + let status = match error { + SandboxError::Unavailable { .. } => StatusCode::SERVICE_UNAVAILABLE, + SandboxError::Timeout { .. } => StatusCode::GATEWAY_TIMEOUT, + SandboxError::InvalidState { .. } | SandboxError::RuntimeVariableConflict { .. } => { + StatusCode::CONFLICT + } + SandboxError::RuntimeEnvironmentNotFound { .. } => StatusCode::NOT_FOUND, + SandboxError::RuntimeCredentialsFailed { .. } => StatusCode::BAD_GATEWAY, + _ => StatusCode::INTERNAL_SERVER_ERROR, + }; + problemdetails::new(status) + .with_title("Application Workspace Failed") + .with_detail(application_workspace_failure_detail(error)) +} + +fn application_workspace_provider_problem( + error: temps_sandbox::error::SandboxError, + application_id: &str, + operation: &'static str, +) -> Problem { + tracing::error!( + %error, + application_id, + operation, + "application workspace provider operation failed" + ); + application_workspace_failure_problem(&error) +} + +fn application_workspace_snapshot_problem( + error: temps_sandbox::error::SandboxSnapshotError, + application_id: &str, + operation: &'static str, +) -> Problem { + use temps_sandbox::error::SandboxSnapshotError; + + tracing::error!( + %error, + application_id, + operation, + "application workspace snapshot operation failed" + ); + let (status, title, detail) = match error { + SandboxSnapshotError::NotFound { .. } => ( + StatusCode::NOT_FOUND, + "Snapshot Not Found", + "The requested workspace snapshot was not found.", + ), + SandboxSnapshotError::NotReady { .. } => ( + StatusCode::UNPROCESSABLE_ENTITY, + "Snapshot Not Ready", + "The workspace snapshot is not ready to restore yet. Try again after it finishes.", + ), + SandboxSnapshotError::CrossBackendRestore { .. } => ( + StatusCode::UNPROCESSABLE_ENTITY, + "Snapshot Restore Not Supported", + "This snapshot cannot be restored by the workspace's current runtime.", + ), + SandboxSnapshotError::NotSupported { .. } => ( + StatusCode::NOT_IMPLEMENTED, + "Snapshots Not Supported", + "The configured sandbox runtime does not support workspace snapshots.", + ), + SandboxSnapshotError::SnapshotInProgress { .. } => ( + StatusCode::CONFLICT, + "Snapshot In Progress", + "Another workspace snapshot is still being created. Wait for it to finish, then try again.", + ), + SandboxSnapshotError::QuotaExceeded { .. } => ( + StatusCode::UNPROCESSABLE_ENTITY, + "Snapshot Storage Limit Reached", + "The workspace snapshot storage limit has been reached. Remove an older snapshot, then try again.", + ), + SandboxSnapshotError::InvalidState { .. } + | SandboxSnapshotError::SandboxNotRunning { .. } => ( + StatusCode::CONFLICT, + "Workspace Not Ready", + "The workspace must be running before this snapshot operation can continue.", + ), + SandboxSnapshotError::SandboxNotFound { .. } => ( + StatusCode::NOT_FOUND, + "Workspace Compute Not Found", + "The workspace compute could not be found. Rebuild the workspace, then try again.", + ), + SandboxSnapshotError::LegacyArtifactUnsupported { .. } => ( + StatusCode::UNPROCESSABLE_ENTITY, + "Snapshot Format Not Supported", + "This older workspace snapshot cannot be restored by the current runtime.", + ), + _ => ( + StatusCode::INTERNAL_SERVER_ERROR, + "Workspace Snapshot Failed", + "Temps could not complete the workspace snapshot operation. Try again; if it continues, contact your Temps administrator.", + ), + }; + problemdetails::new(status) + .with_title(title) + .with_detail(detail) +} + async fn application_workspace_sandbox( state: &AppState, auth: &AuthContext, @@ -3957,7 +4141,7 @@ async fn application_workspace_sandbox( .with_title("Application Sandbox Unavailable") .with_detail("The instance sandbox service is not configured.") })?; - let sandbox = sandboxes + let sandbox = match sandboxes .get_or_create_application_workspace_with_config( auth.user_id(), &application.application.public_id, @@ -3967,12 +4151,29 @@ async fn application_workspace_sandbox( &project_ids, ) .await - .map_err(|error| { + { + Ok(sandbox) => sandbox, + Err(error) => { + let detail = application_workspace_failure_detail(&error); error!(%error, application_id = application_public_id, "failed to prepare application Git workspace"); - problemdetails::new(StatusCode::INTERNAL_SERVER_ERROR) - .with_title("Application Workspace Failed") - .with_detail("Temps could not prepare the persistent application workspace.") - })?; + if let Err(persistence_error) = state + .applications + .update_workspace_runtime_state( + application.application.id, + None, + Some(detail.to_string()), + ) + .await + { + error!( + %persistence_error, + application_id = application_public_id, + "failed to persist application workspace startup diagnostic" + ); + } + return Err(application_workspace_failure_problem(&error)); + } + }; state .applications .record_workspace_sandbox( @@ -5061,9 +5262,11 @@ pub async fn create_global_conversation( ) .await .map_err(|error| { - problemdetails::new(StatusCode::INTERNAL_SERVER_ERROR) - .with_title("Global Chat Sandbox Failed") - .with_detail(error.to_string()) + application_workspace_provider_problem( + error, + &workspace_context_id, + "start global workspace", + ) })?; let conversation = state @@ -5123,7 +5326,9 @@ pub async fn get_global_ai_workspace( let summary = sandboxes .application_workspace_summary(auth.user_id(), &workspace_id) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem(error, &workspace_id, "inspect global workspace") + })?; let defaults = temps_sandbox::services::ApplicationWorkspaceConfig::default(); let mut diagnostic = None; let usage = if let Some(summary) = summary @@ -5209,7 +5414,13 @@ async fn application_workspace_response( let summary = sandboxes .application_workspace_summary(auth.user_id(), &application.application.public_id) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem( + error, + &application.application.public_id, + "inspect workspace", + ) + })?; let mut diagnostic = desired.last_error.clone(); let usage = if let Some(summary) = summary .as_ref() @@ -5490,7 +5701,13 @@ async fn synchronize_application_network_if_running( let Some(summary) = sandboxes .application_workspace_summary(auth.user_id(), &application.application.public_id) .await - .map_err(Problem::from)? + .map_err(|error| { + application_workspace_provider_problem( + error, + &application.application.public_id, + "inspect before data-network synchronization", + ) + })? .filter(|summary| workspace_may_retain_data_plane(&summary.status)) else { return Ok(()); @@ -5507,7 +5724,13 @@ async fn synchronize_application_network_if_running( .collect::>(), ) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem( + error, + &application.application.public_id, + "synchronize data network", + ) + })?; Ok(()) } @@ -5595,7 +5818,13 @@ pub async fn update_application_workspace( if let Some(summary) = sandboxes .application_workspace_summary(auth.user_id(), &application_public_id) .await - .map_err(Problem::from)? + .map_err(|error| { + application_workspace_provider_problem( + error, + &application_public_id, + "inspect before resource update", + ) + })? { if let Err(error) = sandboxes .rebuild_application_workspace( @@ -5617,7 +5846,11 @@ pub async fn update_application_workspace( ), ) .await?; - return Err(Problem::from(error)); + return Err(application_workspace_provider_problem( + error, + &application_public_id, + "rebuild after resource update", + )); } state .applications @@ -5694,14 +5927,22 @@ pub async fn control_application_workspace( let summary = sandboxes .application_workspace_summary(auth.user_id(), &application_public_id) .await - .map_err(Problem::from)? + .map_err(|error| { + application_workspace_provider_problem( + error, + &application_public_id, + "inspect before pause", + ) + })? .ok_or_else(|| { ApplicationError::NotFound(format!("workspace:{application_public_id}")) })?; sandboxes .pause_sandbox(&summary.public_id, auth.user_id()) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem(error, &application_public_id, "pause") + })?; state .applications .record_workspace_sandbox( @@ -5718,32 +5959,29 @@ pub async fn control_application_workspace( .update_workspace_runtime_state(application.application.id, Some("running"), None) .await?; let (_, sandbox_id) = - match application_workspace_sandbox(&state, &auth, &application_public_id).await { - Ok(workspace) => workspace, - Err(problem) => { - state - .applications - .update_workspace_runtime_state( - application.application.id, - None, - Some( - "Workspace resume failed while restoring compute.".to_string(), - ), - ) - .await?; - return Err(problem); - } - }; + application_workspace_sandbox(&state, &auth, &application_public_id).await?; if let Some(summary) = sandboxes .application_workspace_summary(auth.user_id(), &application_public_id) .await - .map_err(Problem::from)? + .map_err(|error| { + application_workspace_provider_problem( + error, + &application_public_id, + "inspect before resume", + ) + })? { if summary.status == "stopped" { sandboxes .resume_sandbox(&sandbox_id, auth.user_id()) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem( + error, + &application_public_id, + "resume", + ) + })?; } } state @@ -5762,7 +6000,9 @@ pub async fn control_application_workspace( sandboxes .restart_sandbox(&sandbox_id, auth.user_id()) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem(error, &application_public_id, "restart") + })?; state .applications .update_workspace_runtime_state(application.application.id, None, None) @@ -5787,7 +6027,9 @@ pub async fn control_application_workspace( (&desired).into(), ) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem(error, &application_public_id, "rebuild") + })?; state .applications .update_workspace_runtime_state(application.application.id, None, None) @@ -5804,7 +6046,13 @@ pub async fn control_application_workspace( let row = sandboxes .find_by_public_id(&sandbox_id, auth.user_id()) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem( + error, + &application_public_id, + "inspect before snapshot", + ) + })?; let snapshot = snapshots .create_snapshot( row.id, @@ -5814,7 +6062,13 @@ pub async fn control_application_workspace( request.label, ) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_snapshot_problem( + error, + &application_public_id, + "create snapshot", + ) + })?; snapshot_id = Some(snapshot.public_id); } "restore" => { @@ -5833,11 +6087,23 @@ pub async fn control_application_workspace( let sandbox_row = sandboxes .find_by_public_id(&sandbox_id, auth.user_id()) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem( + error, + &application_public_id, + "inspect before restore", + ) + })?; let snapshot_row = snapshots .get_snapshot(auth.user_id(), requested_snapshot) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_snapshot_problem( + error, + &application_public_id, + "inspect snapshot before restore", + ) + })?; if snapshot_row.source_sandbox_id != Some(sandbox_row.id) { return Err(problemdetails::new(StatusCode::BAD_REQUEST) .with_title("Snapshot Does Not Belong to Application") @@ -5849,7 +6115,13 @@ pub async fn control_application_workspace( let artifact = snapshots .resolve_for_restore(auth.user_id(), requested_snapshot, Some("docker")) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_snapshot_problem( + error, + &application_public_id, + "resolve snapshot before restore", + ) + })?; let workspace = state .application_workspaces .ensure(&application.application.public_id, &application.projects) @@ -5867,7 +6139,9 @@ pub async fn control_application_workspace( &artifact, ) .await - .map_err(Problem::from)?; + .map_err(|error| { + application_workspace_provider_problem(error, &application_public_id, "restore") + })?; state .applications .update_workspace_runtime_state(application.application.id, None, None) @@ -6386,18 +6660,15 @@ pub async fn send_message( ensure_runtime_permission(&auth, Some(&conv.ai_provider), Some(effective_permission))?; ensure_enabled(&state, Some(&conv.ai_provider)).await?; ensure_context_read_permission(&auth, &conv.context_type)?; - if req.ai_model.is_some() || req.ai_thinking_level.is_some() || req.ai_permission_mode.is_some() - { - conv = state - .service - .update_runtime_options( - &conv, - req.ai_model.as_deref(), - req.ai_thinking_level.as_deref(), - req.ai_permission_mode.as_deref(), - ) - .await?; - } + conv = state + .service + .update_runtime_options( + &conv, + req.ai_model.as_deref(), + req.ai_thinking_level.as_deref(), + req.ai_permission_mode.as_deref(), + ) + .await?; // Page context is advisory framing, not user content: cap it and silently // drop an oversized value rather than failing the message. let page_context = req @@ -6541,18 +6812,15 @@ pub async fn send_user_message( Some(&conversation.ai_provider), Some(effective_permission), )?; - if req.ai_model.is_some() || req.ai_thinking_level.is_some() || req.ai_permission_mode.is_some() - { - conversation = state - .service - .update_runtime_options( - &conversation, - req.ai_model.as_deref(), - req.ai_thinking_level.as_deref(), - req.ai_permission_mode.as_deref(), - ) - .await?; - } + conversation = state + .service + .update_runtime_options( + &conversation, + req.ai_model.as_deref(), + req.ai_thinking_level.as_deref(), + req.ai_permission_mode.as_deref(), + ) + .await?; let attachments = resolve_chat_attachments(&state, &auth, &conversation, &req.attachments).await?; let attachment_metadata = @@ -9141,6 +9409,84 @@ mod tests { ); } + #[test] + fn workspace_startup_failure_classifies_exhausted_private_network_capacity() { + let error = temps_sandbox::error::SandboxError::CreateFailed { + user_id: 7, + reason: "create network temps-sandbox-private: all predefined address pools have been fully subnetted" + .to_string(), + }; + + let detail = application_workspace_failure_detail(&error); + + assert_eq!( + detail, + "This Temps host has no private sandbox network capacity available. Contact your Temps administrator, then try again." + ); + assert!(!detail.contains("temps-sandbox-private")); + assert!(!detail.contains("fully subnetted")); + } + + #[test] + fn workspace_startup_failure_classifies_incompatible_secure_networking() { + let error = temps_sandbox::error::SandboxError::CreateFailed { + user_id: 7, + reason: "failed to parse com.docker.network.bridge.gateway_mode_ipv4 value: isolated (unknown gateway mode isolated)" + .to_string(), + }; + + let detail = application_workspace_failure_detail(&error); + + assert!(detail.contains("incompatible with secure workspace networking")); + assert!(!detail.contains("gateway_mode_ipv4")); + } + + #[test] + fn workspace_startup_failure_falls_back_without_exposing_provider_details() { + let error = temps_sandbox::error::SandboxError::CreateFailed { + user_id: 7, + reason: "provider detail with container temps-sandbox-secret-id".to_string(), + }; + + let detail = application_workspace_failure_detail(&error); + + assert_eq!( + detail, + "Temps could not start workspace compute. Try again; if it continues, contact your Temps administrator." + ); + assert!(!detail.contains("temps-sandbox-secret-id")); + } + + #[test] + fn workspace_provider_problem_never_serializes_raw_provider_details() { + let error = temps_sandbox::error::SandboxError::CreateFailed { + user_id: 7, + reason: "private Docker path /var/run/docker.sock for temps-sandbox-secret-id" + .to_string(), + }; + + let problem = application_workspace_provider_problem(error, "app_test", "test operation"); + let body = serde_json::to_string(&problem.body).expect("problem body serializes"); + + assert!(body.contains("Temps could not start workspace compute")); + assert!(!body.contains("/var/run/docker.sock")); + assert!(!body.contains("temps-sandbox-secret-id")); + } + + #[test] + fn workspace_snapshot_problem_never_serializes_artifact_paths() { + let error = temps_sandbox::error::SandboxSnapshotError::ArtifactMissing { + path: "/private/snapshots/user-7/secret.tar".to_string(), + }; + + let problem = application_workspace_snapshot_problem(error, "app_test", "test snapshot"); + let body = serde_json::to_string(&problem.body).expect("problem body serializes"); + + assert!(body.contains("Temps could not complete")); + assert!(!body.contains("/private/snapshots")); + assert!(!body.contains("secret.tar")); + } + #[test] fn recovering_workspace_may_still_retain_data_plane_access() { assert!(workspace_may_retain_data_plane("running")); diff --git a/crates/temps-ai-chat/src/plugin.rs b/crates/temps-ai-chat/src/plugin.rs index 37d2feaac..d65052ae9 100644 --- a/crates/temps-ai-chat/src/plugin.rs +++ b/crates/temps-ai-chat/src/plugin.rs @@ -133,6 +133,99 @@ impl TempsPlugin for AiChatPlugin { config_service.data_dir(), )); context.register_service(application_workspaces.clone()); + let application_sandboxes = context.get_service::(); + if let (Some(sandboxes), Some(resolver_slot)) = ( + application_sandboxes.as_ref(), + context.get_service::(), + ) { + let sandboxes = sandboxes.clone(); + let workspaces = application_workspaces.clone(); + let applications_for_resolver = applications.clone(); + let resolver: temps_ai_agent_cli::SandboxWorkspaceResolver = Arc::new( + move |principal_id| { + let sandboxes = sandboxes.clone(); + let workspaces = workspaces.clone(); + let applications = applications_for_resolver.clone(); + Box::pin(async move { + let _workspace_quota_reservation = applications + .reserve_global_workspace_quota(principal_id) + .await + .map_err(|error| temps_ai::AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: format!( + "could not reserve the global workspace: {error}" + ), + })?; + let workspace_id = format!("global-user-{principal_id}"); + let mut workspace = workspaces + .ensure(&workspace_id, &[]) + .await + .map_err(|error| temps_ai::AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: format!( + "could not prepare the persistent global workspace: {error}" + ), + })?; + let sandbox = sandboxes + .get_or_create_application_workspace( + principal_id, + &workspace_id, + None, + workspace.host_work_dir.clone(), + ) + .await + .map_err(|error| temps_ai::AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: format!( + "could not start the persistent global workspace sandbox: {error}" + ), + })?; + workspace.sandbox_label = sandbox + .public_id + .strip_prefix("sbx_") + .unwrap_or(&sandbox.public_id) + .to_string(); + let handle = sandbox.handle.ok_or_else(|| temps_ai::AiError::Provider { + purpose: "provider.capabilities.workspace".to_string(), + reason: "the persistent global workspace did not return a running sandbox handle" + .to_string(), + })?; + let sandbox_public_id = sandbox.public_id; + let sandboxes_for_stop = sandboxes.clone(); + let stop: temps_ai_agent_cli::SandboxWorkspaceStopper = Arc::new( + move || { + let sandboxes = sandboxes_for_stop.clone(); + let sandbox_public_id = sandbox_public_id.clone(); + Box::pin(async move { + sandboxes + .pause_sandbox(&sandbox_public_id, principal_id) + .await + .map(|_| ()) + .map_err(|error| temps_ai::AiError::Provider { + purpose: "provider.capabilities.workspace.stop" + .to_string(), + reason: format!( + "could not stop the persistent global workspace after model discovery was interrupted: {error}" + ), + }) + }) + }, + ); + Ok(temps_ai_agent_cli::ResolvedSandboxWorkspace { + workspace, + handle, + stop, + }) + }) + }, + ); + if !resolver_slot.set(resolver) { + return Err(PluginError::InitializationFailed( + "persistent sandbox workspace resolver was registered more than once" + .to_string(), + )); + } + } // Optional: operator-tuned chat limits (turn timeout). Absent in // minimal wirings, where the compiled defaults apply. let config_service = context.get_service::(); @@ -140,8 +233,8 @@ impl TempsPlugin for AiChatPlugin { .with_write_support(write_handle, pending_actions.clone(), audit_service.clone()) .with_application_workspaces(application_workspaces.clone()) .with_application_service(applications.clone()); - if let Some(sandboxes) = context.get_service::() { - service = service.with_application_sandboxes(sandboxes); + if let Some(sandboxes) = &application_sandboxes { + service = service.with_application_sandboxes(sandboxes.clone()); } else { tracing::warn!( "SandboxService is unavailable; application harness turns will fail closed" @@ -178,7 +271,7 @@ impl TempsPlugin for AiChatPlugin { project_service, application_workspaces, config_service, - application_sandboxes: context.get_service::(), + application_sandboxes, sandbox_snapshots: context .get_service::(), source_drop_deployer: context.get_service::(), diff --git a/crates/temps-ai-chat/src/service.rs b/crates/temps-ai-chat/src/service.rs index 2876f6ddc..51a6ebd1a 100644 --- a/crates/temps-ai-chat/src/service.rs +++ b/crates/temps-ai-chat/src/service.rs @@ -2213,6 +2213,7 @@ impl ConversationService { let now = Utc::now(); let runtime = self .resolve_conversation_runtime( + user_id, requested_provider, requested_model, requested_thinking_level, @@ -2282,6 +2283,7 @@ impl ConversationService { }); } self.resolve_conversation_runtime( + user_id, requested_provider, requested_model, requested_thinking_level, @@ -2292,6 +2294,7 @@ impl ConversationService { async fn resolve_conversation_runtime( &self, + principal_id: i32, requested: Option<&str>, requested_model: Option<&str>, requested_thinking_level: Option<&str>, @@ -2302,65 +2305,87 @@ impl ConversationService { Some(value) => value.to_string(), None => self.resolve_default_provider().await?, }; - let capabilities = self + let snapshot = self .ai - .capabilities_for(Some(&provider), temps_ai::RefreshPolicy::Cached) + .capabilities_snapshot_for_principal( + Some(&provider), + principal_id, + temps_ai::RefreshPolicy::Cached, + ) .await .map_err(|error| { ChatError::Ai(format!( "provider '{provider}' is not ready for a new conversation: {error}" )) })?; + let capabilities = snapshot.capabilities; let model = requested_model .map(str::to_string) .or_else(|| capabilities.default_model_id.clone()) .or_else(|| capabilities.models.first().map(|model| model.id.clone())) .unwrap_or_else(|| "default".to_string()); let discovered_model = capabilities.model(&model); - if discovered_model.is_none() && !(capabilities.models.is_empty() && model == "default") { + if snapshot.model_source.is_authoritative() + && discovered_model.is_none() + && !(capabilities.models.is_empty() && model == "default") + { return Err(ChatError::Ai(format!( "model '{model}' is not available for provider '{provider}'" ))); } - let thinking_level = match discovered_model { - Some(discovered) => { - // Project chat always attaches function tools. Providers may - // advertise a narrower set of reasoning modes for tool turns. - let valid_modes = discovered - .tool_thinking_modes - .as_ref() - .unwrap_or(&discovered.thinking_modes); - let desired = requested_thinking_level - .map(str::to_string) - .or_else(|| discovered.default_thinking_mode_id.clone()); - match desired { - Some(value) if valid_modes.iter().any(|option| option.id == value) => { + let thinking_level = if !snapshot.model_source.is_authoritative() { + // Bootstrap and expired inventories do not describe the current + // account's reasoning controls. Preserve the persisted/requested + // value, including an intentional provider-default `None`, even + // when the model id happens to appear in the fallback. + requested_thinking_level.map(str::to_string) + } else { + match discovered_model { + Some(discovered) => { + // Project chat always attaches function tools. Providers may + // advertise a narrower set of reasoning modes for tool turns. + let valid_modes = discovered + .tool_thinking_modes + .as_ref() + .unwrap_or(&discovered.thinking_modes); + let desired = requested_thinking_level + .map(str::to_string) + .or_else(|| discovered.default_thinking_mode_id.clone()); + match desired { + Some(value) if valid_modes.iter().any(|option| option.id == value) => { + Some(value) + } Some(value) + if discovered.tool_thinking_modes.is_some() + && discovered + .thinking_modes + .iter() + .any(|option| option.id == value) => + { + valid_modes.first().map(|option| option.id.clone()) + } + Some(value) => { + return Err(ChatError::Ai(format!( + "thinking option '{value}' is not available for model '{model}'" + ))); + } + None => valid_modes.first().map(|option| option.id.clone()), } - Some(value) - if discovered.tool_thinking_modes.is_some() - && discovered - .thinking_modes - .iter() - .any(|option| option.id == value) => - { - valid_modes.first().map(|option| option.id.clone()) - } - Some(value) => { - return Err(ChatError::Ai(format!( - "thinking option '{value}' is not available for model '{model}'" - ))); - } - None => valid_modes.first().map(|option| option.id.clone()), } + None if snapshot.model_source.is_authoritative() + && requested_thinking_level.is_some() => + { + return Err(ChatError::Ai(format!( + "thinking option '{}' is not available for model '{model}'", + requested_thinking_level.unwrap_or_default() + ))); + } + // A bootstrap or expired model list is a convenience list, not an + // account allowlist. Preserve the requested/saved reasoning value + // and let the provider decide until an explicit refresh produces + // an authoritative inventory. + None => requested_thinking_level.map(str::to_string), } - None if requested_thinking_level.is_some() => { - return Err(ChatError::Ai(format!( - "thinking option '{}' is not available for model '{model}'", - requested_thinking_level.unwrap_or_default() - ))); - } - None => None, }; let permission_mode = requested_permission_mode .map(str::to_string) @@ -2434,15 +2459,10 @@ impl ConversationService { let desired_thinking = normalize_thinking_level(thinking_level) .or_else(|| (!model_changed).then_some(current_thinking).flatten()); let desired_permission = permission_mode.unwrap_or(&conv.ai_permission_mode); - if desired_model == conv.ai_model - && desired_thinking == conv.ai_thinking_level.as_deref() - && desired_permission == conv.ai_permission_mode - { - return Ok(conv.clone()); - } let runtime = self .resolve_conversation_runtime( + conv.created_by, Some(&conv.ai_provider), Some(desired_model), desired_thinking, @@ -2454,6 +2474,18 @@ impl ConversationService { "conversation provider cannot be changed after creation".to_string(), )); } + // A provider's model inventory can change after the conversation was + // created (account policy, entitlement, CLI upgrade, or model + // retirement). Even when the browser sends no option changes, validate + // the persisted selection against the current cached capabilities + // before allowing another turn. The former early return let a stale + // model bypass this guard and fail much later inside the provider CLI. + let resolved_options_unchanged = runtime.model == conv.ai_model + && runtime.thinking_level == conv.ai_thinking_level + && runtime.permission_mode == conv.ai_permission_mode; + if resolved_options_unchanged { + return Ok(conv.clone()); + } ai_conversations::ActiveModel { id: Set(conv.id), // Provider sessions are model-specific. Starting a new harness @@ -6328,6 +6360,82 @@ mod tests { /// while an authenticated host harness is ready for chat. struct HostHarnessOnlyAi; + struct NonAuthoritativeCapabilitiesAi(temps_ai::ModelCatalogSource); + + struct ToolRestrictedCapabilitiesAi; + + #[async_trait] + impl AiService for NonAuthoritativeCapabilitiesAi { + async fn is_available(&self) -> bool { + true + } + + async fn capabilities_snapshot_for_principal( + &self, + provider: Option<&str>, + _principal_id: i32, + _refresh: temps_ai::RefreshPolicy, + ) -> Result { + let capabilities = ScriptedAi::new(vec![]) + .capabilities_for(provider, temps_ai::RefreshPolicy::Cached) + .await?; + Ok(temps_ai::ProviderCapabilitiesSnapshot { + capabilities, + model_source: self.0, + models_refreshed_at: None, + }) + } + + async fn complete(&self, _request: AiRequest) -> Result { + Err(AiError::NotAvailable) + } + + async fn chat_stream(&self, _request: ChatTurnRequest) -> Result { + Err(AiError::NotAvailable) + } + } + + #[async_trait] + impl AiService for ToolRestrictedCapabilitiesAi { + async fn is_available(&self) -> bool { + true + } + + async fn capabilities_snapshot_for_principal( + &self, + provider: Option<&str>, + _principal_id: i32, + _refresh: temps_ai::RefreshPolicy, + ) -> Result { + let mut capabilities = ScriptedAi::new(vec![]) + .capabilities_for(provider, temps_ai::RefreshPolicy::Cached) + .await?; + let model = capabilities + .models + .iter_mut() + .find(|model| model.id == "gpt-4o-mini") + .expect("test model"); + model.tool_thinking_modes = Some(vec![temps_ai::SelectOption { + id: "medium".to_string(), + name: "Medium".to_string(), + description: None, + }]); + Ok(temps_ai::ProviderCapabilitiesSnapshot { + capabilities, + model_source: temps_ai::ModelCatalogSource::Live, + models_refreshed_at: None, + }) + } + + async fn complete(&self, _request: AiRequest) -> Result { + Err(AiError::NotAvailable) + } + + async fn chat_stream(&self, _request: ChatTurnRequest) -> Result { + Err(AiError::NotAvailable) + } + } + #[async_trait] impl AiService for HostHarnessOnlyAi { async fn is_available(&self) -> bool { @@ -8313,6 +8421,7 @@ mod tests { let runtime = service .resolve_conversation_runtime( + 1, Some("gateway_key:1"), Some("gpt-5.6-luna"), Some("medium"), @@ -8402,6 +8511,67 @@ mod tests { message.contains("claude-opus") && message.contains("codex_cli"))); } + #[tokio::test] + async fn update_runtime_options_revalidates_an_unchanged_persisted_model() { + let mut conversation = test_conversation(); + conversation.ai_provider = "claude_cli".to_string(); + conversation.ai_model = "claude-model-no-longer-available".to_string(); + let db = MockDatabase::new(DatabaseBackend::Postgres).into_connection(); + + let error = db_service(db) + .update_runtime_options(&conversation, None, None, None) + .await + .expect_err("a stale persisted model must not bypass capability validation"); + + assert!(matches!(error, ChatError::Ai(message) if + message.contains("claude-model-no-longer-available") + && message.contains("claude_cli"))); + } + + #[tokio::test] + async fn update_runtime_options_persists_reconciled_tool_thinking_mode() { + let mut conversation = test_conversation(); + conversation.ai_provider = "claude_cli".to_string(); + conversation.ai_thinking_level = Some("high".to_string()); + let mut updated = conversation.clone(); + updated.ai_thinking_level = Some("medium".to_string()); + let db = MockDatabase::new(DatabaseBackend::Postgres) + .append_query_results([[updated]]) + .into_connection(); + + let result = db_service_with_ai(db, Arc::new(ToolRestrictedCapabilitiesAi)) + .update_runtime_options(&conversation, None, None, None) + .await + .expect("the reconciled tool-safe thinking mode should persist"); + + assert_eq!(result.ai_thinking_level.as_deref(), Some("medium")); + } + + #[tokio::test] + async fn update_runtime_options_does_not_reject_from_non_authoritative_catalogs() { + for source in [ + temps_ai::ModelCatalogSource::Bootstrap, + temps_ai::ModelCatalogSource::StaleCache, + ] { + for model in ["workspace-entitled-model", "gpt-4o-mini"] { + for thinking_level in [Some("medium".to_string()), None] { + let mut conversation = test_conversation(); + conversation.ai_provider = "claude_cli".to_string(); + conversation.ai_model = model.to_string(); + conversation.ai_thinking_level = thinking_level; + let db = MockDatabase::new(DatabaseBackend::Postgres).into_connection(); + let result = + db_service_with_ai(db, Arc::new(NonAuthoritativeCapabilitiesAi(source))) + .update_runtime_options(&conversation, None, None, None) + .await + .expect("fallback catalogs are not account allowlists"); + + assert_eq!(result, conversation); + } + } + } + } + #[tokio::test] async fn update_runtime_options_preserves_database_failure() { let mut conversation = test_conversation(); diff --git a/crates/temps-ai-gateway/src/plugin.rs b/crates/temps-ai-gateway/src/plugin.rs index ca1ed7db3..ff25eb06b 100644 --- a/crates/temps-ai-gateway/src/plugin.rs +++ b/crates/temps-ai-gateway/src/plugin.rs @@ -136,6 +136,9 @@ impl TempsPlugin for AiGatewayPlugin { })?, ); context.register_service(sandbox_model_relay.clone()); + let sandbox_workspace_resolver = + Arc::new(temps_ai_agent_cli::SandboxWorkspaceResolverSlot::new()); + context.register_service(sandbox_workspace_resolver.clone()); let sandbox_credentials: temps_ai_agent_cli::SandboxCredentialResolver = { let config_service = config_service.clone(); let encryption_service = encryption_service.clone(); @@ -253,6 +256,7 @@ impl TempsPlugin for AiGatewayPlugin { application_workspace_root.clone(), sandbox_credentials.clone(), sandbox_model_relay.clone(), + sandbox_workspace_resolver.as_ref().clone(), ); } else { tracing::warn!( diff --git a/crates/temps-ai/src/lib.rs b/crates/temps-ai/src/lib.rs index 24a1e3f59..15bcc6d2d 100644 --- a/crates/temps-ai/src/lib.rs +++ b/crates/temps-ai/src/lib.rs @@ -29,8 +29,8 @@ pub mod streaming; pub mod typed; pub use provider::{ - ModelCapability, ProviderAuthSource, ProviderCapabilities, RealtimeCapabilities, RefreshPolicy, - SelectOption, + ModelCapability, ModelCatalogSource, ProviderAuthSource, ProviderCapabilities, + ProviderCapabilitiesSnapshot, RealtimeCapabilities, RefreshPolicy, SelectOption, }; pub use service::{AiError, AiRequest, AiResponse, AiService}; pub use streaming::{ diff --git a/crates/temps-ai/src/provider.rs b/crates/temps-ai/src/provider.rs index aa2627c17..ec75b79f9 100644 --- a/crates/temps-ai/src/provider.rs +++ b/crates/temps-ai/src/provider.rs @@ -16,6 +16,25 @@ pub enum RefreshPolicy { Refresh, } +/// Provenance of a provider model inventory. Only live and unexpired cached +/// inventories are authoritative enough to reject a saved model. Bootstrap +/// and stale inventories remain useful for selectors, but must not block a +/// turn because account entitlements may legitimately differ. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ToSchema)] +#[serde(rename_all = "snake_case")] +pub enum ModelCatalogSource { + Live, + Cache, + StaleCache, + Bootstrap, +} + +impl ModelCatalogSource { + pub fn is_authoritative(self) -> bool { + matches!(self, Self::Live | Self::Cache) + } +} + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, ToSchema)] #[serde(rename_all = "snake_case")] pub enum ProviderAuthSource { @@ -64,6 +83,15 @@ pub struct ProviderCapabilities { pub realtime: RealtimeCapabilities, } +/// Capabilities together with enough provenance for callers to distinguish a +/// current account-aware model inventory from a convenience fallback. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, ToSchema)] +pub struct ProviderCapabilitiesSnapshot { + pub capabilities: ProviderCapabilities, + pub model_source: ModelCatalogSource, + pub models_refreshed_at: Option, +} + impl ProviderCapabilities { pub fn model(&self, id: &str) -> Option<&ModelCapability> { self.models.iter().find(|model| model.id == id) diff --git a/crates/temps-ai/src/service.rs b/crates/temps-ai/src/service.rs index cc84a5196..71448c843 100644 --- a/crates/temps-ai/src/service.rs +++ b/crates/temps-ai/src/service.rs @@ -124,6 +124,40 @@ pub trait AiService: Send + Sync { Err(AiError::NotAvailable) } + /// Return capabilities for the provider credential available to the Temps + /// host. The snapshot preserves whether discovery was live, cached, stale, + /// or only a bootstrap fallback. + async fn capabilities_snapshot_for( + &self, + provider: Option<&str>, + refresh: RefreshPolicy, + ) -> Result { + let capabilities = self.capabilities_for(provider, refresh).await?; + Ok(crate::ProviderCapabilitiesSnapshot { + capabilities, + model_source: match refresh { + RefreshPolicy::Refresh => crate::ModelCatalogSource::Live, + RefreshPolicy::Cached => crate::ModelCatalogSource::Cache, + }, + models_refreshed_at: None, + }) + } + + /// Return provider capabilities for the credential used by a user's + /// persistent workspace. Implementations without a distinct workspace + /// credential inherit the ordinary provider capability path. + async fn capabilities_snapshot_for_principal( + &self, + provider: Option<&str>, + _principal_id: i32, + refresh: RefreshPolicy, + ) -> Result { + self.capabilities_snapshot_for(provider, refresh).await + } + + /// Invalidate account-scoped capability state after credentials change. + async fn invalidate_capabilities_for(&self, _provider: Option<&str>) {} + /// Low-level completion. Prefer the [`crate::complete_text`] / /// [`crate::complete_typed`] helpers for everyday use. async fn complete(&self, request: AiRequest) -> Result; diff --git a/crates/temps-sandbox/src/services/registry.rs b/crates/temps-sandbox/src/services/registry.rs index 4c35c7655..9558fa415 100644 --- a/crates/temps-sandbox/src/services/registry.rs +++ b/crates/temps-sandbox/src/services/registry.rs @@ -23,10 +23,10 @@ //! "DB says running, container is actually stopped or gone"), which then //! makes the next `exec` call fail with NotFound and the user confused. -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use std::sync::Arc; use std::time::Duration; -use tokio::sync::RwLock; +use tokio::sync::{Mutex, RwLock}; use temps_agents::error::AgentError; use temps_agents::sandbox::{ @@ -36,6 +36,15 @@ use temps_agents::sandbox::{ pub struct StandaloneSandboxRegistry { provider: Arc, handles: RwLock>, + /// Sandboxes whose live provider handle was adopted in this server + /// generation. Their previous Temps process may have died while a harness + /// exec was active, so the first managed workspace operation must fence + /// those provider CLIs before reusing the container. + recovered_in_this_generation: RwLock>, + /// Serialize the first verified fence per recovered sandbox. The + /// generation marker remains set while the future is in flight, making + /// cancellation fail closed; concurrent callers wait here and re-check it. + recovery_fence_locks: Mutex>>>, } const STARTUP_RECOVERY_TIMEOUT: Duration = Duration::from_secs(5); @@ -45,6 +54,8 @@ impl StandaloneSandboxRegistry { Self { provider, handles: RwLock::new(HashMap::new()), + recovered_in_this_generation: RwLock::new(HashSet::new()), + recovery_fence_locks: Mutex::new(HashMap::new()), } } @@ -61,6 +72,7 @@ impl StandaloneSandboxRegistry { let id = config.run_id; let handle = self.provider.create(config).await?; self.handles.write().await.insert(id, handle.clone()); + self.recovered_in_this_generation.write().await.remove(&id); Ok(handle) } @@ -75,6 +87,7 @@ impl StandaloneSandboxRegistry { let id = config.run_id; let handle = self.provider.create_from_snapshot(artifact, config).await?; self.handles.write().await.insert(id, handle.clone()); + self.recovered_in_this_generation.write().await.remove(&id); Ok(handle) } @@ -106,6 +119,7 @@ impl StandaloneSandboxRegistry { self.handles.write().await.remove(&id); let handle = self.provider.create(config).await?; self.handles.write().await.insert(id, handle.clone()); + self.recovered_in_this_generation.write().await.remove(&id); Ok(handle) } @@ -122,6 +136,7 @@ impl StandaloneSandboxRegistry { self.handles.write().await.remove(&id); let handle = self.provider.create_from_snapshot(artifact, config).await?; self.handles.write().await.insert(id, handle.clone()); + self.recovered_in_this_generation.write().await.remove(&id); Ok(handle) } @@ -187,6 +202,7 @@ impl StandaloneSandboxRegistry { match self.provider.recover_by_name(label).await? { Some(recovered) => { self.handles.write().await.insert(id, recovered.clone()); + self.recovered_in_this_generation.write().await.insert(id); Ok(recovered) } None => Err(AgentError::SandboxNotFound { run_id: id }), @@ -237,6 +253,7 @@ impl StandaloneSandboxRegistry { return Err(e); } self.handles.write().await.remove(&id); + self.recovered_in_this_generation.write().await.remove(&id); Ok(()) } @@ -305,6 +322,7 @@ impl StandaloneSandboxRegistry { match tokio::time::timeout(timeout, self.provider.recover_by_name(label)).await { Ok(Ok(Some(handle))) => { self.handles.write().await.insert(*id, handle); + self.recovered_in_this_generation.write().await.insert(*id); recovered += 1; } Ok(Ok(None)) => {} @@ -330,6 +348,49 @@ impl StandaloneSandboxRegistry { recovered } + /// Fence provider CLI processes that may have outlived the previous Temps + /// server process. This is deliberately narrower than restarting the + /// container: user dev servers, terminals, and other background work keep + /// running, while only the three command shapes launched by the managed + /// harness runtime are terminated before a new turn or model probe starts. + /// + /// A per-sandbox lock makes concurrent callers await the same fence. The + /// generation marker is removed only after the provider verifies that the + /// complete matching process trees are gone. Provider failure, timeout, + /// or future cancellation leaves the marker intact so the next managed + /// operation retries and fails closed until fencing succeeds. + pub async fn fence_recovered_harness_processes( + &self, + id: i32, + public_id: &str, + ) -> Result<(), AgentError> { + let fence_lock = { + let mut locks = self.recovery_fence_locks.lock().await; + locks + .entry(id) + .or_insert_with(|| Arc::new(Mutex::new(()))) + .clone() + }; + let _fence_guard = fence_lock.lock().await; + + if !self.recovered_in_this_generation.read().await.contains(&id) { + return Ok(()); + } + let handle = self.get_or_recover(id, public_id).await?; + self.provider + .fence_process_trees( + &handle, + &[ + r"(^|/)claude --print( |$)", + r"(^|/)codex exec( |$)", + r"(^|/)opencode run( |$)", + ], + ) + .await?; + self.recovered_in_this_generation.write().await.remove(&id); + Ok(()) + } + pub fn provider_name(&self) -> &str { self.provider.name() } @@ -366,6 +427,10 @@ mod tests { stops: AtomicUsize, restarts: AtomicUsize, destroys: AtomicUsize, + fence_patterns: std::sync::Mutex>>, + fence_attempts: AtomicUsize, + fence_failures_remaining: AtomicUsize, + fence_gate: Option>, recovery_delay: Duration, } @@ -377,6 +442,10 @@ mod tests { stops: AtomicUsize::new(0), restarts: AtomicUsize::new(0), destroys: AtomicUsize::new(0), + fence_patterns: std::sync::Mutex::new(Vec::new()), + fence_attempts: AtomicUsize::new(0), + fence_failures_remaining: AtomicUsize::new(0), + fence_gate: None, recovery_delay: Duration::ZERO, } } @@ -391,6 +460,17 @@ mod tests { self.recovery_delay = delay; self } + + fn with_fence_failures(self, failures: usize) -> Self { + self.fence_failures_remaining + .store(failures, Ordering::SeqCst); + self + } + + fn with_fence_gate(mut self, gate: Arc) -> Self { + self.fence_gate = Some(gate); + self + } } #[async_trait] @@ -453,9 +533,47 @@ mod tests { async fn kill_processes( &self, _handle: &SandboxHandle, - _pattern: &str, + pattern: &str, _signal: temps_agents::sandbox::KillSignal, ) -> Result<(), AgentError> { + let _ = pattern; + Ok(()) + } + + async fn fence_process_trees( + &self, + _handle: &SandboxHandle, + patterns: &[&str], + ) -> Result<(), AgentError> { + self.fence_attempts.fetch_add(1, Ordering::SeqCst); + self.fence_patterns + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .push( + patterns + .iter() + .map(|pattern| (*pattern).to_string()) + .collect(), + ); + if let Some(gate) = &self.fence_gate { + gate.acquire() + .await + .expect("test fence gate remains open") + .forget(); + } + if self + .fence_failures_remaining + .fetch_update(Ordering::SeqCst, Ordering::SeqCst, |remaining| { + remaining.checked_sub(1) + }) + .is_ok() + { + return Err(AgentError::SandboxExecFailed { + run_id: 42, + sandbox_id: "sbx_abc123".to_string(), + reason: "simulated strict fence failure".to_string(), + }); + } Ok(()) } @@ -665,6 +783,162 @@ mod tests { ); } + #[tokio::test] + async fn first_workspace_use_fences_only_recovered_harness_processes_once() { + let provider = Arc::new(FakeProvider::new().with_known("abc123")); + let reg = StandaloneSandboxRegistry::new(provider.clone()); + + assert_eq!(reg.recover_active(&[(42, "abc123".to_string())]).await, 1); + reg.fence_recovered_harness_processes(42, "sbx_abc123") + .await + .expect("first-generation fence"); + reg.fence_recovered_harness_processes(42, "sbx_abc123") + .await + .expect("already-fenced workspace"); + + assert_eq!(provider.restarts.load(Ordering::SeqCst), 0); + assert_eq!( + provider + .fence_patterns + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .as_slice(), + [[ + r"(^|/)claude --print( |$)", + r"(^|/)codex exec( |$)", + r"(^|/)opencode run( |$)", + ]] + ); + } + + #[tokio::test] + async fn failed_recovery_fence_remains_required_until_verified() { + let provider = Arc::new( + FakeProvider::new() + .with_known("abc123") + .with_fence_failures(1), + ); + let reg = StandaloneSandboxRegistry::new(provider.clone()); + + assert_eq!(reg.recover_active(&[(42, "abc123".to_string())]).await, 1); + reg.fence_recovered_harness_processes(42, "sbx_abc123") + .await + .expect_err("an unverified fence must fail closed"); + reg.fence_recovered_harness_processes(42, "sbx_abc123") + .await + .expect("the next use retries the fence"); + reg.fence_recovered_harness_processes(42, "sbx_abc123") + .await + .expect("verified fence is not repeated"); + + assert_eq!(provider.fence_attempts.load(Ordering::SeqCst), 2); + } + + #[tokio::test] + async fn cancelled_recovery_fence_remains_required() { + let gate = Arc::new(tokio::sync::Semaphore::new(0)); + let provider = Arc::new( + FakeProvider::new() + .with_known("abc123") + .with_fence_gate(gate.clone()), + ); + let reg = Arc::new(StandaloneSandboxRegistry::new(provider.clone())); + + assert_eq!(reg.recover_active(&[(42, "abc123".to_string())]).await, 1); + let cancelled = { + let reg = reg.clone(); + tokio::spawn(async move { + reg.fence_recovered_harness_processes(42, "sbx_abc123") + .await + }) + }; + while provider.fence_attempts.load(Ordering::SeqCst) == 0 { + tokio::task::yield_now().await; + } + cancelled.abort(); + let _ = cancelled.await; + + gate.add_permits(1); + reg.fence_recovered_harness_processes(42, "sbx_abc123") + .await + .expect("cancellation must leave the fence pending"); + assert_eq!(provider.fence_attempts.load(Ordering::SeqCst), 2); + } + + #[tokio::test] + async fn concurrent_first_use_shares_one_verified_fence() { + let gate = Arc::new(tokio::sync::Semaphore::new(0)); + let provider = Arc::new( + FakeProvider::new() + .with_known("abc123") + .with_fence_gate(gate.clone()), + ); + let reg = Arc::new(StandaloneSandboxRegistry::new(provider.clone())); + + assert_eq!(reg.recover_active(&[(42, "abc123".to_string())]).await, 1); + let first = { + let reg = reg.clone(); + tokio::spawn(async move { + reg.fence_recovered_harness_processes(42, "sbx_abc123") + .await + }) + }; + let second = { + let reg = reg.clone(); + tokio::spawn(async move { + reg.fence_recovered_harness_processes(42, "sbx_abc123") + .await + }) + }; + while provider.fence_attempts.load(Ordering::SeqCst) == 0 { + tokio::task::yield_now().await; + } + tokio::time::sleep(Duration::from_millis(10)).await; + assert_eq!(provider.fence_attempts.load(Ordering::SeqCst), 1); + + gate.add_permits(1); + first.await.expect("first fence task").expect("first fence"); + second + .await + .expect("second fence task") + .expect("shared fence result"); + assert_eq!(provider.fence_attempts.load(Ordering::SeqCst), 1); + } + + #[tokio::test] + async fn newly_created_workspace_does_not_run_restart_fencing() { + let provider = Arc::new(FakeProvider::new()); + let reg = StandaloneSandboxRegistry::new(provider.clone()); + reg.create(SandboxCreateConfig { + run_id: 42, + container_name_override: Some("abc123".to_string()), + host_work_dir: PathBuf::from("/workspace"), + workspace_volume: None, + image: None, + cpu_limit: None, + memory_limit_mb: None, + pids_limit: None, + disk_size_mb: None, + network_mode: None, + env_vars: HashMap::new(), + idle_timeout: Duration::from_secs(60), + backend: None, + owner_user_id: Some(7), + }) + .await + .expect("new workspace"); + + reg.fence_recovered_harness_processes(42, "sbx_abc123") + .await + .expect("new workspace needs no fence"); + + assert!(provider + .fence_patterns + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .is_empty()); + } + #[test] fn label_for_strips_sbx_prefix() { assert_eq!(StandaloneSandboxRegistry::label_for("sbx_abc123"), "abc123"); diff --git a/crates/temps-sandbox/src/services/sandbox_service.rs b/crates/temps-sandbox/src/services/sandbox_service.rs index 6c8fcf898..457865ebc 100644 --- a/crates/temps-sandbox/src/services/sandbox_service.rs +++ b/crates/temps-sandbox/src/services/sandbox_service.rs @@ -199,6 +199,10 @@ pub struct CreateSandboxRequest { #[derive(Debug, Clone)] pub struct ApplicationWorkspaceSandbox { pub public_id: String, + /// Authoritative provider handle adopted through SandboxService. Internal + /// harness callers use this instead of recovering the same live sandbox a + /// second time and mistaking a cold local cache for an orphan. + pub handle: Option, } #[derive(Debug, Clone)] @@ -1689,7 +1693,7 @@ impl SandboxService { self.destroy_sandbox(&untrusted.public_id, user_id).await?; } } - let sandbox = if let Some(mut existing) = existing { + let sandbox_public_id = if let Some(mut existing) = existing { // `project_id` is the generic sandbox credential scope. Keep it // aligned when an application changes its primary project. if existing.project_id != project_id { @@ -1715,9 +1719,7 @@ impl SandboxService { ) .await?; } - ApplicationWorkspaceSandbox { - public_id: existing.public_id, - } + existing.public_id } else { // A per-workspace password makes the bare opaque hostname useless on // its own. The chat API returns only short-lived preview grants; this @@ -1744,16 +1746,18 @@ impl SandboxService { }, ) .await?; - ApplicationWorkspaceSandbox { - public_id: row.public_id, - } + row.public_id }; // Reconcile the complete authorized data plane while stopped compute // cannot use stale memberships. Only after this succeeds may an idle // workspace be resumed. New/rebuilt compute starts with no application // data network; if reconciliation fails, stop it before returning. - let row = self.find_by_public_id(&sandbox.public_id, user_id).await?; + let row = self.find_by_public_id(&sandbox_public_id, user_id).await?; + self.registry + .fence_recovered_harness_processes(row.id, &sandbox_public_id) + .await + .map_err(|error| from_agent_error(&sandbox_public_id, error))?; let configure_result = self .configure_application_data_network_locked(&row, authorized_project_ids) .await; @@ -1770,13 +1774,26 @@ impl SandboxService { return Err(error); } if row.status == "stopped" && config.desired_state == "running" { - self.resume_sandbox(&sandbox.public_id, user_id).await?; + self.resume_sandbox(&sandbox_public_id, user_id).await?; } if config.desired_state == "running" { - self.prepare_application_git_workspace(&sandbox.public_id, user_id) + self.prepare_application_git_workspace(&sandbox_public_id, user_id) .await?; } - Ok(sandbox) + let handle = if config.desired_state == "running" { + Some( + self.registry + .get(row.id, &sandbox_public_id) + .await + .map_err(|error| from_agent_error(&sandbox_public_id, error))?, + ) + } else { + None + }; + Ok(ApplicationWorkspaceSandbox { + public_id: sandbox_public_id, + handle, + }) } pub async fn rebuild_application_workspace( @@ -4648,6 +4665,16 @@ mod storage_cleanup_tests { Ok(()) } + async fn fence_process_trees( + &self, + _handle: &SandboxHandle, + _patterns: &[&str], + ) -> Result<(), AgentError> { + // Restart-recovery fencing is orthogonal to the individual + // lifecycle failure knobs exercised by this service fake. + Ok(()) + } + async fn destroy( &self, handle: &SandboxHandle, @@ -5048,6 +5075,14 @@ mod storage_cleanup_tests { .expect("application preparation must wake its stopped provider runtime"); assert_eq!(sandbox.public_id, PUBLIC_ID); + assert_eq!( + sandbox + .handle + .as_ref() + .expect("running application workspace handle") + .sandbox_name, + "temps-sandbox-deadbeef01234567" + ); assert_eq!( creates.load(Ordering::SeqCst), 1, diff --git a/web/src/api/client/@tanstack/react-query.gen.ts b/web/src/api/client/@tanstack/react-query.gen.ts index ee4001fca..30221c6f6 100644 --- a/web/src/api/client/@tanstack/react-query.gen.ts +++ b/web/src/api/client/@tanstack/react-query.gen.ts @@ -6,8 +6,8 @@ import { type DefaultError, type InfiniteData, infiniteQueryOptions, queryOptions, type UseMutationOptions } from '@tanstack/react-query'; import { client } from '../client.gen'; -import { acknowledgeAlarm, acknowledgeSystemAlarm, activateAiProvider, activateApiKey, activateConnection, activateProvider, addClusterMember, addContext, addEnvironmentDomain, addEvents, addManagedDomain, addProviderModel, addSessionReplayEvents, addTeamMember, adminDrainNode, adminDrainStatus, adminGetNode, adminListNodeContainers, adminListNodes, adminRemoveNode, adminUndrainNode, aggregateApiTraffic, applyHostnameMode, archiveApplication, archiveConversation, archiveFlag, archiveUserConversation, assignRole, attachScheduleServices, authorizeEmailDomainProject, blobCopy, blobDelete, blobDisable, blobDownload, blobEnable, blobList, blobPut, blobStatus, blobUpdate, cancel, cancelBackup, cancelBulkActivationJob, cancelDeployment, cancelDomainOrder, cancelPgUpgrade, cancelRun, cancelScheduleRun, changePasswordSelf, changeProjectSource, changeRequiredPassword, chatCompletions, checkAnalyticsHasEvents, checkCommitExists, checkDomainStatus, checkExplorerSupport, checkForUpdate, checkIpBlocked, checkProviderDeletionSafety, chunkUploadOptions, cleanupExpiredBackups, clearPreviewPassword, cliDeviceApprove, cliDeviceDeny, cliDeviceLookup, cliDevicePoll, cliDeviceStart, cliLogout, clusterDnsStatus, cmd, cmdKill, cmdLogs, confirmPendingAction, confirmUserPendingAction, containerMetricsGetHistory, controlApplicationWorkspace, createAgent, createAlert, createAlertRule, createAnalyticsIngestKey, createApiKey, createApplication, createApplicationConversation, createApplicationPreviewLink, createApplicationProject, createBackupSchedule, createBitbucketProvider, createBulkActivationJob, createCloudflareProvider, createConversation, createCustomDomain, createDashboard, createDeploymentToken, createDnsProvider, createDomain, createDsn, createEmailDomain, createEmailProvider, createEnvironment, createEnvironmentVariable, createFacet, createFlag, createFunnel, createGenericProvider, createGiteaPatProvider, createGithubPatProvider, createGitlabOauthProvider, createGitlabPatProvider, createGitProvider, createGlobalConversation, createGlobalMcp, createGlobalSkill, createGlobalWorkspacePreviewLink, createIncident, createIpAccessControl, createMcp, createMonitor, createNotificationEmailProvider, createNotificationProvider, createNotificationRoute, createOidcProvider, createOidcRoleMapping, createOrRecreateOrder, createPlan, createPr, createProject, createProjectFromTemplate, createProjectRelease, createProjectSecret, createProviderKey, createRelease, createRoute, createS3Source, createSandbox, createService, createSkill, createSlackProvider, createSnapshot, createTeam, createThreadArtifact, createUser, createWebhook, createWebhookProvider, deactivateApiKey, deactivateConnection, deactivateProvider, deauthorizeDiscoveredRouteCert, deleteAgent, deleteAlert, deleteAlertRule, deleteApiKey, deleteBackup, deleteBackupSchedule, deleteConnection, deleteCustomDomain, deleteDashboard, deleteDeploymentToken, deleteDnsProvider, deleteDomain, deleteEmailDomain, deleteEmailProvider, deleteEnvironment, deleteEnvironmentDomain, deleteEnvironmentVariable, deleteExternalImage, deleteFacet, deleteFunnel, deleteGitProvider, deleteGlobalMcp, deleteGlobalSkill, deleteIpAccessControl, deleteMcp, deleteMonitor, deleteNotificationProvider, deleteNotificationRoute, deleteOidcProvider, deleteOidcRoleMapping, deletePreferences, deleteProject, deleteProjectSecret, deleteProviderKey, deleteProviderModel, deleteProviderSafely, deleteReleaseSourceFiles, deleteReleaseSourceMaps, deleteRoute, deleteS3Source, deleteScan, deleteSecret, deleteService, deleteSessionReplay, deleteSkill, deleteSnapshot, deleteSourceMap, deleteStaticBundle, deleteTeam, deleteUser, deleteWebhook, deployApplicationWorkspaceProject, deployFromImage, deployFromImageUpload, deployFromStatic, deployFromUploadedSource, deploymentMetricsGetLatest, deploymentMetricsGetRange, deploymentMetricsToggle, destroySandbox, detachScheduleService, detectPublicEnvExample, detectPublicPresets, disableBackupSchedule, disableMfa, disconnectCloud, discoverWorkloads, domain, downloadApplicationWorkspaceFile, downloadGlobalSkillArchive, downloadGlobalWorkspaceFile, downloadObject, downloadSkillArchive, emailStatus, embeddings, enableBackupSchedule, enrichVisitor, enrollCloud, estimateBulkActivation, exec, execDetached, executeDeploymentOperation, executeImport, extendTimeout, externalServiceEnablePgStatStatements, externalServiceMetricsByDatabase, externalServiceMetricsCreateAlertRule, externalServiceMetricsDeleteAlertRule, externalServiceMetricsGetAlertRules, externalServiceMetricsGetLatest, externalServiceMetricsGetRange, externalServiceMetricsStatus, externalServiceMetricsToggle, externalServiceMetricsUpdateAlertRule, externalServiceResetPgStatStatements, finalizeOrder, finalizeProjectRelease, findConversation, generateJoinToken, generatePresetDockerfile, getAccessInfo, getActiveVisitors, getActivityGraph, getAdminGate, getAgent, getAggregatedBuckets, getAiAgentBreakdown, getAiAgentPages, getAiAgentTimeline, getAiDataAccess, getAiPageBreakdown, getAiProviderStatus, getAiStatusBreakdown, getAlert, getAlertRule, getAllRepositoriesByName, getAnalyticsActiveVisitors, getAnalyticsEventsCount, getAnalyticsSessionEvents, getAnalyticsVisitorSessions, getApiCallers, getApiKey, getApiKeyPermissions, getApiRoutes, getApiSummary, getApiTimeseries, getApiTrafficProxyLogAccess, getApplication, getApplicationWorkspace, getApplicationWorkspaceChanges, getApplicationWorkspaceDiff, getApplicationWorkspaceDirectory, getApplicationWorkspaceFile, getAuditLog, getBackup, getBackupSchedule, getBranchesByRepositoryId, getBucketedIncidents, getBucketedStatus, getBulkActivationJob, getChallengeToken, getChatReadiness, getCliStatus, getCloudAiCapability, getCloudBackfillStatus, getCloudCapability, getCloudStatus, getCloudTelemetryStatus, getClusterHealth, getClusterMember, getCmd, getContainerDetail, getContainerEnvironmentVariable, getContainerLogs, getContainerLogsById, getContainerMetrics, getConversation, getConversationDetail, getConversations, getCronById, getCronExecutions, getCrossProjectTraceSiblings, getCurrentBulkActivationJob, getCurrentMonitorStatus, getCurrentUser, getCustomDomain, getDashboard, getDashboardProjectsAnalytics, getDelivery, getDeployment, getDeploymentContainerLogContent, getDeploymentJobLogs, getDeploymentJobs, getDeploymentOperations, getDeploymentOperationStatus, getDeploymentToken, getDiskStatus, getDnsChanges, getDnsProvider, getDomain, getDomainByHost, getDomainById, getDomainByName, getDomainDnsRecords, getDomainOrder, getEmail, getEmailEvents, getEmailLinks, getEmailProvider, getEmailStats, getEmailTracking, getEmailTrackingStatus, getEntityInfo, getEnvironment, getEnvironmentCrons, getEnvironmentDomains, getEnvironments, getEnvironmentVariables, getEnvironmentVariableValue, getErrorDashboardStats, getErrorEvent, getErrorGroup, getErrorStats, getErrorTimeSeries, getEventDetail, getEventEntries, getEventsCount, getEventsTimeline, getEventTypeBreakdown, getEventVisitors, getExternalImage, getExternalServiceBackupCapability, getFailureReportPreview, getFeatureMaturity, getFile, getFlag, getFlagSnapshot, getFunnelMetrics, getGenaiTrace, getGeneralStats, getGitProvider, getGlobalAiWorkspace, getGlobalEvents, getGlobalEventStats, getGlobalMcp, getGlobalSandboxStatus, getGlobalSkill, getGlobalWorkspaceChanges, getGlobalWorkspaceDiff, getGlobalWorkspaceDirectory, getGlobalWorkspaceFile, getGroupedPageMetrics, getHealth, getHourlyVisits, getHttpChallengeDebug, getImportStatus, getIncident, getIncidentUpdates, getIngestErrors, getIpAccessControl, getIpGeolocation, getJoinTokenStatus, getLastDeployment, getLatestDeploymentMedia, getLatestScan, getLatestScansPerEnvironment, getLiveVisitorsList, getLogContext, getMcp, getMetricsOverTime, getMonitor, getNotificationProvider, getNotificationRoute, getOnDemandCertStatus, getOrCreateDsn, getPageFlow, getPageHourlySessions, getPagePathDetail, getPagePaths, getPagePathsSparklines, getPagePathVisitors, getPendingAction, getPerformanceMetrics, getPgUpgrade, getPgUpgradeLogs, getPipelineHistory, getPipelineStats, getPlatformInfo, getPostgresWalHealth, getPreferences, getPreviewGatewayLogs, getPreviewGatewaySettings, getPreviewGatewayStatus, getPricing, getPrivateIp, getProject, getProjectAlarmsSummary, getProjectBySlug, getProjectCloudTelemetry, getProjectDeployments, getProjects, getProjectServiceEnvironmentVariables, getProjectServiceTemplate, getProjectSessionReplays, getProjectsHealth, getProjectsMonitorHealth, getProjectStatistics, getProjectTemplate, getPropertyBreakdown, getPropertyTimeline, getProviderConnections, getProviderKey, getProviderMetadata, getProvidersMetadata, getProxyLogById, getProxyLogByRequestId, getProxyLogs, getPublicBranches, getPublicComposePreview, getPublicComposeServices, getPublicIp, getPublicRepository, getQueryContainerInfo, getQuota, getRecentActivity, getRemoteExternalImage, getRepositoryBranches, getRepositoryById, getRepositoryByName, getRepositoryComposePreview, getRepositoryComposeServicesLive, getRepositoryEnvExampleLive, getRepositoryPresetByName, getRepositoryPresetLive, getRepositoryTags, getResolvedEnvironmentVariables, getResolvedEnvironmentVariableValue, getRestoreCapabilities, getRestoreRun, getRoute, getRun, getRunWithLogs, getS3Credentials, getS3Source, getSandbox, getSandboxStatus, getScan, getScanByDeployment, getScanVulnerabilities, getService, getServiceBySlug, getServiceEnvironmentVariable, getServiceEnvironmentVariables, getServiceHealthStatus, getServicePreviewEnvironmentVariableNames, getServicePreviewEnvironmentVariablesMasked, getServiceRuntime, getServiceStats, getServiceTypeParameters, getServiceTypes, getSessionDetails, getSessionEvents, getSessionLogs, getSessionReplay, getSessionReplayEvents, getSettings, getSkill, getSlowQueries, getSnapshot, getStaticBundle, getStatusOverview, getSystemAlarmsSummary, getTagsByRepositoryId, getTeam, getTimeBucketStats, getTodayStats, getTrace, getTraefikDiscoveryStatus, getUnifiedTrace, getUniqueCounts, getUniqueEvents, getUpdateCapability, getUpdateStatus, getUptimeHistory, getUsageByProvider, getUsageRecent, getUsageSummary, getUsageTimeseries, getUsageTopModels, getUserConversation, getUserConversationAttachment, getUserPendingAction, getVisibleCustomDomainByHostname, getVisitorByGuid, getVisitorById, getVisitorDetails, getVisitorFacets, getVisitorInfo, getVisitorJourney, getVisitors, getVisitorSessions, getVisitorStats, getWebhook, getWorkspaceFileLimits, grantProjectAccess, handleGitProviderOauthCallback, hasAnalyticsEvents, hasErrorGroups, hasPerformanceMetrics, hasTraces, importApplicationWorkspaceGit, importEmailDomain, importExternalService, importTraefikAcmeJson, ingestLogs, ingestLogsByPath, ingestMetrics, ingestMetricsByPath, ingestSentryEnvelope, ingestSentryEvent, ingestTraces, ingestTracesByPath, ingestTunneledEnvelope, initSessionReplay, inspectDropArchive, issueRuntimeCredentials, jobLogs, jobStatus, killJob, kvDel, kvDisable, kvEnable, kvExpire, kvGet, kvIncr, kvKeys, kvSet, kvStatus, kvTtl, kvUpdate, latestRunForSource, linkApplicationProject, linkCustomDomainToCertificate, linkServiceToProject, listAgentRuns, listAgents, listAiProviders, listAlertRules, listAlerts, listAllConversations, listAllRuns, listAnalyticsIngestKeys, listApiKeys, listApplicationConversations, listApplications, listAuditLogs, listAvailableContainers, listBackupAlerts, listBackupChildren, listBackupSchedules, listBackupsForSchedule, listCommitsByRepositoryId, listConnections, listContainerHistory, listContainers, listContainersAtPath, listConversations, listCustomDomainsForProject, listDashboards, listDeliveries, listDeploymentContainerLogs, listDeploymentTokens, listDiscoverableDomains, listDnsProviders, listDomains, listDsns, listEmailDomainProjects, listEmailDomains, listEmailProviders, listEmails, listEnrollmentTokens, listEntities, listErrorEvents, listErrorGroups, listEvents, listEventTypes, listExternalImages, listExternalPlugins, listExternalServiceBackups, listFacets, listFlags, listFunnels, listGitProviders, listGlobalMcps, listGlobalSkills, listIncidents, listInsights, listIpAccessControl, listJobs, listKnownAiAgents, listManagedDomains, listManagedEnvironmentVariables, listMcps, listMetricLabelKeys, listMetricLabelValues, listMetricNames, listModels, listMonitors, listNotificationProviders, listNotificationRoutes, listOidcProviders, listOidcProviderUsers, listOidcRoleMappings, listOnDemandCerts, listOrders, listPeers, listPendingActions, listPgUpgrades, listPresets, listProjectAccess, listProjectAlarms, listProjectScans, listProjectSecrets, listProjectServices, listProjectTemplates, listProjectTemplateTags, listProviderKeys, listProviderZones, listPublicProviders, listReleaseFiles, listReleases, listRemoteExternalImages, listRenewalAttempts, listRepositoriesByConnection, listRepositoriesByProvider, listRestoreRunsForService, listRootContainers, listRoutes, listS3Sources, listSandboxes, listScheduleRunJobs, listScheduleRuns, listScheduleServices, listSecrets, listServiceHealthStatuses, listServiceProjects, listServices, listServiceSchedules, listSkills, listSnapshots, listSourceBackups, listSourceFiles, listSourceMaps, listSources, listStaticBundles, listSyncedRepositories, listSystemAlarms, listTeamMembers, listTeamProjects, listTeams, listThreadArtifacts, listTraefikDiscoveredRoutes, listUserPendingActions, listUsers, listWebhooks, login, logout, lookupDnsARecords, mintEnrollmentToken, mkdir, nodeHeartbeat, nodeMetricsGetAlertRules, nodeMetricsGetRange, nodeMetricsUpdateAlertRule, observabilityFullEvent, observabilityListEvents, oidcCallback, type Options, patchAdminGate, patchPreviewGatewaySettings, pauseDeployment, pauseSandbox, planRestore, postDnsAck, previewAlert, previewFunnelMetrics, previewHostnameMode, promoteClusterMember, promoteDeployment, provisionDomain, purgeProjectLogs, pushExternalImage, queryData, queryGenaiTraces, queryLogs, queryMetrics, querySpanStats, queryTraces, queryTraceSummaries, readEntityRows, readFile, reAnalyze, reassignProjectCustomDomain, reconcileCloudBackupSource, recordConsoleEvent, recordEventMetrics, recordFlagExposure, recordSpeedMetrics, refreshAiProviderStatus, refreshProviderModels, refreshRouteTable, regenerateDsn, registerExternalImage, registerNode, reinstallGitlabWebhook, rejectPendingAction, rejectUserPendingAction, reloadPlugins, removeClusterMember, removeManagedDomain, removeRole, removeTeamMember, renameConversation, renameUserConversation, renewDomain, repointContinuousArchiveSource, requestDiscoveredRouteCert, requestPasswordReset, resetPassword, resizeSandbox, resolveAlarm, resolvePermission, resolveSystemAlarm, resolveUserPermission, restartContainer, restartPreviewGateway, restartSandbox, restoreApplication, restoreFlag, restoreUser, restoreUserConversation, resumeDeployment, resumeSandbox, retryCluster, retryDelivery, retryFacetBackfill, retryPgUpgrade, retryRun, revealGlobalMcpConfig, revealMcpConfig, revealNotificationProviderConfig, revealServiceEnvironmentVariables, revealServiceParameter, revenueCreateIntegration, revenueDeleteIntegration, revenueGlobalEvents, revenueImportInvoicesCsv, revenueImportSubscriptionsCsv, revenueListIntegrations, revenueListProviders, revenueMetricsCustomers, revenueMetricsGlobalMrr, revenueMetricsGlobalSummary, revenueMetricsMrr, revenueMetricsSummary, revenueRecentEvents, revenueRotateToken, revenueUpdateConfig, revenueUpdateSecret, revokeAnalyticsIngestKey, revokeDsn, revokeEmailDomainProject, revokeEnrollmentToken, revokeJoinToken, revokeProjectAccess, rollbackPgUpgrade, rollbackToDeployment, rootfsGc, rootfsReport, rotateAnalyticsIngestKey, rotateApiKey, rotateClusterCa, rotateDeploymentToken, runBackupForSource, runConnectionHealthCheck, runExternalServiceBackup, runScheduleNow, sandboxCreatePreviewLink, saveAgentToken, saveAiProviderCredential, searchLogs, sendEmail, sendFailureReport, sendProjectAiMessage, sendUserMessage, setAiDataAccess, setAlternateSources, setApplicationPrimaryProject, setDefaultS3Source, setFlagEnvironment, setPreviewPassword, setTraefikDiscoveredRouteEnabled, setupDns, setupDnsChallenge, setupEmailTracking, setupMfa, silenceAlarm, silenceSystemAlarm, sleepEnvironment, smokeTestAgent, sourceSandbox, startAnalysis, startContainer, startFix, startGitProviderOauth, startOidcLoginBySlug, startPgUpgrade, startRestore, startService, startUpdate, statPath, stopContainer, stopSandbox, stopService, stopTurn, stopUserTurn, storageSummary, streamContainerMetrics, syncRepositories, tailDeploymentJobLogs, tailLogs, teardownDeployment, teardownEnvironment, terminal, testNotificationProvider, testOidcProvider, testProvider, testProviderConnection, testProviderKeyById, testProviderKeyInline, testS3ConnectionPreview, testS3SourceConnection, trackClick, trackOpen, triggerAgent, triggerProjectPipeline, triggerScan, triggerServiceHealthCheck, triggerWeeklyDigest, unlinkApplicationProject, unlinkServiceFromProject, updateAgent, updateAiProvider, updateAiProviderPreference, updateAiSummaryPreference, updateAlert, updateAlertRule, updateAnalyticsIngestKey, updateApiKey, updateApplicationWorkspace, updateAutomaticDeploy, updateBackupSchedule, updateCloudFeatures, updateCloudflareProvider, updateConnectionToken, updateCustomDomain, updateDashboard, updateDeploymentToken, updateEmailProvider, updateEnvironmentSettings, updateEnvironmentSubdomain, updateEnvironmentVariable, updateErrorGroup, updateFlag, updateFunnel, updateGitProviderCredentials, updateGitSettings, updateGlobalMcp, updateGlobalSkill, updateIncidentStatus, updateIpAccessControl, updateManagedDomain, updateMcp, updateNotificationEmailProvider, updateNotificationProvider, updateNotificationRoute, updateOidcProvider, updatePermissionMode, updatePreferences, updateProject, updateProjectCloudTelemetry, updateProjectDeploymentConfig, updateProjectSecret, updateProjectSettings, updateProvider, updateProviderKey, updateProviderModel, updateRoute, updateS3Source, updateSelf, updateService, updateServiceResources, updateServiceTemplateRuntime, updateSessionDuration, updateSettings, updateSkill, updateSlackProvider, updateSpeedMetrics, updateTeam, updateTeamMemberRole, updateUser, updateUserPermissionMode, updateWebhook, updateWebhookProvider, upgradePreviewGateway, upgradeProjectServiceTemplate, upgradeService, uploadApplicationWorkspaceFiles, uploadGlobalSkill, uploadGlobalWorkspaceFiles, uploadReleaseFile, uploadSkill, uploadSourceFile, uploadSourceMap, uploadStaticBundle, uploadUserConversationAttachment, upsertSecret, validateConnection, validateEmail, verifyAndEnableMfa, verifyDomain, verifyEmail, verifyManagedDomain, verifyMfaChallenge, verifyStepUp, wakeEnvironment, webhookTrigger, workflowDryRun, writeApplicationWorkspaceFiles, writeFile, writeFiles } from '../sdk.gen'; -import type { AcknowledgeAlarmData, AcknowledgeSystemAlarmData, ActivateAiProviderData, ActivateAiProviderResponse, ActivateApiKeyData, ActivateApiKeyResponse, ActivateConnectionData, ActivateProviderData, AddClusterMemberData, AddClusterMemberResponse, AddContextData, AddEnvironmentDomainData, AddEnvironmentDomainResponse, AddEventsData, AddEventsError, AddEventsResponse2, AddManagedDomainData, AddManagedDomainResponse, AddProviderModelData, AddProviderModelError, AddProviderModelResponse, AddSessionReplayEventsData, AddSessionReplayEventsError, AddSessionReplayEventsResponse, AddTeamMemberData, AddTeamMemberResponse, AdminDrainNodeData, AdminDrainNodeResponse, AdminDrainStatusData, AdminDrainStatusResponse, AdminGetNodeData, AdminGetNodeResponse, AdminListNodeContainersData, AdminListNodeContainersResponse, AdminListNodesData, AdminListNodesResponse, AdminRemoveNodeData, AdminRemoveNodeResponse, AdminUndrainNodeData, AdminUndrainNodeResponse, AggregateApiTrafficData, AggregateApiTrafficError, AggregateApiTrafficResponse, ApplyHostnameModeData, ApplyHostnameModeResponse, ArchiveApplicationData, ArchiveApplicationResponse, ArchiveConversationData, ArchiveConversationResponse, ArchiveFlagData, ArchiveFlagResponse2, ArchiveUserConversationData, ArchiveUserConversationResponse, AssignRoleData, AttachScheduleServicesData, AttachScheduleServicesError, AttachScheduleServicesResponse2, AuthorizeEmailDomainProjectData, AuthorizeEmailDomainProjectResponse, BlobCopyData, BlobCopyError, BlobCopyResponse, BlobDeleteData, BlobDeleteError, BlobDeleteResponse, BlobDisableData, BlobDisableResponse, BlobDownloadData, BlobDownloadError, BlobEnableData, BlobEnableResponse, BlobListData, BlobListError, BlobListResponse, BlobPutData, BlobPutError, BlobPutResponse, BlobStatusData, BlobStatusResponse2, BlobUpdateData, BlobUpdateResponse, CancelBackupData, CancelBackupError, CancelBackupResponse2, CancelBulkActivationJobData, CancelBulkActivationJobError, CancelBulkActivationJobResponse, CancelData, CancelDeploymentData, CancelDeploymentResponse, CancelDomainOrderData, CancelDomainOrderResponse, CancelPgUpgradeData, CancelPgUpgradeError, CancelPgUpgradeResponse, CancelRunData, CancelRunResponse, CancelScheduleRunData, CancelScheduleRunError, CancelScheduleRunResponse, ChangePasswordSelfData, ChangePasswordSelfResponse, ChangeProjectSourceData, ChangeProjectSourceResponse, ChangeRequiredPasswordData, ChangeRequiredPasswordResponse, ChatCompletionsData, ChatCompletionsError, ChatCompletionsResponse, CheckAnalyticsHasEventsData, CheckAnalyticsHasEventsResponse, CheckCommitExistsData, CheckCommitExistsResponse, CheckDomainStatusData, CheckDomainStatusResponse, CheckExplorerSupportData, CheckExplorerSupportResponse, CheckForUpdateData, CheckForUpdateError, CheckForUpdateResponse, CheckIpBlockedData, CheckIpBlockedError, CheckProviderDeletionSafetyData, CheckProviderDeletionSafetyResponse, ChunkUploadOptionsData, ChunkUploadOptionsResponse, CleanupExpiredBackupsData, CleanupExpiredBackupsError, CleanupExpiredBackupsResponse, ClearPreviewPasswordData, ClearPreviewPasswordResponse, CliDeviceApproveData, CliDeviceApproveResponse2, CliDeviceDenyData, CliDeviceDenyResponse, CliDeviceLookupData, CliDeviceLookupResponse2, CliDevicePollData, CliDevicePollResponse2, CliDeviceStartData, CliDeviceStartResponse2, CliLogoutData, CliLogoutResponse, ClusterDnsStatusData, ClusterDnsStatusResponse2, CmdData, CmdKillData, CmdKillResponse, CmdLogsData, CmdResponse2, ConfirmPendingActionData, ConfirmPendingActionResponse, ConfirmUserPendingActionData, ConfirmUserPendingActionResponse, ContainerMetricsGetHistoryData, ContainerMetricsGetHistoryResponse, ControlApplicationWorkspaceData, ControlApplicationWorkspaceResponse, CreateAgentData, CreateAgentResponse, CreateAlertData, CreateAlertError, CreateAlertResponse, CreateAlertRuleData, CreateAlertRuleResponse, CreateAnalyticsIngestKeyData, CreateAnalyticsIngestKeyResponse, CreateApiKeyData, CreateApiKeyResponse2, CreateApplicationConversationData, CreateApplicationConversationResponse, CreateApplicationData, CreateApplicationPreviewLinkData, CreateApplicationPreviewLinkResponse, CreateApplicationProjectData, CreateApplicationProjectResponse, CreateApplicationResponse, CreateBackupScheduleData, CreateBackupScheduleError, CreateBackupScheduleResponse, CreateBitbucketProviderData, CreateBitbucketProviderResponse, CreateBulkActivationJobData, CreateBulkActivationJobError, CreateBulkActivationJobResponse, CreateCloudflareProviderData, CreateCloudflareProviderResponse, CreateConversationData, CreateConversationResponse, CreateCustomDomainData, CreateCustomDomainResponse, CreateDashboardData, CreateDashboardError, CreateDashboardResponse, CreateDeploymentTokenData, CreateDeploymentTokenResponse2, CreateDnsProviderData, CreateDnsProviderResponse, CreateDomainData, CreateDomainResponse, CreateDsnData, CreateDsnResponse, CreateEmailDomainData, CreateEmailDomainResponse, CreateEmailProviderData, CreateEmailProviderResponse, CreateEnvironmentData, CreateEnvironmentResponse, CreateEnvironmentVariableData, CreateEnvironmentVariableResponse, CreateFacetData, CreateFacetError, CreateFacetResponse, CreateFlagData, CreateFlagResponse, CreateFunnelData, CreateFunnelResponse2, CreateGenericProviderData, CreateGenericProviderResponse, CreateGiteaPatProviderData, CreateGiteaPatProviderResponse, CreateGithubPatProviderData, CreateGithubPatProviderResponse, CreateGitlabOauthProviderData, CreateGitlabOauthProviderResponse, CreateGitlabPatProviderData, CreateGitlabPatProviderResponse, CreateGitProviderData, CreateGitProviderResponse, CreateGlobalConversationData, CreateGlobalConversationResponse, CreateGlobalMcpData, CreateGlobalMcpResponse, CreateGlobalSkillData, CreateGlobalSkillResponse, CreateGlobalWorkspacePreviewLinkData, CreateGlobalWorkspacePreviewLinkResponse, CreateIncidentData, CreateIncidentResponse, CreateIpAccessControlData, CreateIpAccessControlError, CreateIpAccessControlResponse, CreateMcpData, CreateMcpResponse, CreateMonitorData, CreateMonitorResponse, CreateNotificationEmailProviderData, CreateNotificationEmailProviderResponse, CreateNotificationProviderData, CreateNotificationProviderResponse, CreateNotificationRouteData, CreateNotificationRouteResponse, CreateOidcProviderData, CreateOidcProviderResponse, CreateOidcRoleMappingData, CreateOidcRoleMappingResponse, CreateOrRecreateOrderData, CreateOrRecreateOrderResponse, CreatePlanData, CreatePlanResponse2, CreatePrData, CreateProjectData, CreateProjectFromTemplateData, CreateProjectFromTemplateResponse2, CreateProjectReleaseData, CreateProjectReleaseResponse, CreateProjectResponse, CreateProjectSecretData, CreateProjectSecretResponse, CreateProviderKeyData, CreateProviderKeyError, CreateProviderKeyResponse, CreatePrResponse2, CreateReleaseData, CreateReleaseResponse, CreateRouteData, CreateRouteResponse, CreateS3SourceData, CreateS3SourceError, CreateS3SourceResponse, CreateSandboxData, CreateSandboxResponse, CreateServiceData, CreateServiceResponse, CreateSkillData, CreateSkillResponse, CreateSlackProviderData, CreateSlackProviderResponse, CreateSnapshotData, CreateSnapshotResponse, CreateTeamData, CreateTeamResponse, CreateThreadArtifactData, CreateThreadArtifactResponse, CreateUserData, CreateUserResponse, CreateWebhookData, CreateWebhookProviderData, CreateWebhookProviderResponse, CreateWebhookResponse, DeactivateApiKeyData, DeactivateApiKeyResponse, DeactivateConnectionData, DeactivateProviderData, DeauthorizeDiscoveredRouteCertData, DeauthorizeDiscoveredRouteCertError, DeauthorizeDiscoveredRouteCertResponse, DeleteAgentData, DeleteAgentResponse, DeleteAlertData, DeleteAlertError, DeleteAlertResponse, DeleteAlertRuleData, DeleteAlertRuleResponse, DeleteApiKeyData, DeleteApiKeyResponse, DeleteBackupData, DeleteBackupError, DeleteBackupResponse, DeleteBackupScheduleData, DeleteBackupScheduleError, DeleteBackupScheduleResponse, DeleteConnectionData, DeleteConnectionResponse, DeleteCustomDomainData, DeleteCustomDomainResponse, DeleteDashboardData, DeleteDashboardError, DeleteDashboardResponse, DeleteDeploymentTokenData, DeleteDeploymentTokenResponse, DeleteDnsProviderData, DeleteDnsProviderResponse, DeleteDomainData, DeleteDomainResponse, DeleteEmailDomainData, DeleteEmailDomainResponse, DeleteEmailProviderData, DeleteEmailProviderResponse, DeleteEnvironmentData, DeleteEnvironmentDomainData, DeleteEnvironmentDomainResponse, DeleteEnvironmentResponse, DeleteEnvironmentVariableData, DeleteEnvironmentVariableResponse, DeleteExternalImageData, DeleteExternalImageResponse, DeleteFacetData, DeleteFacetError, DeleteFacetResponse, DeleteFunnelData, DeleteGitProviderData, DeleteGitProviderResponse, DeleteGlobalMcpData, DeleteGlobalMcpResponse, DeleteGlobalSkillData, DeleteGlobalSkillResponse, DeleteIpAccessControlData, DeleteIpAccessControlError, DeleteIpAccessControlResponse, DeleteMcpData, DeleteMcpResponse, DeleteMonitorData, DeleteMonitorResponse, DeleteNotificationProviderData, DeleteNotificationProviderResponse, DeleteNotificationRouteData, DeleteNotificationRouteResponse, DeleteOidcProviderData, DeleteOidcProviderResponse, DeleteOidcRoleMappingData, DeleteOidcRoleMappingResponse, DeletePreferencesData, DeletePreferencesResponse, DeleteProjectData, DeleteProjectResponse, DeleteProjectSecretData, DeleteProjectSecretResponse, DeleteProviderKeyData, DeleteProviderKeyError, DeleteProviderKeyResponse, DeleteProviderModelData, DeleteProviderModelError, DeleteProviderModelResponse, DeleteProviderSafelyData, DeleteProviderSafelyResponse, DeleteReleaseSourceFilesData, DeleteReleaseSourceFilesResponse, DeleteReleaseSourceMapsData, DeleteReleaseSourceMapsResponse, DeleteRouteData, DeleteRouteResponse, DeleteS3SourceData, DeleteS3SourceError, DeleteS3SourceResponse, DeleteScanData, DeleteScanError, DeleteScanResponse, DeleteSecretData, DeleteSecretResponse, DeleteServiceData, DeleteServiceResponse, DeleteSessionReplayData, DeleteSessionReplayError, DeleteSkillData, DeleteSkillResponse, DeleteSnapshotData, DeleteSnapshotResponse, DeleteSourceMapData, DeleteSourceMapResponse, DeleteStaticBundleData, DeleteStaticBundleResponse, DeleteTeamData, DeleteTeamResponse, DeleteUserData, DeleteUserResponse, DeleteWebhookData, DeleteWebhookResponse, DeployApplicationWorkspaceProjectData, DeployApplicationWorkspaceProjectResponse, DeployFromImageData, DeployFromImageResponse, DeployFromImageUploadData, DeployFromImageUploadResponse, DeployFromStaticData, DeployFromStaticResponse, DeployFromUploadedSourceData, DeployFromUploadedSourceResponse, DeploymentMetricsGetLatestData, DeploymentMetricsGetLatestResponse, DeploymentMetricsGetRangeData, DeploymentMetricsGetRangeResponse, DeploymentMetricsToggleData, DestroySandboxData, DestroySandboxResponse, DetachScheduleServiceData, DetachScheduleServiceError, DetachScheduleServiceResponse, DetectPublicEnvExampleData, DetectPublicEnvExampleResponse, DetectPublicPresetsData, DetectPublicPresetsResponse, DisableBackupScheduleData, DisableBackupScheduleError, DisableBackupScheduleResponse, DisableMfaData, DisableMfaResponse, DisconnectCloudData, DisconnectCloudResponse, DiscoverWorkloadsData, DiscoverWorkloadsResponse, DomainData, DomainResponse2, DownloadApplicationWorkspaceFileData, DownloadApplicationWorkspaceFileResponse, DownloadGlobalSkillArchiveData, DownloadGlobalSkillArchiveResponse, DownloadGlobalWorkspaceFileData, DownloadGlobalWorkspaceFileResponse, DownloadObjectData, DownloadObjectResponse, DownloadSkillArchiveData, DownloadSkillArchiveResponse, EmailStatusData, EmailStatusResponse2, EmbeddingsData, EmbeddingsError, EmbeddingsResponse, EnableBackupScheduleData, EnableBackupScheduleError, EnableBackupScheduleResponse, EnrichVisitorData, EnrichVisitorResponse2, EnrollCloudData, EnrollCloudResponse, EstimateBulkActivationData, EstimateBulkActivationError, EstimateBulkActivationResponse, ExecData, ExecDetachedData, ExecDetachedResponse2, ExecResponse2, ExecuteDeploymentOperationData, ExecuteDeploymentOperationResponse, ExecuteImportData, ExecuteImportResponse2, ExtendTimeoutData, ExtendTimeoutResponse, ExternalServiceEnablePgStatStatementsData, ExternalServiceEnablePgStatStatementsResponse, ExternalServiceMetricsByDatabaseData, ExternalServiceMetricsByDatabaseResponse, ExternalServiceMetricsCreateAlertRuleData, ExternalServiceMetricsCreateAlertRuleResponse, ExternalServiceMetricsDeleteAlertRuleData, ExternalServiceMetricsDeleteAlertRuleResponse, ExternalServiceMetricsGetAlertRulesData, ExternalServiceMetricsGetAlertRulesResponse, ExternalServiceMetricsGetLatestData, ExternalServiceMetricsGetLatestResponse, ExternalServiceMetricsGetRangeData, ExternalServiceMetricsGetRangeResponse, ExternalServiceMetricsStatusData, ExternalServiceMetricsStatusResponse, ExternalServiceMetricsToggleData, ExternalServiceMetricsUpdateAlertRuleData, ExternalServiceMetricsUpdateAlertRuleResponse, ExternalServiceResetPgStatStatementsData, ExternalServiceResetPgStatStatementsResponse, FinalizeOrderData, FinalizeOrderResponse, FinalizeProjectReleaseData, FinalizeProjectReleaseResponse, FindConversationData, FindConversationResponse, GenerateJoinTokenData, GenerateJoinTokenResponse2, GeneratePresetDockerfileData, GeneratePresetDockerfileResponse, GetAccessInfoData, GetAccessInfoResponse, GetActiveVisitorsData, GetActiveVisitorsResponse, GetActivityGraphData, GetActivityGraphError, GetActivityGraphResponse, GetAdminGateData, GetAdminGateResponse, GetAgentData, GetAgentResponse, GetAggregatedBucketsData, GetAggregatedBucketsResponse, GetAiAgentBreakdownData, GetAiAgentBreakdownError, GetAiAgentBreakdownResponse, GetAiAgentPagesData, GetAiAgentPagesError, GetAiAgentPagesResponse, GetAiAgentTimelineData, GetAiAgentTimelineError, GetAiAgentTimelineResponse, GetAiDataAccessData, GetAiDataAccessResponse, GetAiPageBreakdownData, GetAiPageBreakdownError, GetAiPageBreakdownResponse, GetAiProviderStatusData, GetAiProviderStatusError, GetAiProviderStatusResponse, GetAiStatusBreakdownData, GetAiStatusBreakdownError, GetAiStatusBreakdownResponse, GetAlertData, GetAlertError, GetAlertResponse, GetAlertRuleData, GetAlertRuleResponse, GetAllRepositoriesByNameData, GetAllRepositoriesByNameResponse, GetAnalyticsActiveVisitorsData, GetAnalyticsActiveVisitorsResponse, GetAnalyticsEventsCountData, GetAnalyticsEventsCountResponse, GetAnalyticsSessionEventsData, GetAnalyticsSessionEventsResponse, GetAnalyticsVisitorSessionsData, GetAnalyticsVisitorSessionsResponse, GetApiCallersData, GetApiCallersResponse, GetApiKeyData, GetApiKeyPermissionsData, GetApiKeyPermissionsResponse, GetApiKeyResponse, GetApiRoutesData, GetApiRoutesResponse, GetApiSummaryData, GetApiSummaryResponse, GetApiTimeseriesData, GetApiTimeseriesResponse, GetApiTrafficProxyLogAccessData, GetApiTrafficProxyLogAccessError, GetApiTrafficProxyLogAccessResponse, GetApplicationData, GetApplicationResponse, GetApplicationWorkspaceChangesData, GetApplicationWorkspaceChangesResponse, GetApplicationWorkspaceData, GetApplicationWorkspaceDiffData, GetApplicationWorkspaceDiffResponse, GetApplicationWorkspaceDirectoryData, GetApplicationWorkspaceDirectoryResponse, GetApplicationWorkspaceFileData, GetApplicationWorkspaceFileResponse, GetApplicationWorkspaceResponse, GetAuditLogData, GetAuditLogResponse, GetBackupData, GetBackupError, GetBackupResponse, GetBackupScheduleData, GetBackupScheduleError, GetBackupScheduleResponse, GetBranchesByRepositoryIdData, GetBranchesByRepositoryIdResponse, GetBucketedIncidentsData, GetBucketedIncidentsResponse, GetBucketedStatusData, GetBucketedStatusResponse, GetBulkActivationJobData, GetBulkActivationJobError, GetBulkActivationJobResponse, GetChallengeTokenData, GetChallengeTokenResponse, GetChatReadinessData, GetChatReadinessResponse, GetCliStatusData, GetCloudAiCapabilityData, GetCloudAiCapabilityResponse, GetCloudBackfillStatusData, GetCloudBackfillStatusError, GetCloudBackfillStatusResponse, GetCloudCapabilityData, GetCloudCapabilityResponse, GetCloudStatusData, GetCloudStatusResponse, GetCloudTelemetryStatusData, GetCloudTelemetryStatusError, GetCloudTelemetryStatusResponse, GetClusterHealthData, GetClusterHealthResponse, GetClusterMemberData, GetClusterMemberResponse, GetCmdData, GetCmdResponse, GetContainerDetailData, GetContainerDetailResponse, GetContainerEnvironmentVariableData, GetContainerEnvironmentVariableResponse, GetContainerLogsByIdData, GetContainerLogsData, GetContainerMetricsData, GetContainerMetricsResponse, GetConversationData, GetConversationDetailData, GetConversationDetailError, GetConversationDetailResponse, GetConversationResponse, GetConversationsData, GetConversationsError, GetConversationsResponse, GetCronByIdData, GetCronByIdResponse, GetCronExecutionsData, GetCronExecutionsResponse, GetCrossProjectTraceSiblingsData, GetCrossProjectTraceSiblingsError, GetCrossProjectTraceSiblingsResponse, GetCurrentBulkActivationJobData, GetCurrentBulkActivationJobError, GetCurrentBulkActivationJobResponse, GetCurrentMonitorStatusData, GetCurrentMonitorStatusResponse, GetCurrentUserData, GetCurrentUserResponse, GetCustomDomainData, GetCustomDomainResponse, GetDashboardData, GetDashboardError, GetDashboardProjectsAnalyticsData, GetDashboardProjectsAnalyticsResponse, GetDashboardResponse, GetDeliveryData, GetDeliveryResponse, GetDeploymentContainerLogContentData, GetDeploymentContainerLogContentResponse, GetDeploymentData, GetDeploymentJobLogsData, GetDeploymentJobLogsResponse, GetDeploymentJobsData, GetDeploymentJobsResponse, GetDeploymentOperationsData, GetDeploymentOperationsResponse, GetDeploymentOperationStatusData, GetDeploymentOperationStatusResponse, GetDeploymentResponse, GetDeploymentTokenData, GetDeploymentTokenResponse, GetDiskStatusData, GetDiskStatusResponse, GetDnsChangesData, GetDnsChangesResponse, GetDnsProviderData, GetDnsProviderResponse, GetDomainByHostData, GetDomainByHostResponse, GetDomainByIdData, GetDomainByIdResponse, GetDomainByNameData, GetDomainByNameResponse, GetDomainData, GetDomainDnsRecordsData, GetDomainDnsRecordsResponse, GetDomainOrderData, GetDomainOrderResponse, GetDomainResponse, GetEmailData, GetEmailEventsData, GetEmailEventsResponse, GetEmailLinksData, GetEmailLinksResponse, GetEmailProviderData, GetEmailProviderResponse, GetEmailResponse, GetEmailStatsData, GetEmailStatsResponse, GetEmailTrackingData, GetEmailTrackingResponse, GetEmailTrackingStatusData, GetEmailTrackingStatusResponse, GetEntityInfoData, GetEntityInfoResponse, GetEnvironmentCronsData, GetEnvironmentCronsResponse, GetEnvironmentData, GetEnvironmentDomainsData, GetEnvironmentDomainsResponse, GetEnvironmentResponse, GetEnvironmentsData, GetEnvironmentsResponse, GetEnvironmentVariablesData, GetEnvironmentVariablesResponse, GetEnvironmentVariableValueData, GetEnvironmentVariableValueResponse, GetErrorDashboardStatsData, GetErrorDashboardStatsResponse, GetErrorEventData, GetErrorEventResponse, GetErrorGroupData, GetErrorGroupResponse, GetErrorStatsData, GetErrorStatsResponse, GetErrorTimeSeriesData, GetErrorTimeSeriesResponse, GetEventDetailData, GetEventDetailResponse, GetEventEntriesData, GetEventEntriesResponse, GetEventsCountData, GetEventsCountResponse, GetEventsTimelineData, GetEventsTimelineResponse, GetEventTypeBreakdownData, GetEventTypeBreakdownResponse, GetEventVisitorsData, GetEventVisitorsResponse, GetExternalImageData, GetExternalImageResponse, GetExternalServiceBackupCapabilityData, GetExternalServiceBackupCapabilityError, GetExternalServiceBackupCapabilityResponse, GetFailureReportPreviewData, GetFailureReportPreviewResponse, GetFeatureMaturityData, GetFeatureMaturityResponse, GetFileData, GetFileResponse, GetFlagData, GetFlagResponse, GetFlagSnapshotData, GetFlagSnapshotResponse, GetFunnelMetricsData, GetFunnelMetricsResponse, GetGenaiTraceData, GetGenaiTraceError, GetGenaiTraceResponse, GetGeneralStatsData, GetGeneralStatsResponse, GetGitProviderData, GetGitProviderResponse, GetGlobalAiWorkspaceData, GetGlobalAiWorkspaceResponse, GetGlobalEventsData, GetGlobalEventsResponse, GetGlobalEventStatsData, GetGlobalEventStatsResponse, GetGlobalMcpData, GetGlobalMcpResponse, GetGlobalSandboxStatusData, GetGlobalSandboxStatusResponse, GetGlobalSkillData, GetGlobalSkillResponse, GetGlobalWorkspaceChangesData, GetGlobalWorkspaceChangesResponse, GetGlobalWorkspaceDiffData, GetGlobalWorkspaceDiffResponse, GetGlobalWorkspaceDirectoryData, GetGlobalWorkspaceDirectoryResponse, GetGlobalWorkspaceFileData, GetGlobalWorkspaceFileResponse, GetGroupedPageMetricsData, GetGroupedPageMetricsError, GetGroupedPageMetricsResponse, GetHealthData, GetHealthError, GetHealthResponse, GetHourlyVisitsData, GetHourlyVisitsResponse, GetHttpChallengeDebugData, GetHttpChallengeDebugResponse, GetImportStatusData, GetImportStatusResponse, GetIncidentData, GetIncidentResponse, GetIncidentUpdatesData, GetIncidentUpdatesResponse, GetIngestErrorsData, GetIngestErrorsError, GetIngestErrorsResponse, GetIpAccessControlData, GetIpAccessControlError, GetIpAccessControlResponse, GetIpGeolocationData, GetIpGeolocationError, GetIpGeolocationResponse, GetJoinTokenStatusData, GetJoinTokenStatusResponse, GetLastDeploymentData, GetLastDeploymentResponse, GetLatestDeploymentMediaData, GetLatestDeploymentMediaError, GetLatestDeploymentMediaResponse, GetLatestScanData, GetLatestScanError, GetLatestScanResponse, GetLatestScansPerEnvironmentData, GetLatestScansPerEnvironmentError, GetLatestScansPerEnvironmentResponse, GetLiveVisitorsListData, GetLiveVisitorsListResponse, GetLogContextData, GetLogContextError, GetLogContextResponse, GetMcpData, GetMcpResponse, GetMetricsOverTimeData, GetMetricsOverTimeError, GetMetricsOverTimeResponse, GetMonitorData, GetMonitorResponse, GetNotificationProviderData, GetNotificationProviderResponse, GetNotificationRouteData, GetNotificationRouteResponse, GetOnDemandCertStatusData, GetOnDemandCertStatusResponse, GetOrCreateDsnData, GetOrCreateDsnResponse, GetPageFlowData, GetPageFlowResponse, GetPageHourlySessionsData, GetPageHourlySessionsResponse, GetPagePathDetailData, GetPagePathDetailResponse, GetPagePathsData, GetPagePathsResponse, GetPagePathsSparklinesData, GetPagePathsSparklinesResponse, GetPagePathVisitorsData, GetPagePathVisitorsResponse, GetPendingActionData, GetPendingActionResponse, GetPerformanceMetricsData, GetPerformanceMetricsError, GetPerformanceMetricsResponse, GetPgUpgradeData, GetPgUpgradeError, GetPgUpgradeLogsData, GetPgUpgradeLogsError, GetPgUpgradeLogsResponse, GetPgUpgradeResponse, GetPipelineHistoryData, GetPipelineHistoryError, GetPipelineHistoryResponse, GetPipelineStatsData, GetPipelineStatsError, GetPipelineStatsResponse, GetPlatformInfoData, GetPlatformInfoResponse, GetPostgresWalHealthData, GetPostgresWalHealthResponse, GetPreferencesData, GetPreferencesResponse, GetPreviewGatewayLogsData, GetPreviewGatewayLogsError, GetPreviewGatewayLogsResponse, GetPreviewGatewaySettingsData, GetPreviewGatewaySettingsResponse, GetPreviewGatewayStatusData, GetPreviewGatewayStatusError, GetPreviewGatewayStatusResponse, GetPricingData, GetPricingError, GetPricingResponse, GetPrivateIpData, GetProjectAlarmsSummaryData, GetProjectAlarmsSummaryResponse, GetProjectBySlugData, GetProjectBySlugResponse, GetProjectCloudTelemetryData, GetProjectCloudTelemetryError, GetProjectCloudTelemetryResponse, GetProjectData, GetProjectDeploymentsData, GetProjectDeploymentsResponse, GetProjectResponse, GetProjectsData, GetProjectServiceEnvironmentVariablesData, GetProjectServiceEnvironmentVariablesResponse, GetProjectServiceTemplateData, GetProjectServiceTemplateResponse, GetProjectSessionReplaysData, GetProjectSessionReplaysError, GetProjectSessionReplaysResponse2, GetProjectsHealthData, GetProjectsHealthError, GetProjectsHealthResponse, GetProjectsMonitorHealthData, GetProjectsMonitorHealthResponse, GetProjectsResponse, GetProjectStatisticsData, GetProjectStatisticsResponse, GetProjectTemplateData, GetProjectTemplateResponse, GetPropertyBreakdownData, GetPropertyBreakdownResponse, GetPropertyTimelineData, GetPropertyTimelineResponse, GetProviderConnectionsData, GetProviderConnectionsResponse, GetProviderKeyData, GetProviderKeyError, GetProviderKeyResponse, GetProviderMetadataData, GetProviderMetadataResponse, GetProvidersMetadataData, GetProvidersMetadataResponse, GetProxyLogByIdData, GetProxyLogByIdError, GetProxyLogByIdResponse, GetProxyLogByRequestIdData, GetProxyLogByRequestIdError, GetProxyLogByRequestIdResponse, GetProxyLogsData, GetProxyLogsError, GetProxyLogsResponse, GetPublicBranchesData, GetPublicBranchesResponse, GetPublicComposePreviewData, GetPublicComposePreviewResponse, GetPublicComposeServicesData, GetPublicComposeServicesResponse, GetPublicIpData, GetPublicRepositoryData, GetPublicRepositoryResponse, GetQueryContainerInfoData, GetQueryContainerInfoResponse, GetQuotaData, GetQuotaError, GetQuotaResponse, GetRecentActivityData, GetRecentActivityResponse, GetRemoteExternalImageData, GetRemoteExternalImageResponse, GetRepositoryBranchesData, GetRepositoryBranchesResponse, GetRepositoryByIdData, GetRepositoryByIdResponse, GetRepositoryByNameData, GetRepositoryByNameResponse, GetRepositoryComposePreviewData, GetRepositoryComposePreviewResponse, GetRepositoryComposeServicesLiveData, GetRepositoryComposeServicesLiveResponse, GetRepositoryEnvExampleLiveData, GetRepositoryEnvExampleLiveResponse, GetRepositoryPresetByNameData, GetRepositoryPresetByNameResponse, GetRepositoryPresetLiveData, GetRepositoryPresetLiveResponse, GetRepositoryTagsData, GetRepositoryTagsResponse, GetResolvedEnvironmentVariablesData, GetResolvedEnvironmentVariablesResponse, GetResolvedEnvironmentVariableValueData, GetResolvedEnvironmentVariableValueResponse, GetRestoreCapabilitiesData, GetRestoreCapabilitiesError, GetRestoreCapabilitiesResponse, GetRestoreRunData, GetRestoreRunError, GetRestoreRunResponse, GetRouteData, GetRouteResponse, GetRunData, GetRunResponse, GetRunWithLogsData, GetRunWithLogsResponse, GetS3CredentialsData, GetS3CredentialsResponse, GetS3SourceData, GetS3SourceError, GetS3SourceResponse, GetSandboxData, GetSandboxResponse, GetSandboxStatusData, GetSandboxStatusResponse, GetScanByDeploymentData, GetScanByDeploymentError, GetScanByDeploymentResponse, GetScanData, GetScanError, GetScanResponse, GetScanVulnerabilitiesData, GetScanVulnerabilitiesError, GetScanVulnerabilitiesResponse, GetServiceBySlugData, GetServiceBySlugResponse, GetServiceData, GetServiceEnvironmentVariableData, GetServiceEnvironmentVariableResponse, GetServiceEnvironmentVariablesData, GetServiceEnvironmentVariablesResponse, GetServiceHealthStatusData, GetServiceHealthStatusResponse, GetServicePreviewEnvironmentVariableNamesData, GetServicePreviewEnvironmentVariableNamesResponse, GetServicePreviewEnvironmentVariablesMaskedData, GetServicePreviewEnvironmentVariablesMaskedResponse, GetServiceResponse, GetServiceRuntimeData, GetServiceRuntimeResponse, GetServiceStatsData, GetServiceStatsResponse, GetServiceTypeParametersData, GetServiceTypesData, GetServiceTypesResponse, GetSessionDetailsData, GetSessionDetailsResponse, GetSessionEventsData, GetSessionEventsResponse, GetSessionLogsData, GetSessionLogsResponse, GetSessionReplayData, GetSessionReplayError, GetSessionReplayEventsData, GetSessionReplayEventsError, GetSessionReplayEventsResponse, GetSessionReplayResponse2, GetSettingsData, GetSettingsResponse, GetSkillData, GetSkillResponse, GetSlowQueriesData, GetSlowQueriesResponse, GetSnapshotData, GetSnapshotResponse, GetStaticBundleData, GetStaticBundleResponse, GetStatusOverviewData, GetStatusOverviewResponse, GetSystemAlarmsSummaryData, GetSystemAlarmsSummaryResponse, GetTagsByRepositoryIdData, GetTagsByRepositoryIdResponse, GetTeamData, GetTeamResponse, GetTimeBucketStatsData, GetTimeBucketStatsError, GetTimeBucketStatsResponse, GetTodayStatsData, GetTodayStatsError, GetTodayStatsResponse, GetTraceData, GetTraceError, GetTraceResponse, GetTraefikDiscoveryStatusData, GetTraefikDiscoveryStatusError, GetTraefikDiscoveryStatusResponse, GetUnifiedTraceData, GetUnifiedTraceError, GetUnifiedTraceResponse, GetUniqueCountsData, GetUniqueCountsResponse, GetUniqueEventsData, GetUniqueEventsResponse, GetUpdateCapabilityData, GetUpdateCapabilityResponse, GetUpdateStatusData, GetUpdateStatusResponse, GetUptimeHistoryData, GetUptimeHistoryResponse, GetUsageByProviderData, GetUsageByProviderError, GetUsageByProviderResponse, GetUsageRecentData, GetUsageRecentError, GetUsageRecentResponse, GetUsageSummaryData, GetUsageSummaryError, GetUsageSummaryResponse, GetUsageTimeseriesData, GetUsageTimeseriesError, GetUsageTimeseriesResponse, GetUsageTopModelsData, GetUsageTopModelsError, GetUsageTopModelsResponse, GetUserConversationAttachmentData, GetUserConversationAttachmentResponse, GetUserConversationData, GetUserConversationResponse, GetUserPendingActionData, GetUserPendingActionResponse, GetVisibleCustomDomainByHostnameData, GetVisibleCustomDomainByHostnameResponse, GetVisitorByGuidData, GetVisitorByGuidResponse, GetVisitorByIdData, GetVisitorByIdResponse, GetVisitorDetailsData, GetVisitorDetailsResponse, GetVisitorFacetsData, GetVisitorFacetsResponse, GetVisitorInfoData, GetVisitorInfoResponse, GetVisitorJourneyData, GetVisitorJourneyResponse, GetVisitorsData, GetVisitorSessionsData, GetVisitorSessionsError, GetVisitorSessionsResponse2, GetVisitorsResponse, GetVisitorStatsData, GetVisitorStatsResponse, GetWebhookData, GetWebhookResponse, GetWorkspaceFileLimitsData, GetWorkspaceFileLimitsResponse, GrantProjectAccessData, GrantProjectAccessResponse, HandleGitProviderOauthCallbackData, HasAnalyticsEventsData, HasAnalyticsEventsResponse2, HasErrorGroupsData, HasErrorGroupsResponse2, HasPerformanceMetricsData, HasPerformanceMetricsError, HasPerformanceMetricsResponse, HasTracesData, HasTracesError, HasTracesResponse2, ImportApplicationWorkspaceGitData, ImportApplicationWorkspaceGitResponse, ImportEmailDomainData, ImportEmailDomainResponse, ImportExternalServiceData, ImportExternalServiceResponse, ImportTraefikAcmeJsonData, ImportTraefikAcmeJsonError, ImportTraefikAcmeJsonResponse2, IngestLogsByPathData, IngestLogsByPathError, IngestLogsData, IngestLogsError, IngestMetricsByPathData, IngestMetricsByPathError, IngestMetricsData, IngestMetricsError, IngestSentryEnvelopeData, IngestSentryEventData, IngestSentryEventResponse, IngestTracesByPathData, IngestTracesByPathError, IngestTracesData, IngestTracesError, IngestTunneledEnvelopeData, IngestTunneledEnvelopeResponse, InitSessionReplayData, InitSessionReplayError, InitSessionReplayResponse, InspectDropArchiveData, InspectDropArchiveResponse, IssueRuntimeCredentialsData, IssueRuntimeCredentialsResponse, JobLogsData, JobStatusData, JobStatusResponse2, KillJobData, KillJobResponse, KvDelData, KvDelResponse, KvDisableData, KvDisableResponse, KvEnableData, KvEnableResponse, KvExpireData, KvExpireResponse, KvGetData, KvGetResponse, KvIncrData, KvIncrResponse, KvKeysData, KvKeysResponse, KvSetData, KvSetResponse, KvStatusData, KvStatusResponse2, KvTtlData, KvTtlResponse, KvUpdateData, KvUpdateResponse, LatestRunForSourceData, LatestRunForSourceResponse, LinkApplicationProjectData, LinkApplicationProjectResponse, LinkCustomDomainToCertificateData, LinkCustomDomainToCertificateResponse, LinkServiceToProjectData, LinkServiceToProjectResponse, ListAgentRunsData, ListAgentRunsResponse, ListAgentsData, ListAgentsResponse2, ListAiProvidersData, ListAiProvidersResponse, ListAlertRulesData, ListAlertRulesResponse, ListAlertsData, ListAlertsError, ListAlertsResponse, ListAllConversationsData, ListAllConversationsResponse, ListAllRunsData, ListAllRunsResponse, ListAnalyticsIngestKeysData, ListAnalyticsIngestKeysResponse, ListApiKeysData, ListApiKeysResponse, ListApplicationConversationsData, ListApplicationConversationsResponse, ListApplicationsData, ListApplicationsResponse, ListAuditLogsData, ListAuditLogsResponse, ListAvailableContainersData, ListAvailableContainersResponse, ListBackupAlertsData, ListBackupAlertsError, ListBackupAlertsResponse, ListBackupChildrenData, ListBackupChildrenError, ListBackupChildrenResponse, ListBackupSchedulesData, ListBackupSchedulesError, ListBackupSchedulesResponse, ListBackupsForScheduleData, ListBackupsForScheduleError, ListBackupsForScheduleResponse, ListCommitsByRepositoryIdData, ListCommitsByRepositoryIdResponse, ListConnectionsData, ListConnectionsResponse, ListContainerHistoryData, ListContainerHistoryError, ListContainerHistoryResponse, ListContainersAtPathData, ListContainersAtPathResponse, ListContainersData, ListContainersResponse, ListConversationsData, ListConversationsResponse, ListCustomDomainsForProjectData, ListCustomDomainsForProjectResponse, ListDashboardsData, ListDashboardsError, ListDashboardsResponse, ListDeliveriesData, ListDeliveriesResponse, ListDeploymentContainerLogsData, ListDeploymentContainerLogsResponse, ListDeploymentTokensData, ListDeploymentTokensResponse, ListDiscoverableDomainsData, ListDiscoverableDomainsResponse, ListDnsProvidersData, ListDnsProvidersResponse, ListDomainsData, ListDomainsResponse2, ListDsnsData, ListDsnsResponse, ListEmailDomainProjectsData, ListEmailDomainProjectsResponse, ListEmailDomainsData, ListEmailDomainsResponse, ListEmailProvidersData, ListEmailProvidersResponse, ListEmailsData, ListEmailsResponse, ListEnrollmentTokensData, ListEnrollmentTokensResponse, ListEntitiesData, ListEntitiesResponse, ListErrorEventsData, ListErrorEventsResponse, ListErrorGroupsData, ListErrorGroupsResponse, ListEventsData, ListEventsResponse, ListEventTypesData, ListEventTypesResponse, ListExternalImagesData, ListExternalImagesResponse, ListExternalPluginsData, ListExternalPluginsResponse, ListExternalServiceBackupsData, ListExternalServiceBackupsError, ListExternalServiceBackupsResponse, ListFacetsData, ListFacetsError, ListFacetsResponse, ListFlagsData, ListFlagsResponse, ListFunnelsData, ListFunnelsResponse, ListGitProvidersData, ListGitProvidersResponse, ListGlobalMcpsData, ListGlobalMcpsResponse, ListGlobalSkillsData, ListGlobalSkillsResponse, ListIncidentsData, ListInsightsData, ListInsightsError, ListInsightsResponse, ListIpAccessControlData, ListIpAccessControlError, ListIpAccessControlResponse, ListJobsData, ListJobsResponse2, ListKnownAiAgentsData, ListKnownAiAgentsError, ListKnownAiAgentsResponse, ListManagedDomainsData, ListManagedDomainsResponse, ListManagedEnvironmentVariablesData, ListManagedEnvironmentVariablesResponse, ListMcpsData, ListMcpsResponse2, ListMetricLabelKeysData, ListMetricLabelKeysError, ListMetricLabelKeysResponse, ListMetricLabelValuesData, ListMetricLabelValuesError, ListMetricLabelValuesResponse, ListMetricNamesData, ListMetricNamesError, ListMetricNamesResponse, ListModelsData, ListModelsError, ListModelsResponse, ListMonitorsData, ListMonitorsResponse, ListNotificationProvidersData, ListNotificationProvidersResponse, ListNotificationRoutesData, ListNotificationRoutesResponse, ListOidcProvidersData, ListOidcProvidersResponse, ListOidcProviderUsersData, ListOidcProviderUsersResponse, ListOidcRoleMappingsData, ListOidcRoleMappingsResponse, ListOnDemandCertsData, ListOnDemandCertsResponse2, ListOrdersData, ListOrdersResponse2, ListPeersData, ListPeersResponse, ListPendingActionsData, ListPendingActionsResponse, ListPgUpgradesData, ListPgUpgradesError, ListPgUpgradesResponse, ListPresetsData, ListPresetsResponse2, ListProjectAccessData, ListProjectAccessResponse, ListProjectAlarmsData, ListProjectAlarmsResponse, ListProjectScansData, ListProjectScansError, ListProjectScansResponse, ListProjectSecretsData, ListProjectSecretsResponse, ListProjectServicesData, ListProjectServicesResponse, ListProjectTemplatesData, ListProjectTemplatesResponse, ListProjectTemplateTagsData, ListProjectTemplateTagsResponse, ListProviderKeysData, ListProviderKeysError, ListProviderKeysResponse, ListProviderZonesData, ListProviderZonesResponse, ListPublicProvidersData, ListPublicProvidersResponse, ListReleaseFilesData, ListReleaseFilesResponse, ListReleasesData, ListReleasesResponse, ListRemoteExternalImagesData, ListRemoteExternalImagesResponse, ListRenewalAttemptsData, ListRenewalAttemptsResponse2, ListRepositoriesByConnectionData, ListRepositoriesByConnectionResponse, ListRepositoriesByProviderData, ListRepositoriesByProviderResponse, ListRestoreRunsForServiceData, ListRestoreRunsForServiceError, ListRestoreRunsForServiceResponse, ListRootContainersData, ListRootContainersResponse, ListRoutesData, ListRoutesResponse, ListS3SourcesData, ListS3SourcesError, ListS3SourcesResponse, ListSandboxesData, ListSandboxesResponse2, ListScheduleRunJobsData, ListScheduleRunJobsError, ListScheduleRunJobsResponse, ListScheduleRunsData, ListScheduleRunsError, ListScheduleRunsResponse, ListScheduleServicesData, ListScheduleServicesError, ListScheduleServicesResponse, ListSecretsData, ListSecretsResponse2, ListServiceHealthStatusesData, ListServiceHealthStatusesResponse, ListServiceProjectsData, ListServiceProjectsResponse, ListServiceSchedulesData, ListServiceSchedulesError, ListServiceSchedulesResponse, ListServicesData, ListServicesResponse, ListSkillsData, ListSkillsResponse2, ListSnapshotsData, ListSnapshotsResponse2, ListSourceBackupsData, ListSourceBackupsError, ListSourceBackupsResponse, ListSourceFilesData, ListSourceFilesResponse, ListSourceMapsData, ListSourceMapsResponse, ListSourcesData, ListSourcesResponse, ListStaticBundlesData, ListStaticBundlesResponse, ListSyncedRepositoriesData, ListSyncedRepositoriesResponse, ListSystemAlarmsData, ListSystemAlarmsResponse, ListTeamMembersData, ListTeamMembersResponse, ListTeamProjectsData, ListTeamProjectsResponse, ListTeamsData, ListTeamsResponse, ListThreadArtifactsData, ListThreadArtifactsResponse, ListTraefikDiscoveredRoutesData, ListTraefikDiscoveredRoutesError, ListTraefikDiscoveredRoutesResponse, ListUserPendingActionsData, ListUserPendingActionsResponse, ListUsersData, ListUsersResponse, ListWebhooksData, ListWebhooksResponse, LoginData, LoginResponse, LogoutData, LookupDnsARecordsData, LookupDnsARecordsError, LookupDnsARecordsResponse, MintEnrollmentTokenData, MintEnrollmentTokenResponse2, MkdirData, MkdirResponse, NodeHeartbeatData, NodeHeartbeatResponse, NodeMetricsGetAlertRulesData, NodeMetricsGetAlertRulesResponse, NodeMetricsGetRangeData, NodeMetricsGetRangeResponse, NodeMetricsUpdateAlertRuleData, NodeMetricsUpdateAlertRuleResponse, ObservabilityFullEventData, ObservabilityFullEventError, ObservabilityFullEventResponse, ObservabilityListEventsData, ObservabilityListEventsError, ObservabilityListEventsResponse, OidcCallbackData, PatchAdminGateData, PatchAdminGateResponse, PatchPreviewGatewaySettingsData, PatchPreviewGatewaySettingsError, PatchPreviewGatewaySettingsResponse, PauseDeploymentData, PauseDeploymentResponse, PauseSandboxData, PauseSandboxResponse, PlanRestoreData, PlanRestoreError, PlanRestoreResponse, PostDnsAckData, PostDnsAckResponse, PreviewAlertData, PreviewAlertError, PreviewAlertResponse, PreviewFunnelMetricsData, PreviewFunnelMetricsResponse, PreviewHostnameModeData, PreviewHostnameModeResponse, PromoteClusterMemberData, PromoteDeploymentData, PromoteDeploymentResponse, ProvisionDomainData, ProvisionDomainResponse, PurgeProjectLogsData, PurgeProjectLogsError, PushExternalImageData, PushExternalImageResponse, QueryDataData, QueryDataResponse2, QueryGenaiTracesData, QueryGenaiTracesError, QueryGenaiTracesResponse, QueryLogsData, QueryLogsError, QueryLogsResponse, QueryMetricsData, QueryMetricsError, QueryMetricsResponse, QuerySpanStatsData, QuerySpanStatsError, QuerySpanStatsResponse, QueryTracesData, QueryTracesError, QueryTracesResponse, QueryTraceSummariesData, QueryTraceSummariesError, QueryTraceSummariesResponse, ReadEntityRowsData, ReadEntityRowsResponse, ReadFileData, ReadFileResponse2, ReAnalyzeData, ReassignProjectCustomDomainData, ReassignProjectCustomDomainResponse, ReconcileCloudBackupSourceData, ReconcileCloudBackupSourceResponse, RecordConsoleEventData, RecordEventMetricsData, RecordEventMetricsResponse, RecordFlagExposureData, RecordFlagExposureResponse, RecordSpeedMetricsData, RecordSpeedMetricsError, RecordSpeedMetricsResponse, RefreshAiProviderStatusData, RefreshAiProviderStatusError, RefreshAiProviderStatusResponse, RefreshProviderModelsData, RefreshProviderModelsError, RefreshProviderModelsResponse, RefreshRouteTableData, RefreshRouteTableResponse, RegenerateDsnData, RegenerateDsnResponse, RegisterExternalImageData, RegisterExternalImageResponse, RegisterNodeData, RegisterNodeResponse2, ReinstallGitlabWebhookData, ReinstallGitlabWebhookResponse, RejectPendingActionData, RejectPendingActionResponse, RejectUserPendingActionData, RejectUserPendingActionResponse, ReloadPluginsData, ReloadPluginsResponse, RemoveClusterMemberData, RemoveClusterMemberResponse, RemoveManagedDomainData, RemoveManagedDomainResponse, RemoveRoleData, RemoveRoleResponse, RemoveTeamMemberData, RemoveTeamMemberResponse, RenameConversationData, RenameConversationResponse, RenameUserConversationData, RenameUserConversationResponse, RenewDomainData, RenewDomainResponse, RepointContinuousArchiveSourceData, RepointContinuousArchiveSourceResponse, RequestDiscoveredRouteCertData, RequestDiscoveredRouteCertError, RequestPasswordResetData, RequestPasswordResetResponse, ResetPasswordData, ResetPasswordResponse, ResizeSandboxData, ResizeSandboxResponse, ResolveAlarmData, ResolvePermissionData, ResolvePermissionResponse, ResolveSystemAlarmData, ResolveUserPermissionData, ResolveUserPermissionResponse, RestartContainerData, RestartContainerResponse, RestartPreviewGatewayData, RestartPreviewGatewayError, RestartPreviewGatewayResponse, RestartSandboxData, RestartSandboxResponse, RestoreApplicationData, RestoreApplicationResponse, RestoreFlagData, RestoreFlagResponse, RestoreUserConversationData, RestoreUserConversationResponse, RestoreUserData, RestoreUserResponse, ResumeDeploymentData, ResumeDeploymentResponse, ResumeSandboxData, ResumeSandboxResponse, RetryClusterData, RetryClusterResponse, RetryDeliveryData, RetryDeliveryResponse, RetryFacetBackfillData, RetryFacetBackfillError, RetryFacetBackfillResponse, RetryPgUpgradeData, RetryPgUpgradeError, RetryPgUpgradeResponse, RetryRunData, RetryRunResponse, RevealGlobalMcpConfigData, RevealGlobalMcpConfigResponse, RevealMcpConfigData, RevealMcpConfigResponse, RevealNotificationProviderConfigData, RevealNotificationProviderConfigResponse, RevealServiceEnvironmentVariablesData, RevealServiceEnvironmentVariablesResponse, RevealServiceParameterData, RevealServiceParameterResponse, RevenueCreateIntegrationData, RevenueCreateIntegrationResponse, RevenueDeleteIntegrationData, RevenueDeleteIntegrationResponse, RevenueGlobalEventsData, RevenueGlobalEventsResponse, RevenueImportInvoicesCsvData, RevenueImportInvoicesCsvResponse, RevenueImportSubscriptionsCsvData, RevenueImportSubscriptionsCsvResponse, RevenueListIntegrationsData, RevenueListIntegrationsResponse, RevenueListProvidersData, RevenueListProvidersResponse, RevenueMetricsCustomersData, RevenueMetricsCustomersResponse, RevenueMetricsGlobalMrrData, RevenueMetricsGlobalMrrResponse, RevenueMetricsGlobalSummaryData, RevenueMetricsGlobalSummaryResponse, RevenueMetricsMrrData, RevenueMetricsMrrResponse, RevenueMetricsSummaryData, RevenueMetricsSummaryResponse, RevenueRecentEventsData, RevenueRecentEventsResponse, RevenueRotateTokenData, RevenueRotateTokenResponse, RevenueUpdateConfigData, RevenueUpdateConfigResponse, RevenueUpdateSecretData, RevenueUpdateSecretResponse, RevokeAnalyticsIngestKeyData, RevokeAnalyticsIngestKeyResponse, RevokeDsnData, RevokeDsnResponse, RevokeEmailDomainProjectData, RevokeEmailDomainProjectResponse, RevokeEnrollmentTokenData, RevokeEnrollmentTokenResponse, RevokeJoinTokenData, RevokeJoinTokenResponse, RevokeProjectAccessData, RevokeProjectAccessResponse, RollbackPgUpgradeData, RollbackPgUpgradeError, RollbackPgUpgradeResponse, RollbackToDeploymentData, RollbackToDeploymentResponse, RootfsGcData, RootfsReportData, RotateAnalyticsIngestKeyData, RotateAnalyticsIngestKeyResponse, RotateApiKeyData, RotateApiKeyResponse, RotateClusterCaData, RotateClusterCaResponse2, RotateDeploymentTokenData, RotateDeploymentTokenResponse, RunBackupForSourceData, RunBackupForSourceError, RunBackupForSourceResponse, RunConnectionHealthCheckData, RunConnectionHealthCheckResponse, RunExternalServiceBackupData, RunExternalServiceBackupError, RunExternalServiceBackupResponse, RunScheduleNowData, RunScheduleNowError, RunScheduleNowResponse, SandboxCreatePreviewLinkData, SandboxCreatePreviewLinkResponse, SaveAgentTokenData, SaveAgentTokenResponse2, SaveAiProviderCredentialData, SaveAiProviderCredentialResponse, SearchLogsData, SearchLogsError, SearchLogsResponse2, SendEmailData, SendEmailResponse, SendFailureReportData, SendFailureReportResponse, SendProjectAiMessageData, SendProjectAiMessageResponse, SendUserMessageData, SendUserMessageResponse, SetAiDataAccessData, SetAiDataAccessResponse, SetAlternateSourcesData, SetAlternateSourcesResponse, SetApplicationPrimaryProjectData, SetApplicationPrimaryProjectResponse, SetDefaultS3SourceData, SetDefaultS3SourceError, SetDefaultS3SourceResponse, SetFlagEnvironmentData, SetFlagEnvironmentResponse, SetPreviewPasswordData, SetPreviewPasswordResponse2, SetTraefikDiscoveredRouteEnabledData, SetTraefikDiscoveredRouteEnabledError, SetTraefikDiscoveredRouteEnabledResponse, SetupDnsChallengeData, SetupDnsChallengeResponse2, SetupDnsData, SetupDnsResponse2, SetupEmailTrackingData, SetupEmailTrackingResponse, SetupMfaData, SetupMfaResponse, SilenceAlarmData, SilenceSystemAlarmData, SleepEnvironmentData, SleepEnvironmentResponse, SmokeTestAgentData, SmokeTestAgentResponse, SourceSandboxData, SourceSandboxResponse, StartAnalysisData, StartAnalysisResponse, StartContainerData, StartContainerResponse, StartFixData, StartGitProviderOauthData, StartOidcLoginBySlugData, StartPgUpgradeData, StartPgUpgradeError, StartPgUpgradeResponse, StartRestoreData, StartRestoreError, StartRestoreResponse, StartServiceData, StartServiceResponse, StartUpdateData, StartUpdateError, StartUpdateResponse2, StatPathData, StatPathResponse, StopContainerData, StopContainerResponse, StopSandboxData, StopSandboxResponse, StopServiceData, StopServiceResponse, StopTurnData, StopTurnResponse, StopUserTurnData, StopUserTurnResponse, StorageSummaryData, StorageSummaryResponse, StreamContainerMetricsData, SyncRepositoriesData, SyncRepositoriesResponse, TailDeploymentJobLogsData, TailLogsData, TailLogsError, TeardownDeploymentData, TeardownDeploymentResponse, TeardownEnvironmentData, TeardownEnvironmentResponse, TerminalData, TestNotificationProviderData, TestNotificationProviderResponse, TestOidcProviderData, TestOidcProviderResponse, TestProviderConnectionData, TestProviderConnectionResponse, TestProviderData, TestProviderKeyByIdData, TestProviderKeyByIdError, TestProviderKeyByIdResponse, TestProviderKeyInlineData, TestProviderKeyInlineError, TestProviderKeyInlineResponse, TestProviderResponse2, TestS3ConnectionPreviewData, TestS3ConnectionPreviewError, TestS3ConnectionPreviewResponse, TestS3SourceConnectionData, TestS3SourceConnectionError, TestS3SourceConnectionResponse, TrackClickData, TrackOpenData, TriggerAgentData, TriggerAgentResponse, TriggerProjectPipelineData, TriggerProjectPipelineResponse, TriggerScanData, TriggerScanError, TriggerScanResponse2, TriggerServiceHealthCheckData, TriggerServiceHealthCheckResponse, TriggerWeeklyDigestData, TriggerWeeklyDigestResponse, UnlinkApplicationProjectData, UnlinkApplicationProjectResponse, UnlinkServiceFromProjectData, UnlinkServiceFromProjectResponse, UpdateAgentData, UpdateAgentResponse, UpdateAiProviderData, UpdateAiProviderPreferenceData, UpdateAiProviderPreferenceError, UpdateAiProviderPreferenceResponse, UpdateAiProviderResponse2, UpdateAiSummaryPreferenceData, UpdateAiSummaryPreferenceError, UpdateAiSummaryPreferenceResponse, UpdateAlertData, UpdateAlertError, UpdateAlertResponse, UpdateAlertRuleData, UpdateAlertRuleResponse, UpdateAnalyticsIngestKeyData, UpdateAnalyticsIngestKeyResponse, UpdateApiKeyData, UpdateApiKeyResponse, UpdateApplicationWorkspaceData, UpdateApplicationWorkspaceResponse, UpdateAutomaticDeployData, UpdateAutomaticDeployResponse, UpdateBackupScheduleData, UpdateBackupScheduleError, UpdateBackupScheduleResponse, UpdateCloudFeaturesData, UpdateCloudFeaturesResponse, UpdateCloudflareProviderData, UpdateCloudflareProviderResponse, UpdateConnectionTokenData, UpdateConnectionTokenResponse, UpdateCustomDomainData, UpdateCustomDomainResponse, UpdateDashboardData, UpdateDashboardError, UpdateDashboardResponse, UpdateDeploymentTokenData, UpdateDeploymentTokenResponse, UpdateEmailProviderData, UpdateEmailProviderResponse, UpdateEnvironmentSettingsData, UpdateEnvironmentSettingsResponse, UpdateEnvironmentSubdomainData, UpdateEnvironmentSubdomainResponse, UpdateEnvironmentVariableData, UpdateEnvironmentVariableResponse, UpdateErrorGroupData, UpdateFlagData, UpdateFlagResponse, UpdateFunnelData, UpdateGitProviderCredentialsData, UpdateGitProviderCredentialsResponse, UpdateGitSettingsData, UpdateGitSettingsResponse, UpdateGlobalMcpData, UpdateGlobalMcpResponse, UpdateGlobalSkillData, UpdateGlobalSkillResponse, UpdateIncidentStatusData, UpdateIncidentStatusResponse, UpdateIpAccessControlData, UpdateIpAccessControlError, UpdateIpAccessControlResponse, UpdateManagedDomainData, UpdateManagedDomainResponse, UpdateMcpData, UpdateMcpResponse, UpdateNotificationEmailProviderData, UpdateNotificationEmailProviderResponse, UpdateNotificationProviderData, UpdateNotificationProviderResponse, UpdateNotificationRouteData, UpdateNotificationRouteResponse, UpdateOidcProviderData, UpdateOidcProviderResponse, UpdatePermissionModeData, UpdatePermissionModeResponse, UpdatePreferencesData, UpdatePreferencesResponse, UpdateProjectCloudTelemetryData, UpdateProjectCloudTelemetryError, UpdateProjectCloudTelemetryResponse, UpdateProjectData, UpdateProjectDeploymentConfigData, UpdateProjectDeploymentConfigResponse, UpdateProjectResponse, UpdateProjectSecretData, UpdateProjectSecretResponse, UpdateProjectSettingsData, UpdateProjectSettingsResponse, UpdateProviderData, UpdateProviderKeyData, UpdateProviderKeyError, UpdateProviderKeyResponse, UpdateProviderModelData, UpdateProviderModelError, UpdateProviderModelResponse, UpdateProviderResponse, UpdateRouteData, UpdateRouteResponse, UpdateS3SourceData, UpdateS3SourceError, UpdateS3SourceResponse, UpdateSelfData, UpdateSelfResponse, UpdateServiceData, UpdateServiceResourcesData, UpdateServiceResourcesResponse, UpdateServiceResponse, UpdateServiceTemplateRuntimeData, UpdateServiceTemplateRuntimeResponse, UpdateSessionDurationData, UpdateSessionDurationError, UpdateSessionDurationResponse2, UpdateSettingsData, UpdateSettingsResponse, UpdateSkillData, UpdateSkillResponse, UpdateSlackProviderData, UpdateSlackProviderResponse, UpdateSpeedMetricsData, UpdateSpeedMetricsError, UpdateSpeedMetricsResponse, UpdateTeamData, UpdateTeamMemberRoleData, UpdateTeamMemberRoleResponse, UpdateTeamResponse, UpdateUserData, UpdateUserPermissionModeData, UpdateUserPermissionModeResponse, UpdateUserResponse, UpdateWebhookData, UpdateWebhookProviderData, UpdateWebhookProviderResponse, UpdateWebhookResponse, UpgradePreviewGatewayData, UpgradePreviewGatewayError, UpgradePreviewGatewayResponse, UpgradeProjectServiceTemplateData, UpgradeProjectServiceTemplateResponse, UpgradeServiceData, UpgradeServiceResponse, UploadApplicationWorkspaceFilesData, UploadApplicationWorkspaceFilesResponse, UploadGlobalSkillData, UploadGlobalSkillResponse, UploadGlobalWorkspaceFilesData, UploadGlobalWorkspaceFilesResponse, UploadReleaseFileData, UploadReleaseFileResponse, UploadSkillData, UploadSkillResponse, UploadSourceFileData, UploadSourceFileResponse, UploadSourceMapData, UploadSourceMapResponse, UploadStaticBundleData, UploadStaticBundleResponse, UploadUserConversationAttachmentData, UploadUserConversationAttachmentResponse, UpsertSecretData, UpsertSecretResponse, ValidateConnectionData, ValidateConnectionResponse, ValidateEmailData, ValidateEmailResponse2, VerifyAndEnableMfaData, VerifyAndEnableMfaResponse, VerifyDomainData, VerifyDomainResponse, VerifyEmailData, VerifyEmailResponse, VerifyManagedDomainData, VerifyManagedDomainResponse, VerifyMfaChallengeData, VerifyMfaChallengeResponse, VerifyStepUpData, VerifyStepUpResponse, WakeEnvironmentData, WakeEnvironmentResponse, WebhookTriggerData, WebhookTriggerResponse2, WorkflowDryRunData, WorkflowDryRunResponse, WriteApplicationWorkspaceFilesData, WriteApplicationWorkspaceFilesResponse2, WriteFileData, WriteFileResponse, WriteFilesData, WriteFilesResponse2 } from '../types.gen'; +import { acknowledgeAlarm, acknowledgeSystemAlarm, activateAiProvider, activateApiKey, activateConnection, activateProvider, addClusterMember, addContext, addEnvironmentDomain, addEvents, addManagedDomain, addProviderModel, addSessionReplayEvents, addTeamMember, adminDrainNode, adminDrainStatus, adminGetNode, adminListNodeContainers, adminListNodes, adminRemoveNode, adminUndrainNode, aggregateApiTraffic, applyHostnameMode, archiveApplication, archiveConversation, archiveFlag, archiveUserConversation, assignRole, attachScheduleServices, authorizeEmailDomainProject, blobCopy, blobDelete, blobDisable, blobDownload, blobEnable, blobList, blobPut, blobStatus, blobUpdate, cancel, cancelBackup, cancelBulkActivationJob, cancelDeployment, cancelDomainOrder, cancelPgUpgrade, cancelRun, cancelScheduleRun, changePasswordSelf, changeProjectSource, changeRequiredPassword, chatCompletions, checkAnalyticsHasEvents, checkCommitExists, checkDomainStatus, checkExplorerSupport, checkForUpdate, checkIpBlocked, checkProviderDeletionSafety, chunkUploadOptions, cleanupExpiredBackups, clearPreviewPassword, cliDeviceApprove, cliDeviceDeny, cliDeviceLookup, cliDevicePoll, cliDeviceStart, cliLogout, clusterDnsStatus, cmd, cmdKill, cmdLogs, confirmPendingAction, confirmUserPendingAction, containerMetricsGetHistory, controlApplicationWorkspace, createAgent, createAlert, createAlertRule, createAnalyticsIngestKey, createApiKey, createApplication, createApplicationConversation, createApplicationPreviewLink, createApplicationProject, createBackupSchedule, createBitbucketProvider, createBulkActivationJob, createCloudflareProvider, createConversation, createCustomDomain, createDashboard, createDeploymentToken, createDnsProvider, createDomain, createDsn, createEmailDomain, createEmailProvider, createEnvironment, createEnvironmentVariable, createFacet, createFlag, createFunnel, createGenericProvider, createGiteaPatProvider, createGithubPatProvider, createGitlabOauthProvider, createGitlabPatProvider, createGitProvider, createGlobalConversation, createGlobalMcp, createGlobalSkill, createGlobalWorkspacePreviewLink, createIncident, createIpAccessControl, createMcp, createMonitor, createNotificationEmailProvider, createNotificationProvider, createNotificationRoute, createOidcProvider, createOidcRoleMapping, createOrRecreateOrder, createPlan, createPr, createProject, createProjectFromTemplate, createProjectRelease, createProjectSecret, createProviderKey, createRelease, createRoute, createS3Source, createSandbox, createService, createSkill, createSlackProvider, createSnapshot, createTeam, createThreadArtifact, createUser, createWebhook, createWebhookProvider, deactivateApiKey, deactivateConnection, deactivateProvider, deauthorizeDiscoveredRouteCert, deleteAgent, deleteAlert, deleteAlertRule, deleteApiKey, deleteBackup, deleteBackupSchedule, deleteConnection, deleteCustomDomain, deleteDashboard, deleteDeploymentToken, deleteDnsProvider, deleteDomain, deleteEmailDomain, deleteEmailProvider, deleteEnvironment, deleteEnvironmentDomain, deleteEnvironmentVariable, deleteExternalImage, deleteFacet, deleteFunnel, deleteGitProvider, deleteGlobalMcp, deleteGlobalSkill, deleteIpAccessControl, deleteMcp, deleteMonitor, deleteNotificationProvider, deleteNotificationRoute, deleteOidcProvider, deleteOidcRoleMapping, deletePreferences, deleteProject, deleteProjectSecret, deleteProviderKey, deleteProviderModel, deleteProviderSafely, deleteReleaseSourceFiles, deleteReleaseSourceMaps, deleteRoute, deleteS3Source, deleteScan, deleteSecret, deleteService, deleteSessionReplay, deleteSkill, deleteSnapshot, deleteSourceMap, deleteStaticBundle, deleteTeam, deleteUser, deleteWebhook, deployApplicationWorkspaceProject, deployFromImage, deployFromImageUpload, deployFromStatic, deployFromUploadedSource, deploymentMetricsGetLatest, deploymentMetricsGetRange, deploymentMetricsToggle, destroySandbox, detachScheduleService, detectPublicEnvExample, detectPublicPresets, disableBackupSchedule, disableMfa, disconnectCloud, discoverWorkloads, domain, downloadApplicationWorkspaceFile, downloadGlobalSkillArchive, downloadGlobalWorkspaceFile, downloadObject, downloadSkillArchive, emailStatus, embeddings, enableBackupSchedule, enrichVisitor, enrollCloud, estimateBulkActivation, exec, execDetached, executeDeploymentOperation, executeImport, extendTimeout, externalServiceEnablePgStatStatements, externalServiceMetricsByDatabase, externalServiceMetricsCreateAlertRule, externalServiceMetricsDeleteAlertRule, externalServiceMetricsGetAlertRules, externalServiceMetricsGetLatest, externalServiceMetricsGetRange, externalServiceMetricsStatus, externalServiceMetricsToggle, externalServiceMetricsUpdateAlertRule, externalServiceResetPgStatStatements, finalizeOrder, finalizeProjectRelease, findConversation, generateJoinToken, generatePresetDockerfile, getAccessInfo, getActiveVisitors, getActivityGraph, getAdminGate, getAgent, getAggregatedBuckets, getAiAgentBreakdown, getAiAgentPages, getAiAgentTimeline, getAiDataAccess, getAiPageBreakdown, getAiProviderStatus, getAiStatusBreakdown, getAlert, getAlertRule, getAllRepositoriesByName, getAnalyticsActiveVisitors, getAnalyticsEventsCount, getAnalyticsSessionEvents, getAnalyticsVisitorSessions, getApiCallers, getApiKey, getApiKeyPermissions, getApiRoutes, getApiSummary, getApiTimeseries, getApiTrafficProxyLogAccess, getApplication, getApplicationWorkspace, getApplicationWorkspaceChanges, getApplicationWorkspaceDiff, getApplicationWorkspaceDirectory, getApplicationWorkspaceFile, getAuditLog, getBackup, getBackupSchedule, getBranchesByRepositoryId, getBucketedIncidents, getBucketedStatus, getBulkActivationJob, getChallengeToken, getChatReadiness, getCliStatus, getCloudAiCapability, getCloudBackfillStatus, getCloudCapability, getCloudStatus, getCloudTelemetryStatus, getClusterHealth, getClusterMember, getCmd, getContainerDetail, getContainerEnvironmentVariable, getContainerLogs, getContainerLogsById, getContainerMetrics, getConversation, getConversationDetail, getConversations, getCronById, getCronExecutions, getCrossProjectTraceSiblings, getCurrentBulkActivationJob, getCurrentMonitorStatus, getCurrentUser, getCustomDomain, getDashboard, getDashboardProjectsAnalytics, getDelivery, getDeployment, getDeploymentContainerLogContent, getDeploymentJobLogs, getDeploymentJobs, getDeploymentOperations, getDeploymentOperationStatus, getDeploymentToken, getDiskStatus, getDnsChanges, getDnsProvider, getDomain, getDomainByHost, getDomainById, getDomainByName, getDomainDnsRecords, getDomainOrder, getEmail, getEmailEvents, getEmailLinks, getEmailProvider, getEmailStats, getEmailTracking, getEmailTrackingStatus, getEntityInfo, getEnvironment, getEnvironmentCrons, getEnvironmentDomains, getEnvironments, getEnvironmentVariables, getEnvironmentVariableValue, getErrorDashboardStats, getErrorEvent, getErrorGroup, getErrorStats, getErrorTimeSeries, getEventDetail, getEventEntries, getEventsCount, getEventsTimeline, getEventTypeBreakdown, getEventVisitors, getExternalImage, getExternalServiceBackupCapability, getFailureReportPreview, getFeatureMaturity, getFile, getFlag, getFlagSnapshot, getFunnelMetrics, getGenaiTrace, getGeneralStats, getGitProvider, getGlobalAiWorkspace, getGlobalEvents, getGlobalEventStats, getGlobalMcp, getGlobalSandboxStatus, getGlobalSkill, getGlobalWorkspaceChanges, getGlobalWorkspaceDiff, getGlobalWorkspaceDirectory, getGlobalWorkspaceFile, getGroupedPageMetrics, getHealth, getHourlyVisits, getHttpChallengeDebug, getImportStatus, getIncident, getIncidentUpdates, getIngestErrors, getIpAccessControl, getIpGeolocation, getJoinTokenStatus, getLastDeployment, getLatestDeploymentMedia, getLatestScan, getLatestScansPerEnvironment, getLiveVisitorsList, getLogContext, getMcp, getMetricsOverTime, getMonitor, getNotificationProvider, getNotificationRoute, getOnDemandCertStatus, getOrCreateDsn, getPageFlow, getPageHourlySessions, getPagePathDetail, getPagePaths, getPagePathsSparklines, getPagePathVisitors, getPendingAction, getPerformanceMetrics, getPgUpgrade, getPgUpgradeLogs, getPipelineHistory, getPipelineStats, getPlatformInfo, getPostgresWalHealth, getPreferences, getPreviewGatewayLogs, getPreviewGatewaySettings, getPreviewGatewayStatus, getPricing, getPrivateIp, getProject, getProjectAlarmsSummary, getProjectBySlug, getProjectCloudTelemetry, getProjectDeployments, getProjects, getProjectServiceEnvironmentVariables, getProjectServiceTemplate, getProjectSessionReplays, getProjectsHealth, getProjectsMonitorHealth, getProjectStatistics, getProjectTemplate, getPropertyBreakdown, getPropertyTimeline, getProviderConnections, getProviderKey, getProviderMetadata, getProvidersMetadata, getProxyLogById, getProxyLogByRequestId, getProxyLogs, getPublicBranches, getPublicComposePreview, getPublicComposeServices, getPublicIp, getPublicRepository, getQueryContainerInfo, getQuota, getRecentActivity, getRemoteExternalImage, getRepositoryBranches, getRepositoryById, getRepositoryByName, getRepositoryComposePreview, getRepositoryComposeServicesLive, getRepositoryEnvExampleLive, getRepositoryPresetByName, getRepositoryPresetLive, getRepositoryTags, getResolvedEnvironmentVariables, getResolvedEnvironmentVariableValue, getRestoreCapabilities, getRestoreRun, getRoute, getRun, getRunWithLogs, getS3Credentials, getS3Source, getSandbox, getSandboxStatus, getScan, getScanByDeployment, getScanVulnerabilities, getService, getServiceBySlug, getServiceEnvironmentVariable, getServiceEnvironmentVariables, getServiceHealthStatus, getServicePreviewEnvironmentVariableNames, getServicePreviewEnvironmentVariablesMasked, getServiceRuntime, getServiceStats, getServiceTypeParameters, getServiceTypes, getSessionDetails, getSessionEvents, getSessionLogs, getSessionReplay, getSessionReplayEvents, getSettings, getSkill, getSlowQueries, getSnapshot, getStaticBundle, getStatusOverview, getSystemAlarmsSummary, getTagsByRepositoryId, getTeam, getTimeBucketStats, getTodayStats, getTrace, getTraefikDiscoveryStatus, getUnifiedTrace, getUniqueCounts, getUniqueEvents, getUpdateCapability, getUpdateStatus, getUptimeHistory, getUsageByProvider, getUsageRecent, getUsageSummary, getUsageTimeseries, getUsageTopModels, getUserConversation, getUserConversationAttachment, getUserPendingAction, getVisibleCustomDomainByHostname, getVisitorByGuid, getVisitorById, getVisitorDetails, getVisitorFacets, getVisitorInfo, getVisitorJourney, getVisitors, getVisitorSessions, getVisitorStats, getWebhook, getWorkspaceFileLimits, grantProjectAccess, handleGitProviderOauthCallback, hasAnalyticsEvents, hasErrorGroups, hasPerformanceMetrics, hasTraces, importApplicationWorkspaceGit, importEmailDomain, importExternalService, importLocalAiProviderCredential, importTraefikAcmeJson, ingestLogs, ingestLogsByPath, ingestMetrics, ingestMetricsByPath, ingestSentryEnvelope, ingestSentryEvent, ingestTraces, ingestTracesByPath, ingestTunneledEnvelope, initSessionReplay, inspectDropArchive, issueRuntimeCredentials, jobLogs, jobStatus, killJob, kvDel, kvDisable, kvEnable, kvExpire, kvGet, kvIncr, kvKeys, kvSet, kvStatus, kvTtl, kvUpdate, latestRunForSource, linkApplicationProject, linkCustomDomainToCertificate, linkServiceToProject, listAgentRuns, listAgents, listAiProviders, listAlertRules, listAlerts, listAllConversations, listAllRuns, listAnalyticsIngestKeys, listApiKeys, listApplicationConversations, listApplications, listAuditLogs, listAvailableContainers, listBackupAlerts, listBackupChildren, listBackupSchedules, listBackupsForSchedule, listCommitsByRepositoryId, listConnections, listContainerHistory, listContainers, listContainersAtPath, listConversations, listCustomDomainsForProject, listDashboards, listDeliveries, listDeploymentContainerLogs, listDeploymentTokens, listDiscoverableDomains, listDnsProviders, listDomains, listDsns, listEmailDomainProjects, listEmailDomains, listEmailProviders, listEmails, listEnrollmentTokens, listEntities, listErrorEvents, listErrorGroups, listEvents, listEventTypes, listExternalImages, listExternalPlugins, listExternalServiceBackups, listFacets, listFlags, listFunnels, listGitProviders, listGlobalMcps, listGlobalSkills, listIncidents, listInsights, listIpAccessControl, listJobs, listKnownAiAgents, listManagedDomains, listManagedEnvironmentVariables, listMcps, listMetricLabelKeys, listMetricLabelValues, listMetricNames, listModels, listMonitors, listNotificationProviders, listNotificationRoutes, listOidcProviders, listOidcProviderUsers, listOidcRoleMappings, listOnDemandCerts, listOrders, listPeers, listPendingActions, listPgUpgrades, listPresets, listProjectAccess, listProjectAlarms, listProjectScans, listProjectSecrets, listProjectServices, listProjectTemplates, listProjectTemplateTags, listProviderKeys, listProviderZones, listPublicProviders, listReleaseFiles, listReleases, listRemoteExternalImages, listRenewalAttempts, listRepositoriesByConnection, listRepositoriesByProvider, listRestoreRunsForService, listRootContainers, listRoutes, listS3Sources, listSandboxes, listScheduleRunJobs, listScheduleRuns, listScheduleServices, listSecrets, listServiceHealthStatuses, listServiceProjects, listServices, listServiceSchedules, listSkills, listSnapshots, listSourceBackups, listSourceFiles, listSourceMaps, listSources, listStaticBundles, listSyncedRepositories, listSystemAlarms, listTeamMembers, listTeamProjects, listTeams, listThreadArtifacts, listTraefikDiscoveredRoutes, listUserPendingActions, listUsers, listWebhooks, login, logout, lookupDnsARecords, mintEnrollmentToken, mkdir, nodeHeartbeat, nodeMetricsGetAlertRules, nodeMetricsGetRange, nodeMetricsUpdateAlertRule, observabilityFullEvent, observabilityListEvents, oidcCallback, type Options, patchAdminGate, patchPreviewGatewaySettings, pauseDeployment, pauseSandbox, planRestore, postDnsAck, previewAlert, previewFunnelMetrics, previewHostnameMode, promoteClusterMember, promoteDeployment, provisionDomain, purgeProjectLogs, pushExternalImage, queryData, queryGenaiTraces, queryLogs, queryMetrics, querySpanStats, queryTraces, queryTraceSummaries, readEntityRows, readFile, reAnalyze, reassignProjectCustomDomain, reconcileCloudBackupSource, recordConsoleEvent, recordEventMetrics, recordFlagExposure, recordSpeedMetrics, refreshAiProviderModels, refreshAiProviderStatus, refreshProviderModels, refreshRouteTable, regenerateDsn, registerExternalImage, registerNode, reinstallGitlabWebhook, rejectPendingAction, rejectUserPendingAction, reloadPlugins, removeClusterMember, removeManagedDomain, removeRole, removeTeamMember, renameConversation, renameUserConversation, renewDomain, repointContinuousArchiveSource, requestDiscoveredRouteCert, requestPasswordReset, resetPassword, resizeSandbox, resolveAlarm, resolvePermission, resolveSystemAlarm, resolveUserPermission, restartContainer, restartPreviewGateway, restartSandbox, restoreApplication, restoreFlag, restoreUser, restoreUserConversation, resumeDeployment, resumeSandbox, retryCluster, retryDelivery, retryFacetBackfill, retryPgUpgrade, retryRun, revealGlobalMcpConfig, revealMcpConfig, revealNotificationProviderConfig, revealServiceEnvironmentVariables, revealServiceParameter, revenueCreateIntegration, revenueDeleteIntegration, revenueGlobalEvents, revenueImportInvoicesCsv, revenueImportSubscriptionsCsv, revenueListIntegrations, revenueListProviders, revenueMetricsCustomers, revenueMetricsGlobalMrr, revenueMetricsGlobalSummary, revenueMetricsMrr, revenueMetricsSummary, revenueRecentEvents, revenueRotateToken, revenueUpdateConfig, revenueUpdateSecret, revokeAnalyticsIngestKey, revokeDsn, revokeEmailDomainProject, revokeEnrollmentToken, revokeJoinToken, revokeProjectAccess, rollbackPgUpgrade, rollbackToDeployment, rootfsGc, rootfsReport, rotateAnalyticsIngestKey, rotateApiKey, rotateClusterCa, rotateDeploymentToken, runBackupForSource, runConnectionHealthCheck, runExternalServiceBackup, runScheduleNow, sandboxCreatePreviewLink, sandboxIssueRuntimeEnvironment, saveAgentToken, saveAiProviderCredential, searchLogs, sendEmail, sendFailureReport, sendProjectAiMessage, sendUserMessage, setAiDataAccess, setAlternateSources, setApplicationPrimaryProject, setDefaultS3Source, setFlagEnvironment, setPreviewPassword, setTraefikDiscoveredRouteEnabled, setupDns, setupDnsChallenge, setupEmailTracking, setupMfa, silenceAlarm, silenceSystemAlarm, sleepEnvironment, smokeTestAgent, sourceSandbox, startAnalysis, startContainer, startFix, startGitProviderOauth, startOidcLoginBySlug, startPgUpgrade, startRestore, startService, startUpdate, statPath, stopContainer, stopSandbox, stopService, stopTurn, stopUserTurn, storageSummary, streamContainerMetrics, syncRepositories, tailDeploymentJobLogs, tailLogs, teardownDeployment, teardownEnvironment, terminal, testNotificationProvider, testOidcProvider, testProvider, testProviderConnection, testProviderKeyById, testProviderKeyInline, testS3ConnectionPreview, testS3SourceConnection, trackClick, trackOpen, triggerAgent, triggerProjectPipeline, triggerScan, triggerServiceHealthCheck, triggerWeeklyDigest, unlinkApplicationProject, unlinkServiceFromProject, updateAgent, updateAiProvider, updateAiSummaryPreference, updateAlert, updateAlertRule, updateAnalyticsIngestKey, updateApiKey, updateApplicationWorkspace, updateAutomaticDeploy, updateBackupSchedule, updateCloudFeatures, updateCloudflareProvider, updateConnectionToken, updateCustomDomain, updateDashboard, updateDeploymentToken, updateEmailProvider, updateEnvironmentSettings, updateEnvironmentSubdomain, updateEnvironmentVariable, updateErrorGroup, updateFlag, updateFunnel, updateGitProviderCredentials, updateGitSettings, updateGlobalMcp, updateGlobalSkill, updateIncidentStatus, updateIpAccessControl, updateManagedDomain, updateMcp, updateNotificationEmailProvider, updateNotificationProvider, updateNotificationRoute, updateOidcProvider, updatePermissionMode, updatePreferences, updateProject, updateProjectCloudTelemetry, updateProjectDeploymentConfig, updateProjectSecret, updateProjectSettings, updateProvider, updateProviderKey, updateProviderModel, updateRoute, updateS3Source, updateSelf, updateService, updateServiceResources, updateServiceTemplateRuntime, updateSessionDuration, updateSettings, updateSkill, updateSlackProvider, updateSpeedMetrics, updateTeam, updateTeamMemberRole, updateUser, updateUserPermissionMode, updateWebhook, updateWebhookProvider, upgradePreviewGateway, upgradeProjectServiceTemplate, upgradeService, uploadApplicationWorkspaceFiles, uploadGlobalSkill, uploadGlobalWorkspaceFiles, uploadReleaseFile, uploadSkill, uploadSourceFile, uploadSourceMap, uploadStaticBundle, uploadUserConversationAttachment, upsertSecret, validateConnection, validateEmail, verifyAndEnableMfa, verifyDomain, verifyEmail, verifyManagedDomain, verifyMfaChallenge, verifyStepUp, wakeEnvironment, webhookTrigger, workflowDryRun, writeApplicationWorkspaceFiles, writeFile, writeFiles } from '../sdk.gen'; +import type { AcknowledgeAlarmData, AcknowledgeSystemAlarmData, ActivateAiProviderData, ActivateAiProviderResponse, ActivateApiKeyData, ActivateApiKeyResponse, ActivateConnectionData, ActivateProviderData, AddClusterMemberData, AddClusterMemberResponse, AddContextData, AddEnvironmentDomainData, AddEnvironmentDomainResponse, AddEventsData, AddEventsError, AddEventsResponse2, AddManagedDomainData, AddManagedDomainResponse, AddProviderModelData, AddProviderModelError, AddProviderModelResponse, AddSessionReplayEventsData, AddSessionReplayEventsError, AddSessionReplayEventsResponse, AddTeamMemberData, AddTeamMemberResponse, AdminDrainNodeData, AdminDrainNodeResponse, AdminDrainStatusData, AdminDrainStatusResponse, AdminGetNodeData, AdminGetNodeResponse, AdminListNodeContainersData, AdminListNodeContainersResponse, AdminListNodesData, AdminListNodesResponse, AdminRemoveNodeData, AdminRemoveNodeResponse, AdminUndrainNodeData, AdminUndrainNodeResponse, AggregateApiTrafficData, AggregateApiTrafficError, AggregateApiTrafficResponse, ApplyHostnameModeData, ApplyHostnameModeResponse, ArchiveApplicationData, ArchiveApplicationResponse, ArchiveConversationData, ArchiveConversationResponse, ArchiveFlagData, ArchiveFlagResponse2, ArchiveUserConversationData, ArchiveUserConversationResponse, AssignRoleData, AttachScheduleServicesData, AttachScheduleServicesError, AttachScheduleServicesResponse2, AuthorizeEmailDomainProjectData, AuthorizeEmailDomainProjectResponse, BlobCopyData, BlobCopyError, BlobCopyResponse, BlobDeleteData, BlobDeleteError, BlobDeleteResponse, BlobDisableData, BlobDisableResponse, BlobDownloadData, BlobDownloadError, BlobEnableData, BlobEnableResponse, BlobListData, BlobListError, BlobListResponse, BlobPutData, BlobPutError, BlobPutResponse, BlobStatusData, BlobStatusResponse2, BlobUpdateData, BlobUpdateResponse, CancelBackupData, CancelBackupError, CancelBackupResponse2, CancelBulkActivationJobData, CancelBulkActivationJobError, CancelBulkActivationJobResponse, CancelData, CancelDeploymentData, CancelDeploymentResponse, CancelDomainOrderData, CancelDomainOrderResponse, CancelPgUpgradeData, CancelPgUpgradeError, CancelPgUpgradeResponse, CancelRunData, CancelRunResponse, CancelScheduleRunData, CancelScheduleRunError, CancelScheduleRunResponse, ChangePasswordSelfData, ChangePasswordSelfResponse, ChangeProjectSourceData, ChangeProjectSourceResponse, ChangeRequiredPasswordData, ChangeRequiredPasswordResponse, ChatCompletionsData, ChatCompletionsError, ChatCompletionsResponse, CheckAnalyticsHasEventsData, CheckAnalyticsHasEventsResponse, CheckCommitExistsData, CheckCommitExistsResponse, CheckDomainStatusData, CheckDomainStatusResponse, CheckExplorerSupportData, CheckExplorerSupportResponse, CheckForUpdateData, CheckForUpdateError, CheckForUpdateResponse, CheckIpBlockedData, CheckIpBlockedError, CheckProviderDeletionSafetyData, CheckProviderDeletionSafetyResponse, ChunkUploadOptionsData, ChunkUploadOptionsResponse, CleanupExpiredBackupsData, CleanupExpiredBackupsError, CleanupExpiredBackupsResponse, ClearPreviewPasswordData, ClearPreviewPasswordResponse, CliDeviceApproveData, CliDeviceApproveResponse2, CliDeviceDenyData, CliDeviceDenyResponse, CliDeviceLookupData, CliDeviceLookupResponse2, CliDevicePollData, CliDevicePollResponse2, CliDeviceStartData, CliDeviceStartResponse2, CliLogoutData, CliLogoutResponse, ClusterDnsStatusData, ClusterDnsStatusResponse2, CmdData, CmdKillData, CmdKillResponse, CmdLogsData, CmdResponse2, ConfirmPendingActionData, ConfirmPendingActionResponse, ConfirmUserPendingActionData, ConfirmUserPendingActionResponse, ContainerMetricsGetHistoryData, ContainerMetricsGetHistoryResponse, ControlApplicationWorkspaceData, ControlApplicationWorkspaceResponse, CreateAgentData, CreateAgentResponse, CreateAlertData, CreateAlertError, CreateAlertResponse, CreateAlertRuleData, CreateAlertRuleResponse, CreateAnalyticsIngestKeyData, CreateAnalyticsIngestKeyResponse, CreateApiKeyData, CreateApiKeyResponse2, CreateApplicationConversationData, CreateApplicationConversationResponse, CreateApplicationData, CreateApplicationPreviewLinkData, CreateApplicationPreviewLinkResponse, CreateApplicationProjectData, CreateApplicationProjectResponse, CreateApplicationResponse, CreateBackupScheduleData, CreateBackupScheduleError, CreateBackupScheduleResponse, CreateBitbucketProviderData, CreateBitbucketProviderResponse, CreateBulkActivationJobData, CreateBulkActivationJobError, CreateBulkActivationJobResponse, CreateCloudflareProviderData, CreateCloudflareProviderResponse, CreateConversationData, CreateConversationResponse, CreateCustomDomainData, CreateCustomDomainResponse, CreateDashboardData, CreateDashboardError, CreateDashboardResponse, CreateDeploymentTokenData, CreateDeploymentTokenResponse2, CreateDnsProviderData, CreateDnsProviderResponse, CreateDomainData, CreateDomainResponse, CreateDsnData, CreateDsnResponse, CreateEmailDomainData, CreateEmailDomainResponse, CreateEmailProviderData, CreateEmailProviderResponse, CreateEnvironmentData, CreateEnvironmentResponse, CreateEnvironmentVariableData, CreateEnvironmentVariableResponse, CreateFacetData, CreateFacetError, CreateFacetResponse, CreateFlagData, CreateFlagResponse, CreateFunnelData, CreateFunnelResponse2, CreateGenericProviderData, CreateGenericProviderResponse, CreateGiteaPatProviderData, CreateGiteaPatProviderResponse, CreateGithubPatProviderData, CreateGithubPatProviderResponse, CreateGitlabOauthProviderData, CreateGitlabOauthProviderResponse, CreateGitlabPatProviderData, CreateGitlabPatProviderResponse, CreateGitProviderData, CreateGitProviderResponse, CreateGlobalConversationData, CreateGlobalConversationResponse, CreateGlobalMcpData, CreateGlobalMcpResponse, CreateGlobalSkillData, CreateGlobalSkillResponse, CreateGlobalWorkspacePreviewLinkData, CreateGlobalWorkspacePreviewLinkResponse, CreateIncidentData, CreateIncidentResponse, CreateIpAccessControlData, CreateIpAccessControlError, CreateIpAccessControlResponse, CreateMcpData, CreateMcpResponse, CreateMonitorData, CreateMonitorResponse, CreateNotificationEmailProviderData, CreateNotificationEmailProviderResponse, CreateNotificationProviderData, CreateNotificationProviderResponse, CreateNotificationRouteData, CreateNotificationRouteResponse, CreateOidcProviderData, CreateOidcProviderResponse, CreateOidcRoleMappingData, CreateOidcRoleMappingResponse, CreateOrRecreateOrderData, CreateOrRecreateOrderResponse, CreatePlanData, CreatePlanResponse2, CreatePrData, CreateProjectData, CreateProjectFromTemplateData, CreateProjectFromTemplateResponse2, CreateProjectReleaseData, CreateProjectReleaseResponse, CreateProjectResponse, CreateProjectSecretData, CreateProjectSecretResponse, CreateProviderKeyData, CreateProviderKeyError, CreateProviderKeyResponse, CreatePrResponse2, CreateReleaseData, CreateReleaseResponse, CreateRouteData, CreateRouteResponse, CreateS3SourceData, CreateS3SourceError, CreateS3SourceResponse, CreateSandboxData, CreateSandboxResponse, CreateServiceData, CreateServiceResponse, CreateSkillData, CreateSkillResponse, CreateSlackProviderData, CreateSlackProviderResponse, CreateSnapshotData, CreateSnapshotResponse, CreateTeamData, CreateTeamResponse, CreateThreadArtifactData, CreateThreadArtifactResponse, CreateUserData, CreateUserResponse, CreateWebhookData, CreateWebhookProviderData, CreateWebhookProviderResponse, CreateWebhookResponse, DeactivateApiKeyData, DeactivateApiKeyResponse, DeactivateConnectionData, DeactivateProviderData, DeauthorizeDiscoveredRouteCertData, DeauthorizeDiscoveredRouteCertError, DeauthorizeDiscoveredRouteCertResponse, DeleteAgentData, DeleteAgentResponse, DeleteAlertData, DeleteAlertError, DeleteAlertResponse, DeleteAlertRuleData, DeleteAlertRuleResponse, DeleteApiKeyData, DeleteApiKeyResponse, DeleteBackupData, DeleteBackupError, DeleteBackupResponse, DeleteBackupScheduleData, DeleteBackupScheduleError, DeleteBackupScheduleResponse, DeleteConnectionData, DeleteConnectionResponse, DeleteCustomDomainData, DeleteCustomDomainResponse, DeleteDashboardData, DeleteDashboardError, DeleteDashboardResponse, DeleteDeploymentTokenData, DeleteDeploymentTokenResponse, DeleteDnsProviderData, DeleteDnsProviderResponse, DeleteDomainData, DeleteDomainResponse, DeleteEmailDomainData, DeleteEmailDomainResponse, DeleteEmailProviderData, DeleteEmailProviderResponse, DeleteEnvironmentData, DeleteEnvironmentDomainData, DeleteEnvironmentDomainResponse, DeleteEnvironmentResponse, DeleteEnvironmentVariableData, DeleteEnvironmentVariableResponse, DeleteExternalImageData, DeleteExternalImageResponse, DeleteFacetData, DeleteFacetError, DeleteFacetResponse, DeleteFunnelData, DeleteGitProviderData, DeleteGitProviderResponse, DeleteGlobalMcpData, DeleteGlobalMcpResponse, DeleteGlobalSkillData, DeleteGlobalSkillResponse, DeleteIpAccessControlData, DeleteIpAccessControlError, DeleteIpAccessControlResponse, DeleteMcpData, DeleteMcpResponse, DeleteMonitorData, DeleteMonitorResponse, DeleteNotificationProviderData, DeleteNotificationProviderResponse, DeleteNotificationRouteData, DeleteNotificationRouteResponse, DeleteOidcProviderData, DeleteOidcProviderResponse, DeleteOidcRoleMappingData, DeleteOidcRoleMappingResponse, DeletePreferencesData, DeletePreferencesResponse, DeleteProjectData, DeleteProjectResponse, DeleteProjectSecretData, DeleteProjectSecretResponse, DeleteProviderKeyData, DeleteProviderKeyError, DeleteProviderKeyResponse, DeleteProviderModelData, DeleteProviderModelError, DeleteProviderModelResponse, DeleteProviderSafelyData, DeleteProviderSafelyResponse, DeleteReleaseSourceFilesData, DeleteReleaseSourceFilesResponse, DeleteReleaseSourceMapsData, DeleteReleaseSourceMapsResponse, DeleteRouteData, DeleteRouteResponse, DeleteS3SourceData, DeleteS3SourceError, DeleteS3SourceResponse, DeleteScanData, DeleteScanError, DeleteScanResponse, DeleteSecretData, DeleteSecretResponse, DeleteServiceData, DeleteServiceResponse, DeleteSessionReplayData, DeleteSessionReplayError, DeleteSkillData, DeleteSkillResponse, DeleteSnapshotData, DeleteSnapshotResponse, DeleteSourceMapData, DeleteSourceMapResponse, DeleteStaticBundleData, DeleteStaticBundleResponse, DeleteTeamData, DeleteTeamResponse, DeleteUserData, DeleteUserResponse, DeleteWebhookData, DeleteWebhookResponse, DeployApplicationWorkspaceProjectData, DeployApplicationWorkspaceProjectResponse, DeployFromImageData, DeployFromImageResponse, DeployFromImageUploadData, DeployFromImageUploadResponse, DeployFromStaticData, DeployFromStaticResponse, DeployFromUploadedSourceData, DeployFromUploadedSourceResponse, DeploymentMetricsGetLatestData, DeploymentMetricsGetLatestResponse, DeploymentMetricsGetRangeData, DeploymentMetricsGetRangeResponse, DeploymentMetricsToggleData, DestroySandboxData, DestroySandboxResponse, DetachScheduleServiceData, DetachScheduleServiceError, DetachScheduleServiceResponse, DetectPublicEnvExampleData, DetectPublicEnvExampleResponse, DetectPublicPresetsData, DetectPublicPresetsResponse, DisableBackupScheduleData, DisableBackupScheduleError, DisableBackupScheduleResponse, DisableMfaData, DisableMfaResponse, DisconnectCloudData, DisconnectCloudResponse, DiscoverWorkloadsData, DiscoverWorkloadsResponse, DomainData, DomainResponse2, DownloadApplicationWorkspaceFileData, DownloadApplicationWorkspaceFileResponse, DownloadGlobalSkillArchiveData, DownloadGlobalSkillArchiveResponse, DownloadGlobalWorkspaceFileData, DownloadGlobalWorkspaceFileResponse, DownloadObjectData, DownloadObjectResponse, DownloadSkillArchiveData, DownloadSkillArchiveResponse, EmailStatusData, EmailStatusResponse2, EmbeddingsData, EmbeddingsError, EmbeddingsResponse, EnableBackupScheduleData, EnableBackupScheduleError, EnableBackupScheduleResponse, EnrichVisitorData, EnrichVisitorResponse2, EnrollCloudData, EnrollCloudResponse, EstimateBulkActivationData, EstimateBulkActivationError, EstimateBulkActivationResponse, ExecData, ExecDetachedData, ExecDetachedResponse2, ExecResponse2, ExecuteDeploymentOperationData, ExecuteDeploymentOperationResponse, ExecuteImportData, ExecuteImportResponse2, ExtendTimeoutData, ExtendTimeoutResponse, ExternalServiceEnablePgStatStatementsData, ExternalServiceEnablePgStatStatementsResponse, ExternalServiceMetricsByDatabaseData, ExternalServiceMetricsByDatabaseResponse, ExternalServiceMetricsCreateAlertRuleData, ExternalServiceMetricsCreateAlertRuleResponse, ExternalServiceMetricsDeleteAlertRuleData, ExternalServiceMetricsDeleteAlertRuleResponse, ExternalServiceMetricsGetAlertRulesData, ExternalServiceMetricsGetAlertRulesResponse, ExternalServiceMetricsGetLatestData, ExternalServiceMetricsGetLatestResponse, ExternalServiceMetricsGetRangeData, ExternalServiceMetricsGetRangeResponse, ExternalServiceMetricsStatusData, ExternalServiceMetricsStatusResponse, ExternalServiceMetricsToggleData, ExternalServiceMetricsUpdateAlertRuleData, ExternalServiceMetricsUpdateAlertRuleResponse, ExternalServiceResetPgStatStatementsData, ExternalServiceResetPgStatStatementsResponse, FinalizeOrderData, FinalizeOrderResponse, FinalizeProjectReleaseData, FinalizeProjectReleaseResponse, FindConversationData, FindConversationResponse, GenerateJoinTokenData, GenerateJoinTokenResponse2, GeneratePresetDockerfileData, GeneratePresetDockerfileResponse, GetAccessInfoData, GetAccessInfoResponse, GetActiveVisitorsData, GetActiveVisitorsResponse, GetActivityGraphData, GetActivityGraphError, GetActivityGraphResponse, GetAdminGateData, GetAdminGateResponse, GetAgentData, GetAgentResponse, GetAggregatedBucketsData, GetAggregatedBucketsResponse, GetAiAgentBreakdownData, GetAiAgentBreakdownError, GetAiAgentBreakdownResponse, GetAiAgentPagesData, GetAiAgentPagesError, GetAiAgentPagesResponse, GetAiAgentTimelineData, GetAiAgentTimelineError, GetAiAgentTimelineResponse, GetAiDataAccessData, GetAiDataAccessResponse, GetAiPageBreakdownData, GetAiPageBreakdownError, GetAiPageBreakdownResponse, GetAiProviderStatusData, GetAiProviderStatusError, GetAiProviderStatusResponse, GetAiStatusBreakdownData, GetAiStatusBreakdownError, GetAiStatusBreakdownResponse, GetAlertData, GetAlertError, GetAlertResponse, GetAlertRuleData, GetAlertRuleResponse, GetAllRepositoriesByNameData, GetAllRepositoriesByNameResponse, GetAnalyticsActiveVisitorsData, GetAnalyticsActiveVisitorsResponse, GetAnalyticsEventsCountData, GetAnalyticsEventsCountResponse, GetAnalyticsSessionEventsData, GetAnalyticsSessionEventsResponse, GetAnalyticsVisitorSessionsData, GetAnalyticsVisitorSessionsResponse, GetApiCallersData, GetApiCallersResponse, GetApiKeyData, GetApiKeyPermissionsData, GetApiKeyPermissionsResponse, GetApiKeyResponse, GetApiRoutesData, GetApiRoutesResponse, GetApiSummaryData, GetApiSummaryResponse, GetApiTimeseriesData, GetApiTimeseriesResponse, GetApiTrafficProxyLogAccessData, GetApiTrafficProxyLogAccessError, GetApiTrafficProxyLogAccessResponse, GetApplicationData, GetApplicationResponse, GetApplicationWorkspaceChangesData, GetApplicationWorkspaceChangesResponse, GetApplicationWorkspaceData, GetApplicationWorkspaceDiffData, GetApplicationWorkspaceDiffResponse, GetApplicationWorkspaceDirectoryData, GetApplicationWorkspaceDirectoryResponse, GetApplicationWorkspaceFileData, GetApplicationWorkspaceFileResponse, GetApplicationWorkspaceResponse, GetAuditLogData, GetAuditLogResponse, GetBackupData, GetBackupError, GetBackupResponse, GetBackupScheduleData, GetBackupScheduleError, GetBackupScheduleResponse, GetBranchesByRepositoryIdData, GetBranchesByRepositoryIdResponse, GetBucketedIncidentsData, GetBucketedIncidentsResponse, GetBucketedStatusData, GetBucketedStatusResponse, GetBulkActivationJobData, GetBulkActivationJobError, GetBulkActivationJobResponse, GetChallengeTokenData, GetChallengeTokenResponse, GetChatReadinessData, GetChatReadinessResponse, GetCliStatusData, GetCloudAiCapabilityData, GetCloudAiCapabilityResponse, GetCloudBackfillStatusData, GetCloudBackfillStatusError, GetCloudBackfillStatusResponse, GetCloudCapabilityData, GetCloudCapabilityResponse, GetCloudStatusData, GetCloudStatusResponse, GetCloudTelemetryStatusData, GetCloudTelemetryStatusError, GetCloudTelemetryStatusResponse, GetClusterHealthData, GetClusterHealthResponse, GetClusterMemberData, GetClusterMemberResponse, GetCmdData, GetCmdResponse, GetContainerDetailData, GetContainerDetailResponse, GetContainerEnvironmentVariableData, GetContainerEnvironmentVariableResponse, GetContainerLogsByIdData, GetContainerLogsData, GetContainerMetricsData, GetContainerMetricsResponse, GetConversationData, GetConversationDetailData, GetConversationDetailError, GetConversationDetailResponse, GetConversationResponse, GetConversationsData, GetConversationsError, GetConversationsResponse, GetCronByIdData, GetCronByIdResponse, GetCronExecutionsData, GetCronExecutionsResponse, GetCrossProjectTraceSiblingsData, GetCrossProjectTraceSiblingsError, GetCrossProjectTraceSiblingsResponse, GetCurrentBulkActivationJobData, GetCurrentBulkActivationJobError, GetCurrentBulkActivationJobResponse, GetCurrentMonitorStatusData, GetCurrentMonitorStatusResponse, GetCurrentUserData, GetCurrentUserResponse, GetCustomDomainData, GetCustomDomainResponse, GetDashboardData, GetDashboardError, GetDashboardProjectsAnalyticsData, GetDashboardProjectsAnalyticsResponse, GetDashboardResponse, GetDeliveryData, GetDeliveryResponse, GetDeploymentContainerLogContentData, GetDeploymentContainerLogContentResponse, GetDeploymentData, GetDeploymentJobLogsData, GetDeploymentJobLogsResponse, GetDeploymentJobsData, GetDeploymentJobsResponse, GetDeploymentOperationsData, GetDeploymentOperationsResponse, GetDeploymentOperationStatusData, GetDeploymentOperationStatusResponse, GetDeploymentResponse, GetDeploymentTokenData, GetDeploymentTokenResponse, GetDiskStatusData, GetDiskStatusResponse, GetDnsChangesData, GetDnsChangesResponse, GetDnsProviderData, GetDnsProviderResponse, GetDomainByHostData, GetDomainByHostResponse, GetDomainByIdData, GetDomainByIdResponse, GetDomainByNameData, GetDomainByNameResponse, GetDomainData, GetDomainDnsRecordsData, GetDomainDnsRecordsResponse, GetDomainOrderData, GetDomainOrderResponse, GetDomainResponse, GetEmailData, GetEmailEventsData, GetEmailEventsResponse, GetEmailLinksData, GetEmailLinksResponse, GetEmailProviderData, GetEmailProviderResponse, GetEmailResponse, GetEmailStatsData, GetEmailStatsResponse, GetEmailTrackingData, GetEmailTrackingResponse, GetEmailTrackingStatusData, GetEmailTrackingStatusResponse, GetEntityInfoData, GetEntityInfoResponse, GetEnvironmentCronsData, GetEnvironmentCronsResponse, GetEnvironmentData, GetEnvironmentDomainsData, GetEnvironmentDomainsResponse, GetEnvironmentResponse, GetEnvironmentsData, GetEnvironmentsResponse, GetEnvironmentVariablesData, GetEnvironmentVariablesResponse, GetEnvironmentVariableValueData, GetEnvironmentVariableValueResponse, GetErrorDashboardStatsData, GetErrorDashboardStatsResponse, GetErrorEventData, GetErrorEventResponse, GetErrorGroupData, GetErrorGroupResponse, GetErrorStatsData, GetErrorStatsResponse, GetErrorTimeSeriesData, GetErrorTimeSeriesResponse, GetEventDetailData, GetEventDetailResponse, GetEventEntriesData, GetEventEntriesResponse, GetEventsCountData, GetEventsCountResponse, GetEventsTimelineData, GetEventsTimelineResponse, GetEventTypeBreakdownData, GetEventTypeBreakdownResponse, GetEventVisitorsData, GetEventVisitorsResponse, GetExternalImageData, GetExternalImageResponse, GetExternalServiceBackupCapabilityData, GetExternalServiceBackupCapabilityError, GetExternalServiceBackupCapabilityResponse, GetFailureReportPreviewData, GetFailureReportPreviewResponse, GetFeatureMaturityData, GetFeatureMaturityResponse, GetFileData, GetFileResponse, GetFlagData, GetFlagResponse, GetFlagSnapshotData, GetFlagSnapshotResponse, GetFunnelMetricsData, GetFunnelMetricsResponse, GetGenaiTraceData, GetGenaiTraceError, GetGenaiTraceResponse, GetGeneralStatsData, GetGeneralStatsResponse, GetGitProviderData, GetGitProviderResponse, GetGlobalAiWorkspaceData, GetGlobalAiWorkspaceResponse, GetGlobalEventsData, GetGlobalEventsResponse, GetGlobalEventStatsData, GetGlobalEventStatsResponse, GetGlobalMcpData, GetGlobalMcpResponse, GetGlobalSandboxStatusData, GetGlobalSandboxStatusResponse, GetGlobalSkillData, GetGlobalSkillResponse, GetGlobalWorkspaceChangesData, GetGlobalWorkspaceChangesResponse, GetGlobalWorkspaceDiffData, GetGlobalWorkspaceDiffResponse, GetGlobalWorkspaceDirectoryData, GetGlobalWorkspaceDirectoryResponse, GetGlobalWorkspaceFileData, GetGlobalWorkspaceFileResponse, GetGroupedPageMetricsData, GetGroupedPageMetricsError, GetGroupedPageMetricsResponse, GetHealthData, GetHealthError, GetHealthResponse, GetHourlyVisitsData, GetHourlyVisitsResponse, GetHttpChallengeDebugData, GetHttpChallengeDebugResponse, GetImportStatusData, GetImportStatusResponse, GetIncidentData, GetIncidentResponse, GetIncidentUpdatesData, GetIncidentUpdatesResponse, GetIngestErrorsData, GetIngestErrorsError, GetIngestErrorsResponse, GetIpAccessControlData, GetIpAccessControlError, GetIpAccessControlResponse, GetIpGeolocationData, GetIpGeolocationError, GetIpGeolocationResponse, GetJoinTokenStatusData, GetJoinTokenStatusResponse, GetLastDeploymentData, GetLastDeploymentResponse, GetLatestDeploymentMediaData, GetLatestDeploymentMediaError, GetLatestDeploymentMediaResponse, GetLatestScanData, GetLatestScanError, GetLatestScanResponse, GetLatestScansPerEnvironmentData, GetLatestScansPerEnvironmentError, GetLatestScansPerEnvironmentResponse, GetLiveVisitorsListData, GetLiveVisitorsListResponse, GetLogContextData, GetLogContextError, GetLogContextResponse, GetMcpData, GetMcpResponse, GetMetricsOverTimeData, GetMetricsOverTimeError, GetMetricsOverTimeResponse, GetMonitorData, GetMonitorResponse, GetNotificationProviderData, GetNotificationProviderResponse, GetNotificationRouteData, GetNotificationRouteResponse, GetOnDemandCertStatusData, GetOnDemandCertStatusResponse, GetOrCreateDsnData, GetOrCreateDsnResponse, GetPageFlowData, GetPageFlowResponse, GetPageHourlySessionsData, GetPageHourlySessionsResponse, GetPagePathDetailData, GetPagePathDetailResponse, GetPagePathsData, GetPagePathsResponse, GetPagePathsSparklinesData, GetPagePathsSparklinesResponse, GetPagePathVisitorsData, GetPagePathVisitorsResponse, GetPendingActionData, GetPendingActionResponse, GetPerformanceMetricsData, GetPerformanceMetricsError, GetPerformanceMetricsResponse, GetPgUpgradeData, GetPgUpgradeError, GetPgUpgradeLogsData, GetPgUpgradeLogsError, GetPgUpgradeLogsResponse, GetPgUpgradeResponse, GetPipelineHistoryData, GetPipelineHistoryError, GetPipelineHistoryResponse, GetPipelineStatsData, GetPipelineStatsError, GetPipelineStatsResponse, GetPlatformInfoData, GetPlatformInfoResponse, GetPostgresWalHealthData, GetPostgresWalHealthResponse, GetPreferencesData, GetPreferencesResponse, GetPreviewGatewayLogsData, GetPreviewGatewayLogsError, GetPreviewGatewayLogsResponse, GetPreviewGatewaySettingsData, GetPreviewGatewaySettingsResponse, GetPreviewGatewayStatusData, GetPreviewGatewayStatusError, GetPreviewGatewayStatusResponse, GetPricingData, GetPricingError, GetPricingResponse, GetPrivateIpData, GetProjectAlarmsSummaryData, GetProjectAlarmsSummaryResponse, GetProjectBySlugData, GetProjectBySlugResponse, GetProjectCloudTelemetryData, GetProjectCloudTelemetryError, GetProjectCloudTelemetryResponse, GetProjectData, GetProjectDeploymentsData, GetProjectDeploymentsResponse, GetProjectResponse, GetProjectsData, GetProjectServiceEnvironmentVariablesData, GetProjectServiceEnvironmentVariablesResponse, GetProjectServiceTemplateData, GetProjectServiceTemplateResponse, GetProjectSessionReplaysData, GetProjectSessionReplaysError, GetProjectSessionReplaysResponse2, GetProjectsHealthData, GetProjectsHealthError, GetProjectsHealthResponse, GetProjectsMonitorHealthData, GetProjectsMonitorHealthResponse, GetProjectsResponse, GetProjectStatisticsData, GetProjectStatisticsResponse, GetProjectTemplateData, GetProjectTemplateResponse, GetPropertyBreakdownData, GetPropertyBreakdownResponse, GetPropertyTimelineData, GetPropertyTimelineResponse, GetProviderConnectionsData, GetProviderConnectionsResponse, GetProviderKeyData, GetProviderKeyError, GetProviderKeyResponse, GetProviderMetadataData, GetProviderMetadataResponse, GetProvidersMetadataData, GetProvidersMetadataResponse, GetProxyLogByIdData, GetProxyLogByIdError, GetProxyLogByIdResponse, GetProxyLogByRequestIdData, GetProxyLogByRequestIdError, GetProxyLogByRequestIdResponse, GetProxyLogsData, GetProxyLogsError, GetProxyLogsResponse, GetPublicBranchesData, GetPublicBranchesResponse, GetPublicComposePreviewData, GetPublicComposePreviewResponse, GetPublicComposeServicesData, GetPublicComposeServicesResponse, GetPublicIpData, GetPublicRepositoryData, GetPublicRepositoryResponse, GetQueryContainerInfoData, GetQueryContainerInfoResponse, GetQuotaData, GetQuotaError, GetQuotaResponse, GetRecentActivityData, GetRecentActivityResponse, GetRemoteExternalImageData, GetRemoteExternalImageResponse, GetRepositoryBranchesData, GetRepositoryBranchesResponse, GetRepositoryByIdData, GetRepositoryByIdResponse, GetRepositoryByNameData, GetRepositoryByNameResponse, GetRepositoryComposePreviewData, GetRepositoryComposePreviewResponse, GetRepositoryComposeServicesLiveData, GetRepositoryComposeServicesLiveResponse, GetRepositoryEnvExampleLiveData, GetRepositoryEnvExampleLiveResponse, GetRepositoryPresetByNameData, GetRepositoryPresetByNameResponse, GetRepositoryPresetLiveData, GetRepositoryPresetLiveResponse, GetRepositoryTagsData, GetRepositoryTagsResponse, GetResolvedEnvironmentVariablesData, GetResolvedEnvironmentVariablesResponse, GetResolvedEnvironmentVariableValueData, GetResolvedEnvironmentVariableValueResponse, GetRestoreCapabilitiesData, GetRestoreCapabilitiesError, GetRestoreCapabilitiesResponse, GetRestoreRunData, GetRestoreRunError, GetRestoreRunResponse, GetRouteData, GetRouteResponse, GetRunData, GetRunResponse, GetRunWithLogsData, GetRunWithLogsResponse, GetS3CredentialsData, GetS3CredentialsResponse, GetS3SourceData, GetS3SourceError, GetS3SourceResponse, GetSandboxData, GetSandboxResponse, GetSandboxStatusData, GetSandboxStatusResponse, GetScanByDeploymentData, GetScanByDeploymentError, GetScanByDeploymentResponse, GetScanData, GetScanError, GetScanResponse, GetScanVulnerabilitiesData, GetScanVulnerabilitiesError, GetScanVulnerabilitiesResponse, GetServiceBySlugData, GetServiceBySlugResponse, GetServiceData, GetServiceEnvironmentVariableData, GetServiceEnvironmentVariableResponse, GetServiceEnvironmentVariablesData, GetServiceEnvironmentVariablesResponse, GetServiceHealthStatusData, GetServiceHealthStatusResponse, GetServicePreviewEnvironmentVariableNamesData, GetServicePreviewEnvironmentVariableNamesResponse, GetServicePreviewEnvironmentVariablesMaskedData, GetServicePreviewEnvironmentVariablesMaskedResponse, GetServiceResponse, GetServiceRuntimeData, GetServiceRuntimeResponse, GetServiceStatsData, GetServiceStatsResponse, GetServiceTypeParametersData, GetServiceTypesData, GetServiceTypesResponse, GetSessionDetailsData, GetSessionDetailsResponse, GetSessionEventsData, GetSessionEventsResponse, GetSessionLogsData, GetSessionLogsResponse, GetSessionReplayData, GetSessionReplayError, GetSessionReplayEventsData, GetSessionReplayEventsError, GetSessionReplayEventsResponse, GetSessionReplayResponse2, GetSettingsData, GetSettingsResponse, GetSkillData, GetSkillResponse, GetSlowQueriesData, GetSlowQueriesResponse, GetSnapshotData, GetSnapshotResponse, GetStaticBundleData, GetStaticBundleResponse, GetStatusOverviewData, GetStatusOverviewResponse, GetSystemAlarmsSummaryData, GetSystemAlarmsSummaryResponse, GetTagsByRepositoryIdData, GetTagsByRepositoryIdResponse, GetTeamData, GetTeamResponse, GetTimeBucketStatsData, GetTimeBucketStatsError, GetTimeBucketStatsResponse, GetTodayStatsData, GetTodayStatsError, GetTodayStatsResponse, GetTraceData, GetTraceError, GetTraceResponse, GetTraefikDiscoveryStatusData, GetTraefikDiscoveryStatusError, GetTraefikDiscoveryStatusResponse, GetUnifiedTraceData, GetUnifiedTraceError, GetUnifiedTraceResponse, GetUniqueCountsData, GetUniqueCountsResponse, GetUniqueEventsData, GetUniqueEventsResponse, GetUpdateCapabilityData, GetUpdateCapabilityResponse, GetUpdateStatusData, GetUpdateStatusResponse, GetUptimeHistoryData, GetUptimeHistoryResponse, GetUsageByProviderData, GetUsageByProviderError, GetUsageByProviderResponse, GetUsageRecentData, GetUsageRecentError, GetUsageRecentResponse, GetUsageSummaryData, GetUsageSummaryError, GetUsageSummaryResponse, GetUsageTimeseriesData, GetUsageTimeseriesError, GetUsageTimeseriesResponse, GetUsageTopModelsData, GetUsageTopModelsError, GetUsageTopModelsResponse, GetUserConversationAttachmentData, GetUserConversationAttachmentResponse, GetUserConversationData, GetUserConversationResponse, GetUserPendingActionData, GetUserPendingActionResponse, GetVisibleCustomDomainByHostnameData, GetVisibleCustomDomainByHostnameResponse, GetVisitorByGuidData, GetVisitorByGuidResponse, GetVisitorByIdData, GetVisitorByIdResponse, GetVisitorDetailsData, GetVisitorDetailsResponse, GetVisitorFacetsData, GetVisitorFacetsResponse, GetVisitorInfoData, GetVisitorInfoResponse, GetVisitorJourneyData, GetVisitorJourneyResponse, GetVisitorsData, GetVisitorSessionsData, GetVisitorSessionsError, GetVisitorSessionsResponse2, GetVisitorsResponse, GetVisitorStatsData, GetVisitorStatsResponse, GetWebhookData, GetWebhookResponse, GetWorkspaceFileLimitsData, GetWorkspaceFileLimitsResponse, GrantProjectAccessData, GrantProjectAccessResponse, HandleGitProviderOauthCallbackData, HasAnalyticsEventsData, HasAnalyticsEventsResponse2, HasErrorGroupsData, HasErrorGroupsResponse2, HasPerformanceMetricsData, HasPerformanceMetricsError, HasPerformanceMetricsResponse, HasTracesData, HasTracesError, HasTracesResponse2, ImportApplicationWorkspaceGitData, ImportApplicationWorkspaceGitResponse, ImportEmailDomainData, ImportEmailDomainResponse, ImportExternalServiceData, ImportExternalServiceResponse, ImportLocalAiProviderCredentialData, ImportLocalAiProviderCredentialResponse, ImportTraefikAcmeJsonData, ImportTraefikAcmeJsonError, ImportTraefikAcmeJsonResponse2, IngestLogsByPathData, IngestLogsByPathError, IngestLogsData, IngestLogsError, IngestMetricsByPathData, IngestMetricsByPathError, IngestMetricsData, IngestMetricsError, IngestSentryEnvelopeData, IngestSentryEventData, IngestSentryEventResponse, IngestTracesByPathData, IngestTracesByPathError, IngestTracesData, IngestTracesError, IngestTunneledEnvelopeData, IngestTunneledEnvelopeResponse, InitSessionReplayData, InitSessionReplayError, InitSessionReplayResponse, InspectDropArchiveData, InspectDropArchiveResponse, IssueRuntimeCredentialsData, IssueRuntimeCredentialsResponse, JobLogsData, JobStatusData, JobStatusResponse2, KillJobData, KillJobResponse, KvDelData, KvDelResponse, KvDisableData, KvDisableResponse, KvEnableData, KvEnableResponse, KvExpireData, KvExpireResponse, KvGetData, KvGetResponse, KvIncrData, KvIncrResponse, KvKeysData, KvKeysResponse, KvSetData, KvSetResponse, KvStatusData, KvStatusResponse2, KvTtlData, KvTtlResponse, KvUpdateData, KvUpdateResponse, LatestRunForSourceData, LatestRunForSourceResponse, LinkApplicationProjectData, LinkApplicationProjectResponse, LinkCustomDomainToCertificateData, LinkCustomDomainToCertificateResponse, LinkServiceToProjectData, LinkServiceToProjectResponse, ListAgentRunsData, ListAgentRunsResponse, ListAgentsData, ListAgentsResponse2, ListAiProvidersData, ListAiProvidersResponse, ListAlertRulesData, ListAlertRulesResponse, ListAlertsData, ListAlertsError, ListAlertsResponse, ListAllConversationsData, ListAllConversationsResponse, ListAllRunsData, ListAllRunsResponse, ListAnalyticsIngestKeysData, ListAnalyticsIngestKeysResponse, ListApiKeysData, ListApiKeysResponse, ListApplicationConversationsData, ListApplicationConversationsResponse, ListApplicationsData, ListApplicationsResponse, ListAuditLogsData, ListAuditLogsResponse, ListAvailableContainersData, ListAvailableContainersResponse, ListBackupAlertsData, ListBackupAlertsError, ListBackupAlertsResponse, ListBackupChildrenData, ListBackupChildrenError, ListBackupChildrenResponse, ListBackupSchedulesData, ListBackupSchedulesError, ListBackupSchedulesResponse, ListBackupsForScheduleData, ListBackupsForScheduleError, ListBackupsForScheduleResponse, ListCommitsByRepositoryIdData, ListCommitsByRepositoryIdResponse, ListConnectionsData, ListConnectionsResponse, ListContainerHistoryData, ListContainerHistoryError, ListContainerHistoryResponse, ListContainersAtPathData, ListContainersAtPathResponse, ListContainersData, ListContainersResponse, ListConversationsData, ListConversationsResponse, ListCustomDomainsForProjectData, ListCustomDomainsForProjectResponse, ListDashboardsData, ListDashboardsError, ListDashboardsResponse, ListDeliveriesData, ListDeliveriesResponse, ListDeploymentContainerLogsData, ListDeploymentContainerLogsResponse, ListDeploymentTokensData, ListDeploymentTokensResponse, ListDiscoverableDomainsData, ListDiscoverableDomainsResponse, ListDnsProvidersData, ListDnsProvidersResponse, ListDomainsData, ListDomainsResponse2, ListDsnsData, ListDsnsResponse, ListEmailDomainProjectsData, ListEmailDomainProjectsResponse, ListEmailDomainsData, ListEmailDomainsResponse, ListEmailProvidersData, ListEmailProvidersResponse, ListEmailsData, ListEmailsResponse, ListEnrollmentTokensData, ListEnrollmentTokensResponse, ListEntitiesData, ListEntitiesResponse, ListErrorEventsData, ListErrorEventsResponse, ListErrorGroupsData, ListErrorGroupsResponse, ListEventsData, ListEventsResponse, ListEventTypesData, ListEventTypesResponse, ListExternalImagesData, ListExternalImagesResponse, ListExternalPluginsData, ListExternalPluginsResponse, ListExternalServiceBackupsData, ListExternalServiceBackupsError, ListExternalServiceBackupsResponse, ListFacetsData, ListFacetsError, ListFacetsResponse, ListFlagsData, ListFlagsResponse, ListFunnelsData, ListFunnelsResponse, ListGitProvidersData, ListGitProvidersResponse, ListGlobalMcpsData, ListGlobalMcpsResponse, ListGlobalSkillsData, ListGlobalSkillsResponse, ListIncidentsData, ListInsightsData, ListInsightsError, ListInsightsResponse, ListIpAccessControlData, ListIpAccessControlError, ListIpAccessControlResponse, ListJobsData, ListJobsResponse2, ListKnownAiAgentsData, ListKnownAiAgentsError, ListKnownAiAgentsResponse, ListManagedDomainsData, ListManagedDomainsResponse, ListManagedEnvironmentVariablesData, ListManagedEnvironmentVariablesResponse, ListMcpsData, ListMcpsResponse2, ListMetricLabelKeysData, ListMetricLabelKeysError, ListMetricLabelKeysResponse, ListMetricLabelValuesData, ListMetricLabelValuesError, ListMetricLabelValuesResponse, ListMetricNamesData, ListMetricNamesError, ListMetricNamesResponse, ListModelsData, ListModelsError, ListModelsResponse, ListMonitorsData, ListMonitorsResponse, ListNotificationProvidersData, ListNotificationProvidersResponse, ListNotificationRoutesData, ListNotificationRoutesResponse, ListOidcProvidersData, ListOidcProvidersResponse, ListOidcProviderUsersData, ListOidcProviderUsersResponse, ListOidcRoleMappingsData, ListOidcRoleMappingsResponse, ListOnDemandCertsData, ListOnDemandCertsResponse2, ListOrdersData, ListOrdersResponse2, ListPeersData, ListPeersResponse, ListPendingActionsData, ListPendingActionsResponse, ListPgUpgradesData, ListPgUpgradesError, ListPgUpgradesResponse, ListPresetsData, ListPresetsResponse2, ListProjectAccessData, ListProjectAccessResponse, ListProjectAlarmsData, ListProjectAlarmsResponse, ListProjectScansData, ListProjectScansError, ListProjectScansResponse, ListProjectSecretsData, ListProjectSecretsResponse, ListProjectServicesData, ListProjectServicesResponse, ListProjectTemplatesData, ListProjectTemplatesResponse, ListProjectTemplateTagsData, ListProjectTemplateTagsResponse, ListProviderKeysData, ListProviderKeysError, ListProviderKeysResponse, ListProviderZonesData, ListProviderZonesResponse, ListPublicProvidersData, ListPublicProvidersResponse, ListReleaseFilesData, ListReleaseFilesResponse, ListReleasesData, ListReleasesResponse, ListRemoteExternalImagesData, ListRemoteExternalImagesResponse, ListRenewalAttemptsData, ListRenewalAttemptsResponse2, ListRepositoriesByConnectionData, ListRepositoriesByConnectionResponse, ListRepositoriesByProviderData, ListRepositoriesByProviderResponse, ListRestoreRunsForServiceData, ListRestoreRunsForServiceError, ListRestoreRunsForServiceResponse, ListRootContainersData, ListRootContainersResponse, ListRoutesData, ListRoutesResponse, ListS3SourcesData, ListS3SourcesError, ListS3SourcesResponse, ListSandboxesData, ListSandboxesResponse2, ListScheduleRunJobsData, ListScheduleRunJobsError, ListScheduleRunJobsResponse, ListScheduleRunsData, ListScheduleRunsError, ListScheduleRunsResponse, ListScheduleServicesData, ListScheduleServicesError, ListScheduleServicesResponse, ListSecretsData, ListSecretsResponse2, ListServiceHealthStatusesData, ListServiceHealthStatusesResponse, ListServiceProjectsData, ListServiceProjectsResponse, ListServiceSchedulesData, ListServiceSchedulesError, ListServiceSchedulesResponse, ListServicesData, ListServicesResponse, ListSkillsData, ListSkillsResponse2, ListSnapshotsData, ListSnapshotsResponse2, ListSourceBackupsData, ListSourceBackupsError, ListSourceBackupsResponse, ListSourceFilesData, ListSourceFilesResponse, ListSourceMapsData, ListSourceMapsResponse, ListSourcesData, ListSourcesResponse, ListStaticBundlesData, ListStaticBundlesResponse, ListSyncedRepositoriesData, ListSyncedRepositoriesResponse, ListSystemAlarmsData, ListSystemAlarmsResponse, ListTeamMembersData, ListTeamMembersResponse, ListTeamProjectsData, ListTeamProjectsResponse, ListTeamsData, ListTeamsResponse, ListThreadArtifactsData, ListThreadArtifactsResponse, ListTraefikDiscoveredRoutesData, ListTraefikDiscoveredRoutesError, ListTraefikDiscoveredRoutesResponse, ListUserPendingActionsData, ListUserPendingActionsResponse, ListUsersData, ListUsersResponse, ListWebhooksData, ListWebhooksResponse, LoginData, LoginResponse, LogoutData, LookupDnsARecordsData, LookupDnsARecordsError, LookupDnsARecordsResponse, MintEnrollmentTokenData, MintEnrollmentTokenResponse2, MkdirData, MkdirResponse, NodeHeartbeatData, NodeHeartbeatResponse, NodeMetricsGetAlertRulesData, NodeMetricsGetAlertRulesResponse, NodeMetricsGetRangeData, NodeMetricsGetRangeResponse, NodeMetricsUpdateAlertRuleData, NodeMetricsUpdateAlertRuleResponse, ObservabilityFullEventData, ObservabilityFullEventError, ObservabilityFullEventResponse, ObservabilityListEventsData, ObservabilityListEventsError, ObservabilityListEventsResponse, OidcCallbackData, PatchAdminGateData, PatchAdminGateResponse, PatchPreviewGatewaySettingsData, PatchPreviewGatewaySettingsError, PatchPreviewGatewaySettingsResponse, PauseDeploymentData, PauseDeploymentResponse, PauseSandboxData, PauseSandboxResponse, PlanRestoreData, PlanRestoreError, PlanRestoreResponse, PostDnsAckData, PostDnsAckResponse, PreviewAlertData, PreviewAlertError, PreviewAlertResponse, PreviewFunnelMetricsData, PreviewFunnelMetricsResponse, PreviewHostnameModeData, PreviewHostnameModeResponse, PromoteClusterMemberData, PromoteDeploymentData, PromoteDeploymentResponse, ProvisionDomainData, ProvisionDomainResponse, PurgeProjectLogsData, PurgeProjectLogsError, PushExternalImageData, PushExternalImageResponse, QueryDataData, QueryDataResponse2, QueryGenaiTracesData, QueryGenaiTracesError, QueryGenaiTracesResponse, QueryLogsData, QueryLogsError, QueryLogsResponse, QueryMetricsData, QueryMetricsError, QueryMetricsResponse, QuerySpanStatsData, QuerySpanStatsError, QuerySpanStatsResponse, QueryTracesData, QueryTracesError, QueryTracesResponse, QueryTraceSummariesData, QueryTraceSummariesError, QueryTraceSummariesResponse, ReadEntityRowsData, ReadEntityRowsResponse, ReadFileData, ReadFileResponse2, ReAnalyzeData, ReassignProjectCustomDomainData, ReassignProjectCustomDomainResponse, ReconcileCloudBackupSourceData, ReconcileCloudBackupSourceResponse, RecordConsoleEventData, RecordEventMetricsData, RecordEventMetricsResponse, RecordFlagExposureData, RecordFlagExposureResponse, RecordSpeedMetricsData, RecordSpeedMetricsError, RecordSpeedMetricsResponse, RefreshAiProviderModelsData, RefreshAiProviderModelsResponse, RefreshAiProviderStatusData, RefreshAiProviderStatusError, RefreshAiProviderStatusResponse, RefreshProviderModelsData, RefreshProviderModelsError, RefreshProviderModelsResponse2, RefreshRouteTableData, RefreshRouteTableResponse, RegenerateDsnData, RegenerateDsnResponse, RegisterExternalImageData, RegisterExternalImageResponse, RegisterNodeData, RegisterNodeResponse2, ReinstallGitlabWebhookData, ReinstallGitlabWebhookResponse, RejectPendingActionData, RejectPendingActionResponse, RejectUserPendingActionData, RejectUserPendingActionResponse, ReloadPluginsData, ReloadPluginsResponse, RemoveClusterMemberData, RemoveClusterMemberResponse, RemoveManagedDomainData, RemoveManagedDomainResponse, RemoveRoleData, RemoveRoleResponse, RemoveTeamMemberData, RemoveTeamMemberResponse, RenameConversationData, RenameConversationResponse, RenameUserConversationData, RenameUserConversationResponse, RenewDomainData, RenewDomainResponse, RepointContinuousArchiveSourceData, RepointContinuousArchiveSourceResponse, RequestDiscoveredRouteCertData, RequestDiscoveredRouteCertError, RequestPasswordResetData, RequestPasswordResetResponse, ResetPasswordData, ResetPasswordResponse, ResizeSandboxData, ResizeSandboxResponse, ResolveAlarmData, ResolvePermissionData, ResolvePermissionResponse, ResolveSystemAlarmData, ResolveUserPermissionData, ResolveUserPermissionResponse, RestartContainerData, RestartContainerResponse, RestartPreviewGatewayData, RestartPreviewGatewayError, RestartPreviewGatewayResponse, RestartSandboxData, RestartSandboxResponse, RestoreApplicationData, RestoreApplicationResponse, RestoreFlagData, RestoreFlagResponse, RestoreUserConversationData, RestoreUserConversationResponse, RestoreUserData, RestoreUserResponse, ResumeDeploymentData, ResumeDeploymentResponse, ResumeSandboxData, ResumeSandboxResponse, RetryClusterData, RetryClusterResponse, RetryDeliveryData, RetryDeliveryResponse, RetryFacetBackfillData, RetryFacetBackfillError, RetryFacetBackfillResponse, RetryPgUpgradeData, RetryPgUpgradeError, RetryPgUpgradeResponse, RetryRunData, RetryRunResponse, RevealGlobalMcpConfigData, RevealGlobalMcpConfigResponse, RevealMcpConfigData, RevealMcpConfigResponse, RevealNotificationProviderConfigData, RevealNotificationProviderConfigResponse, RevealServiceEnvironmentVariablesData, RevealServiceEnvironmentVariablesResponse, RevealServiceParameterData, RevealServiceParameterResponse, RevenueCreateIntegrationData, RevenueCreateIntegrationResponse, RevenueDeleteIntegrationData, RevenueDeleteIntegrationResponse, RevenueGlobalEventsData, RevenueGlobalEventsResponse, RevenueImportInvoicesCsvData, RevenueImportInvoicesCsvResponse, RevenueImportSubscriptionsCsvData, RevenueImportSubscriptionsCsvResponse, RevenueListIntegrationsData, RevenueListIntegrationsResponse, RevenueListProvidersData, RevenueListProvidersResponse, RevenueMetricsCustomersData, RevenueMetricsCustomersResponse, RevenueMetricsGlobalMrrData, RevenueMetricsGlobalMrrResponse, RevenueMetricsGlobalSummaryData, RevenueMetricsGlobalSummaryResponse, RevenueMetricsMrrData, RevenueMetricsMrrResponse, RevenueMetricsSummaryData, RevenueMetricsSummaryResponse, RevenueRecentEventsData, RevenueRecentEventsResponse, RevenueRotateTokenData, RevenueRotateTokenResponse, RevenueUpdateConfigData, RevenueUpdateConfigResponse, RevenueUpdateSecretData, RevenueUpdateSecretResponse, RevokeAnalyticsIngestKeyData, RevokeAnalyticsIngestKeyResponse, RevokeDsnData, RevokeDsnResponse, RevokeEmailDomainProjectData, RevokeEmailDomainProjectResponse, RevokeEnrollmentTokenData, RevokeEnrollmentTokenResponse, RevokeJoinTokenData, RevokeJoinTokenResponse, RevokeProjectAccessData, RevokeProjectAccessResponse, RollbackPgUpgradeData, RollbackPgUpgradeError, RollbackPgUpgradeResponse, RollbackToDeploymentData, RollbackToDeploymentResponse, RootfsGcData, RootfsReportData, RotateAnalyticsIngestKeyData, RotateAnalyticsIngestKeyResponse, RotateApiKeyData, RotateApiKeyResponse, RotateClusterCaData, RotateClusterCaResponse2, RotateDeploymentTokenData, RotateDeploymentTokenResponse, RunBackupForSourceData, RunBackupForSourceError, RunBackupForSourceResponse, RunConnectionHealthCheckData, RunConnectionHealthCheckResponse, RunExternalServiceBackupData, RunExternalServiceBackupError, RunExternalServiceBackupResponse, RunScheduleNowData, RunScheduleNowError, RunScheduleNowResponse, SandboxCreatePreviewLinkData, SandboxCreatePreviewLinkResponse, SandboxIssueRuntimeEnvironmentData, SandboxIssueRuntimeEnvironmentResponse, SaveAgentTokenData, SaveAgentTokenResponse2, SaveAiProviderCredentialData, SaveAiProviderCredentialResponse, SearchLogsData, SearchLogsError, SearchLogsResponse2, SendEmailData, SendEmailResponse, SendFailureReportData, SendFailureReportResponse, SendProjectAiMessageData, SendProjectAiMessageResponse, SendUserMessageData, SendUserMessageResponse, SetAiDataAccessData, SetAiDataAccessResponse, SetAlternateSourcesData, SetAlternateSourcesResponse, SetApplicationPrimaryProjectData, SetApplicationPrimaryProjectResponse, SetDefaultS3SourceData, SetDefaultS3SourceError, SetDefaultS3SourceResponse, SetFlagEnvironmentData, SetFlagEnvironmentResponse, SetPreviewPasswordData, SetPreviewPasswordResponse2, SetTraefikDiscoveredRouteEnabledData, SetTraefikDiscoveredRouteEnabledError, SetTraefikDiscoveredRouteEnabledResponse, SetupDnsChallengeData, SetupDnsChallengeResponse2, SetupDnsData, SetupDnsResponse2, SetupEmailTrackingData, SetupEmailTrackingResponse, SetupMfaData, SetupMfaResponse, SilenceAlarmData, SilenceSystemAlarmData, SleepEnvironmentData, SleepEnvironmentResponse, SmokeTestAgentData, SmokeTestAgentResponse, SourceSandboxData, SourceSandboxResponse, StartAnalysisData, StartAnalysisResponse, StartContainerData, StartContainerResponse, StartFixData, StartGitProviderOauthData, StartOidcLoginBySlugData, StartPgUpgradeData, StartPgUpgradeError, StartPgUpgradeResponse, StartRestoreData, StartRestoreError, StartRestoreResponse, StartServiceData, StartServiceResponse, StartUpdateData, StartUpdateError, StartUpdateResponse2, StatPathData, StatPathResponse, StopContainerData, StopContainerResponse, StopSandboxData, StopSandboxResponse, StopServiceData, StopServiceResponse, StopTurnData, StopTurnResponse, StopUserTurnData, StopUserTurnResponse, StorageSummaryData, StorageSummaryResponse, StreamContainerMetricsData, SyncRepositoriesData, SyncRepositoriesResponse, TailDeploymentJobLogsData, TailLogsData, TailLogsError, TeardownDeploymentData, TeardownDeploymentResponse, TeardownEnvironmentData, TeardownEnvironmentResponse, TerminalData, TestNotificationProviderData, TestNotificationProviderResponse, TestOidcProviderData, TestOidcProviderResponse, TestProviderConnectionData, TestProviderConnectionResponse, TestProviderData, TestProviderKeyByIdData, TestProviderKeyByIdError, TestProviderKeyByIdResponse, TestProviderKeyInlineData, TestProviderKeyInlineError, TestProviderKeyInlineResponse, TestProviderResponse2, TestS3ConnectionPreviewData, TestS3ConnectionPreviewError, TestS3ConnectionPreviewResponse, TestS3SourceConnectionData, TestS3SourceConnectionError, TestS3SourceConnectionResponse, TrackClickData, TrackOpenData, TriggerAgentData, TriggerAgentResponse, TriggerProjectPipelineData, TriggerProjectPipelineResponse, TriggerScanData, TriggerScanError, TriggerScanResponse2, TriggerServiceHealthCheckData, TriggerServiceHealthCheckResponse, TriggerWeeklyDigestData, TriggerWeeklyDigestResponse, UnlinkApplicationProjectData, UnlinkApplicationProjectResponse, UnlinkServiceFromProjectData, UnlinkServiceFromProjectResponse, UpdateAgentData, UpdateAgentResponse, UpdateAiProviderData, UpdateAiProviderResponse2, UpdateAiSummaryPreferenceData, UpdateAiSummaryPreferenceError, UpdateAiSummaryPreferenceResponse, UpdateAlertData, UpdateAlertError, UpdateAlertResponse, UpdateAlertRuleData, UpdateAlertRuleResponse, UpdateAnalyticsIngestKeyData, UpdateAnalyticsIngestKeyResponse, UpdateApiKeyData, UpdateApiKeyResponse, UpdateApplicationWorkspaceData, UpdateApplicationWorkspaceResponse, UpdateAutomaticDeployData, UpdateAutomaticDeployResponse, UpdateBackupScheduleData, UpdateBackupScheduleError, UpdateBackupScheduleResponse, UpdateCloudFeaturesData, UpdateCloudFeaturesResponse, UpdateCloudflareProviderData, UpdateCloudflareProviderResponse, UpdateConnectionTokenData, UpdateConnectionTokenResponse, UpdateCustomDomainData, UpdateCustomDomainResponse, UpdateDashboardData, UpdateDashboardError, UpdateDashboardResponse, UpdateDeploymentTokenData, UpdateDeploymentTokenResponse, UpdateEmailProviderData, UpdateEmailProviderResponse, UpdateEnvironmentSettingsData, UpdateEnvironmentSettingsResponse, UpdateEnvironmentSubdomainData, UpdateEnvironmentSubdomainResponse, UpdateEnvironmentVariableData, UpdateEnvironmentVariableResponse, UpdateErrorGroupData, UpdateFlagData, UpdateFlagResponse, UpdateFunnelData, UpdateGitProviderCredentialsData, UpdateGitProviderCredentialsResponse, UpdateGitSettingsData, UpdateGitSettingsResponse, UpdateGlobalMcpData, UpdateGlobalMcpResponse, UpdateGlobalSkillData, UpdateGlobalSkillResponse, UpdateIncidentStatusData, UpdateIncidentStatusResponse, UpdateIpAccessControlData, UpdateIpAccessControlError, UpdateIpAccessControlResponse, UpdateManagedDomainData, UpdateManagedDomainResponse, UpdateMcpData, UpdateMcpResponse, UpdateNotificationEmailProviderData, UpdateNotificationEmailProviderResponse, UpdateNotificationProviderData, UpdateNotificationProviderResponse, UpdateNotificationRouteData, UpdateNotificationRouteResponse, UpdateOidcProviderData, UpdateOidcProviderResponse, UpdatePermissionModeData, UpdatePermissionModeResponse, UpdatePreferencesData, UpdatePreferencesResponse, UpdateProjectCloudTelemetryData, UpdateProjectCloudTelemetryError, UpdateProjectCloudTelemetryResponse, UpdateProjectData, UpdateProjectDeploymentConfigData, UpdateProjectDeploymentConfigResponse, UpdateProjectResponse, UpdateProjectSecretData, UpdateProjectSecretResponse, UpdateProjectSettingsData, UpdateProjectSettingsResponse, UpdateProviderData, UpdateProviderKeyData, UpdateProviderKeyError, UpdateProviderKeyResponse, UpdateProviderModelData, UpdateProviderModelError, UpdateProviderModelResponse, UpdateProviderResponse, UpdateRouteData, UpdateRouteResponse, UpdateS3SourceData, UpdateS3SourceError, UpdateS3SourceResponse, UpdateSelfData, UpdateSelfResponse, UpdateServiceData, UpdateServiceResourcesData, UpdateServiceResourcesResponse, UpdateServiceResponse, UpdateServiceTemplateRuntimeData, UpdateServiceTemplateRuntimeResponse, UpdateSessionDurationData, UpdateSessionDurationError, UpdateSessionDurationResponse2, UpdateSettingsData, UpdateSettingsResponse, UpdateSkillData, UpdateSkillResponse, UpdateSlackProviderData, UpdateSlackProviderResponse, UpdateSpeedMetricsData, UpdateSpeedMetricsError, UpdateSpeedMetricsResponse, UpdateTeamData, UpdateTeamMemberRoleData, UpdateTeamMemberRoleResponse, UpdateTeamResponse, UpdateUserData, UpdateUserPermissionModeData, UpdateUserPermissionModeResponse, UpdateUserResponse, UpdateWebhookData, UpdateWebhookProviderData, UpdateWebhookProviderResponse, UpdateWebhookResponse, UpgradePreviewGatewayData, UpgradePreviewGatewayError, UpgradePreviewGatewayResponse, UpgradeProjectServiceTemplateData, UpgradeProjectServiceTemplateResponse, UpgradeServiceData, UpgradeServiceResponse, UploadApplicationWorkspaceFilesData, UploadApplicationWorkspaceFilesResponse, UploadGlobalSkillData, UploadGlobalSkillResponse, UploadGlobalWorkspaceFilesData, UploadGlobalWorkspaceFilesResponse, UploadReleaseFileData, UploadReleaseFileResponse, UploadSkillData, UploadSkillResponse, UploadSourceFileData, UploadSourceFileResponse, UploadSourceMapData, UploadSourceMapResponse, UploadStaticBundleData, UploadStaticBundleResponse, UploadUserConversationAttachmentData, UploadUserConversationAttachmentResponse, UpsertSecretData, UpsertSecretResponse, ValidateConnectionData, ValidateConnectionResponse, ValidateEmailData, ValidateEmailResponse2, VerifyAndEnableMfaData, VerifyAndEnableMfaResponse, VerifyDomainData, VerifyDomainResponse, VerifyEmailData, VerifyEmailResponse, VerifyManagedDomainData, VerifyManagedDomainResponse, VerifyMfaChallengeData, VerifyMfaChallengeResponse, VerifyStepUpData, VerifyStepUpResponse, WakeEnvironmentData, WakeEnvironmentResponse, WebhookTriggerData, WebhookTriggerResponse2, WorkflowDryRunData, WorkflowDryRunResponse, WriteApplicationWorkspaceFilesData, WriteApplicationWorkspaceFilesResponse2, WriteFileData, WriteFileResponse, WriteFilesData, WriteFilesResponse2 } from '../types.gen'; export type QueryKey = [ Pick & { @@ -1392,20 +1392,6 @@ export const getPricingOptions = (options?: Options) => queryOpt queryKey: getPricingQueryKey(options) }); -export const updateAiProviderPreferenceMutation = (options?: Partial>): UseMutationOptions> => { - const mutationOptions: UseMutationOptions> = { - mutationFn: async (fnOptions) => { - const { data } = await updateAiProviderPreference({ - ...options, - ...fnOptions, - throwOnError: true - }); - return data; - } - }; - return mutationOptions; -}; - export const getAiProviderStatusQueryKey = (options?: Options) => createQueryKey('getAiProviderStatus', options); export const getAiProviderStatusOptions = (options?: Options) => queryOptions>({ @@ -1535,8 +1521,8 @@ export const addProviderModelMutation = (options?: Partial>): UseMutationOptions> => { - const mutationOptions: UseMutationOptions> = { +export const refreshProviderModelsMutation = (options?: Partial>): UseMutationOptions> => { + const mutationOptions: UseMutationOptions> = { mutationFn: async (fnOptions) => { const { data } = await refreshProviderModels({ ...options, @@ -5717,7 +5703,7 @@ export const listServicesInfiniteQueryKey = (options?: Options * Get all external services */ export const listServicesInfiniteOptions = (options?: Options) => { - const opts = infiniteQueryOptions, QueryKey>, number | null | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( + const opts = infiniteQueryOptions, QueryKey>, number | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( // @ts-ignore { queryFn: async ({ pageParam, queryKey, signal }) => { @@ -5743,6 +5729,8 @@ export const listServicesInfiniteOptions = (options?: Options) /** * Create new external service + * + * Create a managed external service. The `parameters` object is service-type-specific. Read `get_service_type_parameters` for the chosen `service_type` immediately before creating the service and provide every field that schema marks as required. Set `project_id` to create and link the service in one approval-gated operation. */ export const createServiceMutation = (options?: Partial>): UseMutationOptions> => { const mutationOptions: UseMutationOptions> = { @@ -5856,7 +5844,7 @@ export const listProjectServicesInfiniteQueryKey = (options: Options) => { - const opts = infiniteQueryOptions, QueryKey>, number | null | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( + const opts = infiniteQueryOptions, QueryKey>, number | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( // @ts-ignore { queryFn: async ({ pageParam, queryKey, signal }) => { @@ -6489,7 +6477,7 @@ export const listServiceProjectsInfiniteQueryKey = (options: Options) => { - const opts = infiniteQueryOptions, QueryKey>, number | null | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( + const opts = infiniteQueryOptions, QueryKey>, number | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( // @ts-ignore { queryFn: async ({ pageParam, queryKey, signal }) => { @@ -9161,7 +9149,7 @@ export const listNotificationProvidersInfiniteQueryKey = (options?: Options) => { - const opts = infiniteQueryOptions, QueryKey>, number | null | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( + const opts = infiniteQueryOptions, QueryKey>, number | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( // @ts-ignore { queryFn: async ({ pageParam, queryKey, signal }) => { @@ -9445,7 +9433,7 @@ export const listNotificationRoutesOptions = (options?: Options): QueryKey> => createQueryKey('listNotificationRoutes', options, true); export const listNotificationRoutesInfiniteOptions = (options?: Options) => { - const opts = infiniteQueryOptions, QueryKey>, number | null | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( + const opts = infiniteQueryOptions, QueryKey>, number | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( // @ts-ignore { queryFn: async ({ pageParam, queryKey, signal }) => { @@ -9550,7 +9538,7 @@ export const listOrdersInfiniteQueryKey = (options?: Options): Q * List all ACME orders */ export const listOrdersInfiniteOptions = (options?: Options) => { - const opts = infiniteQueryOptions, QueryKey>, number | null | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( + const opts = infiniteQueryOptions, QueryKey>, number | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( // @ts-ignore { queryFn: async ({ pageParam, queryKey, signal }) => { @@ -16114,7 +16102,7 @@ export const listWebhooksInfiniteQueryKey = (options: Options) * List all webhooks for a project */ export const listWebhooksInfiniteOptions = (options: Options) => { - const opts = infiniteQueryOptions, QueryKey>, number | null | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( + const opts = infiniteQueryOptions, QueryKey>, number | Pick>[0], 'body' | 'headers' | 'path' | 'query'>>( // @ts-ignore { queryFn: async ({ pageParam, queryKey, signal }) => { @@ -17145,6 +17133,45 @@ export const saveAiProviderCredentialMutation = (options?: Partial>): UseMutationOptions> => { + const mutationOptions: UseMutationOptions> = { + mutationFn: async (fnOptions) => { + const { data } = await importLocalAiProviderCredential({ + ...options, + ...fnOptions, + throwOnError: true + }); + return data; + } + }; + return mutationOptions; +}; + +/** + * Refresh exactly one provider's account-aware model inventory. This is an + * explicit write operation because it starts a CLI process (and, for Claude + * workspaces, a short-lived isolated sandbox). The AI service applies a + * provider-scoped single-flight and cooldown before doing that work. + */ +export const refreshAiProviderModelsMutation = (options?: Partial>): UseMutationOptions> => { + const mutationOptions: UseMutationOptions> = { + mutationFn: async (fnOptions) => { + const { data } = await refreshAiProviderModels({ + ...options, + ...fnOptions, + throwOnError: true + }); + return data; + } + }; + return mutationOptions; +}; + /** * Replace a compromised cluster CA and invalidate outstanding enrollment * tokens. Existing workers fail closed until they are re-enrolled. @@ -19020,6 +19047,24 @@ export const resumeSandboxMutation = (options?: Partial>): UseMutationOptions> => { + const mutationOptions: UseMutationOptions> = { + mutationFn: async (fnOptions) => { + const { data } = await sandboxIssueRuntimeEnvironment({ + ...options, + ...fnOptions, + throwOnError: true + }); + return data; + } + }; + return mutationOptions; +}; + /** * `POST /v1/sandboxes/{id}/snapshots` * diff --git a/web/src/api/client/index.ts b/web/src/api/client/index.ts index 2b90635f7..0968bf8b1 100644 --- a/web/src/api/client/index.ts +++ b/web/src/api/client/index.ts @@ -3,5 +3,5 @@ // This file is auto-generated by @hey-api/openapi-ts -export { acknowledgeAlarm, acknowledgeSystemAlarm, activateAiProvider, activateApiKey, activateConnection, activateProvider, addClusterMember, addContext, addEnvironmentDomain, addEvents, addManagedDomain, addProviderModel, addSessionReplayEvents, addTeamMember, adminDrainNode, adminDrainStatus, adminGetNode, adminListNodeContainers, adminListNodes, adminRemoveNode, adminUndrainNode, aggregateApiTraffic, applyHostnameMode, archiveApplication, archiveConversation, archiveFlag, archiveUserConversation, assignRole, attachScheduleServices, authorizeEmailDomainProject, blobCopy, blobDelete, blobDisable, blobDownload, blobEnable, blobHead, blobList, blobPut, blobStatus, blobUpdate, cancel, cancelBackup, cancelBulkActivationJob, cancelDeployment, cancelDomainOrder, cancelPgUpgrade, cancelRun, cancelScheduleRun, changePasswordSelf, changeProjectSource, changeRequiredPassword, chatCompletions, checkAnalyticsHasEvents, checkCommitExists, checkDomainStatus, checkExplorerSupport, checkForUpdate, checkIpBlocked, checkProviderDeletionSafety, chunkUploadOptions, cleanupExpiredBackups, clearPreviewPassword, cliDeviceApprove, cliDeviceDeny, cliDeviceLookup, cliDevicePoll, cliDeviceStart, cliLogout, clusterDnsStatus, cmd, cmdKill, cmdLogs, confirmPendingAction, confirmUserPendingAction, containerMetricsGetHistory, controlApplicationWorkspace, createAgent, createAlert, createAlertRule, createAnalyticsIngestKey, createApiKey, createApplication, createApplicationConversation, createApplicationPreviewLink, createApplicationProject, createBackupSchedule, createBitbucketProvider, createBulkActivationJob, createCloudflareProvider, createConversation, createCustomDomain, createDashboard, createDeploymentToken, createDnsProvider, createDomain, createDsn, createEmailDomain, createEmailProvider, createEnvironment, createEnvironmentVariable, createFacet, createFlag, createFunnel, createGenericProvider, createGiteaPatProvider, createGithubPatProvider, createGitlabOauthProvider, createGitlabPatProvider, createGitProvider, createGlobalConversation, createGlobalMcp, createGlobalSkill, createGlobalWorkspacePreviewLink, createIncident, createIpAccessControl, createMcp, createMonitor, createNotificationEmailProvider, createNotificationProvider, createNotificationRoute, createOidcProvider, createOidcRoleMapping, createOrRecreateOrder, createPlan, createPr, createProject, createProjectFromTemplate, createProjectRelease, createProjectSecret, createProviderKey, createRelease, createRoute, createS3Source, createSandbox, createService, createSkill, createSlackProvider, createSnapshot, createTeam, createThreadArtifact, createUser, createWebhook, createWebhookProvider, deactivateApiKey, deactivateConnection, deactivateProvider, deauthorizeDiscoveredRouteCert, deleteAgent, deleteAlert, deleteAlertRule, deleteApiKey, deleteBackup, deleteBackupSchedule, deleteConnection, deleteCustomDomain, deleteDashboard, deleteDeploymentToken, deleteDnsProvider, deleteDomain, deleteEmailDomain, deleteEmailProvider, deleteEnvironment, deleteEnvironmentDomain, deleteEnvironmentVariable, deleteExternalImage, deleteFacet, deleteFunnel, deleteGitProvider, deleteGlobalMcp, deleteGlobalSkill, deleteIpAccessControl, deleteMcp, deleteMonitor, deleteNotificationProvider, deleteNotificationRoute, deleteOidcProvider, deleteOidcRoleMapping, deletePreferences, deleteProject, deleteProjectSecret, deleteProviderKey, deleteProviderModel, deleteProviderSafely, deleteReleaseSourceFiles, deleteReleaseSourceMaps, deleteRoute, deleteS3Source, deleteScan, deleteSecret, deleteService, deleteSessionReplay, deleteSkill, deleteSnapshot, deleteSourceMap, deleteStaticBundle, deleteTeam, deleteUser, deleteWebhook, deployApplicationWorkspaceProject, deployFromImage, deployFromImageUpload, deployFromStatic, deployFromUploadedSource, deploymentMetricsGetLatest, deploymentMetricsGetRange, deploymentMetricsToggle, destroySandbox, detachScheduleService, detectPublicEnvExample, detectPublicPresets, disableBackupSchedule, disableMfa, disconnectCloud, discoverWorkloads, domain, downloadApplicationWorkspaceFile, downloadGlobalSkillArchive, downloadGlobalWorkspaceFile, downloadObject, downloadSkillArchive, emailStatus, embeddings, enableBackupSchedule, enrichVisitor, enrollCloud, estimateBulkActivation, exec, execDetached, executeDeploymentOperation, executeImport, extendTimeout, externalServiceEnablePgStatStatements, externalServiceMetricsByDatabase, externalServiceMetricsCreateAlertRule, externalServiceMetricsDeleteAlertRule, externalServiceMetricsGetAlertRules, externalServiceMetricsGetLatest, externalServiceMetricsGetRange, externalServiceMetricsStatus, externalServiceMetricsToggle, externalServiceMetricsUpdateAlertRule, externalServiceResetPgStatStatements, finalizeOrder, finalizeProjectRelease, findConversation, generateJoinToken, generatePresetDockerfile, getAccessInfo, getActiveVisitors, getActivityGraph, getAdminGate, getAgent, getAggregatedBuckets, getAiAgentBreakdown, getAiAgentPages, getAiAgentTimeline, getAiDataAccess, getAiPageBreakdown, getAiProviderStatus, getAiStatusBreakdown, getAlert, getAlertRule, getAllRepositoriesByName, getAnalyticsActiveVisitors, getAnalyticsEventsCount, getAnalyticsSessionEvents, getAnalyticsVisitorSessions, getApiCallers, getApiKey, getApiKeyPermissions, getApiRoutes, getApiSummary, getApiTimeseries, getApiTrafficProxyLogAccess, getApplication, getApplicationWorkspace, getApplicationWorkspaceChanges, getApplicationWorkspaceDiff, getApplicationWorkspaceDirectory, getApplicationWorkspaceFile, getAuditLog, getBackup, getBackupSchedule, getBranchesByRepositoryId, getBucketedIncidents, getBucketedStatus, getBulkActivationJob, getChallengeToken, getChatReadiness, getCliStatus, getCloudAiCapability, getCloudBackfillStatus, getCloudCapability, getCloudStatus, getCloudTelemetryStatus, getClusterHealth, getClusterMember, getCmd, getContainerDetail, getContainerEnvironmentVariable, getContainerLogs, getContainerLogsById, getContainerMetrics, getConversation, getConversationDetail, getConversations, getCronById, getCronExecutions, getCrossProjectTraceSiblings, getCurrentBulkActivationJob, getCurrentMonitorStatus, getCurrentUser, getCustomDomain, getDashboard, getDashboardProjectsAnalytics, getDelivery, getDeployment, getDeploymentContainerLogContent, getDeploymentJobLogs, getDeploymentJobs, getDeploymentOperations, getDeploymentOperationStatus, getDeploymentToken, getDiskStatus, getDnsChanges, getDnsProvider, getDomain, getDomainByHost, getDomainById, getDomainByName, getDomainDnsRecords, getDomainOrder, getEmail, getEmailEvents, getEmailLinks, getEmailProvider, getEmailStats, getEmailTracking, getEmailTrackingStatus, getEntityInfo, getEnvironment, getEnvironmentCrons, getEnvironmentDomains, getEnvironments, getEnvironmentVariables, getEnvironmentVariableValue, getErrorDashboardStats, getErrorEvent, getErrorGroup, getErrorStats, getErrorTimeSeries, getEventDetail, getEventEntries, getEventsCount, getEventsTimeline, getEventTypeBreakdown, getEventVisitors, getExternalImage, getExternalServiceBackupCapability, getFailureReportPreview, getFeatureMaturity, getFile, getFlag, getFlagSnapshot, getFunnelMetrics, getGenaiTrace, getGeneralStats, getGitProvider, getGlobalAiWorkspace, getGlobalEvents, getGlobalEventStats, getGlobalMcp, getGlobalSandboxStatus, getGlobalSkill, getGlobalWorkspaceChanges, getGlobalWorkspaceDiff, getGlobalWorkspaceDirectory, getGlobalWorkspaceFile, getGroupedPageMetrics, getHealth, getHourlyVisits, getHttpChallengeDebug, getImportStatus, getIncident, getIncidentUpdates, getIngestErrors, getIpAccessControl, getIpGeolocation, getJoinTokenStatus, getLastDeployment, getLatestDeploymentMedia, getLatestScan, getLatestScansPerEnvironment, getLiveVisitorsList, getLogContext, getMcp, getMetricsOverTime, getMonitor, getNotificationProvider, getNotificationRoute, getOnDemandCertStatus, getOrCreateDsn, getPageFlow, getPageHourlySessions, getPagePathDetail, getPagePaths, getPagePathsSparklines, getPagePathVisitors, getPendingAction, getPerformanceMetrics, getPgUpgrade, getPgUpgradeLogs, getPipelineHistory, getPipelineStats, getPlatformInfo, getPostgresWalHealth, getPreferences, getPreviewGatewayLogs, getPreviewGatewaySettings, getPreviewGatewayStatus, getPricing, getPrivateIp, getProject, getProjectAlarmsSummary, getProjectBySlug, getProjectCloudTelemetry, getProjectDeployments, getProjects, getProjectServiceEnvironmentVariables, getProjectServiceTemplate, getProjectSessionReplays, getProjectsHealth, getProjectsMonitorHealth, getProjectStatistics, getProjectTemplate, getPropertyBreakdown, getPropertyTimeline, getProviderConnections, getProviderKey, getProviderMetadata, getProvidersMetadata, getProxyLogById, getProxyLogByRequestId, getProxyLogs, getPublicBranches, getPublicComposePreview, getPublicComposeServices, getPublicIp, getPublicRepository, getQueryContainerInfo, getQuota, getRecentActivity, getRemoteExternalImage, getRepositoryBranches, getRepositoryById, getRepositoryByName, getRepositoryComposePreview, getRepositoryComposeServicesLive, getRepositoryEnvExampleLive, getRepositoryPresetByName, getRepositoryPresetLive, getRepositoryTags, getResolvedEnvironmentVariables, getResolvedEnvironmentVariableValue, getRestoreCapabilities, getRestoreRun, getRoute, getRun, getRunWithLogs, getS3Credentials, getS3Source, getSandbox, getSandboxStatus, getScan, getScanByDeployment, getScanVulnerabilities, getService, getServiceBySlug, getServiceEnvironmentVariable, getServiceEnvironmentVariables, getServiceHealthStatus, getServicePreviewEnvironmentVariableNames, getServicePreviewEnvironmentVariablesMasked, getServiceRuntime, getServiceStats, getServiceTypeParameters, getServiceTypes, getSessionDetails, getSessionEvents, getSessionLogs, getSessionReplay, getSessionReplayEvents, getSettings, getSkill, getSlowQueries, getSnapshot, getStaticBundle, getStatusOverview, getSystemAlarmsSummary, getTagsByRepositoryId, getTeam, getTimeBucketStats, getTodayStats, getTrace, getTraefikDiscoveryStatus, getUnifiedTrace, getUniqueCounts, getUniqueEvents, getUpdateCapability, getUpdateStatus, getUptimeHistory, getUsageByProvider, getUsageRecent, getUsageSummary, getUsageTimeseries, getUsageTopModels, getUserConversation, getUserConversationAttachment, getUserPendingAction, getVisibleCustomDomainByHostname, getVisitorByGuid, getVisitorById, getVisitorDetails, getVisitorFacets, getVisitorInfo, getVisitorJourney, getVisitors, getVisitorSessions, getVisitorStats, getWebhook, getWorkspaceFileLimits, grantProjectAccess, handleGitProviderOauthCallback, hasAnalyticsEvents, hasErrorGroups, hasPerformanceMetrics, hasTraces, importApplicationWorkspaceGit, importEmailDomain, importExternalService, importTraefikAcmeJson, ingestLogs, ingestLogsByPath, ingestMetrics, ingestMetricsByPath, ingestSentryEnvelope, ingestSentryEvent, ingestTraces, ingestTracesByPath, ingestTunneledEnvelope, initSessionReplay, inspectDropArchive, issueRuntimeCredentials, jobLogs, jobStatus, killJob, kvDel, kvDisable, kvEnable, kvExpire, kvGet, kvIncr, kvKeys, kvSet, kvStatus, kvTtl, kvUpdate, latestRunForSource, linkApplicationProject, linkCustomDomainToCertificate, linkServiceToProject, listAgentRuns, listAgents, listAiProviders, listAlertRules, listAlerts, listAllConversations, listAllRuns, listAnalyticsIngestKeys, listApiKeys, listApplicationConversations, listApplications, listAuditLogs, listAvailableContainers, listBackupAlerts, listBackupChildren, listBackupSchedules, listBackupsForSchedule, listCommitsByRepositoryId, listConnections, listContainerHistory, listContainers, listContainersAtPath, listConversations, listCustomDomainsForProject, listDashboards, listDeliveries, listDeploymentContainerLogs, listDeploymentTokens, listDiscoverableDomains, listDnsProviders, listDomains, listDsns, listEmailDomainProjects, listEmailDomains, listEmailProviders, listEmails, listEnrollmentTokens, listEntities, listErrorEvents, listErrorGroups, listEvents, listEventTypes, listExternalImages, listExternalPlugins, listExternalServiceBackups, listFacets, listFlags, listFunnels, listGitProviders, listGlobalMcps, listGlobalSkills, listIncidents, listInsights, listIpAccessControl, listJobs, listKnownAiAgents, listManagedDomains, listManagedEnvironmentVariables, listMcps, listMetricLabelKeys, listMetricLabelValues, listMetricNames, listModels, listMonitors, listNotificationProviders, listNotificationRoutes, listOidcProviders, listOidcProviderUsers, listOidcRoleMappings, listOnDemandCerts, listOrders, listPeers, listPendingActions, listPgUpgrades, listPresets, listProjectAccess, listProjectAlarms, listProjectScans, listProjectSecrets, listProjectServices, listProjectTemplates, listProjectTemplateTags, listProviderKeys, listProviderZones, listPublicProviders, listReleaseFiles, listReleases, listRemoteExternalImages, listRenewalAttempts, listRepositoriesByConnection, listRepositoriesByProvider, listRestoreRunsForService, listRootContainers, listRoutes, listS3Sources, listSandboxes, listScheduleRunJobs, listScheduleRuns, listScheduleServices, listSecrets, listServiceHealthStatuses, listServiceProjects, listServices, listServiceSchedules, listSkills, listSnapshots, listSourceBackups, listSourceFiles, listSourceMaps, listSources, listStaticBundles, listSyncedRepositories, listSystemAlarms, listTeamMembers, listTeamProjects, listTeams, listThreadArtifacts, listTraefikDiscoveredRoutes, listUserPendingActions, listUsers, listWebhooks, login, logout, lookupDnsARecords, mintEnrollmentToken, mkdir, nodeHeartbeat, nodeMetricsGetAlertRules, nodeMetricsGetRange, nodeMetricsUpdateAlertRule, observabilityFullEvent, observabilityListEvents, oidcCallback, type Options, patchAdminGate, patchPreviewGatewaySettings, pauseDeployment, pauseSandbox, planRestore, postDnsAck, previewAlert, previewFunnelMetrics, previewHostnameMode, promoteClusterMember, promoteDeployment, provisionDomain, purgeProjectLogs, pushExternalImage, queryData, queryGenaiTraces, queryLogs, queryMetrics, querySpanStats, queryTraces, queryTraceSummaries, readEntityRows, readFile, reAnalyze, reassignProjectCustomDomain, reconcileCloudBackupSource, recordConsoleEvent, recordEventMetrics, recordFlagExposure, recordSpeedMetrics, refreshAiProviderStatus, refreshProviderModels, refreshRouteTable, regenerateDsn, registerExternalImage, registerNode, reinstallGitlabWebhook, rejectPendingAction, rejectUserPendingAction, reloadPlugins, removeClusterMember, removeManagedDomain, removeRole, removeTeamMember, renameConversation, renameUserConversation, renewDomain, repointContinuousArchiveSource, requestDiscoveredRouteCert, requestPasswordReset, resetPassword, resizeSandbox, resolveAlarm, resolvePermission, resolveSystemAlarm, resolveUserPermission, restartContainer, restartPreviewGateway, restartSandbox, restoreApplication, restoreFlag, restoreUser, restoreUserConversation, resumeDeployment, resumeSandbox, retryCluster, retryDelivery, retryFacetBackfill, retryPgUpgrade, retryRun, revealGlobalMcpConfig, revealMcpConfig, revealNotificationProviderConfig, revealServiceEnvironmentVariables, revealServiceParameter, revenueCreateIntegration, revenueDeleteIntegration, revenueGlobalEvents, revenueImportInvoicesCsv, revenueImportSubscriptionsCsv, revenueListIntegrations, revenueListProviders, revenueMetricsCustomers, revenueMetricsGlobalMrr, revenueMetricsGlobalSummary, revenueMetricsMrr, revenueMetricsSummary, revenueRecentEvents, revenueRotateToken, revenueUpdateConfig, revenueUpdateSecret, revokeAnalyticsIngestKey, revokeDsn, revokeEmailDomainProject, revokeEnrollmentToken, revokeJoinToken, revokeProjectAccess, rollbackPgUpgrade, rollbackToDeployment, rootfsGc, rootfsReport, rotateAnalyticsIngestKey, rotateApiKey, rotateClusterCa, rotateDeploymentToken, runBackupForSource, runConnectionHealthCheck, runExternalServiceBackup, runScheduleNow, sandboxCreatePreviewLink, saveAgentToken, saveAiProviderCredential, searchLogs, sendEmail, sendFailureReport, sendProjectAiMessage, sendUserMessage, setAiDataAccess, setAlternateSources, setApplicationPrimaryProject, setDefaultS3Source, setFlagEnvironment, setPreviewPassword, setTraefikDiscoveredRouteEnabled, setupDns, setupDnsChallenge, setupEmailTracking, setupMfa, silenceAlarm, silenceSystemAlarm, sleepEnvironment, smokeTestAgent, sourceSandbox, startAnalysis, startContainer, startFix, startGitProviderOauth, startOidcLoginBySlug, startPgUpgrade, startRestore, startService, startUpdate, statPath, stopContainer, stopSandbox, stopService, stopTurn, stopUserTurn, storageSummary, streamContainerMetrics, streamEvents, streamRunEvents, syncRepositories, tailDeploymentJobLogs, tailLogs, teardownDeployment, teardownEnvironment, terminal, testNotificationProvider, testOidcProvider, testProvider, testProviderConnection, testProviderKeyById, testProviderKeyInline, testS3ConnectionPreview, testS3SourceConnection, trackClick, trackOpen, triggerAgent, triggerProjectPipeline, triggerScan, triggerServiceHealthCheck, triggerWeeklyDigest, unlinkApplicationProject, unlinkServiceFromProject, updateAgent, updateAiProvider, updateAiProviderPreference, updateAiSummaryPreference, updateAlert, updateAlertRule, updateAnalyticsIngestKey, updateApiKey, updateApplicationWorkspace, updateAutomaticDeploy, updateBackupSchedule, updateCloudFeatures, updateCloudflareProvider, updateConnectionToken, updateCustomDomain, updateDashboard, updateDeploymentToken, updateEmailProvider, updateEnvironmentSettings, updateEnvironmentSubdomain, updateEnvironmentVariable, updateErrorGroup, updateFlag, updateFunnel, updateGitProviderCredentials, updateGitSettings, updateGlobalMcp, updateGlobalSkill, updateIncidentStatus, updateIpAccessControl, updateManagedDomain, updateMcp, updateNotificationEmailProvider, updateNotificationProvider, updateNotificationRoute, updateOidcProvider, updatePermissionMode, updatePreferences, updateProject, updateProjectCloudTelemetry, updateProjectDeploymentConfig, updateProjectSecret, updateProjectSettings, updateProvider, updateProviderKey, updateProviderModel, updateRoute, updateS3Source, updateSelf, updateService, updateServiceResources, updateServiceTemplateRuntime, updateSessionDuration, updateSettings, updateSkill, updateSlackProvider, updateSpeedMetrics, updateTeam, updateTeamMemberRole, updateUser, updateUserPermissionMode, updateWebhook, updateWebhookProvider, upgradePreviewGateway, upgradeProjectServiceTemplate, upgradeService, uploadApplicationWorkspaceFiles, uploadGlobalSkill, uploadGlobalWorkspaceFiles, uploadReleaseFile, uploadSkill, uploadSourceFile, uploadSourceMap, uploadStaticBundle, uploadUserConversationAttachment, upsertSecret, validateConnection, validateEmail, verifyAndEnableMfa, verifyDomain, verifyEmail, verifyManagedDomain, verifyMfaChallenge, verifyStepUp, wakeEnvironment, webhookTrigger, workflowDryRun, writeApplicationWorkspaceFiles, writeFile, writeFiles } from './sdk.gen'; -export type { AcknowledgeAlarmData, AcknowledgeAlarmErrors, AcknowledgeAlarmResponses, AcknowledgeSystemAlarmData, AcknowledgeSystemAlarmErrors, AcknowledgeSystemAlarmResponses, AcmeOrderResponse, ActivateAiProviderData, ActivateAiProviderErrors, ActivateAiProviderResponse, ActivateAiProviderResponses, ActivateApiKeyData, ActivateApiKeyErrors, ActivateApiKeyResponse, ActivateApiKeyResponses, ActivateConnectionData, ActivateConnectionErrors, ActivateConnectionResponses, ActivateProviderData, ActivateProviderErrors, ActivateProviderResponse, ActivateProviderResponses, ActiveVisitor, ActiveVisitorCountResponse, ActiveVisitorsQuery, ActiveVisitorsResponse, ActivityDay, ActivityEvent, ActivityGraphQuery, ActivityGraphResponse, AddClusterMemberData, AddClusterMemberErrors, AddClusterMemberRequest, AddClusterMemberResponse, AddClusterMemberResponses, AddContextData, AddContextErrors, AddContextRequest, AddContextResponses, AddEnvironmentDomainData, AddEnvironmentDomainErrors, AddEnvironmentDomainRequest, AddEnvironmentDomainResponse, AddEnvironmentDomainResponses, AddEventsData, AddEventsError, AddEventsErrors, AddEventsRequest, AddEventsResponse, AddEventsResponse2, AddEventsResponses, AddManagedDomainApiRequest, AddManagedDomainData, AddManagedDomainErrors, AddManagedDomainResponse, AddManagedDomainResponses, AddProviderModelData, AddProviderModelError, AddProviderModelErrors, AddProviderModelRequest, AddProviderModelResponse, AddProviderModelResponses, AddSessionReplayEventsData, AddSessionReplayEventsError, AddSessionReplayEventsErrors, AddSessionReplayEventsResponse, AddSessionReplayEventsResponses, AddTeamMemberData, AddTeamMemberErrors, AddTeamMemberResponse, AddTeamMemberResponses, AdminDrainNodeData, AdminDrainNodeErrors, AdminDrainNodeResponse, AdminDrainNodeResponses, AdminDrainStatusData, AdminDrainStatusErrors, AdminDrainStatusResponse, AdminDrainStatusResponses, AdminGateResponse, AdminGateSource, AdminGetNodeData, AdminGetNodeErrors, AdminGetNodeResponse, AdminGetNodeResponses, AdminListNodeContainersData, AdminListNodeContainersErrors, AdminListNodeContainersResponse, AdminListNodeContainersResponses, AdminListNodesData, AdminListNodesErrors, AdminListNodesResponse, AdminListNodesResponses, AdminRemoveNodeData, AdminRemoveNodeErrors, AdminRemoveNodeResponse, AdminRemoveNodeResponses, AdminUndrainNodeData, AdminUndrainNodeErrors, AdminUndrainNodeResponse, AdminUndrainNodeResponses, AgentConfigResponse, AgentRunLogResponse, AgentRunResponse, AgentRunWithLogsResponse, AgentSandboxSettings, AgentSandboxSettingsMasked, AggregateApiTrafficData, AggregateApiTrafficError, AggregateApiTrafficErrors, AggregateApiTrafficResponse, AggregateApiTrafficResponses, AggregatedBucketItem, AggregatedBucketsQuery, AggregatedBucketsResponse, AggregationLevel, AggregationTemporality, AiAgentBreakdownResponse, AiAgentBreakdownRow, AiAgentDescriptor, AiAgentPageRow, AiAgentPagesResponse, AiAgentTimelineResponse, AiAgentTimelineRow, AiChatLimitsSettings, AiCliStatusDto, AiConfigSettings, AiDataAccessResponse, AiModelOptionDto, AiPageBreakdownResponse, AiPageBreakdownRow, AiProviderStatusResponse, AiSelectOptionDto, AiStatusBreakdownResponse, AiStatusBreakdownRow, AiSummaryPreferenceDto, AiWorkspaceFileLimitsSettings, AlarmListResponse, AlarmResponse, AlarmSummaryResponse, AlertRuleResponse, AllocEntry, AnalyticsIngestKey, AnalyticsSessionEventsResponse, AnnotatedSpan, AnomalyAlgorithm, AnomalyParams, AnomalyPreviewPointResponse, AnomalyPreviewRequest, AnomalyPreviewResponse, ApiCallerEntry, ApiCallersResponse, ApiKeyListResponse, ApiKeyResponse, ApiRouteEntry, ApiRoutesResponse, ApiTimeseriesPoint, ApiTimeseriesResponse, ApiTrafficSummary, ApiTrafficSummaryResponse, ApplicationPreviewLinkResponse, ApplicationProjectDeploymentResponse, ApplicationProjectEnvironmentResponse, ApplicationProjectResponse, ApplicationResponse, ApplicationWorkspaceChangesResponse, ApplicationWorkspaceDiffResponse, ApplicationWorkspaceDirectoryEntryResponse, ApplicationWorkspaceDirectoryResponse, ApplicationWorkspaceFileContentResponse, ApplicationWorkspaceFileResponse, ApplicationWorkspaceFileWrite, ApplicationWorkspaceResponse, ApplyHostnameModeData, ApplyHostnameModeErrors, ApplyHostnameModeRequest, ApplyHostnameModeResponse, ApplyHostnameModeResponses, AppSettings, AppSettingsResponse, ArchiveApplicationData, ArchiveApplicationErrors, ArchiveApplicationResponse, ArchiveApplicationResponses, ArchiveConversationData, ArchiveConversationErrors, ArchiveConversationResponse, ArchiveConversationResponses, ArchiveFlagData, ArchiveFlagErrors, ArchiveFlagResponse, ArchiveFlagResponse2, ArchiveFlagResponses, ArchiveMode, ArchiveUserConversationData, ArchiveUserConversationErrors, ArchiveUserConversationResponse, ArchiveUserConversationResponses, AssignRoleData, AssignRoleErrors, AssignRoleRequest, AssignRoleResponses, AttachScheduleServicesData, AttachScheduleServicesError, AttachScheduleServicesErrors, AttachScheduleServicesRequest, AttachScheduleServicesResponse, AttachScheduleServicesResponse2, AttachScheduleServicesResponses, AuditLogIpInfo, AuditLogResponse, AuditLogUserInfo, AuthFlavorDto, AuthorizedEmailDomainProjectResponse, AuthorizeEmailDomainProjectData, AuthorizeEmailDomainProjectErrors, AuthorizeEmailDomainProjectResponse, AuthorizeEmailDomainProjectResponses, AuthResponse, AuthStatusResponse, AuthTokenResponse, AutofixerRunResponse, AutofixerRunWithLogsResponse, AutofixRunConfig, AutoWatchParams, AvailableAiProviderDto, AvailableContainerInfo, AvailablePermissions, BackupAlertListResponse, BackupAlertResponse, BackupResponse, BackupScheduleResponse, BitbucketAuthInput, BlobCopyData, BlobCopyError, BlobCopyErrors, BlobCopyResponse, BlobCopyResponses, BlobDeleteData, BlobDeleteError, BlobDeleteErrors, BlobDeleteResponse, BlobDeleteResponses, BlobDisableData, BlobDisableErrors, BlobDisableResponse, BlobDisableResponses, BlobDownloadData, BlobDownloadError, BlobDownloadErrors, BlobDownloadResponses, BlobEnableData, BlobEnableErrors, BlobEnableResponse, BlobEnableResponses, BlobHeadData, BlobHeadError, BlobHeadErrors, BlobHeadResponses, BlobListData, BlobListError, BlobListErrors, BlobListResponse, BlobListResponses, BlobPutData, BlobPutError, BlobPutErrors, BlobPutResponse, BlobPutResponses, BlobResponse, BlobStatusData, BlobStatusErrors, BlobStatusResponse, BlobStatusResponse2, BlobStatusResponses, BlobUpdateData, BlobUpdateErrors, BlobUpdateResponse, BlobUpdateResponses, BranchInfo, BranchListResponse, BrowserCount, BrowsersQuery, BuildConfiguration, BuildLimitsSettings, BulkActivationEstimateResponse, BulkActivationEtaState, BulkActivationJobProjectResponse, BulkActivationJobResponse, BulkActivationProjectEstimateResponse, BulkJobProjectStatus, BulkJobStatus, BulkJobTrigger, CancelBackupData, CancelBackupError, CancelBackupErrors, CancelBackupResponse, CancelBackupResponse2, CancelBackupResponses, CancelBulkActivationJobData, CancelBulkActivationJobError, CancelBulkActivationJobErrors, CancelBulkActivationJobResponse, CancelBulkActivationJobResponses, CancelData, CancelDeploymentData, CancelDeploymentErrors, CancelDeploymentResponse, CancelDeploymentResponses, CancelDomainOrderData, CancelDomainOrderErrors, CancelDomainOrderResponse, CancelDomainOrderResponses, CancelErrors, CancelPgUpgradeData, CancelPgUpgradeError, CancelPgUpgradeErrors, CancelPgUpgradeResponse, CancelPgUpgradeResponses, CancelResponses, CancelRunData, CancelRunErrors, CancelRunResponse, CancelRunResponses, CancelScheduleRunData, CancelScheduleRunError, CancelScheduleRunErrors, CancelScheduleRunResponse, CancelScheduleRunResponses, CertStatusResponse, ChallengeConfig, ChallengeError, ChallengeValidationStatus, ChangePasswordRequest, ChangePasswordSelfData, ChangePasswordSelfErrors, ChangePasswordSelfResponse, ChangePasswordSelfResponses, ChangeProjectSourceData, ChangeProjectSourceErrors, ChangeProjectSourceRequest, ChangeProjectSourceResponse, ChangeProjectSourceResponses, ChangeRequiredPasswordData, ChangeRequiredPasswordErrors, ChangeRequiredPasswordResponse, ChangeRequiredPasswordResponses, ChatAttachmentReference, ChatAttachmentResponse, ChatAttachmentUpload, ChatCompletionChoice, ChatCompletionRequest, ChatCompletionResponse, ChatCompletionsData, ChatCompletionsError, ChatCompletionsErrors, ChatCompletionsResponse, ChatCompletionsResponses, ChatMessage, ChatReadinessResponse, CheckAnalyticsHasEventsData, CheckAnalyticsHasEventsErrors, CheckAnalyticsHasEventsResponse, CheckAnalyticsHasEventsResponses, CheckCommitExistsData, CheckCommitExistsErrors, CheckCommitExistsResponse, CheckCommitExistsResponses, CheckDomainStatusData, CheckDomainStatusErrors, CheckDomainStatusResponse, CheckDomainStatusResponses, CheckExplorerSupportData, CheckExplorerSupportErrors, CheckExplorerSupportResponse, CheckExplorerSupportResponses, CheckForUpdateData, CheckForUpdateError, CheckForUpdateErrors, CheckForUpdateResponse, CheckForUpdateResponses, CheckIpBlockedData, CheckIpBlockedError, CheckIpBlockedErrors, CheckIpBlockedResponses, CheckProviderDeletionSafetyData, CheckProviderDeletionSafetyErrors, CheckProviderDeletionSafetyResponse, CheckProviderDeletionSafetyResponses, ChildBackupEntryResponse, ChildBackupListResponse, ChunkUploadOptionsData, ChunkUploadOptionsResponse, ChunkUploadOptionsResponses, CleanupExpiredBackupsData, CleanupExpiredBackupsError, CleanupExpiredBackupsErrors, CleanupExpiredBackupsRequest, CleanupExpiredBackupsResponse, CleanupExpiredBackupsResponses, ClearPreviewPasswordData, ClearPreviewPasswordErrors, ClearPreviewPasswordResponse, ClearPreviewPasswordResponses, CliDeviceApproveData, CliDeviceApproveErrors, CliDeviceApproveRequest, CliDeviceApproveResponse, CliDeviceApproveResponse2, CliDeviceApproveResponses, CliDeviceDenyData, CliDeviceDenyErrors, CliDeviceDenyResponse, CliDeviceDenyResponses, CliDeviceLookupData, CliDeviceLookupErrors, CliDeviceLookupResponse, CliDeviceLookupResponse2, CliDeviceLookupResponses, CliDevicePollData, CliDevicePollErrors, CliDevicePollRequest, CliDevicePollResponse, CliDevicePollResponse2, CliDevicePollResponses, CliDeviceStartData, CliDeviceStartErrors, CliDeviceStartRequest, CliDeviceStartResponse, CliDeviceStartResponse2, CliDeviceStartResponses, ClientOptions, CliLoginRequest, CliLogoutData, CliLogoutErrors, CliLogoutResponse, CliLogoutResponses, CloudAiCapability, CloudAnalyticsWriteMode, CloudBackfillStatusResponse, CloudCapability, CloudFeatureSwitchesRequest, CloudflareConfig, CloudProvider, CloudSettings, CloudStatus, CloudTelemetryBackfillStatus, CloudTelemetryFidelity, CloudTelemetryWriteMode, CloudTelemetryWriteStatusResponse, ClusterCapacity, ClusterDnsSettings, ClusterDnsStatusData, ClusterDnsStatusErrors, ClusterDnsStatusResponse, ClusterDnsStatusResponse2, ClusterDnsStatusResponses, ClusterHealthReportResponse, ClusterMemberHealthResponse, ClusterMemberRequest, ClusterNetworkSettings, CmdBody, CmdData, CmdErrors, CmdInner, CmdKillBody, CmdKillData, CmdKillErrors, CmdKillResponse, CmdKillResponses, CmdLogsData, CmdLogsErrors, CmdLogsResponses, CmdResponse, CmdResponse2, CmdResponses, CommitExistsResponse, CommitInfo, CommitListResponse, Comparator, ComposePortMapping, ComposePreviewRequest, ComposePreviewResponse, ComposePublicPort, ComposeServiceFamily, ComposeServicePreviewResponse, ConfirmPendingActionData, ConfirmPendingActionErrors, ConfirmPendingActionResponse, ConfirmPendingActionResponses, ConfirmUserPendingActionData, ConfirmUserPendingActionErrors, ConfirmUserPendingActionResponse, ConfirmUserPendingActionResponses, ConnectionLimitSettings, ConnectionListQuery, ConnectionListResponse, ConnectionResponse, ConnectionTestResult, ConsoleEventPayload, ContainerActionResponse, ContainerDetailResponse, ContainerEnvironmentVariableValueResponse, ContainerHistoryEntry, ContainerHistoryListResponse, ContainerInfoResponse, ContainerInventoryItem, ContainerListResponse, ContainerLogSettings, ContainerLogsQuery, ContainerMetricHistoryPoint, ContainerMetricsGetHistoryData, ContainerMetricsGetHistoryErrors, ContainerMetricsGetHistoryResponse, ContainerMetricsGetHistoryResponses, ContainerMetricsHistoryQuery, ContainerMetricsResponse, ContainerResponse, ContainerRuntimeInfo, ContainerStatsSample, ContentPart, ContextLine, ContextLogsRequest, ContextLogsResponse, ContinuousArchiveSourceResponse, ControlApplicationWorkspaceData, ControlApplicationWorkspaceErrors, ControlApplicationWorkspaceRequest, ControlApplicationWorkspaceResponse, ControlApplicationWorkspaceResponses, ConversationDetailResponse, ConversationListScope, ConversationListStatus, ConversationMessagePageResponse, ConversationResponse, ConversationsQueryParams, ConversationSummary, CopyBlobRequest, CostAnalysis, CreatableServiceTypeRoute, CreateAgentData, CreateAgentErrors, CreateAgentResponse, CreateAgentResponses, CreateAlertData, CreateAlertError, CreateAlertErrors, CreateAlertResponse, CreateAlertResponses, CreateAlertRuleData, CreateAlertRuleErrors, CreateAlertRuleRequest, CreateAlertRuleResponse, CreateAlertRuleResponses, CreateAnalyticsIngestKeyData, CreateAnalyticsIngestKeyErrors, CreateAnalyticsIngestKeyRequest, CreateAnalyticsIngestKeyResponse, CreateAnalyticsIngestKeyResponses, CreateApiKeyData, CreateApiKeyErrors, CreateApiKeyRequest, CreateApiKeyResponse, CreateApiKeyResponse2, CreateApiKeyResponses, CreateApplicationConversationData, CreateApplicationConversationErrors, CreateApplicationConversationRequest, CreateApplicationConversationResponse, CreateApplicationConversationResponses, CreateApplicationData, CreateApplicationErrors, CreateApplicationPreviewLinkData, CreateApplicationPreviewLinkErrors, CreateApplicationPreviewLinkRequest, CreateApplicationPreviewLinkResponse, CreateApplicationPreviewLinkResponses, CreateApplicationProjectData, CreateApplicationProjectErrors, CreateApplicationProjectRequest, CreateApplicationProjectResponse, CreateApplicationProjectResponses, CreateApplicationRequest, CreateApplicationResponse, CreateApplicationResponses, CreateBackupScheduleData, CreateBackupScheduleError, CreateBackupScheduleErrors, CreateBackupScheduleRequest, CreateBackupScheduleResponse, CreateBackupScheduleResponses, CreateBitbucketProviderData, CreateBitbucketProviderErrors, CreateBitbucketProviderResponse, CreateBitbucketProviderResponses, CreateBitbucketRequest, CreateBulkActivationJobData, CreateBulkActivationJobError, CreateBulkActivationJobErrors, CreateBulkActivationJobRequest, CreateBulkActivationJobResponse, CreateBulkActivationJobResponses, CreateCloudflareProviderData, CreateCloudflareProviderErrors, CreateCloudflareProviderRequest, CreateCloudflareProviderResponse, CreateCloudflareProviderResponses, CreateConversationData, CreateConversationErrors, CreateConversationRequest, CreateConversationResponse, CreateConversationResponses, CreateCustomDomainData, CreateCustomDomainErrors, CreateCustomDomainResponse, CreateCustomDomainResponses, CreateDashboardData, CreateDashboardError, CreateDashboardErrors, CreateDashboardRequest, CreateDashboardResponse, CreateDashboardResponses, CreateDeploymentTokenData, CreateDeploymentTokenErrors, CreateDeploymentTokenRequest, CreateDeploymentTokenResponse, CreateDeploymentTokenResponse2, CreateDeploymentTokenResponses, CreateDnsProviderData, CreateDnsProviderErrors, CreateDnsProviderRequest, CreateDnsProviderResponse, CreateDnsProviderResponses, CreateDomainData, CreateDomainErrors, CreateDomainRequest, CreateDomainResponse, CreateDomainResponses, CreatedResource, CreateDsnData, CreateDsnErrors, CreateDsnRequest, CreateDsnResponse, CreateDsnResponses, CreateEmailDomainData, CreateEmailDomainErrors, CreateEmailDomainRequest, CreateEmailDomainResponse, CreateEmailDomainResponses, CreateEmailProviderData, CreateEmailProviderErrors, CreateEmailProviderRequest, CreateEmailProviderResponse, CreateEmailProviderResponses, CreateEnvironmentData, CreateEnvironmentErrors, CreateEnvironmentRequest, CreateEnvironmentResponse, CreateEnvironmentResponses, CreateEnvironmentVariableData, CreateEnvironmentVariableErrors, CreateEnvironmentVariableRequest, CreateEnvironmentVariableResponse, CreateEnvironmentVariableResponses, CreateExternalServiceRequest, CreateFacetData, CreateFacetError, CreateFacetErrors, CreateFacetRequest, CreateFacetResponse, CreateFacetResponses, CreateFlagData, CreateFlagErrors, CreateFlagRequest, CreateFlagResponse, CreateFlagResponses, CreateFunnelData, CreateFunnelErrors, CreateFunnelRequest, CreateFunnelResponse, CreateFunnelResponse2, CreateFunnelResponses, CreateFunnelStep, CreateGenericProviderData, CreateGenericProviderErrors, CreateGenericProviderResponse, CreateGenericProviderResponses, CreateGenericRequest, CreateGiteaPatProviderData, CreateGiteaPatProviderErrors, CreateGiteaPatProviderResponse, CreateGiteaPatProviderResponses, CreateGiteaPatRequest, CreateGithubPatProviderData, CreateGithubPatProviderErrors, CreateGithubPatProviderResponse, CreateGithubPatProviderResponses, CreateGitHubPatRequest, CreateGitlabOauthProviderData, CreateGitlabOauthProviderErrors, CreateGitlabOauthProviderResponse, CreateGitlabOauthProviderResponses, CreateGitLabOAuthRequest, CreateGitlabPatProviderData, CreateGitlabPatProviderErrors, CreateGitlabPatProviderResponse, CreateGitlabPatProviderResponses, CreateGitLabPatRequest, CreateGitProviderData, CreateGitProviderErrors, CreateGitProviderResponse, CreateGitProviderResponses, CreateGlobalConversationData, CreateGlobalConversationErrors, CreateGlobalConversationRequest, CreateGlobalConversationResponse, CreateGlobalConversationResponses, CreateGlobalMcpData, CreateGlobalMcpErrors, CreateGlobalMcpResponse, CreateGlobalMcpResponses, CreateGlobalSkillData, CreateGlobalSkillErrors, CreateGlobalSkillResponse, CreateGlobalSkillResponses, CreateGlobalWorkspacePreviewLinkData, CreateGlobalWorkspacePreviewLinkErrors, CreateGlobalWorkspacePreviewLinkResponse, CreateGlobalWorkspacePreviewLinkResponses, CreateIncidentData, CreateIncidentErrors, CreateIncidentRequest, CreateIncidentResponse, CreateIncidentResponses, CreateIntegrationBody, CreateIpAccessControlData, CreateIpAccessControlError, CreateIpAccessControlErrors, CreateIpAccessControlRequest, CreateIpAccessControlResponse, CreateIpAccessControlResponses, CreateMcpData, CreateMcpErrors, CreateMcpRequest, CreateMcpResponse, CreateMcpResponses, CreateMetricAlertRequest, CreateMonitorData, CreateMonitorErrors, CreateMonitorRequest, CreateMonitorResponse, CreateMonitorResponses, CreateNotificationEmailProviderData, CreateNotificationEmailProviderErrors, CreateNotificationEmailProviderRequest, CreateNotificationEmailProviderResponse, CreateNotificationEmailProviderResponses, CreateNotificationProviderData, CreateNotificationProviderErrors, CreateNotificationProviderResponse, CreateNotificationProviderResponses, CreateNotificationRouteData, CreateNotificationRouteErrors, CreateNotificationRouteRequest, CreateNotificationRouteResponse, CreateNotificationRouteResponses, CreateOidcProviderData, CreateOidcProviderErrors, CreateOidcProviderRequest, CreateOidcProviderResponse, CreateOidcProviderResponses, CreateOidcRoleMappingData, CreateOidcRoleMappingRequest, CreateOidcRoleMappingResponse, CreateOidcRoleMappingResponses, CreateOrRecreateOrderData, CreateOrRecreateOrderErrors, CreateOrRecreateOrderResponse, CreateOrRecreateOrderResponses, CreatePlanData, CreatePlanErrors, CreatePlanRequest, CreatePlanResponse, CreatePlanResponse2, CreatePlanResponses, CreatePrData, CreatePrErrors, CreateProjectAccessRequest, CreateProjectData, CreateProjectErrors, CreateProjectFromTemplateData, CreateProjectFromTemplateErrors, CreateProjectFromTemplateRequest, CreateProjectFromTemplateResponse, CreateProjectFromTemplateResponse2, CreateProjectFromTemplateResponses, CreateProjectReleaseData, CreateProjectReleaseErrors, CreateProjectReleaseResponse, CreateProjectReleaseResponses, CreateProjectRequest, CreateProjectResponse, CreateProjectResponses, CreateProjectSecretData, CreateProjectSecretErrors, CreateProjectSecretRequest, CreateProjectSecretResponse, CreateProjectSecretResponses, CreateProviderKeyData, CreateProviderKeyError, CreateProviderKeyErrors, CreateProviderKeyRequest, CreateProviderKeyResponse, CreateProviderKeyResponses, CreateProviderRequest, CreatePrResponse, CreatePrResponse2, CreatePrResponses, CreateReleaseData, CreateReleaseErrors, CreateReleaseResponse, CreateReleaseResponses, CreateRouteData, CreateRouteErrors, CreateRouteRequest, CreateRouteResponse, CreateRouteResponses, CreateS3SourceData, CreateS3SourceError, CreateS3SourceErrors, CreateS3SourceRequest, CreateS3SourceResponse, CreateS3SourceResponses, CreateSandboxBody, CreateSandboxData, CreateSandboxErrors, CreateSandboxResponse, CreateSandboxResponses, CreateServiceData, CreateServiceErrors, CreateServiceResponse, CreateServiceResponses, CreateSkillData, CreateSkillErrors, CreateSkillRequest, CreateSkillResponse, CreateSkillResponses, CreateSlackProviderData, CreateSlackProviderErrors, CreateSlackProviderRequest, CreateSlackProviderResponse, CreateSlackProviderResponses, CreateSnapshotBody, CreateSnapshotData, CreateSnapshotErrors, CreateSnapshotResponse, CreateSnapshotResponses, CreateTeamData, CreateTeamErrors, CreateTeamMemberRequest, CreateTeamRequest, CreateTeamResponse, CreateTeamResponses, CreateThreadArtifactData, CreateThreadArtifactErrors, CreateThreadArtifactRequest, CreateThreadArtifactResponse, CreateThreadArtifactResponses, CreateUserData, CreateUserErrors, CreateUserRequest, CreateUserResponse, CreateUserResponses, CreateWebhookData, CreateWebhookErrors, CreateWebhookProviderData, CreateWebhookProviderErrors, CreateWebhookProviderRequest, CreateWebhookProviderResponse, CreateWebhookProviderResponses, CreateWebhookRequestBody, CreateWebhookResponse, CreateWebhookResponses, CronExecutionInfo, CronInfo, CrossProjectSiblingRef, CrossProjectTraceResponse, CurrentStatusResponse, CustomDomainRequest, CustomDomainResponse, CustomerMovementResponse, DashboardLayout, DashboardProjectsAnalyticsQuery, DashboardProjectsAnalyticsResponse, DashboardSection, DashboardTile, DatabaseMetricsResponse, DatabaseMetricsRow, DataImplication, DataImplicationSeverity, DeactivateApiKeyData, DeactivateApiKeyErrors, DeactivateApiKeyResponse, DeactivateApiKeyResponses, DeactivateConnectionData, DeactivateConnectionErrors, DeactivateConnectionResponses, DeactivateProviderData, DeactivateProviderErrors, DeactivateProviderResponses, DeauthorizeDiscoveredRouteCertData, DeauthorizeDiscoveredRouteCertError, DeauthorizeDiscoveredRouteCertErrors, DeauthorizeDiscoveredRouteCertResponse, DeauthorizeDiscoveredRouteCertResponses, DeleteAgentData, DeleteAgentErrors, DeleteAgentResponse, DeleteAgentResponses, DeleteAlertData, DeleteAlertError, DeleteAlertErrors, DeleteAlertResponse, DeleteAlertResponses, DeleteAlertRuleData, DeleteAlertRuleErrors, DeleteAlertRuleResponse, DeleteAlertRuleResponses, DeleteApiKeyData, DeleteApiKeyErrors, DeleteApiKeyResponse, DeleteApiKeyResponses, DeleteBackupData, DeleteBackupError, DeleteBackupErrors, DeleteBackupResponse, DeleteBackupResponses, DeleteBackupScheduleData, DeleteBackupScheduleError, DeleteBackupScheduleErrors, DeleteBackupScheduleResponse, DeleteBackupScheduleResponses, DeleteBlobRequest, DeleteBlobResponse, DeleteConnectionData, DeleteConnectionErrors, DeleteConnectionResponse, DeleteConnectionResponses, DeleteCustomDomainData, DeleteCustomDomainErrors, DeleteCustomDomainResponse, DeleteCustomDomainResponses, DeleteDashboardData, DeleteDashboardError, DeleteDashboardErrors, DeleteDashboardResponse, DeleteDashboardResponses, DeleteDeploymentTokenData, DeleteDeploymentTokenErrors, DeleteDeploymentTokenResponse, DeleteDeploymentTokenResponses, DeleteDnsProviderData, DeleteDnsProviderErrors, DeleteDnsProviderResponse, DeleteDnsProviderResponses, DeleteDomainData, DeleteDomainErrors, DeleteDomainResponse, DeleteDomainResponses, DeleteEmailDomainData, DeleteEmailDomainErrors, DeleteEmailDomainResponse, DeleteEmailDomainResponses, DeleteEmailProviderData, DeleteEmailProviderErrors, DeleteEmailProviderResponse, DeleteEmailProviderResponses, DeleteEnvironmentData, DeleteEnvironmentDomainData, DeleteEnvironmentDomainErrors, DeleteEnvironmentDomainResponse, DeleteEnvironmentDomainResponses, DeleteEnvironmentErrors, DeleteEnvironmentResponse, DeleteEnvironmentResponses, DeleteEnvironmentVariableData, DeleteEnvironmentVariableErrors, DeleteEnvironmentVariableResponse, DeleteEnvironmentVariableResponses, DeleteExternalImageData, DeleteExternalImageErrors, DeleteExternalImageResponse, DeleteExternalImageResponses, DeleteFacetData, DeleteFacetError, DeleteFacetErrors, DeleteFacetResponse, DeleteFacetResponses, DeleteFunnelData, DeleteFunnelErrors, DeleteFunnelResponses, DeleteGitProviderData, DeleteGitProviderErrors, DeleteGitProviderResponse, DeleteGitProviderResponses, DeleteGlobalMcpData, DeleteGlobalMcpErrors, DeleteGlobalMcpResponse, DeleteGlobalMcpResponses, DeleteGlobalSkillData, DeleteGlobalSkillErrors, DeleteGlobalSkillResponse, DeleteGlobalSkillResponses, DeleteIpAccessControlData, DeleteIpAccessControlError, DeleteIpAccessControlErrors, DeleteIpAccessControlResponse, DeleteIpAccessControlResponses, DeleteMcpData, DeleteMcpErrors, DeleteMcpResponse, DeleteMcpResponses, DeleteMonitorData, DeleteMonitorErrors, DeleteMonitorResponse, DeleteMonitorResponses, DeleteNotificationProviderData, DeleteNotificationProviderErrors, DeleteNotificationProviderResponse, DeleteNotificationProviderResponses, DeleteNotificationRouteData, DeleteNotificationRouteErrors, DeleteNotificationRouteResponse, DeleteNotificationRouteResponses, DeleteOidcProviderData, DeleteOidcProviderResponse, DeleteOidcProviderResponses, DeleteOidcRoleMappingData, DeleteOidcRoleMappingResponse, DeleteOidcRoleMappingResponses, DeletePreferencesData, DeletePreferencesErrors, DeletePreferencesResponse, DeletePreferencesResponses, DeleteProjectData, DeleteProjectErrors, DeleteProjectResponse, DeleteProjectResponses, DeleteProjectSecretData, DeleteProjectSecretErrors, DeleteProjectSecretResponse, DeleteProjectSecretResponses, DeleteProviderKeyData, DeleteProviderKeyError, DeleteProviderKeyErrors, DeleteProviderKeyResponse, DeleteProviderKeyResponses, DeleteProviderModelData, DeleteProviderModelError, DeleteProviderModelErrors, DeleteProviderModelResponse, DeleteProviderModelResponses, DeleteProviderSafelyData, DeleteProviderSafelyErrors, DeleteProviderSafelyResponse, DeleteProviderSafelyResponses, DeleteReleaseSourceFilesData, DeleteReleaseSourceFilesErrors, DeleteReleaseSourceFilesResponse, DeleteReleaseSourceFilesResponses, DeleteReleaseSourceMapsData, DeleteReleaseSourceMapsErrors, DeleteReleaseSourceMapsResponse, DeleteReleaseSourceMapsResponses, DeleteResponse, DeleteRouteData, DeleteRouteErrors, DeleteRouteResponse, DeleteRouteResponses, DeleteS3SourceData, DeleteS3SourceError, DeleteS3SourceErrors, DeleteS3SourceResponse, DeleteS3SourceResponses, DeleteScanData, DeleteScanError, DeleteScanErrors, DeleteScanResponse, DeleteScanResponses, DeleteSecretData, DeleteSecretErrors, DeleteSecretResponse, DeleteSecretResponses, DeleteServiceData, DeleteServiceErrors, DeleteServiceResponse, DeleteServiceResponses, DeleteSessionReplayData, DeleteSessionReplayError, DeleteSessionReplayErrors, DeleteSessionReplayResponses, DeleteSkillData, DeleteSkillErrors, DeleteSkillResponse, DeleteSkillResponses, DeleteSnapshotData, DeleteSnapshotErrors, DeleteSnapshotResponse, DeleteSnapshotResponses, DeleteSourceMapData, DeleteSourceMapErrors, DeleteSourceMapResponse, DeleteSourceMapResponses, DeleteStaticBundleData, DeleteStaticBundleErrors, DeleteStaticBundleResponse, DeleteStaticBundleResponses, DeleteTeamData, DeleteTeamErrors, DeleteTeamResponse, DeleteTeamResponses, DeleteUserData, DeleteUserErrors, DeleteUserResponse, DeleteUserResponses, DeleteWebhookData, DeleteWebhookErrors, DeleteWebhookResponse, DeleteWebhookResponses, DelRequest, DelResponse, DeployApplicationProjectRequest, DeployApplicationWorkspaceProjectData, DeployApplicationWorkspaceProjectErrors, DeployApplicationWorkspaceProjectResponse, DeployApplicationWorkspaceProjectResponses, DeployFromImageData, DeployFromImageErrors, DeployFromImageRequest, DeployFromImageResponse, DeployFromImageResponses, DeployFromImageUploadData, DeployFromImageUploadErrors, DeployFromImageUploadQuery, DeployFromImageUploadResponse, DeployFromImageUploadResponses, DeployFromStaticData, DeployFromStaticErrors, DeployFromStaticRequest, DeployFromStaticResponse, DeployFromStaticResponses, DeployFromUploadedSourceData, DeployFromUploadedSourceErrors, DeployFromUploadedSourceResponse, DeployFromUploadedSourceResponses, DeploymentConfig, DeploymentConfigSnapshot, DeploymentConfiguration, DeploymentContainerLogContentResponse, DeploymentContainerLogResponse, DeploymentContainerLogsListResponse, DeploymentEnvironmentResponse, DeploymentJobResponse, DeploymentJobsResponse, DeploymentListResponse, DeploymentMetadata, DeploymentMetricsGetLatestData, DeploymentMetricsGetLatestErrors, DeploymentMetricsGetLatestResponse, DeploymentMetricsGetLatestResponses, DeploymentMetricsGetRangeData, DeploymentMetricsGetRangeErrors, DeploymentMetricsGetRangeResponse, DeploymentMetricsGetRangeResponses, DeploymentMetricsToggleData, DeploymentMetricsToggleErrors, DeploymentMetricsToggleResponses, DeploymentResponse, DeploymentStateResponse, DeploymentStrategy, DeploymentTokenListResponse, DeploymentTokenResponse, DestroySandboxData, DestroySandboxErrors, DestroySandboxResponse, DestroySandboxResponses, DetachScheduleServiceData, DetachScheduleServiceError, DetachScheduleServiceErrors, DetachScheduleServiceResponse, DetachScheduleServiceResponses, DetectionConfig, DetectPublicEnvExampleData, DetectPublicEnvExampleErrors, DetectPublicEnvExampleResponse, DetectPublicEnvExampleResponses, DetectPublicPresetsData, DetectPublicPresetsErrors, DetectPublicPresetsResponse, DetectPublicPresetsResponses, DeviceCount, DigestSections, Direction, DisableBackupScheduleData, DisableBackupScheduleError, DisableBackupScheduleErrors, DisableBackupScheduleResponse, DisableBackupScheduleResponses, DisableBlobResponse, DisableKvResponse, DisableMfaData, DisableMfaErrors, DisableMfaRequest, DisableMfaResponse, DisableMfaResponses, DisconnectCloudData, DisconnectCloudResponse, DisconnectCloudResponses, DiscoverRequest, DiscoverResponse, DiscoverWorkloadsData, DiscoverWorkloadsErrors, DiscoverWorkloadsResponse, DiscoverWorkloadsResponses, DiskInfo, DiskSpaceAlert, DiskSpaceAlertSettings, DiskSpaceCheckResult, DnsAckRequest, DnsAckResponse, DnsChallengeRecordResult, DnsChangesResponse, DnsCompletionResponse, DnsLookupError, DnsLookupRequest, DnsLookupResponse, DnsProviderCredentials, DnsProviderResponse, DnsProviderSettings, DnsProviderSettingsMasked, DnsProviderType, DnsRecord, DnsRecordChange, DnsRecordContent, DnsRecordResponse, DnsRecordSetupResult, DnsRecordStatusResponse, DnsResolverHeartbeat, DnsZone, DockerComposePresetConfig, DockerfilePresetConfig, DockerfileVariant, DockerRegistrySettings, DockerRegistrySettingsMasked, DomainAction, DomainChallengeResponse, DomainData, DomainEnvironmentResponse, DomainError, DomainErrors, DomainPlan, DomainResponse, DomainResponse2, DomainResponses, DownloadApplicationWorkspaceFileData, DownloadApplicationWorkspaceFileErrors, DownloadApplicationWorkspaceFileResponse, DownloadApplicationWorkspaceFileResponses, DownloadGlobalSkillArchiveData, DownloadGlobalSkillArchiveErrors, DownloadGlobalSkillArchiveResponse, DownloadGlobalSkillArchiveResponses, DownloadGlobalWorkspaceFileData, DownloadGlobalWorkspaceFileErrors, DownloadGlobalWorkspaceFileResponse, DownloadGlobalWorkspaceFileResponses, DownloadObjectData, DownloadObjectErrors, DownloadObjectResponse, DownloadObjectResponses, DownloadSkillArchiveData, DownloadSkillArchiveErrors, DownloadSkillArchiveResponse, DownloadSkillArchiveResponses, DrainNodeResponse, DrainStatusResponse, DropArchiveUpload, DropInspectionResponse, DropOffPoint, DropPresetCandidate, EmailConfig, EmailDomainResponse, EmailDomainWithDnsResponse, EmailProviderResponse, EmailProviderTypeRoute, EmailRequest, EmailResponse, EmailStatsResponse, EmailStatusData, EmailStatusErrors, EmailStatusResponse, EmailStatusResponse2, EmailStatusResponses, EmailTrackingResponse, EmailTrackingSetupResponse, EmailTrackingStatusResponse, EmbeddingData, EmbeddingInput, EmbeddingRequest, EmbeddingResponse, EmbeddingsData, EmbeddingsError, EmbeddingsErrors, EmbeddingsResponse, EmbeddingsResponses, EmbeddingUsage, EnableBackupScheduleData, EnableBackupScheduleError, EnableBackupScheduleErrors, EnableBackupScheduleResponse, EnableBackupScheduleResponses, EnableBlobRequest, EnableBlobResponse, EnableKvRequest, EnableKvResponse, EnablePgStatStatementsResponse, EndpointDto, EnqueuedJob, EnrichVisitorData, EnrichVisitorErrors, EnrichVisitorRequest, EnrichVisitorResponse, EnrichVisitorResponse2, EnrichVisitorResponses, EnrollCloudData, EnrollCloudRequest, EnrollCloudResponse, EnrollCloudResponses, EnrollmentTokenInfo, EnrollmentTokenListResponse, EntityInfoResponse, EntityResponse, EnvExampleVariable, EnvExampleVariableResponse, EnvironmentConfiguration, EnvironmentDomainResponse, EnvironmentInfo, EnvironmentResponse, EnvironmentVariable, EnvironmentVariableInfo, EnvironmentVariableResponse, EnvironmentVariableValueResponse, EnvVarInput, EnvVarIntegrationInfo, EnvVarResponse, EnvVarTemplate, EnvVarTemplateResponse, ErrorDashboardStatsQuery, ErrorDashboardStatsResponse, ErrorEventResponse, ErrorGroupDeploymentResponse, ErrorGroupResponse, ErrorGroupStatsResponse, ErrorResponse, ErrorRow, ErrorTimeSeriesDataResponse, ErrorTimeSeriesQuery, EstimateBulkActivationData, EstimateBulkActivationError, EstimateBulkActivationErrors, EstimateBulkActivationRequest, EstimateBulkActivationResponse, EstimateBulkActivationResponses, EventActivityBucket, EventBreakdown, EventBrowserStats, EventCount, EventCountryStats, EventDetailQuery, EventDetailResponse, EventEntriesQuery, EventEntriesResponse, EventEntryInfo, EventKind, EventMetricsPayload, EventReferrerStats, EventsCountQuery, EventsResponse, EventTimeline, EventTimelineQuery, EventType, EventTypeBreakdown, EventTypeBreakdownQuery, EventTypeResponse, EventTypesResponse, EventVisitorInfo, EventVisitorsQuery, EventVisitorsResponse, ExecBody, ExecData, ExecDetachedData, ExecDetachedErrors, ExecDetachedResponse, ExecDetachedResponse2, ExecDetachedResponses, ExecErrors, ExecResponse, ExecResponse2, ExecResponses, ExecuteDeploymentOperationData, ExecuteDeploymentOperationErrors, ExecuteDeploymentOperationResponse, ExecuteDeploymentOperationResponses, ExecuteImportData, ExecuteImportErrors, ExecuteImportRequest, ExecuteImportResponse, ExecuteImportResponse2, ExecuteImportResponses, ExecuteOperationRequest, ExpireRequest, ExpireResponse, ExplorerSupportResponse, ExtendTimeoutBody, ExtendTimeoutData, ExtendTimeoutErrors, ExtendTimeoutResponse, ExtendTimeoutResponses, ExternalImageResponse, ExternalServiceBackupCapabilityResponse, ExternalServiceBackupResponse, ExternalServiceDetails, ExternalServiceEnablePgStatStatementsData, ExternalServiceEnablePgStatStatementsErrors, ExternalServiceEnablePgStatStatementsResponse, ExternalServiceEnablePgStatStatementsResponses, ExternalServiceInfo, ExternalServiceMetricsByDatabaseData, ExternalServiceMetricsByDatabaseErrors, ExternalServiceMetricsByDatabaseResponse, ExternalServiceMetricsByDatabaseResponses, ExternalServiceMetricsCreateAlertRuleData, ExternalServiceMetricsCreateAlertRuleErrors, ExternalServiceMetricsCreateAlertRuleResponse, ExternalServiceMetricsCreateAlertRuleResponses, ExternalServiceMetricsDeleteAlertRuleData, ExternalServiceMetricsDeleteAlertRuleErrors, ExternalServiceMetricsDeleteAlertRuleResponse, ExternalServiceMetricsDeleteAlertRuleResponses, ExternalServiceMetricsGetAlertRulesData, ExternalServiceMetricsGetAlertRulesErrors, ExternalServiceMetricsGetAlertRulesResponse, ExternalServiceMetricsGetAlertRulesResponses, ExternalServiceMetricsGetLatestData, ExternalServiceMetricsGetLatestErrors, ExternalServiceMetricsGetLatestResponse, ExternalServiceMetricsGetLatestResponses, ExternalServiceMetricsGetRangeData, ExternalServiceMetricsGetRangeErrors, ExternalServiceMetricsGetRangeResponse, ExternalServiceMetricsGetRangeResponses, ExternalServiceMetricsStatusData, ExternalServiceMetricsStatusErrors, ExternalServiceMetricsStatusResponse, ExternalServiceMetricsStatusResponses, ExternalServiceMetricsToggleData, ExternalServiceMetricsToggleErrors, ExternalServiceMetricsToggleResponses, ExternalServiceMetricsUpdateAlertRuleData, ExternalServiceMetricsUpdateAlertRuleErrors, ExternalServiceMetricsUpdateAlertRuleResponse, ExternalServiceMetricsUpdateAlertRuleResponses, ExternalServiceResetPgStatStatementsData, ExternalServiceResetPgStatStatementsErrors, ExternalServiceResetPgStatStatementsResponse, ExternalServiceResetPgStatStatementsResponses, ExternalServiceSummary, FacetBackendKind, FacetCapability, FacetInfo, FacetsResponse, FacetStatus, FailureReportPreviewResponse, FeatureMaturity, FieldResponse, FinalizeOrderData, FinalizeOrderErrors, FinalizeOrderResponse, FinalizeOrderResponses, FinalizeProjectReleaseData, FinalizeProjectReleaseErrors, FinalizeProjectReleaseResponse, FinalizeProjectReleaseResponses, FindConversationData, FindConversationErrors, FindConversationResponse, FindConversationResponses, FiringSeriesEntry, FlagEnvironmentResponse, FlagListResponse, FlagResponse, FlagSnapshot, FlagSnapshotResponse, FlagValueType, ForecastAlgorithm, ForecastParams, FullError, FullEvent, FullRequest, FunnelMetricsResponse, FunnelResponse, GatewayStatus, GenAiEvent, GenAiSpanDetail, GenAiTraceDetailResponse, GenAiTraceSummariesResponse, GenAiTraceSummary, GeneralStatsQuery, GeneralStatsResponse, GenerateDockerfileRequest, GenerateDockerfileResponse, GenerateJoinTokenData, GenerateJoinTokenErrors, GenerateJoinTokenResponse, GenerateJoinTokenResponse2, GenerateJoinTokenResponses, GeneratePresetDockerfileData, GeneratePresetDockerfileErrors, GeneratePresetDockerfileResponse, GeneratePresetDockerfileResponses, GeoLocationResponse, GeoRestrictionsConfig, GetAccessInfoData, GetAccessInfoErrors, GetAccessInfoResponse, GetAccessInfoResponses, GetActiveVisitorsData, GetActiveVisitorsErrors, GetActiveVisitorsResponse, GetActiveVisitorsResponses, GetActivityGraphData, GetActivityGraphError, GetActivityGraphErrors, GetActivityGraphResponse, GetActivityGraphResponses, GetAdminGateData, GetAdminGateErrors, GetAdminGateResponse, GetAdminGateResponses, GetAgentData, GetAgentErrors, GetAgentResponse, GetAgentResponses, GetAggregatedBucketsData, GetAggregatedBucketsErrors, GetAggregatedBucketsResponse, GetAggregatedBucketsResponses, GetAiAgentBreakdownData, GetAiAgentBreakdownError, GetAiAgentBreakdownErrors, GetAiAgentBreakdownResponse, GetAiAgentBreakdownResponses, GetAiAgentPagesData, GetAiAgentPagesError, GetAiAgentPagesErrors, GetAiAgentPagesResponse, GetAiAgentPagesResponses, GetAiAgentTimelineData, GetAiAgentTimelineError, GetAiAgentTimelineErrors, GetAiAgentTimelineResponse, GetAiAgentTimelineResponses, GetAiDataAccessData, GetAiDataAccessErrors, GetAiDataAccessResponse, GetAiDataAccessResponses, GetAiPageBreakdownData, GetAiPageBreakdownError, GetAiPageBreakdownErrors, GetAiPageBreakdownResponse, GetAiPageBreakdownResponses, GetAiProviderStatusData, GetAiProviderStatusError, GetAiProviderStatusErrors, GetAiProviderStatusResponse, GetAiProviderStatusResponses, GetAiStatusBreakdownData, GetAiStatusBreakdownError, GetAiStatusBreakdownErrors, GetAiStatusBreakdownResponse, GetAiStatusBreakdownResponses, GetAlertData, GetAlertError, GetAlertErrors, GetAlertResponse, GetAlertResponses, GetAlertRuleData, GetAlertRuleErrors, GetAlertRuleResponse, GetAlertRuleResponses, GetAllRepositoriesByNameData, GetAllRepositoriesByNameErrors, GetAllRepositoriesByNameResponse, GetAllRepositoriesByNameResponses, GetAnalyticsActiveVisitorsData, GetAnalyticsActiveVisitorsErrors, GetAnalyticsActiveVisitorsResponse, GetAnalyticsActiveVisitorsResponses, GetAnalyticsEventsCountData, GetAnalyticsEventsCountErrors, GetAnalyticsEventsCountResponse, GetAnalyticsEventsCountResponses, GetAnalyticsSessionEventsData, GetAnalyticsSessionEventsErrors, GetAnalyticsSessionEventsResponse, GetAnalyticsSessionEventsResponses, GetAnalyticsVisitorSessionsData, GetAnalyticsVisitorSessionsErrors, GetAnalyticsVisitorSessionsResponse, GetAnalyticsVisitorSessionsResponses, GetApiCallersData, GetApiCallersErrors, GetApiCallersResponse, GetApiCallersResponses, GetApiKeyData, GetApiKeyErrors, GetApiKeyPermissionsData, GetApiKeyPermissionsErrors, GetApiKeyPermissionsResponse, GetApiKeyPermissionsResponses, GetApiKeyResponse, GetApiKeyResponses, GetApiRoutesData, GetApiRoutesErrors, GetApiRoutesResponse, GetApiRoutesResponses, GetApiSummaryData, GetApiSummaryErrors, GetApiSummaryResponse, GetApiSummaryResponses, GetApiTimeseriesData, GetApiTimeseriesErrors, GetApiTimeseriesResponse, GetApiTimeseriesResponses, GetApiTrafficProxyLogAccessData, GetApiTrafficProxyLogAccessError, GetApiTrafficProxyLogAccessErrors, GetApiTrafficProxyLogAccessResponse, GetApiTrafficProxyLogAccessResponses, GetApplicationData, GetApplicationErrors, GetApplicationResponse, GetApplicationResponses, GetApplicationWorkspaceChangesData, GetApplicationWorkspaceChangesErrors, GetApplicationWorkspaceChangesResponse, GetApplicationWorkspaceChangesResponses, GetApplicationWorkspaceData, GetApplicationWorkspaceDiffData, GetApplicationWorkspaceDiffErrors, GetApplicationWorkspaceDiffResponse, GetApplicationWorkspaceDiffResponses, GetApplicationWorkspaceDirectoryData, GetApplicationWorkspaceDirectoryErrors, GetApplicationWorkspaceDirectoryResponse, GetApplicationWorkspaceDirectoryResponses, GetApplicationWorkspaceErrors, GetApplicationWorkspaceFileData, GetApplicationWorkspaceFileErrors, GetApplicationWorkspaceFileResponse, GetApplicationWorkspaceFileResponses, GetApplicationWorkspaceResponse, GetApplicationWorkspaceResponses, GetAuditLogData, GetAuditLogErrors, GetAuditLogResponse, GetAuditLogResponses, GetBackupData, GetBackupError, GetBackupErrors, GetBackupResponse, GetBackupResponses, GetBackupScheduleData, GetBackupScheduleError, GetBackupScheduleErrors, GetBackupScheduleResponse, GetBackupScheduleResponses, GetBranchesByRepositoryIdData, GetBranchesByRepositoryIdErrors, GetBranchesByRepositoryIdResponse, GetBranchesByRepositoryIdResponses, GetBucketedIncidentsData, GetBucketedIncidentsErrors, GetBucketedIncidentsResponse, GetBucketedIncidentsResponses, GetBucketedStatusData, GetBucketedStatusErrors, GetBucketedStatusResponse, GetBucketedStatusResponses, GetBulkActivationJobData, GetBulkActivationJobError, GetBulkActivationJobErrors, GetBulkActivationJobResponse, GetBulkActivationJobResponses, GetChallengeTokenData, GetChallengeTokenErrors, GetChallengeTokenResponse, GetChallengeTokenResponses, GetChatReadinessData, GetChatReadinessErrors, GetChatReadinessResponse, GetChatReadinessResponses, GetCliStatusData, GetCliStatusErrors, GetCliStatusResponses, GetCloudAiCapabilityData, GetCloudAiCapabilityResponse, GetCloudAiCapabilityResponses, GetCloudBackfillStatusData, GetCloudBackfillStatusError, GetCloudBackfillStatusErrors, GetCloudBackfillStatusResponse, GetCloudBackfillStatusResponses, GetCloudCapabilityData, GetCloudCapabilityResponse, GetCloudCapabilityResponses, GetCloudStatusData, GetCloudStatusResponse, GetCloudStatusResponses, GetCloudTelemetryStatusData, GetCloudTelemetryStatusError, GetCloudTelemetryStatusErrors, GetCloudTelemetryStatusResponse, GetCloudTelemetryStatusResponses, GetClusterHealthData, GetClusterHealthErrors, GetClusterHealthResponse, GetClusterHealthResponses, GetClusterMemberData, GetClusterMemberErrors, GetClusterMemberResponse, GetClusterMemberResponses, GetCmdData, GetCmdErrors, GetCmdResponse, GetCmdResponses, GetContainerDetailData, GetContainerDetailErrors, GetContainerDetailResponse, GetContainerDetailResponses, GetContainerEnvironmentVariableData, GetContainerEnvironmentVariableErrors, GetContainerEnvironmentVariableResponse, GetContainerEnvironmentVariableResponses, GetContainerLogsByIdData, GetContainerLogsByIdErrors, GetContainerLogsData, GetContainerLogsErrors, GetContainerMetricsData, GetContainerMetricsErrors, GetContainerMetricsResponse, GetContainerMetricsResponses, GetConversationData, GetConversationDetailData, GetConversationDetailError, GetConversationDetailErrors, GetConversationDetailResponse, GetConversationDetailResponses, GetConversationErrors, GetConversationResponse, GetConversationResponses, GetConversationsData, GetConversationsError, GetConversationsErrors, GetConversationsResponse, GetConversationsResponses, GetCronByIdData, GetCronByIdErrors, GetCronByIdResponse, GetCronByIdResponses, GetCronExecutionsData, GetCronExecutionsErrors, GetCronExecutionsResponse, GetCronExecutionsResponses, GetCrossProjectTraceSiblingsData, GetCrossProjectTraceSiblingsError, GetCrossProjectTraceSiblingsErrors, GetCrossProjectTraceSiblingsResponse, GetCrossProjectTraceSiblingsResponses, GetCurrentBulkActivationJobData, GetCurrentBulkActivationJobError, GetCurrentBulkActivationJobErrors, GetCurrentBulkActivationJobResponse, GetCurrentBulkActivationJobResponses, GetCurrentMonitorStatusData, GetCurrentMonitorStatusErrors, GetCurrentMonitorStatusResponse, GetCurrentMonitorStatusResponses, GetCurrentUserData, GetCurrentUserErrors, GetCurrentUserResponse, GetCurrentUserResponses, GetCustomDomainData, GetCustomDomainErrors, GetCustomDomainResponse, GetCustomDomainResponses, GetDashboardData, GetDashboardError, GetDashboardErrors, GetDashboardProjectsAnalyticsData, GetDashboardProjectsAnalyticsErrors, GetDashboardProjectsAnalyticsResponse, GetDashboardProjectsAnalyticsResponses, GetDashboardResponse, GetDashboardResponses, GetDeliveryData, GetDeliveryErrors, GetDeliveryResponse, GetDeliveryResponses, GetDeploymentContainerLogContentData, GetDeploymentContainerLogContentErrors, GetDeploymentContainerLogContentResponse, GetDeploymentContainerLogContentResponses, GetDeploymentData, GetDeploymentErrors, GetDeploymentJobLogsData, GetDeploymentJobLogsErrors, GetDeploymentJobLogsResponse, GetDeploymentJobLogsResponses, GetDeploymentJobsData, GetDeploymentJobsErrors, GetDeploymentJobsResponse, GetDeploymentJobsResponses, GetDeploymentOperationsData, GetDeploymentOperationsErrors, GetDeploymentOperationsResponse, GetDeploymentOperationsResponses, GetDeploymentOperationStatusData, GetDeploymentOperationStatusErrors, GetDeploymentOperationStatusResponse, GetDeploymentOperationStatusResponses, GetDeploymentResponse, GetDeploymentResponses, GetDeploymentsParams, GetDeploymentTokenData, GetDeploymentTokenErrors, GetDeploymentTokenResponse, GetDeploymentTokenResponses, GetDiskStatusData, GetDiskStatusErrors, GetDiskStatusResponse, GetDiskStatusResponses, GetDnsChangesData, GetDnsChangesErrors, GetDnsChangesResponse, GetDnsChangesResponses, GetDnsProviderData, GetDnsProviderErrors, GetDnsProviderResponse, GetDnsProviderResponses, GetDomainByHostData, GetDomainByHostErrors, GetDomainByHostResponse, GetDomainByHostResponses, GetDomainByIdData, GetDomainByIdErrors, GetDomainByIdResponse, GetDomainByIdResponses, GetDomainByNameData, GetDomainByNameErrors, GetDomainByNameResponse, GetDomainByNameResponses, GetDomainData, GetDomainDnsRecordsData, GetDomainDnsRecordsErrors, GetDomainDnsRecordsResponse, GetDomainDnsRecordsResponses, GetDomainErrors, GetDomainOrderData, GetDomainOrderErrors, GetDomainOrderResponse, GetDomainOrderResponses, GetDomainResponse, GetDomainResponses, GetEmailData, GetEmailErrors, GetEmailEventsData, GetEmailEventsErrors, GetEmailEventsResponse, GetEmailEventsResponses, GetEmailLinksData, GetEmailLinksErrors, GetEmailLinksResponse, GetEmailLinksResponses, GetEmailProviderData, GetEmailProviderErrors, GetEmailProviderResponse, GetEmailProviderResponses, GetEmailResponse, GetEmailResponses, GetEmailStatsData, GetEmailStatsErrors, GetEmailStatsResponse, GetEmailStatsResponses, GetEmailTrackingData, GetEmailTrackingErrors, GetEmailTrackingResponse, GetEmailTrackingResponses, GetEmailTrackingStatusData, GetEmailTrackingStatusErrors, GetEmailTrackingStatusResponse, GetEmailTrackingStatusResponses, GetEntityInfoData, GetEntityInfoErrors, GetEntityInfoResponse, GetEntityInfoResponses, GetEnvironmentCronsData, GetEnvironmentCronsErrors, GetEnvironmentCronsResponse, GetEnvironmentCronsResponses, GetEnvironmentData, GetEnvironmentDomainsData, GetEnvironmentDomainsErrors, GetEnvironmentDomainsResponse, GetEnvironmentDomainsResponses, GetEnvironmentErrors, GetEnvironmentResponse, GetEnvironmentResponses, GetEnvironmentsData, GetEnvironmentsErrors, GetEnvironmentsResponse, GetEnvironmentsResponses, GetEnvironmentVariablesData, GetEnvironmentVariablesErrors, GetEnvironmentVariablesQuery, GetEnvironmentVariablesResponse, GetEnvironmentVariablesResponses, GetEnvironmentVariableValueData, GetEnvironmentVariableValueErrors, GetEnvironmentVariableValueResponse, GetEnvironmentVariableValueResponses, GetErrorDashboardStatsData, GetErrorDashboardStatsErrors, GetErrorDashboardStatsResponse, GetErrorDashboardStatsResponses, GetErrorEventData, GetErrorEventErrors, GetErrorEventResponse, GetErrorEventResponses, GetErrorGroupData, GetErrorGroupErrors, GetErrorGroupResponse, GetErrorGroupResponses, GetErrorStatsData, GetErrorStatsErrors, GetErrorStatsResponse, GetErrorStatsResponses, GetErrorTimeSeriesData, GetErrorTimeSeriesErrors, GetErrorTimeSeriesResponse, GetErrorTimeSeriesResponses, GetEventDetailData, GetEventDetailErrors, GetEventDetailResponse, GetEventDetailResponses, GetEventEntriesData, GetEventEntriesErrors, GetEventEntriesResponse, GetEventEntriesResponses, GetEventsCountData, GetEventsCountErrors, GetEventsCountResponse, GetEventsCountResponses, GetEventsTimelineData, GetEventsTimelineErrors, GetEventsTimelineResponse, GetEventsTimelineResponses, GetEventTypeBreakdownData, GetEventTypeBreakdownErrors, GetEventTypeBreakdownResponse, GetEventTypeBreakdownResponses, GetEventVisitorsData, GetEventVisitorsErrors, GetEventVisitorsResponse, GetEventVisitorsResponses, GetExternalImageData, GetExternalImageErrors, GetExternalImageResponse, GetExternalImageResponses, GetExternalServiceBackupCapabilityData, GetExternalServiceBackupCapabilityError, GetExternalServiceBackupCapabilityErrors, GetExternalServiceBackupCapabilityResponse, GetExternalServiceBackupCapabilityResponses, GetFailureReportPreviewData, GetFailureReportPreviewErrors, GetFailureReportPreviewResponse, GetFailureReportPreviewResponses, GetFeatureMaturityData, GetFeatureMaturityErrors, GetFeatureMaturityResponse, GetFeatureMaturityResponses, GetFileData, GetFileErrors, GetFileResponse, GetFileResponses, GetFlagData, GetFlagErrors, GetFlagResponse, GetFlagResponses, GetFlagSnapshotData, GetFlagSnapshotErrors, GetFlagSnapshotResponse, GetFlagSnapshotResponses, GetFunnelMetricsData, GetFunnelMetricsErrors, GetFunnelMetricsQuery, GetFunnelMetricsResponse, GetFunnelMetricsResponses, GetGenaiTraceData, GetGenaiTraceError, GetGenaiTraceErrors, GetGenaiTraceResponse, GetGenaiTraceResponses, GetGeneralStatsData, GetGeneralStatsErrors, GetGeneralStatsResponse, GetGeneralStatsResponses, GetGitProviderData, GetGitProviderErrors, GetGitProviderResponse, GetGitProviderResponses, GetGlobalAiWorkspaceData, GetGlobalAiWorkspaceErrors, GetGlobalAiWorkspaceResponse, GetGlobalAiWorkspaceResponses, GetGlobalEventsData, GetGlobalEventsErrors, GetGlobalEventsResponse, GetGlobalEventsResponses, GetGlobalEventStatsData, GetGlobalEventStatsErrors, GetGlobalEventStatsResponse, GetGlobalEventStatsResponses, GetGlobalMcpData, GetGlobalMcpErrors, GetGlobalMcpResponse, GetGlobalMcpResponses, GetGlobalSandboxStatusData, GetGlobalSandboxStatusErrors, GetGlobalSandboxStatusResponse, GetGlobalSandboxStatusResponses, GetGlobalSkillData, GetGlobalSkillErrors, GetGlobalSkillResponse, GetGlobalSkillResponses, GetGlobalWorkspaceChangesData, GetGlobalWorkspaceChangesErrors, GetGlobalWorkspaceChangesResponse, GetGlobalWorkspaceChangesResponses, GetGlobalWorkspaceDiffData, GetGlobalWorkspaceDiffErrors, GetGlobalWorkspaceDiffResponse, GetGlobalWorkspaceDiffResponses, GetGlobalWorkspaceDirectoryData, GetGlobalWorkspaceDirectoryErrors, GetGlobalWorkspaceDirectoryResponse, GetGlobalWorkspaceDirectoryResponses, GetGlobalWorkspaceFileData, GetGlobalWorkspaceFileErrors, GetGlobalWorkspaceFileResponse, GetGlobalWorkspaceFileResponses, GetGroupedPageMetricsData, GetGroupedPageMetricsError, GetGroupedPageMetricsErrors, GetGroupedPageMetricsResponse, GetGroupedPageMetricsResponses, GetHealthData, GetHealthError, GetHealthErrors, GetHealthResponse, GetHealthResponses, GetHourlyVisitsData, GetHourlyVisitsErrors, GetHourlyVisitsResponse, GetHourlyVisitsResponses, GetHttpChallengeDebugData, GetHttpChallengeDebugErrors, GetHttpChallengeDebugResponse, GetHttpChallengeDebugResponses, GetImportStatusData, GetImportStatusErrors, GetImportStatusResponse, GetImportStatusResponses, GetIncidentData, GetIncidentErrors, GetIncidentResponse, GetIncidentResponses, GetIncidentUpdatesData, GetIncidentUpdatesErrors, GetIncidentUpdatesResponse, GetIncidentUpdatesResponses, GetIngestErrorsData, GetIngestErrorsError, GetIngestErrorsErrors, GetIngestErrorsResponse, GetIngestErrorsResponses, GetIpAccessControlData, GetIpAccessControlError, GetIpAccessControlErrors, GetIpAccessControlResponse, GetIpAccessControlResponses, GetIpGeolocationData, GetIpGeolocationError, GetIpGeolocationErrors, GetIpGeolocationResponse, GetIpGeolocationResponses, GetJoinTokenStatusData, GetJoinTokenStatusErrors, GetJoinTokenStatusResponse, GetJoinTokenStatusResponses, GetLastDeploymentData, GetLastDeploymentErrors, GetLastDeploymentResponse, GetLastDeploymentResponses, GetLatestDeploymentMediaData, GetLatestDeploymentMediaError, GetLatestDeploymentMediaErrors, GetLatestDeploymentMediaResponse, GetLatestDeploymentMediaResponses, GetLatestScanData, GetLatestScanError, GetLatestScanErrors, GetLatestScanResponse, GetLatestScanResponses, GetLatestScansPerEnvironmentData, GetLatestScansPerEnvironmentError, GetLatestScansPerEnvironmentErrors, GetLatestScansPerEnvironmentResponse, GetLatestScansPerEnvironmentResponses, GetLiveVisitorsListData, GetLiveVisitorsListErrors, GetLiveVisitorsListResponse, GetLiveVisitorsListResponses, GetLogContextData, GetLogContextError, GetLogContextErrors, GetLogContextResponse, GetLogContextResponses, GetMcpData, GetMcpErrors, GetMcpResponse, GetMcpResponses, GetMetricsOverTimeData, GetMetricsOverTimeError, GetMetricsOverTimeErrors, GetMetricsOverTimeResponse, GetMetricsOverTimeResponses, GetMonitorData, GetMonitorErrors, GetMonitorResponse, GetMonitorResponses, GetNotificationProviderData, GetNotificationProviderErrors, GetNotificationProviderResponse, GetNotificationProviderResponses, GetNotificationRouteData, GetNotificationRouteErrors, GetNotificationRouteResponse, GetNotificationRouteResponses, GetOnDemandCertStatusData, GetOnDemandCertStatusErrors, GetOnDemandCertStatusResponse, GetOnDemandCertStatusResponses, GetOrCreateDsnData, GetOrCreateDsnErrors, GetOrCreateDsnRequest, GetOrCreateDsnResponse, GetOrCreateDsnResponses, GetPageFlowData, GetPageFlowErrors, GetPageFlowResponse, GetPageFlowResponses, GetPageHourlySessionsData, GetPageHourlySessionsErrors, GetPageHourlySessionsResponse, GetPageHourlySessionsResponses, GetPagePathDetailData, GetPagePathDetailErrors, GetPagePathDetailResponse, GetPagePathDetailResponses, GetPagePathsData, GetPagePathsErrors, GetPagePathsResponse, GetPagePathsResponses, GetPagePathsSparklinesData, GetPagePathsSparklinesErrors, GetPagePathsSparklinesResponse, GetPagePathsSparklinesResponses, GetPagePathVisitorsData, GetPagePathVisitorsErrors, GetPagePathVisitorsResponse, GetPagePathVisitorsResponses, GetPendingActionData, GetPendingActionErrors, GetPendingActionResponse, GetPendingActionResponses, GetPerformanceMetricsData, GetPerformanceMetricsError, GetPerformanceMetricsErrors, GetPerformanceMetricsResponse, GetPerformanceMetricsResponses, GetPgUpgradeData, GetPgUpgradeError, GetPgUpgradeErrors, GetPgUpgradeLogsData, GetPgUpgradeLogsError, GetPgUpgradeLogsErrors, GetPgUpgradeLogsResponse, GetPgUpgradeLogsResponses, GetPgUpgradeResponse, GetPgUpgradeResponses, GetPipelineHistoryData, GetPipelineHistoryError, GetPipelineHistoryErrors, GetPipelineHistoryResponse, GetPipelineHistoryResponses, GetPipelineStatsData, GetPipelineStatsError, GetPipelineStatsErrors, GetPipelineStatsResponse, GetPipelineStatsResponses, GetPlatformInfoData, GetPlatformInfoErrors, GetPlatformInfoResponse, GetPlatformInfoResponses, GetPostgresWalHealthData, GetPostgresWalHealthErrors, GetPostgresWalHealthResponse, GetPostgresWalHealthResponses, GetPreferencesData, GetPreferencesErrors, GetPreferencesResponse, GetPreferencesResponses, GetPreviewGatewayLogsData, GetPreviewGatewayLogsError, GetPreviewGatewayLogsErrors, GetPreviewGatewayLogsResponse, GetPreviewGatewayLogsResponses, GetPreviewGatewaySettingsData, GetPreviewGatewaySettingsResponse, GetPreviewGatewaySettingsResponses, GetPreviewGatewayStatusData, GetPreviewGatewayStatusError, GetPreviewGatewayStatusErrors, GetPreviewGatewayStatusResponse, GetPreviewGatewayStatusResponses, GetPricingData, GetPricingError, GetPricingErrors, GetPricingResponse, GetPricingResponses, GetPrivateIpData, GetPrivateIpErrors, GetPrivateIpResponses, GetProjectAlarmsSummaryData, GetProjectAlarmsSummaryErrors, GetProjectAlarmsSummaryResponse, GetProjectAlarmsSummaryResponses, GetProjectBySlugData, GetProjectBySlugErrors, GetProjectBySlugResponse, GetProjectBySlugResponses, GetProjectCloudTelemetryData, GetProjectCloudTelemetryError, GetProjectCloudTelemetryErrors, GetProjectCloudTelemetryResponse, GetProjectCloudTelemetryResponses, GetProjectData, GetProjectDeploymentsData, GetProjectDeploymentsErrors, GetProjectDeploymentsResponse, GetProjectDeploymentsResponses, GetProjectErrors, GetProjectResponse, GetProjectResponses, GetProjectsData, GetProjectSecretsQuery, GetProjectsErrors, GetProjectServiceEnvironmentVariablesData, GetProjectServiceEnvironmentVariablesErrors, GetProjectServiceEnvironmentVariablesResponse, GetProjectServiceEnvironmentVariablesResponses, GetProjectServiceTemplateData, GetProjectServiceTemplateErrors, GetProjectServiceTemplateResponse, GetProjectServiceTemplateResponses, GetProjectSessionReplaysData, GetProjectSessionReplaysError, GetProjectSessionReplaysErrors, GetProjectSessionReplaysQuery, GetProjectSessionReplaysResponse, GetProjectSessionReplaysResponse2, GetProjectSessionReplaysResponses, GetProjectsHealthData, GetProjectsHealthError, GetProjectsHealthErrors, GetProjectsHealthResponse, GetProjectsHealthResponses, GetProjectsMonitorHealthData, GetProjectsMonitorHealthErrors, GetProjectsMonitorHealthResponse, GetProjectsMonitorHealthResponses, GetProjectsResponse, GetProjectsResponses, GetProjectStatisticsData, GetProjectStatisticsErrors, GetProjectStatisticsResponse, GetProjectStatisticsResponses, GetProjectTemplateData, GetProjectTemplateErrors, GetProjectTemplateResponse, GetProjectTemplateResponses, GetPropertyBreakdownData, GetPropertyBreakdownErrors, GetPropertyBreakdownResponse, GetPropertyBreakdownResponses, GetPropertyTimelineData, GetPropertyTimelineErrors, GetPropertyTimelineResponse, GetPropertyTimelineResponses, GetProviderConnectionsData, GetProviderConnectionsErrors, GetProviderConnectionsResponse, GetProviderConnectionsResponses, GetProviderKeyData, GetProviderKeyError, GetProviderKeyErrors, GetProviderKeyResponse, GetProviderKeyResponses, GetProviderMetadataData, GetProviderMetadataErrors, GetProviderMetadataResponse, GetProviderMetadataResponses, GetProvidersMetadataData, GetProvidersMetadataErrors, GetProvidersMetadataResponse, GetProvidersMetadataResponses, GetProxyLogByIdData, GetProxyLogByIdError, GetProxyLogByIdErrors, GetProxyLogByIdResponse, GetProxyLogByIdResponses, GetProxyLogByRequestIdData, GetProxyLogByRequestIdError, GetProxyLogByRequestIdErrors, GetProxyLogByRequestIdResponse, GetProxyLogByRequestIdResponses, GetProxyLogsData, GetProxyLogsError, GetProxyLogsErrors, GetProxyLogsResponse, GetProxyLogsResponses, GetPublicBranchesData, GetPublicBranchesErrors, GetPublicBranchesResponse, GetPublicBranchesResponses, GetPublicComposePreviewData, GetPublicComposePreviewErrors, GetPublicComposePreviewResponse, GetPublicComposePreviewResponses, GetPublicComposeServicesData, GetPublicComposeServicesErrors, GetPublicComposeServicesResponse, GetPublicComposeServicesResponses, GetPublicIpData, GetPublicIpErrors, GetPublicIpResponses, GetPublicRepositoryData, GetPublicRepositoryErrors, GetPublicRepositoryResponse, GetPublicRepositoryResponses, GetQueryContainerInfoData, GetQueryContainerInfoErrors, GetQueryContainerInfoResponse, GetQueryContainerInfoResponses, GetQuotaData, GetQuotaError, GetQuotaErrors, GetQuotaResponse, GetQuotaResponses, GetRecentActivityData, GetRecentActivityErrors, GetRecentActivityResponse, GetRecentActivityResponses, GetRemoteExternalImageData, GetRemoteExternalImageErrors, GetRemoteExternalImageResponse, GetRemoteExternalImageResponses, GetRepositoryBranchesData, GetRepositoryBranchesErrors, GetRepositoryBranchesResponse, GetRepositoryBranchesResponses, GetRepositoryByIdData, GetRepositoryByIdErrors, GetRepositoryByIdResponse, GetRepositoryByIdResponses, GetRepositoryByNameData, GetRepositoryByNameErrors, GetRepositoryByNameResponse, GetRepositoryByNameResponses, GetRepositoryComposePreviewData, GetRepositoryComposePreviewErrors, GetRepositoryComposePreviewResponse, GetRepositoryComposePreviewResponses, GetRepositoryComposeServicesLiveData, GetRepositoryComposeServicesLiveErrors, GetRepositoryComposeServicesLiveResponse, GetRepositoryComposeServicesLiveResponses, GetRepositoryEnvExampleLiveData, GetRepositoryEnvExampleLiveErrors, GetRepositoryEnvExampleLiveResponse, GetRepositoryEnvExampleLiveResponses, GetRepositoryPresetByNameData, GetRepositoryPresetByNameErrors, GetRepositoryPresetByNameResponse, GetRepositoryPresetByNameResponses, GetRepositoryPresetLiveData, GetRepositoryPresetLiveErrors, GetRepositoryPresetLiveResponse, GetRepositoryPresetLiveResponses, GetRepositoryTagsData, GetRepositoryTagsErrors, GetRepositoryTagsResponse, GetRepositoryTagsResponses, GetRequest, GetResolvedEnvironmentVariablesData, GetResolvedEnvironmentVariablesErrors, GetResolvedEnvironmentVariablesResponse, GetResolvedEnvironmentVariablesResponses, GetResolvedEnvironmentVariableValueData, GetResolvedEnvironmentVariableValueErrors, GetResolvedEnvironmentVariableValueResponse, GetResolvedEnvironmentVariableValueResponses, GetResponse, GetRestoreCapabilitiesData, GetRestoreCapabilitiesError, GetRestoreCapabilitiesErrors, GetRestoreCapabilitiesResponse, GetRestoreCapabilitiesResponses, GetRestoreRunData, GetRestoreRunError, GetRestoreRunErrors, GetRestoreRunResponse, GetRestoreRunResponses, GetRouteData, GetRouteErrors, GetRouteResponse, GetRouteResponses, GetRunData, GetRunErrors, GetRunResponse, GetRunResponses, GetRunWithLogsData, GetRunWithLogsErrors, GetRunWithLogsResponse, GetRunWithLogsResponses, GetS3CredentialsData, GetS3CredentialsErrors, GetS3CredentialsResponse, GetS3CredentialsResponses, GetS3SourceData, GetS3SourceError, GetS3SourceErrors, GetS3SourceResponse, GetS3SourceResponses, GetSandboxData, GetSandboxErrors, GetSandboxResponse, GetSandboxResponses, GetSandboxStatusData, GetSandboxStatusErrors, GetSandboxStatusResponse, GetSandboxStatusResponses, GetScanByDeploymentData, GetScanByDeploymentError, GetScanByDeploymentErrors, GetScanByDeploymentResponse, GetScanByDeploymentResponses, GetScanData, GetScanError, GetScanErrors, GetScanResponse, GetScanResponses, GetScanVulnerabilitiesData, GetScanVulnerabilitiesError, GetScanVulnerabilitiesErrors, GetScanVulnerabilitiesResponse, GetScanVulnerabilitiesResponses, GetServiceBySlugData, GetServiceBySlugErrors, GetServiceBySlugResponse, GetServiceBySlugResponses, GetServiceData, GetServiceEnvironmentVariableData, GetServiceEnvironmentVariableErrors, GetServiceEnvironmentVariableResponse, GetServiceEnvironmentVariableResponses, GetServiceEnvironmentVariablesData, GetServiceEnvironmentVariablesErrors, GetServiceEnvironmentVariablesResponse, GetServiceEnvironmentVariablesResponses, GetServiceErrors, GetServiceHealthStatusData, GetServiceHealthStatusErrors, GetServiceHealthStatusResponse, GetServiceHealthStatusResponses, GetServicePreviewEnvironmentVariableNamesData, GetServicePreviewEnvironmentVariableNamesErrors, GetServicePreviewEnvironmentVariableNamesResponse, GetServicePreviewEnvironmentVariableNamesResponses, GetServicePreviewEnvironmentVariablesMaskedData, GetServicePreviewEnvironmentVariablesMaskedErrors, GetServicePreviewEnvironmentVariablesMaskedResponse, GetServicePreviewEnvironmentVariablesMaskedResponses, GetServiceResponse, GetServiceResponses, GetServiceRuntimeData, GetServiceRuntimeErrors, GetServiceRuntimeResponse, GetServiceRuntimeResponses, GetServiceStatsData, GetServiceStatsErrors, GetServiceStatsResponse, GetServiceStatsResponses, GetServiceTypeParametersData, GetServiceTypeParametersErrors, GetServiceTypeParametersResponses, GetServiceTypesData, GetServiceTypesErrors, GetServiceTypesResponse, GetServiceTypesResponses, GetSessionDetailsData, GetSessionDetailsErrors, GetSessionDetailsResponse, GetSessionDetailsResponses, GetSessionEventsData, GetSessionEventsErrors, GetSessionEventsResponse, GetSessionEventsResponses, GetSessionLogsData, GetSessionLogsErrors, GetSessionLogsResponse, GetSessionLogsResponses, GetSessionReplayData, GetSessionReplayError, GetSessionReplayErrors, GetSessionReplayEventsData, GetSessionReplayEventsError, GetSessionReplayEventsErrors, GetSessionReplayEventsResponse, GetSessionReplayEventsResponses, GetSessionReplayResponse, GetSessionReplayResponse2, GetSessionReplayResponses, GetSettingsData, GetSettingsErrors, GetSettingsResponse, GetSettingsResponses, GetSkillData, GetSkillErrors, GetSkillResponse, GetSkillResponses, GetSlowQueriesData, GetSlowQueriesErrors, GetSlowQueriesResponse, GetSlowQueriesResponses, GetSnapshotData, GetSnapshotErrors, GetSnapshotResponse, GetSnapshotResponses, GetStaticBundleData, GetStaticBundleErrors, GetStaticBundleResponse, GetStaticBundleResponses, GetStatusOverviewData, GetStatusOverviewErrors, GetStatusOverviewResponse, GetStatusOverviewResponses, GetSystemAlarmsSummaryData, GetSystemAlarmsSummaryErrors, GetSystemAlarmsSummaryResponse, GetSystemAlarmsSummaryResponses, GetTagsByRepositoryIdData, GetTagsByRepositoryIdErrors, GetTagsByRepositoryIdResponse, GetTagsByRepositoryIdResponses, GetTeamData, GetTeamErrors, GetTeamResponse, GetTeamResponses, GetTimeBucketStatsData, GetTimeBucketStatsError, GetTimeBucketStatsErrors, GetTimeBucketStatsResponse, GetTimeBucketStatsResponses, GetTodayStatsData, GetTodayStatsError, GetTodayStatsErrors, GetTodayStatsResponse, GetTodayStatsResponses, GetTraceData, GetTraceError, GetTraceErrors, GetTraceResponse, GetTraceResponses, GetTraefikDiscoveryStatusData, GetTraefikDiscoveryStatusError, GetTraefikDiscoveryStatusErrors, GetTraefikDiscoveryStatusResponse, GetTraefikDiscoveryStatusResponses, GetUnifiedTraceData, GetUnifiedTraceError, GetUnifiedTraceErrors, GetUnifiedTraceResponse, GetUnifiedTraceResponses, GetUniqueCountsData, GetUniqueCountsErrors, GetUniqueCountsResponse, GetUniqueCountsResponses, GetUniqueEventsData, GetUniqueEventsErrors, GetUniqueEventsQuery, GetUniqueEventsResponse, GetUniqueEventsResponses, GetUpdateCapabilityData, GetUpdateCapabilityErrors, GetUpdateCapabilityResponse, GetUpdateCapabilityResponses, GetUpdateStatusData, GetUpdateStatusErrors, GetUpdateStatusResponse, GetUpdateStatusResponses, GetUptimeHistoryData, GetUptimeHistoryErrors, GetUptimeHistoryResponse, GetUptimeHistoryResponses, GetUsageByProviderData, GetUsageByProviderError, GetUsageByProviderErrors, GetUsageByProviderResponse, GetUsageByProviderResponses, GetUsageRecentData, GetUsageRecentError, GetUsageRecentErrors, GetUsageRecentResponse, GetUsageRecentResponses, GetUsageSummaryData, GetUsageSummaryError, GetUsageSummaryErrors, GetUsageSummaryResponse, GetUsageSummaryResponses, GetUsageTimeseriesData, GetUsageTimeseriesError, GetUsageTimeseriesErrors, GetUsageTimeseriesResponse, GetUsageTimeseriesResponses, GetUsageTopModelsData, GetUsageTopModelsError, GetUsageTopModelsErrors, GetUsageTopModelsResponse, GetUsageTopModelsResponses, GetUserConversationAttachmentData, GetUserConversationAttachmentErrors, GetUserConversationAttachmentResponse, GetUserConversationAttachmentResponses, GetUserConversationData, GetUserConversationErrors, GetUserConversationResponse, GetUserConversationResponses, GetUserPendingActionData, GetUserPendingActionErrors, GetUserPendingActionResponse, GetUserPendingActionResponses, GetVisibleCustomDomainByHostnameData, GetVisibleCustomDomainByHostnameErrors, GetVisibleCustomDomainByHostnameResponse, GetVisibleCustomDomainByHostnameResponses, GetVisitorByGuidData, GetVisitorByGuidErrors, GetVisitorByGuidResponse, GetVisitorByGuidResponses, GetVisitorByIdData, GetVisitorByIdErrors, GetVisitorByIdResponse, GetVisitorByIdResponses, GetVisitorDetailsData, GetVisitorDetailsErrors, GetVisitorDetailsResponse, GetVisitorDetailsResponses, GetVisitorFacetsData, GetVisitorFacetsErrors, GetVisitorFacetsResponse, GetVisitorFacetsResponses, GetVisitorInfoData, GetVisitorInfoErrors, GetVisitorInfoResponse, GetVisitorInfoResponses, GetVisitorJourneyData, GetVisitorJourneyErrors, GetVisitorJourneyResponse, GetVisitorJourneyResponses, GetVisitorsData, GetVisitorsErrors, GetVisitorSessionsData, GetVisitorSessionsError, GetVisitorSessionsErrors, GetVisitorSessionsQuery, GetVisitorSessionsResponse, GetVisitorSessionsResponse2, GetVisitorSessionsResponses, GetVisitorsResponse, GetVisitorsResponses, GetVisitorStatsData, GetVisitorStatsErrors, GetVisitorStatsResponse, GetVisitorStatsResponses, GetWebhookData, GetWebhookErrors, GetWebhookResponse, GetWebhookResponses, GetWorkspaceFileLimitsData, GetWorkspaceFileLimitsErrors, GetWorkspaceFileLimitsResponse, GetWorkspaceFileLimitsResponses, GitPushEvent, GitRef, GitRefResponse, GitSourcePlan, GlobalConversationResponse, GlobalEventStatsResponse, GlobalMrrResponse, GlobalRecentEventResponse, GlobalRevenueSummaryResponse, GrantProjectAccessData, GrantProjectAccessErrors, GrantProjectAccessResponse, GrantProjectAccessResponses, GroupedPageMetric, GroupedPageMetricsQuery, GroupedPageMetricsResponse, HandleGitProviderOauthCallbackData, HandleGitProviderOauthCallbackErrors, HasAnalyticsEventsData, HasAnalyticsEventsErrors, HasAnalyticsEventsResponse, HasAnalyticsEventsResponse2, HasAnalyticsEventsResponses, HasErrorGroupsData, HasErrorGroupsErrors, HasErrorGroupsResponse, HasErrorGroupsResponse2, HasErrorGroupsResponses, HasEventsQuery, HasEventsResponse, HasMetricsQuery, HasMetricsResponse, HasPerformanceMetricsData, HasPerformanceMetricsError, HasPerformanceMetricsErrors, HasPerformanceMetricsResponse, HasPerformanceMetricsResponses, HasTracesData, HasTracesError, HasTracesErrors, HasTracesResponse, HasTracesResponse2, HasTracesResponses, HealthCheckConfiguration, HealthCheckEntryResponse, HealthResponse, HealthStatus, HealthSummary, HeartbeatApiRequest, HeartbeatResponse, HierarchyLevel, HistogramSummary, HostnameChange, HostnamePreviewResponse, HourlyPageSessions, HourlyVisitsQuery, HttpChallengeDebugResponse, ImageRetentionSettings, ImageRuntimeConfig, ImportApplicationWorkspaceGitData, ImportApplicationWorkspaceGitErrors, ImportApplicationWorkspaceGitRequest, ImportApplicationWorkspaceGitResponse, ImportApplicationWorkspaceGitResponses, ImportCredentials, ImportedHostVerdict, ImportEmailDomainData, ImportEmailDomainErrors, ImportEmailDomainRequest, ImportEmailDomainResponse, ImportEmailDomainResponses, ImportExecutionStatus, ImportExternalServiceData, ImportExternalServiceErrors, ImportExternalServiceRequest, ImportExternalServiceResponse, ImportExternalServiceResponses, ImportOutcomeResponse, ImportPlan, ImportRowErrorResponse, ImportSelector, ImportSource, ImportSourceCapabilities, ImportSourceInfo, ImportStatusResponse, ImportTraefikAcmeJsonData, ImportTraefikAcmeJsonError, ImportTraefikAcmeJsonErrors, ImportTraefikAcmeJsonRequest, ImportTraefikAcmeJsonResponse, ImportTraefikAcmeJsonResponse2, ImportTraefikAcmeJsonResponses, IncidentBucket, IncidentBucketedResponse, IncidentResponse, IncidentUpdateResponse, IncrRequest, IncrResponse, IngestErrorsResponse, IngestErrorSummary, IngestLogsByPathData, IngestLogsByPathError, IngestLogsByPathErrors, IngestLogsByPathResponses, IngestLogsData, IngestLogsError, IngestLogsErrors, IngestLogsResponses, IngestMetricsByPathData, IngestMetricsByPathError, IngestMetricsByPathErrors, IngestMetricsByPathResponses, IngestMetricsData, IngestMetricsError, IngestMetricsErrors, IngestMetricsResponses, IngestSentryEnvelopeData, IngestSentryEnvelopeErrors, IngestSentryEnvelopeResponses, IngestSentryEventData, IngestSentryEventErrors, IngestSentryEventResponse, IngestSentryEventResponses, IngestTracesByPathData, IngestTracesByPathError, IngestTracesByPathErrors, IngestTracesByPathResponses, IngestTracesData, IngestTracesError, IngestTracesErrors, IngestTracesResponses, IngestTunneledEnvelopeData, IngestTunneledEnvelopeErrors, IngestTunneledEnvelopeResponse, IngestTunneledEnvelopeResponses, InitAuthResponse, InitSessionReplayData, InitSessionReplayError, InitSessionReplayErrors, InitSessionReplayResponse, InitSessionReplayResponses, Insight, InsightSeverity, InsightsResponse, InsightStatus, InspectDropArchiveData, InspectDropArchiveErrors, InspectDropArchiveResponse, InspectDropArchiveResponses, IntegrationResponse, IpAccessControlQuery, IpAccessControlResponse, IssueRuntimeCredentialsData, IssueRuntimeCredentialsErrors, IssueRuntimeCredentialsResponse, IssueRuntimeCredentialsResponses, JobLogsData, JobLogsErrors, JobLogsResponses, JobStatusData, JobStatusErrors, JobStatusResponse, JobStatusResponse2, JobStatusResponses, JobSummaryResponse, JoinTokenStatusResponse, JourneyEvent, JourneySession, KeysRequest, KeysResponse, KillJobBody, KillJobData, KillJobErrors, KillJobResponse, KillJobResponses, KnownAiAgentsResponse, KvDelData, KvDelErrors, KvDelResponse, KvDelResponses, KvDisableData, KvDisableErrors, KvDisableResponse, KvDisableResponses, KvEnableData, KvEnableErrors, KvEnableResponse, KvEnableResponses, KvExpireData, KvExpireErrors, KvExpireResponse, KvExpireResponses, KvGetData, KvGetErrors, KvGetResponse, KvGetResponses, KvIncrData, KvIncrErrors, KvIncrResponse, KvIncrResponses, KvKeysData, KvKeysErrors, KvKeysResponse, KvKeysResponses, KvSetData, KvSetErrors, KvSetResponse, KvSetResponses, KvStatusData, KvStatusErrors, KvStatusResponse, KvStatusResponse2, KvStatusResponses, KvTtlData, KvTtlErrors, KvTtlResponse, KvTtlResponses, KvUpdateData, KvUpdateErrors, KvUpdateResponse, KvUpdateResponses, LatestDeploymentMediaResponse, LatestDeploymentMediaResponseItem, LatestRunForSourceData, LatestRunForSourceErrors, LatestRunForSourceResponse, LatestRunForSourceResponses, LemonSqueezyConfig, LetsEncryptSettings, LineContext, LinkApplicationProjectData, LinkApplicationProjectErrors, LinkApplicationProjectRequest, LinkApplicationProjectResponse, LinkApplicationProjectResponses, LinkCustomDomainToCertificateData, LinkCustomDomainToCertificateErrors, LinkCustomDomainToCertificateResponse, LinkCustomDomainToCertificateResponses, LinkServiceRequest, LinkServiceToProjectData, LinkServiceToProjectErrors, LinkServiceToProjectResponse, LinkServiceToProjectResponses, ListAgentRunsData, ListAgentRunsErrors, ListAgentRunsResponse, ListAgentRunsResponses, ListAgentsData, ListAgentsErrors, ListAgentsResponse, ListAgentsResponse2, ListAgentsResponses, ListAiProvidersData, ListAiProvidersErrors, ListAiProvidersResponse, ListAiProvidersResponses, ListAlertRulesData, ListAlertRulesErrors, ListAlertRulesResponse, ListAlertRulesResponses, ListAlertsData, ListAlertsError, ListAlertsErrors, ListAlertsResponse, ListAlertsResponses, ListAllConversationsData, ListAllConversationsErrors, ListAllConversationsResponse, ListAllConversationsResponses, ListAllRunsData, ListAllRunsErrors, ListAllRunsResponse, ListAllRunsResponses, ListAnalyticsIngestKeysData, ListAnalyticsIngestKeysErrors, ListAnalyticsIngestKeysResponse, ListAnalyticsIngestKeysResponses, ListApiKeysData, ListApiKeysErrors, ListApiKeysQuery, ListApiKeysResponse, ListApiKeysResponses, ListApplicationConversationsData, ListApplicationConversationsErrors, ListApplicationConversationsResponse, ListApplicationConversationsResponses, ListApplicationsData, ListApplicationsErrors, ListApplicationsResponse, ListApplicationsResponses, ListAuditLogsData, ListAuditLogsErrors, ListAuditLogsQuery, ListAuditLogsResponse, ListAuditLogsResponses, ListAvailableContainersData, ListAvailableContainersErrors, ListAvailableContainersResponse, ListAvailableContainersResponses, ListBackupAlertsData, ListBackupAlertsError, ListBackupAlertsErrors, ListBackupAlertsResponse, ListBackupAlertsResponses, ListBackupChildrenData, ListBackupChildrenError, ListBackupChildrenErrors, ListBackupChildrenResponse, ListBackupChildrenResponses, ListBackupSchedulesData, ListBackupSchedulesError, ListBackupSchedulesErrors, ListBackupSchedulesResponse, ListBackupSchedulesResponses, ListBackupsForScheduleData, ListBackupsForScheduleError, ListBackupsForScheduleErrors, ListBackupsForScheduleResponse, ListBackupsForScheduleResponses, ListBlobsQuery, ListBlobsResponse, ListCommitsByRepositoryIdData, ListCommitsByRepositoryIdErrors, ListCommitsByRepositoryIdResponse, ListCommitsByRepositoryIdResponses, ListConnectionsData, ListConnectionsErrors, ListConnectionsResponse, ListConnectionsResponses, ListContainerHistoryData, ListContainerHistoryError, ListContainerHistoryErrors, ListContainerHistoryResponse, ListContainerHistoryResponses, ListContainersAtPathData, ListContainersAtPathErrors, ListContainersAtPathResponse, ListContainersAtPathResponses, ListContainersData, ListContainersErrors, ListContainersResponse, ListContainersResponses, ListConversationsData, ListConversationsErrors, ListConversationsResponse, ListConversationsResponses, ListCustomDomainsForProjectData, ListCustomDomainsForProjectErrors, ListCustomDomainsForProjectResponse, ListCustomDomainsForProjectResponses, ListCustomDomainsResponse, ListDashboardsData, ListDashboardsError, ListDashboardsErrors, ListDashboardsResponse, ListDashboardsResponses, ListDeliveriesData, ListDeliveriesErrors, ListDeliveriesResponse, ListDeliveriesResponses, ListDeploymentContainerLogsData, ListDeploymentContainerLogsErrors, ListDeploymentContainerLogsResponse, ListDeploymentContainerLogsResponses, ListDeploymentTokensData, ListDeploymentTokensErrors, ListDeploymentTokensQuery, ListDeploymentTokensResponse, ListDeploymentTokensResponses, ListDiscoverableDomainsData, ListDiscoverableDomainsErrors, ListDiscoverableDomainsResponse, ListDiscoverableDomainsResponses, ListDiscoveredRoutesQuery, ListDnsProvidersData, ListDnsProvidersErrors, ListDnsProvidersResponse, ListDnsProvidersResponses, ListDomainsData, ListDomainsErrors, ListDomainsResponse, ListDomainsResponse2, ListDomainsResponses, ListDsnsData, ListDsnsErrors, ListDsnsResponse, ListDsnsResponses, ListEmailDomainProjectsData, ListEmailDomainProjectsErrors, ListEmailDomainProjectsResponse, ListEmailDomainProjectsResponses, ListEmailDomainsData, ListEmailDomainsErrors, ListEmailDomainsResponse, ListEmailDomainsResponses, ListEmailProvidersData, ListEmailProvidersErrors, ListEmailProvidersResponse, ListEmailProvidersResponses, ListEmailsData, ListEmailsErrors, ListEmailsResponse, ListEmailsResponses, ListEnrollmentTokensData, ListEnrollmentTokensErrors, ListEnrollmentTokensResponse, ListEnrollmentTokensResponses, ListEntitiesData, ListEntitiesErrors, ListEntitiesQuery, ListEntitiesResponse, ListEntitiesResponses, ListErrorEventsData, ListErrorEventsErrors, ListErrorEventsQuery, ListErrorEventsResponse, ListErrorEventsResponses, ListErrorGroupsData, ListErrorGroupsErrors, ListErrorGroupsQuery, ListErrorGroupsResponse, ListErrorGroupsResponses, ListEventsData, ListEventsResponse, ListEventsResponses, ListEventTypesData, ListEventTypesResponse, ListEventTypesResponses, ListExternalImagesData, ListExternalImagesErrors, ListExternalImagesResponse, ListExternalImagesResponses, ListExternalPluginsData, ListExternalPluginsErrors, ListExternalPluginsResponse, ListExternalPluginsResponses, ListExternalServiceBackupsData, ListExternalServiceBackupsError, ListExternalServiceBackupsErrors, ListExternalServiceBackupsResponse, ListExternalServiceBackupsResponses, ListFacetsData, ListFacetsError, ListFacetsErrors, ListFacetsResponse, ListFacetsResponses, ListFlagsData, ListFlagsErrors, ListFlagsResponse, ListFlagsResponses, ListFunnelsData, ListFunnelsErrors, ListFunnelsResponse, ListFunnelsResponses, ListGitProvidersData, ListGitProvidersErrors, ListGitProvidersResponse, ListGitProvidersResponses, ListGlobalMcpsData, ListGlobalMcpsErrors, ListGlobalMcpsResponse, ListGlobalMcpsResponses, ListGlobalSkillsData, ListGlobalSkillsErrors, ListGlobalSkillsResponse, ListGlobalSkillsResponses, ListIncidentsData, ListIncidentsErrors, ListIncidentsResponses, ListInsightsData, ListInsightsError, ListInsightsErrors, ListInsightsResponse, ListInsightsResponses, ListIpAccessControlData, ListIpAccessControlError, ListIpAccessControlErrors, ListIpAccessControlResponse, ListIpAccessControlResponses, ListJobsData, ListJobsErrors, ListJobsResponse, ListJobsResponse2, ListJobsResponses, ListKnownAiAgentsData, ListKnownAiAgentsError, ListKnownAiAgentsErrors, ListKnownAiAgentsResponse, ListKnownAiAgentsResponses, ListManagedDomainsData, ListManagedDomainsErrors, ListManagedDomainsResponse, ListManagedDomainsResponses, ListManagedEnvironmentVariablesData, ListManagedEnvironmentVariablesErrors, ListManagedEnvironmentVariablesResponse, ListManagedEnvironmentVariablesResponses, ListMcpsData, ListMcpsErrors, ListMcpsResponse, ListMcpsResponse2, ListMcpsResponses, ListMetricLabelKeysData, ListMetricLabelKeysError, ListMetricLabelKeysErrors, ListMetricLabelKeysResponse, ListMetricLabelKeysResponses, ListMetricLabelValuesData, ListMetricLabelValuesError, ListMetricLabelValuesErrors, ListMetricLabelValuesResponse, ListMetricLabelValuesResponses, ListMetricNamesData, ListMetricNamesError, ListMetricNamesErrors, ListMetricNamesResponse, ListMetricNamesResponses, ListModelsData, ListModelsError, ListModelsErrors, ListModelsResponse, ListModelsResponses, ListMonitorsData, ListMonitorsErrors, ListMonitorsResponse, ListMonitorsResponses, ListNotificationProvidersData, ListNotificationProvidersErrors, ListNotificationProvidersResponse, ListNotificationProvidersResponses, ListNotificationRoutesData, ListNotificationRoutesErrors, ListNotificationRoutesResponse, ListNotificationRoutesResponses, ListOidcProvidersData, ListOidcProvidersResponse, ListOidcProvidersResponses, ListOidcProviderUsersData, ListOidcProviderUsersErrors, ListOidcProviderUsersResponse, ListOidcProviderUsersResponses, ListOidcRoleMappingsData, ListOidcRoleMappingsResponse, ListOidcRoleMappingsResponses, ListOnDemandCertsData, ListOnDemandCertsErrors, ListOnDemandCertsResponse, ListOnDemandCertsResponse2, ListOnDemandCertsResponses, ListOrdersData, ListOrdersErrors, ListOrdersResponse, ListOrdersResponse2, ListOrdersResponses, ListPeersData, ListPeersErrors, ListPeersResponse, ListPeersResponses, ListPendingActionsData, ListPendingActionsErrors, ListPendingActionsResponse, ListPendingActionsResponses, ListPgUpgradesData, ListPgUpgradesError, ListPgUpgradesErrors, ListPgUpgradesResponse, ListPgUpgradesResponses, ListPresetsData, ListPresetsErrors, ListPresetsResponse, ListPresetsResponse2, ListPresetsResponses, ListProjectAccessData, ListProjectAccessErrors, ListProjectAccessResponse, ListProjectAccessResponses, ListProjectAlarmsData, ListProjectAlarmsErrors, ListProjectAlarmsResponse, ListProjectAlarmsResponses, ListProjectScansData, ListProjectScansError, ListProjectScansErrors, ListProjectScansResponse, ListProjectScansResponses, ListProjectSecretsData, ListProjectSecretsErrors, ListProjectSecretsResponse, ListProjectSecretsResponses, ListProjectServicesData, ListProjectServicesErrors, ListProjectServicesResponse, ListProjectServicesResponses, ListProjectTemplatesData, ListProjectTemplatesErrors, ListProjectTemplatesResponse, ListProjectTemplatesResponses, ListProjectTemplateTagsData, ListProjectTemplateTagsErrors, ListProjectTemplateTagsResponse, ListProjectTemplateTagsResponses, ListProviderDomainsResponse, ListProviderKeysData, ListProviderKeysError, ListProviderKeysErrors, ListProviderKeysResponse, ListProviderKeysResponses, ListProviderZonesData, ListProviderZonesErrors, ListProviderZonesResponse, ListProviderZonesResponses, ListPublicProvidersData, ListPublicProvidersResponse, ListPublicProvidersResponses, ListReleaseFilesData, ListReleaseFilesErrors, ListReleaseFilesResponse, ListReleaseFilesResponses, ListReleasesData, ListReleasesErrors, ListReleasesResponse, ListReleasesResponses, ListRemoteExternalImagesData, ListRemoteExternalImagesErrors, ListRemoteExternalImagesResponse, ListRemoteExternalImagesResponses, ListRenewalAttemptsData, ListRenewalAttemptsErrors, ListRenewalAttemptsResponse, ListRenewalAttemptsResponse2, ListRenewalAttemptsResponses, ListRepositoriesByConnectionData, ListRepositoriesByConnectionErrors, ListRepositoriesByConnectionResponse, ListRepositoriesByConnectionResponses, ListRepositoriesByProviderData, ListRepositoriesByProviderErrors, ListRepositoriesByProviderResponse, ListRepositoriesByProviderResponses, ListRestoreRunsForServiceData, ListRestoreRunsForServiceError, ListRestoreRunsForServiceErrors, ListRestoreRunsForServiceResponse, ListRestoreRunsForServiceResponses, ListRootContainersData, ListRootContainersErrors, ListRootContainersResponse, ListRootContainersResponses, ListRoutesData, ListRoutesErrors, ListRoutesResponse, ListRoutesResponses, ListRunsResponse, ListS3SourcesData, ListS3SourcesError, ListS3SourcesErrors, ListS3SourcesResponse, ListS3SourcesResponses, ListSandboxesData, ListSandboxesErrors, ListSandboxesResponse, ListSandboxesResponse2, ListSandboxesResponses, ListScansQuery, ListScheduleRunJobsData, ListScheduleRunJobsError, ListScheduleRunJobsErrors, ListScheduleRunJobsResponse, ListScheduleRunJobsResponses, ListScheduleRunsData, ListScheduleRunsError, ListScheduleRunsErrors, ListScheduleRunsResponse, ListScheduleRunsResponses, ListScheduleServicesData, ListScheduleServicesError, ListScheduleServicesErrors, ListScheduleServicesResponse, ListScheduleServicesResponses, ListSecretsData, ListSecretsErrors, ListSecretsResponse, ListSecretsResponse2, ListSecretsResponses, ListServiceHealthStatusesData, ListServiceHealthStatusesErrors, ListServiceHealthStatusesResponse, ListServiceHealthStatusesResponses, ListServiceProjectsData, ListServiceProjectsErrors, ListServiceProjectsResponse, ListServiceProjectsResponses, ListServiceSchedulesData, ListServiceSchedulesError, ListServiceSchedulesErrors, ListServiceSchedulesResponse, ListServiceSchedulesResponses, ListServicesData, ListServicesErrors, ListServicesResponse, ListServicesResponses, ListSkillsData, ListSkillsErrors, ListSkillsResponse, ListSkillsResponse2, ListSkillsResponses, ListSnapshotsData, ListSnapshotsErrors, ListSnapshotsResponse, ListSnapshotsResponse2, ListSnapshotsResponses, ListSourceBackupsData, ListSourceBackupsError, ListSourceBackupsErrors, ListSourceBackupsResponse, ListSourceBackupsResponses, ListSourceFilesData, ListSourceFilesErrors, ListSourceFilesResponse, ListSourceFilesResponses, ListSourceMapsData, ListSourceMapsErrors, ListSourceMapsResponse, ListSourceMapsResponses, ListSourcesData, ListSourcesErrors, ListSourcesResponse, ListSourcesResponses, ListStaticBundlesData, ListStaticBundlesErrors, ListStaticBundlesResponse, ListStaticBundlesResponses, ListSyncedRepositoriesData, ListSyncedRepositoriesErrors, ListSyncedRepositoriesResponse, ListSyncedRepositoriesResponses, ListSystemAlarmsData, ListSystemAlarmsErrors, ListSystemAlarmsResponse, ListSystemAlarmsResponses, ListTagsResponse, ListTeamMembersData, ListTeamMembersErrors, ListTeamMembersResponse, ListTeamMembersResponses, ListTeamProjectsData, ListTeamProjectsErrors, ListTeamProjectsResponse, ListTeamProjectsResponses, ListTeamsData, ListTeamsErrors, ListTeamsResponse, ListTeamsResponses, ListTemplatesQuery, ListTemplatesResponse, ListThreadArtifactsData, ListThreadArtifactsErrors, ListThreadArtifactsResponse, ListThreadArtifactsResponses, ListTraefikDiscoveredRoutesData, ListTraefikDiscoveredRoutesError, ListTraefikDiscoveredRoutesErrors, ListTraefikDiscoveredRoutesResponse, ListTraefikDiscoveredRoutesResponses, ListUserPendingActionsData, ListUserPendingActionsErrors, ListUserPendingActionsResponse, ListUserPendingActionsResponses, ListUsersData, ListUsersErrors, ListUsersResponse, ListUsersResponses, ListVulnerabilitiesQuery, ListWebhooksData, ListWebhooksErrors, ListWebhooksResponse, ListWebhooksResponses, LiveVisitorInfo, LiveVisitorsListResponse, LocationCount, LocationGranularity, LocationInfo, LoginData, LoginErrors, LoginRequest, LoginResponse, LoginResponses, LogLevel, LogoutData, LogoutErrors, LogoutResponses, LogRecord, LogSearchLine, LogSeverity, LogSource, LogsQuery, LogsResponse, LogStream, LookupDnsARecordsData, LookupDnsARecordsError, LookupDnsARecordsErrors, LookupDnsARecordsResponse, LookupDnsARecordsResponses, ManagedBackupSetup, ManagedBackupSetupAction, ManagedBackupSetupStatus, ManagedDomainResponse, ManagedEnvironmentVariable, ManagedEnvironmentVariableSource, ManualAction, ManualActionTiming, Maturity, McpDefinitionResponse, McpServerSettings, MessageContent, MessagePart, MessageResponse, MeteredMode, MetricAggregation, MetricBucket, MetricDataPoint, MetricsOverTimeResponse, MetricsQuery, MetricsRangeQuery, MetricsStatusResponse, MetricsStoreKind, MetricsSummaryResponse, MetricType, MfaRequiredResponse, MfaSetupResponse, MfaVerificationRequest, MigrationStep, MigrationSummary, MintEnrollmentTokenData, MintEnrollmentTokenErrors, MintEnrollmentTokenRequest, MintEnrollmentTokenResponse, MintEnrollmentTokenResponse2, MintEnrollmentTokenResponses, MiscResult, MkdirBody, MkdirData, MkdirErrors, MkdirResponse, MkdirResponses, ModelCapability, ModelInfo, ModelListResponse, ModelPricing, ModelUsage, MonitoringSettings, MonitoringSettingsMasked, MonitorResponse, MonitorStatus, MrrBucketResponse, MultiNodeSettings, MultiNodeSettingsMasked, MxResult, NavEntry, NavSection, NetworkConfiguration, NetworkMode, NetworkPoolEntry, NixpacksPresetConfig, NixpacksProvider, NodeContainerListResponse, NodeContainerResponse, NodeCostInfo, NodeDnsStatusEntry, NodeHeartbeatData, NodeHeartbeatErrors, NodeHeartbeatResponse, NodeHeartbeatResponses, NodeInfoResponse, NodeListResponse, NodeMetricsGetAlertRulesData, NodeMetricsGetAlertRulesErrors, NodeMetricsGetAlertRulesResponse, NodeMetricsGetAlertRulesResponses, NodeMetricsGetRangeData, NodeMetricsGetRangeErrors, NodeMetricsGetRangeResponse, NodeMetricsGetRangeResponses, NodeMetricsUpdateAlertRuleData, NodeMetricsUpdateAlertRuleErrors, NodeMetricsUpdateAlertRuleResponse, NodeMetricsUpdateAlertRuleResponses, NotificationPreferencesResponse, NotificationProviderResponse, NotificationRoute, NotificationRoutePage, ObservabilityCompressionSettings, ObservabilityEvent, ObservabilityFullEventData, ObservabilityFullEventError, ObservabilityFullEventErrors, ObservabilityFullEventResponse, ObservabilityFullEventResponses, ObservabilityListEventsData, ObservabilityListEventsError, ObservabilityListEventsErrors, ObservabilityListEventsResponse, ObservabilityListEventsResponses, ObservabilityRetentionSettings, OidcCallbackData, OidcProviderResponse, OidcProvidersListResponse, OidcProviderSummary, OidcProviderUserResponse, OidcRoleMappingResponse, OidcTestConnectionResponse, OnDemandCertAttemptResponse, OnDemandCertRow, OnDemandTlsSettings, OpenAiError, OpenAiErrorResponse, OperatingSystemCount, OperationResultResponse, OperationResultsResponse, OtelDashboardResponse, OtelDashboardsResponse, OtelMetricAlertRuleResponse, OtelMetricAlertsResponse, OtelMetricLabelKeysResponse, OtelMetricLabelValuesResponse, OtelMetricNamesResponse, OtelMetricsResponse, OutlierAlgorithm, OutlierParams, OverprovisioningAssessment, OverprovisioningVerdict, PageActivityBucket, PageCountryStats, PageFlowEntry, PageFlowQuery, PageFlowResponse, PageHourlySessionsQuery, PageHourlySessionsResponse, PagePathDetailQuery, PagePathDetailResponse, PagePathInfo, PagePathSparkline, PagePathSparklinePoint, PagePathsQuery, PagePathsResponse, PagePathsSparklineQuery, PagePathsSparklineResponse, PagePathVisitorsQuery, PagePathVisitorsResponse, PageReferrerStats, PagesComparisonResponse, PageSessionComparison, PageSessionStats, PageSessionStatsQuery, PageTransition, PageVisit, PageVisitorSession, PaginatedEmailsResponse, PaginatedEntitiesResponse, PaginatedErrorEventsResponse, PaginatedErrorGroupsResponse, PaginatedEventsResponse, PaginatedExternalImagesResponse, PaginatedProjectList, PaginatedStaticBundlesResponse, Pagination, PaginationMeta, PaginationParams, PasswordProtectionConfig, PatchAdminGateData, PatchAdminGateErrors, PatchAdminGateResponse, PatchAdminGateResponses, PatchPreviewGatewaySettingsData, PatchPreviewGatewaySettingsError, PatchPreviewGatewaySettingsErrors, PatchPreviewGatewaySettingsResponse, PatchPreviewGatewaySettingsResponses, PatchSettingsRequest, PathVisitors, PathVisitorsAnalyticsQuery, PathVisitorsResponse, PauseDeploymentData, PauseDeploymentErrors, PauseDeploymentResponse, PauseDeploymentResponses, PauseSandboxData, PauseSandboxErrors, PauseSandboxResponse, PauseSandboxResponses, PeerEntry, PeerListResponse, PendingActionResponse, PerformanceMetricsQuery, PerformanceMetricsResponse, PermissionDecision, PermissionInfo, PermissionKind, PermissionRequest, PermissionRequestedEvent, PgUpgradeLogResponse, PgUpgradeResponse, PipelineHistoryPoint, PipelineHistoryResponse, PipelineSeries, PipelineStats, PipelineStatsResponse, PlanComplexity, PlanMetadata, PlanRestoreData, PlanRestoreError, PlanRestoreErrors, PlanRestoreResponse, PlanRestoreResponses, PlanSourceBackup, PlanTarget, PlatformInfo, PluginCapability, PluginManifest, PortMapping, PostDnsAckData, PostDnsAckErrors, PostDnsAckResponse, PostDnsAckResponses, PostgresWalHealth, PresetConfigSchema, PresetInfo, PresetResponse, PreviewAlertData, PreviewAlertError, PreviewAlertErrors, PreviewAlertResponse, PreviewAlertResponses, PreviewFunnelMetricsData, PreviewFunnelMetricsErrors, PreviewFunnelMetricsResponse, PreviewFunnelMetricsResponses, PreviewGatewayLogsResponse, PreviewGatewaySettings, PreviewGatewaySettingsMasked, PreviewGatewaySettingsResponse, PreviewHostnameModeData, PreviewHostnameModeErrors, PreviewHostnameModeResponse, PreviewHostnameModeResponses, PreviewShareLinkBody, PreviewShareLinkResponse, PricingResponse, ProblemDetails, ProjectAccessResponse, ProjectCloudTelemetryResponse, ProjectConfiguration, ProjectDashboardAnalytics, ProjectDsnResponse, ProjectEnvVarInput, ProjectHealthSummary, ProjectHourlyRequestCount, ProjectInfo, ProjectMonitorHealth, ProjectPresetResponse, ProjectQuery, ProjectRef, ProjectResponse, ProjectSecretEnvironmentInfo, ProjectSecretResponse, ProjectServiceInfo, ProjectsHealthResponse, ProjectsMonitorHealthResponse, ProjectStatisticsResponse, ProjectStatsBreakdown, ProjectTemplate, ProjectType, ProjectUsageInfoResponse, PromoteClusterMemberData, PromoteClusterMemberErrors, PromoteClusterMemberResponses, PromoteDeploymentData, PromoteDeploymentErrors, PromoteDeploymentRequest, PromoteDeploymentResponse, PromoteDeploymentResponses, PropertyBreakdownItem, PropertyBreakdownQuery, PropertyBreakdownResponse, PropertyColumn, PropertyTimelineItem, PropertyTimelineQuery, PropertyTimelineResponse, Protocol, ProviderCatalogDto, ProviderCatalogResponse, ProviderConfig, ProviderConfigMasked, ProviderDeletionCheckResponse, ProviderDescriptor, ProviderDetailResponse, ProviderDomainIdentityResponse, ProviderKeyResponse, ProviderMetadata, ProviderModelResponse, ProviderResponse, ProviderUsage, ProvisionDomainData, ProvisionDomainErrors, ProvisionDomainResponse, ProvisionDomainResponses, ProvisionResponse, ProxyLogAccessResponse, ProxyLogResponse, ProxyLogsPaginatedResponse, PublicComposePreviewRequest, PublicComposePreviewResponse, PublicComposeServicePreview, PublicComposeServicesResponse, PublicEnvExampleResponse, PublicHostnameStrategy, PublicPresetResponse, PublicRepositoryInfo, PurgeLogsRequest, PurgeProjectLogsData, PurgeProjectLogsError, PurgeProjectLogsErrors, PurgeProjectLogsResponses, PushedExternalImageResponse, PushExternalImageData, PushExternalImageErrors, PushExternalImageResponse, PushExternalImageResponses, PushImageRequest, QueryDataData, QueryDataErrors, QueryDataRequest, QueryDataResponse, QueryDataResponse2, QueryDataResponses, QueryGenaiTracesData, QueryGenaiTracesError, QueryGenaiTracesErrors, QueryGenaiTracesResponse, QueryGenaiTracesResponses, QueryLogsData, QueryLogsError, QueryLogsErrors, QueryLogsResponse, QueryLogsResponses, QueryMetricsData, QueryMetricsError, QueryMetricsErrors, QueryMetricsResponse, QueryMetricsResponses, QuerySpanStatsData, QuerySpanStatsError, QuerySpanStatsErrors, QuerySpanStatsResponse, QuerySpanStatsResponses, QueryTracesData, QueryTracesError, QueryTracesErrors, QueryTracesResponse, QueryTracesResponses, QueryTraceSummariesData, QueryTraceSummariesError, QueryTraceSummariesErrors, QueryTraceSummariesResponse, QueryTraceSummariesResponses, QuotaResponse, RateLimitConfig, RateLimitSettings, ReachabilityStatus, ReadEntityRowsData, ReadEntityRowsErrors, ReadEntityRowsResponse, ReadEntityRowsResponses, ReadFileData, ReadFileErrors, ReadFileResponse, ReadFileResponse2, ReadFileResponses, ReadRowsQuery, ReAnalyzeData, ReAnalyzeErrors, ReAnalyzeResponses, ReassignCustomDomainRequest, ReassignProjectCustomDomainData, ReassignProjectCustomDomainErrors, ReassignProjectCustomDomainResponse, ReassignProjectCustomDomainResponses, RecentActivityQuery, RecentActivityResponse, RecentEventResponse, RecentQueryParams, ReconcileCloudBackupSourceData, ReconcileCloudBackupSourceResponse, ReconcileCloudBackupSourceResponses, RecordConsoleEventData, RecordConsoleEventErrors, RecordConsoleEventResponses, RecordEventMetricsData, RecordEventMetricsErrors, RecordEventMetricsResponse, RecordEventMetricsResponses, RecordExposureRequest, RecordExposureResponse, RecordFlagExposureData, RecordFlagExposureErrors, RecordFlagExposureResponse, RecordFlagExposureResponses, RecordListResponse, RecordSpeedMetricsData, RecordSpeedMetricsError, RecordSpeedMetricsErrors, RecordSpeedMetricsResponse, RecordSpeedMetricsResponses, RecoveryTarget, ReferrerCount, ReferrersAnalyticsQuery, RefreshAiProviderStatusData, RefreshAiProviderStatusError, RefreshAiProviderStatusErrors, RefreshAiProviderStatusResponse, RefreshAiProviderStatusResponses, RefreshProviderModelsData, RefreshProviderModelsError, RefreshProviderModelsErrors, RefreshProviderModelsResponse, RefreshProviderModelsResponses, RefreshRouteTableData, RefreshRouteTableErrors, RefreshRouteTableResponse, RefreshRouteTableResponses, RegenerateDsnData, RegenerateDsnErrors, RegenerateDsnRequest, RegenerateDsnResponse, RegenerateDsnResponses, RegisterExternalImageData, RegisterExternalImageErrors, RegisterExternalImageResponse, RegisterExternalImageResponses, RegisterImageRequest, RegisterNodeApiRequest, RegisterNodeData, RegisterNodeErrors, RegisterNodeResponse, RegisterNodeResponse2, RegisterNodeResponses, RegisterRequest, ReinstallGitlabWebhookData, ReinstallGitlabWebhookErrors, ReinstallGitlabWebhookResponse, ReinstallGitlabWebhookResponses, ReinstallWebhookResponse, RejectPendingActionData, RejectPendingActionErrors, RejectPendingActionResponse, RejectPendingActionResponses, RejectUserPendingActionData, RejectUserPendingActionErrors, RejectUserPendingActionResponse, RejectUserPendingActionResponses, ReleaseCheckResult, ReleaseListResponse, ReloadPluginsData, ReloadPluginsErrors, ReloadPluginsResponse, ReloadPluginsResponses, ReloadResponse, RemoteDeploymentResponse, RemoveClusterMemberData, RemoveClusterMemberErrors, RemoveClusterMemberResponse, RemoveClusterMemberResponses, RemoveManagedDomainData, RemoveManagedDomainErrors, RemoveManagedDomainResponse, RemoveManagedDomainResponses, RemoveNodeResponse, RemoveRoleData, RemoveRoleErrors, RemoveRoleResponse, RemoveRoleResponses, RemoveTeamMemberData, RemoveTeamMemberErrors, RemoveTeamMemberResponse, RemoveTeamMemberResponses, RenameConversationData, RenameConversationErrors, RenameConversationRequest, RenameConversationResponse, RenameConversationResponses, RenameUserConversationData, RenameUserConversationErrors, RenameUserConversationResponse, RenameUserConversationResponses, RenewalAttemptResponse, RenewDomainData, RenewDomainErrors, RenewDomainResponse, RenewDomainResponses, RepointContinuousArchiveSourceData, RepointContinuousArchiveSourceErrors, RepointContinuousArchiveSourceRequest, RepointContinuousArchiveSourceResponse, RepointContinuousArchiveSourceResponses, RepositoryComposeServicesResponse, RepositoryEnvExampleResponse, RepositoryListQuery, RepositoryListResponse, RepositoryPresetResponse, RepositoryResponse, RepositorySyncStartedResponse, RequestDiscoveredRouteCertData, RequestDiscoveredRouteCertError, RequestDiscoveredRouteCertErrors, RequestDiscoveredRouteCertRequest, RequestDiscoveredRouteCertResponses, RequestPasswordResetData, RequestPasswordResetErrors, RequestPasswordResetResponse, RequestPasswordResetResponses, RequestRow, RequestTimeoutSettings, RequiredPasswordChangeRequest, RequiredPasswordChangeResponse, ResetPasswordData, ResetPasswordErrors, ResetPasswordRequest, ResetPasswordResponse, ResetPasswordResponses, ResetPgStatStatementsRequest, ResetPgStatStatementsResponse, ResizeSandboxBody, ResizeSandboxData, ResizeSandboxErrors, ResizeSandboxResponse, ResizeSandboxResponses, ResolveAlarmData, ResolveAlarmErrors, ResolveAlarmResponses, ResolvedEnvVarResponse, ResolvedEnvVarSource, ResolvePermissionData, ResolvePermissionErrors, ResolvePermissionRequest, ResolvePermissionResponse, ResolvePermissionResponses, ResolveSystemAlarmData, ResolveSystemAlarmErrors, ResolveSystemAlarmResponses, ResolveUserPermissionData, ResolveUserPermissionErrors, ResolveUserPermissionResponse, ResolveUserPermissionResponses, ResourceCounts, ResourceFootprint, ResourceInfo, ResourceLimitApplyResult, ResourceLimits, ResourceLimitsResponse, ResourceLimitsUpdateResponse, ResourcesBody, RestartContainerData, RestartContainerErrors, RestartContainerResponse, RestartContainerResponses, RestartPreviewGatewayData, RestartPreviewGatewayError, RestartPreviewGatewayErrors, RestartPreviewGatewayResponse, RestartPreviewGatewayResponses, RestartSandboxData, RestartSandboxErrors, RestartSandboxResponse, RestartSandboxResponses, RestoreApplicationData, RestoreApplicationErrors, RestoreApplicationResponse, RestoreApplicationResponses, RestoreCapabilities, RestoreCapabilitiesResponse, RestoreFlagData, RestoreFlagErrors, RestoreFlagResponse, RestoreFlagResponses, RestorePlan, RestoreRequestMode, RestoreRunView, RestoreUserConversationData, RestoreUserConversationErrors, RestoreUserConversationResponse, RestoreUserConversationResponses, RestoreUserData, RestoreUserErrors, RestoreUserResponse, RestoreUserResponses, ResumeDeploymentData, ResumeDeploymentErrors, ResumeDeploymentResponse, ResumeDeploymentResponses, ResumeSandboxData, ResumeSandboxErrors, ResumeSandboxResponse, ResumeSandboxResponses, RetentionCleanupFailure, RetentionCleanupReport, RetryClusterData, RetryClusterErrors, RetryClusterRequest, RetryClusterResponse, RetryClusterResponses, RetryDeliveryData, RetryDeliveryErrors, RetryDeliveryResponse, RetryDeliveryResponses, RetryFacetBackfillData, RetryFacetBackfillError, RetryFacetBackfillErrors, RetryFacetBackfillResponse, RetryFacetBackfillResponses, RetryPgUpgradeData, RetryPgUpgradeError, RetryPgUpgradeErrors, RetryPgUpgradeResponse, RetryPgUpgradeResponses, RetryRunData, RetryRunErrors, RetryRunResponse, RetryRunResponses, RevealGlobalMcpConfigData, RevealGlobalMcpConfigErrors, RevealGlobalMcpConfigResponse, RevealGlobalMcpConfigResponses, RevealMcpConfigData, RevealMcpConfigErrors, RevealMcpConfigResponse, RevealMcpConfigResponses, RevealNotificationProviderConfigData, RevealNotificationProviderConfigErrors, RevealNotificationProviderConfigResponse, RevealNotificationProviderConfigResponses, RevealServiceEnvironmentVariablesData, RevealServiceEnvironmentVariablesErrors, RevealServiceEnvironmentVariablesResponse, RevealServiceEnvironmentVariablesResponses, RevealServiceParameterData, RevealServiceParameterErrors, RevealServiceParameterResponse, RevealServiceParameterResponses, RevenueCreateIntegrationData, RevenueCreateIntegrationErrors, RevenueCreateIntegrationResponse, RevenueCreateIntegrationResponses, RevenueDeleteIntegrationData, RevenueDeleteIntegrationResponse, RevenueDeleteIntegrationResponses, RevenueGlobalEventsData, RevenueGlobalEventsResponse, RevenueGlobalEventsResponses, RevenueImportInvoicesCsvData, RevenueImportInvoicesCsvErrors, RevenueImportInvoicesCsvResponse, RevenueImportInvoicesCsvResponses, RevenueImportSubscriptionsCsvData, RevenueImportSubscriptionsCsvErrors, RevenueImportSubscriptionsCsvResponse, RevenueImportSubscriptionsCsvResponses, RevenueListIntegrationsData, RevenueListIntegrationsResponse, RevenueListIntegrationsResponses, RevenueListProvidersData, RevenueListProvidersResponse, RevenueListProvidersResponses, RevenueMetricsCustomersData, RevenueMetricsCustomersResponse, RevenueMetricsCustomersResponses, RevenueMetricsGlobalMrrData, RevenueMetricsGlobalMrrResponse, RevenueMetricsGlobalMrrResponses, RevenueMetricsGlobalSummaryData, RevenueMetricsGlobalSummaryResponse, RevenueMetricsGlobalSummaryResponses, RevenueMetricsMrrData, RevenueMetricsMrrResponse, RevenueMetricsMrrResponses, RevenueMetricsSummaryData, RevenueMetricsSummaryResponse, RevenueMetricsSummaryResponses, RevenueRecentEventsData, RevenueRecentEventsResponse, RevenueRecentEventsResponses, RevenueRotateTokenData, RevenueRotateTokenResponse, RevenueRotateTokenResponses, RevenueRow, RevenueUpdateConfigData, RevenueUpdateConfigErrors, RevenueUpdateConfigResponse, RevenueUpdateConfigResponses, RevenueUpdateSecretData, RevenueUpdateSecretErrors, RevenueUpdateSecretResponse, RevenueUpdateSecretResponses, RevokeAnalyticsIngestKeyData, RevokeAnalyticsIngestKeyErrors, RevokeAnalyticsIngestKeyResponse, RevokeAnalyticsIngestKeyResponses, RevokeDsnData, RevokeDsnErrors, RevokeDsnResponse, RevokeDsnResponses, RevokeEmailDomainProjectData, RevokeEmailDomainProjectErrors, RevokeEmailDomainProjectResponse, RevokeEmailDomainProjectResponses, RevokeEnrollmentTokenData, RevokeEnrollmentTokenErrors, RevokeEnrollmentTokenResponse, RevokeEnrollmentTokenResponses, RevokeJoinTokenData, RevokeJoinTokenErrors, RevokeJoinTokenResponse, RevokeJoinTokenResponses, RevokeProjectAccessData, RevokeProjectAccessErrors, RevokeProjectAccessResponse, RevokeProjectAccessResponses, RiskLevel, RoleInfo, RollbackPgUpgradeData, RollbackPgUpgradeError, RollbackPgUpgradeErrors, RollbackPgUpgradeResponse, RollbackPgUpgradeResponses, RollbackToDeploymentData, RollbackToDeploymentErrors, RollbackToDeploymentResponse, RollbackToDeploymentResponses, RootfsCacheEntry, RootfsGcData, RootfsGcReport, RootfsGcResponses, RootfsReport, RootfsReportData, RootfsReportResponses, RootfsVmEntry, RotateAnalyticsIngestKeyData, RotateAnalyticsIngestKeyErrors, RotateAnalyticsIngestKeyResponse, RotateAnalyticsIngestKeyResponses, RotateApiKeyData, RotateApiKeyErrors, RotateApiKeyResponse, RotateApiKeyResponses, RotateClusterCaData, RotateClusterCaErrors, RotateClusterCaRequest, RotateClusterCaResponse, RotateClusterCaResponse2, RotateClusterCaResponses, RotateDeploymentTokenData, RotateDeploymentTokenErrors, RotateDeploymentTokenResponse, RotateDeploymentTokenResponses, RouteRefreshResponse, RouteResponse, RouteRole, RouteUser, RouteUserWithRoles, RunBackupForSourceData, RunBackupForSourceError, RunBackupForSourceErrors, RunBackupForSourceResponse, RunBackupForSourceResponses, RunBackupRequest, RunConnectionHealthCheckData, RunConnectionHealthCheckErrors, RunConnectionHealthCheckResponse, RunConnectionHealthCheckResponses, RunExternalServiceBackupData, RunExternalServiceBackupError, RunExternalServiceBackupErrors, RunExternalServiceBackupRequest, RunExternalServiceBackupResponse, RunExternalServiceBackupResponses, RunScheduleNowData, RunScheduleNowError, RunScheduleNowErrors, RunScheduleNowResponse, RunScheduleNowResponses, RuntimeCredentialsResponse, S3ConnectionTestResponse, S3CredentialsResponse, S3SourceResponse, S3SourceResponseWritable, SandboxCreatePreviewLinkData, SandboxCreatePreviewLinkErrors, SandboxCreatePreviewLinkResponse, SandboxCreatePreviewLinkResponses, SandboxDomainResponse, SandboxEvent, SandboxEventsResponse, SandboxInner, SandboxResponse, SandboxRoute, SandboxStatusResponse, SaveAgentTokenData, SaveAgentTokenErrors, SaveAgentTokenRequest, SaveAgentTokenResponse, SaveAgentTokenResponse2, SaveAgentTokenResponses, SaveAiProviderCredentialData, SaveAiProviderCredentialErrors, SaveAiProviderCredentialResponse, SaveAiProviderCredentialResponses, SaveCredentialRequest, SaveCredentialResponse, ScalewayCredentialsRequest, ScanResponse, ScheduleRunEntry, ScheduleRunJobEntry, ScheduleRunListResponse, ScheduleRunResponse, ScheduleRunSummary, ScheduleRunSummaryList, ScreenshotSettings, SearchLogsData, SearchLogsError, SearchLogsErrors, SearchLogsRequest, SearchLogsResponse, SearchLogsResponse2, SearchLogsResponses, SearchMode, Seasonality, SecretResponse, SecurityConfig, SecurityHeadersConfig, SecurityHeadersSettings, SelectOption, SelfUpdateAttempt, SelfUpdateBlocker, SelfUpdatePhase, SelfUpdateRestartMode, SelfUpdateSettings, SelfUpdateStatus, SendEmailData, SendEmailErrors, SendEmailRequestBody, SendEmailResponse, SendEmailResponseBody, SendEmailResponses, SendFailureReportData, SendFailureReportErrors, SendFailureReportRequest, SendFailureReportResponse, SendFailureReportResponses, SendMessageAcceptedResponse, SendMessageRequest, SendProjectAiMessageData, SendProjectAiMessageErrors, SendProjectAiMessageResponse, SendProjectAiMessageResponses, SendUserMessageData, SendUserMessageErrors, SendUserMessageResponse, SendUserMessageResponses, SensitiveConfigValueResponse, SensitiveMcpConfigValueResponse, SensitiveValueResponse, SentryChunkUploadResponse, SentryCreateReleaseRequest, SentryEventRequest, SentryEventResponse, SentryReleaseFileResponse, SentryReleaseProjectRef, SentryReleaseResponse, SeriesStateEntry, ServiceAccessInfo, ServiceAction, ServiceAlertRuleResponse, ServiceBackupEntryResponse, ServiceBackupListResponse, ServiceCreateAlertRuleRequest, ServiceHealthResponse, ServiceHealthStatusBatchResponse, ServiceHealthStatusEntryResponse, ServiceMemberInfo, ServiceParameter, ServicePlan, ServiceResourceLimits, ServiceRuntimeReport, ServiceStatsReport, ServiceTemplateChangeKind, ServiceTemplateInstance, ServiceTemplateInstanceResponse, ServiceTemplateUpgradeChange, ServiceTypeInfo, ServiceTypeRoute, ServiceUpdateAlertRuleRequest, SesCredentialsRequest, SessionDetails, SessionDetailsQuery, SessionEvent, SessionEventDto, SessionEventsQuery, SessionEventsResponse, SessionLogsQuery, SessionLogsResponse, SessionReplayEventsRequest, SessionReplayInfoDto, SessionReplayInitRequest, SessionReplayInitResponse, SessionReplayWithEventsDto, SessionReplayWithVisitorDto, SessionRequestLog, SessionSummary, SetAiDataAccessData, SetAiDataAccessErrors, SetAiDataAccessResponse, SetAiDataAccessResponses, SetAlternateSourcesData, SetAlternateSourcesErrors, SetAlternateSourcesRequest, SetAlternateSourcesResponse, SetAlternateSourcesResponses, SetApplicationPrimaryProjectData, SetApplicationPrimaryProjectErrors, SetApplicationPrimaryProjectResponse, SetApplicationPrimaryProjectResponses, SetDefaultS3SourceData, SetDefaultS3SourceError, SetDefaultS3SourceErrors, SetDefaultS3SourceResponse, SetDefaultS3SourceResponses, SetFlagEnvironmentData, SetFlagEnvironmentErrors, SetFlagEnvironmentRequest, SetFlagEnvironmentResponse, SetFlagEnvironmentResponses, SetPreviewPasswordBody, SetPreviewPasswordData, SetPreviewPasswordErrors, SetPreviewPasswordResponse, SetPreviewPasswordResponse2, SetPreviewPasswordResponses, SetRequest, SetResponse, SettingsUpdateResponse, SetTraefikDiscoveredRouteEnabledData, SetTraefikDiscoveredRouteEnabledError, SetTraefikDiscoveredRouteEnabledErrors, SetTraefikDiscoveredRouteEnabledResponse, SetTraefikDiscoveredRouteEnabledResponses, SetupDnsChallengeData, SetupDnsChallengeErrors, SetupDnsChallengeRequest, SetupDnsChallengeResponse, SetupDnsChallengeResponse2, SetupDnsChallengeResponses, SetupDnsData, SetupDnsErrors, SetupDnsRequest, SetupDnsResponse, SetupDnsResponse2, SetupDnsResponses, SetupEmailTrackingData, SetupEmailTrackingErrors, SetupEmailTrackingResponse, SetupEmailTrackingResponses, SetupMfaData, SetupMfaErrors, SetupMfaRequest, SetupMfaResponse, SetupMfaResponses, SiblingRef, SilenceAlarmData, SilenceAlarmErrors, SilenceAlarmRequest, SilenceAlarmResponses, SilenceSystemAlarmData, SilenceSystemAlarmErrors, SilenceSystemAlarmResponses, SkillDefinitionResponse, SlackConfig, SleepEnvironmentData, SleepEnvironmentErrors, SleepEnvironmentResponse, SleepEnvironmentResponses, SlowQueriesResponse, SlowQueryRow, SmartFilter, SmokeTestAgentData, SmokeTestAgentErrors, SmokeTestAgentResponse, SmokeTestAgentResponses, SmokeTestResponse, SmtpCredentialsRequest, SmtpEncryptionRoute, SmtpResult, SnapshotResponse, SourceArchiveUpload, SourceBackupEntry, SourceBackupIndexResponse, SourceBody, SourceFileListResponse, SourceFileResponse, SourceMapListResponse, SourceMapResponse, SourceSandboxData, SourceSandboxErrors, SourceSandboxResponse, SourceSandboxResponses, SourceType, SpanEvent, SpanKind, SpanRecord, SpanRow, SpanStats, SpanStatsResponse, SpanStatusCode, SpeedMetricsPayload, SpeedSegmentFilters, StaleSlot, StartAnalysisData, StartAnalysisErrors, StartAnalysisRequest, StartAnalysisResponse, StartAnalysisResponses, StartContainerData, StartContainerErrors, StartContainerResponse, StartContainerResponses, StartFixData, StartFixErrors, StartFixResponses, StartGitProviderOauthData, StartGitProviderOauthErrors, StartOidcLoginBySlugData, StartOidcLoginBySlugErrors, StartPgUpgradeData, StartPgUpgradeError, StartPgUpgradeErrors, StartPgUpgradeRequest, StartPgUpgradeResponse, StartPgUpgradeResponses, StartRestoreData, StartRestoreError, StartRestoreErrors, StartRestoreRequest, StartRestoreResponse, StartRestoreResponses, StartServiceData, StartServiceErrors, StartServiceResponse, StartServiceResponses, StartUpdateData, StartUpdateError, StartUpdateErrors, StartUpdateRequest, StartUpdateResponse, StartUpdateResponse2, StartUpdateResponses, StaticBundleResponse, StaticParams, StaticPresetConfig, StatPathData, StatPathErrors, StatPathResponse, StatPathResponses, StatResponse, StatsFilters, StatusBucket, StatusBucketedResponse, StatusCodeCount, StatusCodesQuery, StatusPageOverview, StepConversionResponse, StepResourceType, StepResult, StepUpResponse, StopContainerData, StopContainerErrors, StopContainerResponse, StopContainerResponses, StopSandboxData, StopSandboxErrors, StopSandboxResponse, StopSandboxResponses, StopSequence, StopServiceData, StopServiceErrors, StopServiceResponse, StopServiceResponses, StopTurnData, StopTurnErrors, StopTurnResponse, StopTurnResponses, StopUserTurnData, StopUserTurnErrors, StopUserTurnResponse, StopUserTurnResponses, StorageQuota, StorageSummary, StorageSummaryData, StorageSummaryErrors, StorageSummaryResponse, StorageSummaryResponses, StreamContainerMetricsData, StreamContainerMetricsErrors, StreamContainerMetricsResponses, StreamEventsData, StreamEventsErrors, StreamEventsResponses, StreamRunEventsData, StreamRunEventsErrors, StreamRunEventsResponses, StreamStructuredOutputRequest, StripeConfig, SupervisorKind, SyncedRepositoryListQuery, SyncRepositoriesData, SyncRepositoriesErrors, SyncRepositoriesResponse, SyncRepositoriesResponses, SyntaxResult, TagInfo, TagListResponse, TailDeploymentJobLogsData, TailDeploymentJobLogsErrors, TailLogsData, TailLogsError, TailLogsErrors, TailLogsRequest, TailLogsResponses, TargetRecommendation, TeamListResponse, TeamMemberResponse, TeamResponse, TeamRole, TeardownDeploymentData, TeardownDeploymentErrors, TeardownDeploymentResponse, TeardownDeploymentResponses, TeardownEnvironmentData, TeardownEnvironmentErrors, TeardownEnvironmentResponse, TeardownEnvironmentResponses, TelemetryGapWindowResponse, TelemetryWriteIntervalReason, TelemetryWriteIntervalResponse, TemplateKind, TemplateResources, TemplateResponse, TenantResourceCeilings, TerminalData, TerminalErrors, TestEmailRequest, TestEmailResponse, TestNotificationProviderData, TestNotificationProviderErrors, TestNotificationProviderResponse, TestNotificationProviderResponses, TestOidcProviderData, TestOidcProviderResponse, TestOidcProviderResponses, TestProviderConnectionData, TestProviderConnectionErrors, TestProviderConnectionResponse, TestProviderConnectionResponses, TestProviderData, TestProviderErrors, TestProviderKeyByIdData, TestProviderKeyByIdError, TestProviderKeyByIdErrors, TestProviderKeyByIdResponse, TestProviderKeyByIdResponses, TestProviderKeyInlineData, TestProviderKeyInlineError, TestProviderKeyInlineErrors, TestProviderKeyInlineResponse, TestProviderKeyInlineResponses, TestProviderKeyRequest, TestProviderKeyResponse, TestProviderResponse, TestProviderResponse2, TestProviderResponses, TestS3ConnectionPreviewData, TestS3ConnectionPreviewError, TestS3ConnectionPreviewErrors, TestS3ConnectionPreviewResponse, TestS3ConnectionPreviewResponses, TestS3SourceConnectionData, TestS3SourceConnectionError, TestS3SourceConnectionErrors, TestS3SourceConnectionResponse, TestS3SourceConnectionResponses, ThreadArtifactResponse, TimeBucketStats, TimeBucketStatsResponse, TimeseriesBucket, TimeseriesQueryParams, TlsMode, TodayStatsResponse, ToggleAiDataAccessRequest, ToggleDeploymentMetricsRequest, ToggleServiceMetricsRequest, TokenRenewalRequest, ToolCallEvent, ToolInfo, ToolResultEvent, TopModelsQueryParams, TraceProjectRef, TracesResponse, TraceSummariesResponse, TraceSummary, TrackClickData, TrackClickErrors, TrackedLinkResponse, TrackingEventResponse, TrackOpenData, TrackOpenErrors, TrackOpenResponses, TraefikDiscoveredRouteListResponse, TraefikDiscoveredRouteResponse, TraefikDiscoveryConflictResponse, TraefikDiscoverySetupResponse, TraefikDiscoveryStatusResponse, TraefikReconciliationResponse, TraefikRouteTlsBlock, TrafficAggregationRequest, TrafficAggregationResponse, TrafficAggregationRow, TrafficDimension, TrafficDimensionValue, TrafficFilter, TrafficFilterOperator, TrafficMetric, TrafficMetricValues, TrafficOrderBy, TrafficOrderField, TrafficSortDirection, TriggerAgentData, TriggerAgentErrors, TriggerAgentRequest, TriggerAgentResponse, TriggerAgentResponses, TriggerDigestResponse, TriggerPipelinePayload, TriggerPipelineResponse, TriggerProjectPipelineData, TriggerProjectPipelineErrors, TriggerProjectPipelineResponse, TriggerProjectPipelineResponses, TriggerScanData, TriggerScanError, TriggerScanErrors, TriggerScanRequest, TriggerScanResponse, TriggerScanResponse2, TriggerScanResponses, TriggerServiceHealthCheckData, TriggerServiceHealthCheckErrors, TriggerServiceHealthCheckResponse, TriggerServiceHealthCheckResponses, TriggerWeeklyDigestData, TriggerWeeklyDigestErrors, TriggerWeeklyDigestResponse, TriggerWeeklyDigestResponses, TtlRequest, TtlResponse, TxtRecord, UiManifest, UiRoute, UndrainNodeResponse, UnifiedTrace, UniqueCountsQuery, UniqueCountsResponse, UnlinkApplicationProjectData, UnlinkApplicationProjectErrors, UnlinkApplicationProjectResponse, UnlinkApplicationProjectResponses, UnlinkServiceFromProjectData, UnlinkServiceFromProjectErrors, UnlinkServiceFromProjectResponse, UnlinkServiceFromProjectResponses, UnsupportedFeature, UpdateAdminGateRequest, UpdateAgentData, UpdateAgentErrors, UpdateAgentResponse, UpdateAgentResponses, UpdateAiProviderData, UpdateAiProviderErrors, UpdateAiProviderPreferenceData, UpdateAiProviderPreferenceError, UpdateAiProviderPreferenceErrors, UpdateAiProviderPreferenceResponse, UpdateAiProviderPreferenceResponses, UpdateAiProviderRequest, UpdateAiProviderResponse, UpdateAiProviderResponse2, UpdateAiProviderResponses, UpdateAiSummaryPreferenceData, UpdateAiSummaryPreferenceError, UpdateAiSummaryPreferenceErrors, UpdateAiSummaryPreferenceRequest, UpdateAiSummaryPreferenceResponse, UpdateAiSummaryPreferenceResponses, UpdateAlertData, UpdateAlertError, UpdateAlertErrors, UpdateAlertResponse, UpdateAlertResponses, UpdateAlertRuleData, UpdateAlertRuleErrors, UpdateAlertRuleRequest, UpdateAlertRuleResponse, UpdateAlertRuleResponses, UpdateAnalyticsIngestKeyData, UpdateAnalyticsIngestKeyErrors, UpdateAnalyticsIngestKeyRequest, UpdateAnalyticsIngestKeyResponse, UpdateAnalyticsIngestKeyResponses, UpdateApiKeyData, UpdateApiKeyErrors, UpdateApiKeyRequest, UpdateApiKeyResponse, UpdateApiKeyResponses, UpdateApplicationWorkspaceData, UpdateApplicationWorkspaceErrors, UpdateApplicationWorkspaceRequest, UpdateApplicationWorkspaceResponse, UpdateApplicationWorkspaceResponses, UpdateAutomaticDeployData, UpdateAutomaticDeployErrors, UpdateAutomaticDeployRequest, UpdateAutomaticDeployResponse, UpdateAutomaticDeployResponses, UpdateBackupScheduleData, UpdateBackupScheduleError, UpdateBackupScheduleErrors, UpdateBackupScheduleRequest, UpdateBackupScheduleResponse, UpdateBackupScheduleResponses, UpdateBlobRequest, UpdateBlobResponse, UpdateCapabilityResponse, UpdateCloudFeaturesData, UpdateCloudFeaturesResponse, UpdateCloudFeaturesResponses, UpdateCloudflareProviderData, UpdateCloudflareProviderErrors, UpdateCloudflareProviderRequest, UpdateCloudflareProviderResponse, UpdateCloudflareProviderResponses, UpdateConfigBody, UpdateConnectionTokenData, UpdateConnectionTokenErrors, UpdateConnectionTokenResponse, UpdateConnectionTokenResponses, UpdateCustomDomainData, UpdateCustomDomainErrors, UpdateCustomDomainRequest, UpdateCustomDomainResponse, UpdateCustomDomainResponses, UpdateDashboardData, UpdateDashboardError, UpdateDashboardErrors, UpdateDashboardRequest, UpdateDashboardResponse, UpdateDashboardResponses, UpdateDeploymentConfigRequest, UpdateDeploymentTokenData, UpdateDeploymentTokenErrors, UpdateDeploymentTokenRequest, UpdateDeploymentTokenResponse, UpdateDeploymentTokenResponses, UpdateDnsProviderRequest, UpdateEmailProviderData, UpdateEmailProviderErrors, UpdateEmailProviderRequest, UpdateEmailProviderResponse, UpdateEmailProviderResponses, UpdateEnvironmentSettingsData, UpdateEnvironmentSettingsErrors, UpdateEnvironmentSettingsRequest, UpdateEnvironmentSettingsResponse, UpdateEnvironmentSettingsResponses, UpdateEnvironmentSubdomainData, UpdateEnvironmentSubdomainErrors, UpdateEnvironmentSubdomainRequest, UpdateEnvironmentSubdomainResponse, UpdateEnvironmentSubdomainResponses, UpdateEnvironmentVariableData, UpdateEnvironmentVariableErrors, UpdateEnvironmentVariableRequest, UpdateEnvironmentVariableResponse, UpdateEnvironmentVariableResponses, UpdateErrorGroupData, UpdateErrorGroupErrors, UpdateErrorGroupRequest, UpdateErrorGroupResponses, UpdateExternalServiceRequest, UpdateFlagData, UpdateFlagErrors, UpdateFlagRequest, UpdateFlagResponse, UpdateFlagResponses, UpdateFunnelData, UpdateFunnelErrors, UpdateFunnelResponses, UpdateGitProviderCredentialsData, UpdateGitProviderCredentialsErrors, UpdateGitProviderCredentialsResponse, UpdateGitProviderCredentialsResponses, UpdateGitSettingsData, UpdateGitSettingsErrors, UpdateGitSettingsRequest, UpdateGitSettingsResponse, UpdateGitSettingsResponses, UpdateGlobalMcpData, UpdateGlobalMcpErrors, UpdateGlobalMcpResponse, UpdateGlobalMcpResponses, UpdateGlobalSkillData, UpdateGlobalSkillErrors, UpdateGlobalSkillResponse, UpdateGlobalSkillResponses, UpdateIncidentStatusData, UpdateIncidentStatusErrors, UpdateIncidentStatusRequest, UpdateIncidentStatusResponse, UpdateIncidentStatusResponses, UpdateIpAccessControlData, UpdateIpAccessControlError, UpdateIpAccessControlErrors, UpdateIpAccessControlRequest, UpdateIpAccessControlResponse, UpdateIpAccessControlResponses, UpdateKvRequest, UpdateKvResponse, UpdateManagedDomainApiRequest, UpdateManagedDomainData, UpdateManagedDomainErrors, UpdateManagedDomainResponse, UpdateManagedDomainResponses, UpdateMcpData, UpdateMcpErrors, UpdateMcpRequest, UpdateMcpResponse, UpdateMcpResponses, UpdateMemberRoleRequest, UpdateMetricAlertRequest, UpdateNotificationEmailProviderData, UpdateNotificationEmailProviderErrors, UpdateNotificationEmailProviderRequest, UpdateNotificationEmailProviderResponse, UpdateNotificationEmailProviderResponses, UpdateNotificationProviderData, UpdateNotificationProviderErrors, UpdateNotificationProviderResponse, UpdateNotificationProviderResponses, UpdateNotificationRouteData, UpdateNotificationRouteErrors, UpdateNotificationRouteRequest, UpdateNotificationRouteResponse, UpdateNotificationRouteResponses, UpdateOidcProviderData, UpdateOidcProviderRequest, UpdateOidcProviderResponse, UpdateOidcProviderResponses, UpdatePermissionModeData, UpdatePermissionModeErrors, UpdatePermissionModeRequest, UpdatePermissionModeResponse, UpdatePermissionModeResponses, UpdatePreferencesData, UpdatePreferencesErrors, UpdatePreferencesRequest, UpdatePreferencesResponse, UpdatePreferencesResponses, UpdateProjectCloudTelemetryData, UpdateProjectCloudTelemetryError, UpdateProjectCloudTelemetryErrors, UpdateProjectCloudTelemetryRequest, UpdateProjectCloudTelemetryResponse, UpdateProjectCloudTelemetryResponses, UpdateProjectData, UpdateProjectDeploymentConfigData, UpdateProjectDeploymentConfigErrors, UpdateProjectDeploymentConfigResponse, UpdateProjectDeploymentConfigResponses, UpdateProjectErrors, UpdateProjectResponse, UpdateProjectResponses, UpdateProjectSecretData, UpdateProjectSecretErrors, UpdateProjectSecretRequest, UpdateProjectSecretResponse, UpdateProjectSecretResponses, UpdateProjectSettingsData, UpdateProjectSettingsErrors, UpdateProjectSettingsRequest, UpdateProjectSettingsResponse, UpdateProjectSettingsResponses, UpdateProviderCredentialsRequest, UpdateProviderData, UpdateProviderErrors, UpdateProviderKeyData, UpdateProviderKeyError, UpdateProviderKeyErrors, UpdateProviderKeyRequest, UpdateProviderKeyResponse, UpdateProviderKeyResponses, UpdateProviderModelData, UpdateProviderModelError, UpdateProviderModelErrors, UpdateProviderModelRequest, UpdateProviderModelResponse, UpdateProviderModelResponses, UpdateProviderPreferenceRequest, UpdateProviderRequest, UpdateProviderResponse, UpdateProviderResponses, UpdateRouteData, UpdateRouteErrors, UpdateRouteRequest, UpdateRouteResponse, UpdateRouteResponses, UpdateS3SourceData, UpdateS3SourceError, UpdateS3SourceErrors, UpdateS3SourceRequest, UpdateS3SourceResponse, UpdateS3SourceResponses, UpdateSecretBody, UpdateSelfData, UpdateSelfErrors, UpdateSelfRequest, UpdateSelfResponse, UpdateSelfResponses, UpdateServiceData, UpdateServiceErrors, UpdateServiceResourcesData, UpdateServiceResourcesErrors, UpdateServiceResourcesResponse, UpdateServiceResourcesResponses, UpdateServiceResponse, UpdateServiceResponses, UpdateServiceTemplateRuntimeData, UpdateServiceTemplateRuntimeErrors, UpdateServiceTemplateRuntimeRequest, UpdateServiceTemplateRuntimeResponse, UpdateServiceTemplateRuntimeResponses, UpdateSessionDurationData, UpdateSessionDurationError, UpdateSessionDurationErrors, UpdateSessionDurationRequest, UpdateSessionDurationResponse, UpdateSessionDurationResponse2, UpdateSessionDurationResponses, UpdateSettingsData, UpdateSettingsErrors, UpdateSettingsResponse, UpdateSettingsResponses, UpdateSkillData, UpdateSkillErrors, UpdateSkillRequest, UpdateSkillResponse, UpdateSkillResponses, UpdateSlackProviderData, UpdateSlackProviderErrors, UpdateSlackProviderRequest, UpdateSlackProviderResponse, UpdateSlackProviderResponses, UpdateSpeedMetricsData, UpdateSpeedMetricsError, UpdateSpeedMetricsErrors, UpdateSpeedMetricsPayload, UpdateSpeedMetricsResponse, UpdateSpeedMetricsResponses, UpdateStatusResponse, UpdateTeamData, UpdateTeamErrors, UpdateTeamMemberRoleData, UpdateTeamMemberRoleErrors, UpdateTeamMemberRoleResponse, UpdateTeamMemberRoleResponses, UpdateTeamRequest, UpdateTeamResponse, UpdateTeamResponses, UpdateTokenRequest, UpdateTokenResponse, UpdateTraefikRouteEnabledRequest, UpdateUserData, UpdateUserErrors, UpdateUserPermissionModeData, UpdateUserPermissionModeErrors, UpdateUserPermissionModeResponse, UpdateUserPermissionModeResponses, UpdateUserRequest, UpdateUserResponse, UpdateUserResponses, UpdateWebhookData, UpdateWebhookErrors, UpdateWebhookProviderData, UpdateWebhookProviderErrors, UpdateWebhookProviderRequest, UpdateWebhookProviderResponse, UpdateWebhookProviderResponses, UpdateWebhookRequestBody, UpdateWebhookResponse, UpdateWebhookResponses, UpgradeExternalServiceRequest, UpgradePreviewGatewayData, UpgradePreviewGatewayError, UpgradePreviewGatewayErrors, UpgradePreviewGatewayResponse, UpgradePreviewGatewayResponses, UpgradeProjectServiceTemplateData, UpgradeProjectServiceTemplateErrors, UpgradeProjectServiceTemplateResponse, UpgradeProjectServiceTemplateResponses, UpgradeRequest, UpgradeServiceData, UpgradeServiceErrors, UpgradeServiceResponse, UpgradeServiceResponses, UpgradeServiceTemplateRequest, UploadApplicationWorkspaceFilesData, UploadApplicationWorkspaceFilesErrors, UploadApplicationWorkspaceFilesResponse, UploadApplicationWorkspaceFilesResponses, UploadGlobalSkillData, UploadGlobalSkillErrors, UploadGlobalSkillResponse, UploadGlobalSkillResponses, UploadGlobalWorkspaceFilesData, UploadGlobalWorkspaceFilesErrors, UploadGlobalWorkspaceFilesResponse, UploadGlobalWorkspaceFilesResponses, UploadReleaseFileData, UploadReleaseFileErrors, UploadReleaseFileResponse, UploadReleaseFileResponses, UploadSkillData, UploadSkillErrors, UploadSkillResponse, UploadSkillResponses, UploadSourceFileData, UploadSourceFileErrors, UploadSourceFileResponse, UploadSourceFileResponses, UploadSourceMapData, UploadSourceMapErrors, UploadSourceMapResponse, UploadSourceMapResponses, UploadStaticBundleData, UploadStaticBundleErrors, UploadStaticBundleResponse, UploadStaticBundleResponses, UploadUserConversationAttachmentData, UploadUserConversationAttachmentErrors, UploadUserConversationAttachmentResponse, UploadUserConversationAttachmentResponses, UpsertAgentRequest, UpsertSecretData, UpsertSecretErrors, UpsertSecretRequest, UpsertSecretResponse, UpsertSecretResponses, UptimeDataPoint, UptimeHistoryResponse, UsageFilter, UsageInfo, UsageLogEntry, UsageLogPage, UsageQueryParams, UsageSource, UsageSummary, UserResponse, ValidateConnectionData, ValidateConnectionErrors, ValidateConnectionResponse, ValidateConnectionResponses, ValidateEmailData, ValidateEmailErrors, ValidateEmailRequest, ValidateEmailResponse, ValidateEmailResponse2, ValidateEmailResponses, ValidationLevel, ValidationReport, ValidationResponse, ValidationResult, ValidationStatus, ValidationSummary, VerifyAndEnableMfaData, VerifyAndEnableMfaErrors, VerifyAndEnableMfaResponse, VerifyAndEnableMfaResponses, VerifyDomainData, VerifyDomainErrors, VerifyDomainResponse, VerifyDomainResponses, VerifyEmailData, VerifyEmailErrors, VerifyEmailResponse, VerifyEmailResponses, VerifyManagedDomainData, VerifyManagedDomainErrors, VerifyManagedDomainResponse, VerifyManagedDomainResponses, VerifyMfaChallengeData, VerifyMfaChallengeErrors, VerifyMfaChallengeResponse, VerifyMfaChallengeResponses, VerifyMfaRequest, VerifyStepUpData, VerifyStepUpErrors, VerifyStepUpRequest, VerifyStepUpResponse, VerifyStepUpResponses, ViewItem, ViewsOverTime, ViewsOverTimeQuery, VisitorDetails, VisitorFacets, VisitorFacetsQuery, VisitorFacetValue, VisitorInfo, VisitorJourneyQuery, VisitorJourneyResponse, VisitorLocationsQuery, VisitorRecord, VisitorSegmentFilters, VisitorSessionsQuery, VisitorSessionsResponse, VisitorsListQuery, VisitorsResponse, VisitorStats, VisitorWithGeolocation, VolumeMount, VolumeType, VulnerabilityResponse, WakeEnvironmentData, WakeEnvironmentErrors, WakeEnvironmentResponse, WakeEnvironmentResponses, WalWarning, WalWarningSeverity, WebhookConfig, WebhookDeliveryResponse, WebhookResponse, WebhookTriggerData, WebhookTriggerErrors, WebhookTriggerRequest, WebhookTriggerResponse, WebhookTriggerResponse2, WebhookTriggerResponses, WorkflowDryRunData, WorkflowDryRunErrors, WorkflowDryRunRequest, WorkflowDryRunResponse, WorkflowDryRunResponses, WorkloadDescriptor, WorkloadId, WorkloadStatus, WorkloadType, WriteApplicationWorkspaceFilesData, WriteApplicationWorkspaceFilesErrors, WriteApplicationWorkspaceFilesRequest, WriteApplicationWorkspaceFilesResponse, WriteApplicationWorkspaceFilesResponse2, WriteApplicationWorkspaceFilesResponses, WriteFileBody, WriteFileData, WriteFileErrors, WriteFileResponse, WriteFileResponses, WriteFilesBody, WriteFilesData, WriteFilesErrors, WriteFilesResponse, WriteFilesResponse2, WriteFilesResponses, ZoneListResponse } from './types.gen'; +export { acknowledgeAlarm, acknowledgeSystemAlarm, activateAiProvider, activateApiKey, activateConnection, activateProvider, addClusterMember, addContext, addEnvironmentDomain, addEvents, addManagedDomain, addProviderModel, addSessionReplayEvents, addTeamMember, adminDrainNode, adminDrainStatus, adminGetNode, adminListNodeContainers, adminListNodes, adminRemoveNode, adminUndrainNode, aggregateApiTraffic, applyHostnameMode, archiveApplication, archiveConversation, archiveFlag, archiveUserConversation, assignRole, attachScheduleServices, authorizeEmailDomainProject, blobCopy, blobDelete, blobDisable, blobDownload, blobEnable, blobHead, blobList, blobPut, blobStatus, blobUpdate, cancel, cancelBackup, cancelBulkActivationJob, cancelDeployment, cancelDomainOrder, cancelPgUpgrade, cancelRun, cancelScheduleRun, changePasswordSelf, changeProjectSource, changeRequiredPassword, chatCompletions, checkAnalyticsHasEvents, checkCommitExists, checkDomainStatus, checkExplorerSupport, checkForUpdate, checkIpBlocked, checkProviderDeletionSafety, chunkUploadOptions, cleanupExpiredBackups, clearPreviewPassword, cliDeviceApprove, cliDeviceDeny, cliDeviceLookup, cliDevicePoll, cliDeviceStart, cliLogout, clusterDnsStatus, cmd, cmdKill, cmdLogs, confirmPendingAction, confirmUserPendingAction, containerMetricsGetHistory, controlApplicationWorkspace, createAgent, createAlert, createAlertRule, createAnalyticsIngestKey, createApiKey, createApplication, createApplicationConversation, createApplicationPreviewLink, createApplicationProject, createBackupSchedule, createBitbucketProvider, createBulkActivationJob, createCloudflareProvider, createConversation, createCustomDomain, createDashboard, createDeploymentToken, createDnsProvider, createDomain, createDsn, createEmailDomain, createEmailProvider, createEnvironment, createEnvironmentVariable, createFacet, createFlag, createFunnel, createGenericProvider, createGiteaPatProvider, createGithubPatProvider, createGitlabOauthProvider, createGitlabPatProvider, createGitProvider, createGlobalConversation, createGlobalMcp, createGlobalSkill, createGlobalWorkspacePreviewLink, createIncident, createIpAccessControl, createMcp, createMonitor, createNotificationEmailProvider, createNotificationProvider, createNotificationRoute, createOidcProvider, createOidcRoleMapping, createOrRecreateOrder, createPlan, createPr, createProject, createProjectFromTemplate, createProjectRelease, createProjectSecret, createProviderKey, createRelease, createRoute, createS3Source, createSandbox, createService, createSkill, createSlackProvider, createSnapshot, createTeam, createThreadArtifact, createUser, createWebhook, createWebhookProvider, deactivateApiKey, deactivateConnection, deactivateProvider, deauthorizeDiscoveredRouteCert, deleteAgent, deleteAlert, deleteAlertRule, deleteApiKey, deleteBackup, deleteBackupSchedule, deleteConnection, deleteCustomDomain, deleteDashboard, deleteDeploymentToken, deleteDnsProvider, deleteDomain, deleteEmailDomain, deleteEmailProvider, deleteEnvironment, deleteEnvironmentDomain, deleteEnvironmentVariable, deleteExternalImage, deleteFacet, deleteFunnel, deleteGitProvider, deleteGlobalMcp, deleteGlobalSkill, deleteIpAccessControl, deleteMcp, deleteMonitor, deleteNotificationProvider, deleteNotificationRoute, deleteOidcProvider, deleteOidcRoleMapping, deletePreferences, deleteProject, deleteProjectSecret, deleteProviderKey, deleteProviderModel, deleteProviderSafely, deleteReleaseSourceFiles, deleteReleaseSourceMaps, deleteRoute, deleteS3Source, deleteScan, deleteSecret, deleteService, deleteSessionReplay, deleteSkill, deleteSnapshot, deleteSourceMap, deleteStaticBundle, deleteTeam, deleteUser, deleteWebhook, deployApplicationWorkspaceProject, deployFromImage, deployFromImageUpload, deployFromStatic, deployFromUploadedSource, deploymentMetricsGetLatest, deploymentMetricsGetRange, deploymentMetricsToggle, destroySandbox, detachScheduleService, detectPublicEnvExample, detectPublicPresets, disableBackupSchedule, disableMfa, disconnectCloud, discoverWorkloads, domain, downloadApplicationWorkspaceFile, downloadGlobalSkillArchive, downloadGlobalWorkspaceFile, downloadObject, downloadSkillArchive, emailStatus, embeddings, enableBackupSchedule, enrichVisitor, enrollCloud, estimateBulkActivation, exec, execDetached, executeDeploymentOperation, executeImport, extendTimeout, externalServiceEnablePgStatStatements, externalServiceMetricsByDatabase, externalServiceMetricsCreateAlertRule, externalServiceMetricsDeleteAlertRule, externalServiceMetricsGetAlertRules, externalServiceMetricsGetLatest, externalServiceMetricsGetRange, externalServiceMetricsStatus, externalServiceMetricsToggle, externalServiceMetricsUpdateAlertRule, externalServiceResetPgStatStatements, finalizeOrder, finalizeProjectRelease, findConversation, generateJoinToken, generatePresetDockerfile, getAccessInfo, getActiveVisitors, getActivityGraph, getAdminGate, getAgent, getAggregatedBuckets, getAiAgentBreakdown, getAiAgentPages, getAiAgentTimeline, getAiDataAccess, getAiPageBreakdown, getAiProviderStatus, getAiStatusBreakdown, getAlert, getAlertRule, getAllRepositoriesByName, getAnalyticsActiveVisitors, getAnalyticsEventsCount, getAnalyticsSessionEvents, getAnalyticsVisitorSessions, getApiCallers, getApiKey, getApiKeyPermissions, getApiRoutes, getApiSummary, getApiTimeseries, getApiTrafficProxyLogAccess, getApplication, getApplicationWorkspace, getApplicationWorkspaceChanges, getApplicationWorkspaceDiff, getApplicationWorkspaceDirectory, getApplicationWorkspaceFile, getAuditLog, getBackup, getBackupSchedule, getBranchesByRepositoryId, getBucketedIncidents, getBucketedStatus, getBulkActivationJob, getChallengeToken, getChatReadiness, getCliStatus, getCloudAiCapability, getCloudBackfillStatus, getCloudCapability, getCloudStatus, getCloudTelemetryStatus, getClusterHealth, getClusterMember, getCmd, getContainerDetail, getContainerEnvironmentVariable, getContainerLogs, getContainerLogsById, getContainerMetrics, getConversation, getConversationDetail, getConversations, getCronById, getCronExecutions, getCrossProjectTraceSiblings, getCurrentBulkActivationJob, getCurrentMonitorStatus, getCurrentUser, getCustomDomain, getDashboard, getDashboardProjectsAnalytics, getDelivery, getDeployment, getDeploymentContainerLogContent, getDeploymentJobLogs, getDeploymentJobs, getDeploymentOperations, getDeploymentOperationStatus, getDeploymentToken, getDiskStatus, getDnsChanges, getDnsProvider, getDomain, getDomainByHost, getDomainById, getDomainByName, getDomainDnsRecords, getDomainOrder, getEmail, getEmailEvents, getEmailLinks, getEmailProvider, getEmailStats, getEmailTracking, getEmailTrackingStatus, getEntityInfo, getEnvironment, getEnvironmentCrons, getEnvironmentDomains, getEnvironments, getEnvironmentVariables, getEnvironmentVariableValue, getErrorDashboardStats, getErrorEvent, getErrorGroup, getErrorStats, getErrorTimeSeries, getEventDetail, getEventEntries, getEventsCount, getEventsTimeline, getEventTypeBreakdown, getEventVisitors, getExternalImage, getExternalServiceBackupCapability, getFailureReportPreview, getFeatureMaturity, getFile, getFlag, getFlagSnapshot, getFunnelMetrics, getGenaiTrace, getGeneralStats, getGitProvider, getGlobalAiWorkspace, getGlobalEvents, getGlobalEventStats, getGlobalMcp, getGlobalSandboxStatus, getGlobalSkill, getGlobalWorkspaceChanges, getGlobalWorkspaceDiff, getGlobalWorkspaceDirectory, getGlobalWorkspaceFile, getGroupedPageMetrics, getHealth, getHourlyVisits, getHttpChallengeDebug, getImportStatus, getIncident, getIncidentUpdates, getIngestErrors, getIpAccessControl, getIpGeolocation, getJoinTokenStatus, getLastDeployment, getLatestDeploymentMedia, getLatestScan, getLatestScansPerEnvironment, getLiveVisitorsList, getLogContext, getMcp, getMetricsOverTime, getMonitor, getNotificationProvider, getNotificationRoute, getOnDemandCertStatus, getOrCreateDsn, getPageFlow, getPageHourlySessions, getPagePathDetail, getPagePaths, getPagePathsSparklines, getPagePathVisitors, getPendingAction, getPerformanceMetrics, getPgUpgrade, getPgUpgradeLogs, getPipelineHistory, getPipelineStats, getPlatformInfo, getPostgresWalHealth, getPreferences, getPreviewGatewayLogs, getPreviewGatewaySettings, getPreviewGatewayStatus, getPricing, getPrivateIp, getProject, getProjectAlarmsSummary, getProjectBySlug, getProjectCloudTelemetry, getProjectDeployments, getProjects, getProjectServiceEnvironmentVariables, getProjectServiceTemplate, getProjectSessionReplays, getProjectsHealth, getProjectsMonitorHealth, getProjectStatistics, getProjectTemplate, getPropertyBreakdown, getPropertyTimeline, getProviderConnections, getProviderKey, getProviderMetadata, getProvidersMetadata, getProxyLogById, getProxyLogByRequestId, getProxyLogs, getPublicBranches, getPublicComposePreview, getPublicComposeServices, getPublicIp, getPublicRepository, getQueryContainerInfo, getQuota, getRecentActivity, getRemoteExternalImage, getRepositoryBranches, getRepositoryById, getRepositoryByName, getRepositoryComposePreview, getRepositoryComposeServicesLive, getRepositoryEnvExampleLive, getRepositoryPresetByName, getRepositoryPresetLive, getRepositoryTags, getResolvedEnvironmentVariables, getResolvedEnvironmentVariableValue, getRestoreCapabilities, getRestoreRun, getRoute, getRun, getRunWithLogs, getS3Credentials, getS3Source, getSandbox, getSandboxStatus, getScan, getScanByDeployment, getScanVulnerabilities, getService, getServiceBySlug, getServiceEnvironmentVariable, getServiceEnvironmentVariables, getServiceHealthStatus, getServicePreviewEnvironmentVariableNames, getServicePreviewEnvironmentVariablesMasked, getServiceRuntime, getServiceStats, getServiceTypeParameters, getServiceTypes, getSessionDetails, getSessionEvents, getSessionLogs, getSessionReplay, getSessionReplayEvents, getSettings, getSkill, getSlowQueries, getSnapshot, getStaticBundle, getStatusOverview, getSystemAlarmsSummary, getTagsByRepositoryId, getTeam, getTimeBucketStats, getTodayStats, getTrace, getTraefikDiscoveryStatus, getUnifiedTrace, getUniqueCounts, getUniqueEvents, getUpdateCapability, getUpdateStatus, getUptimeHistory, getUsageByProvider, getUsageRecent, getUsageSummary, getUsageTimeseries, getUsageTopModels, getUserConversation, getUserConversationAttachment, getUserPendingAction, getVisibleCustomDomainByHostname, getVisitorByGuid, getVisitorById, getVisitorDetails, getVisitorFacets, getVisitorInfo, getVisitorJourney, getVisitors, getVisitorSessions, getVisitorStats, getWebhook, getWorkspaceFileLimits, grantProjectAccess, handleGitProviderOauthCallback, hasAnalyticsEvents, hasErrorGroups, hasPerformanceMetrics, hasTraces, importApplicationWorkspaceGit, importEmailDomain, importExternalService, importLocalAiProviderCredential, importTraefikAcmeJson, ingestLogs, ingestLogsByPath, ingestMetrics, ingestMetricsByPath, ingestSentryEnvelope, ingestSentryEvent, ingestTraces, ingestTracesByPath, ingestTunneledEnvelope, initSessionReplay, inspectDropArchive, issueRuntimeCredentials, jobLogs, jobStatus, killJob, kvDel, kvDisable, kvEnable, kvExpire, kvGet, kvIncr, kvKeys, kvSet, kvStatus, kvTtl, kvUpdate, latestRunForSource, linkApplicationProject, linkCustomDomainToCertificate, linkServiceToProject, listAgentRuns, listAgents, listAiProviders, listAlertRules, listAlerts, listAllConversations, listAllRuns, listAnalyticsIngestKeys, listApiKeys, listApplicationConversations, listApplications, listAuditLogs, listAvailableContainers, listBackupAlerts, listBackupChildren, listBackupSchedules, listBackupsForSchedule, listCommitsByRepositoryId, listConnections, listContainerHistory, listContainers, listContainersAtPath, listConversations, listCustomDomainsForProject, listDashboards, listDeliveries, listDeploymentContainerLogs, listDeploymentTokens, listDiscoverableDomains, listDnsProviders, listDomains, listDsns, listEmailDomainProjects, listEmailDomains, listEmailProviders, listEmails, listEnrollmentTokens, listEntities, listErrorEvents, listErrorGroups, listEvents, listEventTypes, listExternalImages, listExternalPlugins, listExternalServiceBackups, listFacets, listFlags, listFunnels, listGitProviders, listGlobalMcps, listGlobalSkills, listIncidents, listInsights, listIpAccessControl, listJobs, listKnownAiAgents, listManagedDomains, listManagedEnvironmentVariables, listMcps, listMetricLabelKeys, listMetricLabelValues, listMetricNames, listModels, listMonitors, listNotificationProviders, listNotificationRoutes, listOidcProviders, listOidcProviderUsers, listOidcRoleMappings, listOnDemandCerts, listOrders, listPeers, listPendingActions, listPgUpgrades, listPresets, listProjectAccess, listProjectAlarms, listProjectScans, listProjectSecrets, listProjectServices, listProjectTemplates, listProjectTemplateTags, listProviderKeys, listProviderZones, listPublicProviders, listReleaseFiles, listReleases, listRemoteExternalImages, listRenewalAttempts, listRepositoriesByConnection, listRepositoriesByProvider, listRestoreRunsForService, listRootContainers, listRoutes, listS3Sources, listSandboxes, listScheduleRunJobs, listScheduleRuns, listScheduleServices, listSecrets, listServiceHealthStatuses, listServiceProjects, listServices, listServiceSchedules, listSkills, listSnapshots, listSourceBackups, listSourceFiles, listSourceMaps, listSources, listStaticBundles, listSyncedRepositories, listSystemAlarms, listTeamMembers, listTeamProjects, listTeams, listThreadArtifacts, listTraefikDiscoveredRoutes, listUserPendingActions, listUsers, listWebhooks, login, logout, lookupDnsARecords, mintEnrollmentToken, mkdir, nodeHeartbeat, nodeMetricsGetAlertRules, nodeMetricsGetRange, nodeMetricsUpdateAlertRule, observabilityFullEvent, observabilityListEvents, oidcCallback, type Options, patchAdminGate, patchPreviewGatewaySettings, pauseDeployment, pauseSandbox, planRestore, postDnsAck, previewAlert, previewFunnelMetrics, previewHostnameMode, promoteClusterMember, promoteDeployment, provisionDomain, purgeProjectLogs, pushExternalImage, queryData, queryGenaiTraces, queryLogs, queryMetrics, querySpanStats, queryTraces, queryTraceSummaries, readEntityRows, readFile, reAnalyze, reassignProjectCustomDomain, reconcileCloudBackupSource, recordConsoleEvent, recordEventMetrics, recordFlagExposure, recordSpeedMetrics, refreshAiProviderModels, refreshAiProviderStatus, refreshProviderModels, refreshRouteTable, regenerateDsn, registerExternalImage, registerNode, reinstallGitlabWebhook, rejectPendingAction, rejectUserPendingAction, reloadPlugins, removeClusterMember, removeManagedDomain, removeRole, removeTeamMember, renameConversation, renameUserConversation, renewDomain, repointContinuousArchiveSource, requestDiscoveredRouteCert, requestPasswordReset, resetPassword, resizeSandbox, resolveAlarm, resolvePermission, resolveSystemAlarm, resolveUserPermission, restartContainer, restartPreviewGateway, restartSandbox, restoreApplication, restoreFlag, restoreUser, restoreUserConversation, resumeDeployment, resumeSandbox, retryCluster, retryDelivery, retryFacetBackfill, retryPgUpgrade, retryRun, revealGlobalMcpConfig, revealMcpConfig, revealNotificationProviderConfig, revealServiceEnvironmentVariables, revealServiceParameter, revenueCreateIntegration, revenueDeleteIntegration, revenueGlobalEvents, revenueImportInvoicesCsv, revenueImportSubscriptionsCsv, revenueListIntegrations, revenueListProviders, revenueMetricsCustomers, revenueMetricsGlobalMrr, revenueMetricsGlobalSummary, revenueMetricsMrr, revenueMetricsSummary, revenueRecentEvents, revenueRotateToken, revenueUpdateConfig, revenueUpdateSecret, revokeAnalyticsIngestKey, revokeDsn, revokeEmailDomainProject, revokeEnrollmentToken, revokeJoinToken, revokeProjectAccess, rollbackPgUpgrade, rollbackToDeployment, rootfsGc, rootfsReport, rotateAnalyticsIngestKey, rotateApiKey, rotateClusterCa, rotateDeploymentToken, runBackupForSource, runConnectionHealthCheck, runExternalServiceBackup, runScheduleNow, sandboxCreatePreviewLink, sandboxIssueRuntimeEnvironment, saveAgentToken, saveAiProviderCredential, searchLogs, sendEmail, sendFailureReport, sendProjectAiMessage, sendUserMessage, setAiDataAccess, setAlternateSources, setApplicationPrimaryProject, setDefaultS3Source, setFlagEnvironment, setPreviewPassword, setTraefikDiscoveredRouteEnabled, setupDns, setupDnsChallenge, setupEmailTracking, setupMfa, silenceAlarm, silenceSystemAlarm, sleepEnvironment, smokeTestAgent, sourceSandbox, startAnalysis, startContainer, startFix, startGitProviderOauth, startOidcLoginBySlug, startPgUpgrade, startRestore, startService, startUpdate, statPath, stopContainer, stopSandbox, stopService, stopTurn, stopUserTurn, storageSummary, streamContainerMetrics, streamEvents, streamRunEvents, syncRepositories, tailDeploymentJobLogs, tailLogs, teardownDeployment, teardownEnvironment, terminal, testNotificationProvider, testOidcProvider, testProvider, testProviderConnection, testProviderKeyById, testProviderKeyInline, testS3ConnectionPreview, testS3SourceConnection, trackClick, trackOpen, triggerAgent, triggerProjectPipeline, triggerScan, triggerServiceHealthCheck, triggerWeeklyDigest, unlinkApplicationProject, unlinkServiceFromProject, updateAgent, updateAiProvider, updateAiSummaryPreference, updateAlert, updateAlertRule, updateAnalyticsIngestKey, updateApiKey, updateApplicationWorkspace, updateAutomaticDeploy, updateBackupSchedule, updateCloudFeatures, updateCloudflareProvider, updateConnectionToken, updateCustomDomain, updateDashboard, updateDeploymentToken, updateEmailProvider, updateEnvironmentSettings, updateEnvironmentSubdomain, updateEnvironmentVariable, updateErrorGroup, updateFlag, updateFunnel, updateGitProviderCredentials, updateGitSettings, updateGlobalMcp, updateGlobalSkill, updateIncidentStatus, updateIpAccessControl, updateManagedDomain, updateMcp, updateNotificationEmailProvider, updateNotificationProvider, updateNotificationRoute, updateOidcProvider, updatePermissionMode, updatePreferences, updateProject, updateProjectCloudTelemetry, updateProjectDeploymentConfig, updateProjectSecret, updateProjectSettings, updateProvider, updateProviderKey, updateProviderModel, updateRoute, updateS3Source, updateSelf, updateService, updateServiceResources, updateServiceTemplateRuntime, updateSessionDuration, updateSettings, updateSkill, updateSlackProvider, updateSpeedMetrics, updateTeam, updateTeamMemberRole, updateUser, updateUserPermissionMode, updateWebhook, updateWebhookProvider, upgradePreviewGateway, upgradeProjectServiceTemplate, upgradeService, uploadApplicationWorkspaceFiles, uploadGlobalSkill, uploadGlobalWorkspaceFiles, uploadReleaseFile, uploadSkill, uploadSourceFile, uploadSourceMap, uploadStaticBundle, uploadUserConversationAttachment, upsertSecret, validateConnection, validateEmail, verifyAndEnableMfa, verifyDomain, verifyEmail, verifyManagedDomain, verifyMfaChallenge, verifyStepUp, wakeEnvironment, webhookTrigger, workflowDryRun, writeApplicationWorkspaceFiles, writeFile, writeFiles } from './sdk.gen'; +export type { AcknowledgeAlarmData, AcknowledgeAlarmErrors, AcknowledgeAlarmResponses, AcknowledgeSystemAlarmData, AcknowledgeSystemAlarmErrors, AcknowledgeSystemAlarmResponses, AcmeOrderResponse, ActivateAiProviderData, ActivateAiProviderErrors, ActivateAiProviderResponse, ActivateAiProviderResponses, ActivateApiKeyData, ActivateApiKeyErrors, ActivateApiKeyResponse, ActivateApiKeyResponses, ActivateConnectionData, ActivateConnectionErrors, ActivateConnectionResponses, ActivateProviderData, ActivateProviderErrors, ActivateProviderResponse, ActivateProviderResponses, ActiveVisitor, ActiveVisitorCountResponse, ActiveVisitorsQuery, ActiveVisitorsResponse, ActivityDay, ActivityEvent, ActivityGraphQuery, ActivityGraphResponse, AddClusterMemberData, AddClusterMemberErrors, AddClusterMemberRequest, AddClusterMemberResponse, AddClusterMemberResponses, AddContextData, AddContextErrors, AddContextRequest, AddContextResponses, AddEnvironmentDomainData, AddEnvironmentDomainErrors, AddEnvironmentDomainRequest, AddEnvironmentDomainResponse, AddEnvironmentDomainResponses, AddEventsData, AddEventsError, AddEventsErrors, AddEventsRequest, AddEventsResponse, AddEventsResponse2, AddEventsResponses, AddManagedDomainApiRequest, AddManagedDomainData, AddManagedDomainErrors, AddManagedDomainResponse, AddManagedDomainResponses, AddProviderModelData, AddProviderModelError, AddProviderModelErrors, AddProviderModelRequest, AddProviderModelResponse, AddProviderModelResponses, AddSessionReplayEventsData, AddSessionReplayEventsError, AddSessionReplayEventsErrors, AddSessionReplayEventsResponse, AddSessionReplayEventsResponses, AddTeamMemberData, AddTeamMemberErrors, AddTeamMemberResponse, AddTeamMemberResponses, AdminDrainNodeData, AdminDrainNodeErrors, AdminDrainNodeResponse, AdminDrainNodeResponses, AdminDrainStatusData, AdminDrainStatusErrors, AdminDrainStatusResponse, AdminDrainStatusResponses, AdminGateResponse, AdminGateSource, AdminGetNodeData, AdminGetNodeErrors, AdminGetNodeResponse, AdminGetNodeResponses, AdminListNodeContainersData, AdminListNodeContainersErrors, AdminListNodeContainersResponse, AdminListNodeContainersResponses, AdminListNodesData, AdminListNodesErrors, AdminListNodesResponse, AdminListNodesResponses, AdminRemoveNodeData, AdminRemoveNodeErrors, AdminRemoveNodeResponse, AdminRemoveNodeResponses, AdminUndrainNodeData, AdminUndrainNodeErrors, AdminUndrainNodeResponse, AdminUndrainNodeResponses, AgentConfigResponse, AgentRunLogResponse, AgentRunResponse, AgentRunWithLogsResponse, AgentSandboxSettings, AgentSandboxSettingsMasked, AggregateApiTrafficData, AggregateApiTrafficError, AggregateApiTrafficErrors, AggregateApiTrafficResponse, AggregateApiTrafficResponses, AggregatedBucketItem, AggregatedBucketsQuery, AggregatedBucketsResponse, AggregationLevel, AggregationTemporality, AiAgentBreakdownResponse, AiAgentBreakdownRow, AiAgentDescriptor, AiAgentPageRow, AiAgentPagesResponse, AiAgentTimelineResponse, AiAgentTimelineRow, AiChatLimitsSettings, AiConfigSettings, AiDataAccessResponse, AiModelOptionDto, AiPageBreakdownResponse, AiPageBreakdownRow, AiProviderStatusResponse, AiSelectOptionDto, AiStatusBreakdownResponse, AiStatusBreakdownRow, AiSummaryPreferenceDto, AiWorkspaceFileLimitsSettings, AlarmListResponse, AlarmResponse, AlarmSummaryResponse, AlertRuleResponse, AllocEntry, AnalyticsIngestKey, AnalyticsSessionEventsResponse, AnnotatedSpan, AnomalyAlgorithm, AnomalyParams, AnomalyPreviewPointResponse, AnomalyPreviewRequest, AnomalyPreviewResponse, ApiCallerEntry, ApiCallersResponse, ApiKeyListResponse, ApiKeyResponse, ApiRouteEntry, ApiRoutesResponse, ApiTimeseriesPoint, ApiTimeseriesResponse, ApiTrafficSummary, ApiTrafficSummaryResponse, ApplicationPreviewLinkResponse, ApplicationProjectDeploymentResponse, ApplicationProjectEnvironmentResponse, ApplicationProjectResponse, ApplicationResponse, ApplicationWorkspaceChangesResponse, ApplicationWorkspaceDiffResponse, ApplicationWorkspaceDirectoryEntryResponse, ApplicationWorkspaceDirectoryResponse, ApplicationWorkspaceFileContentResponse, ApplicationWorkspaceFileResponse, ApplicationWorkspaceFileWrite, ApplicationWorkspaceResponse, ApplyHostnameModeData, ApplyHostnameModeErrors, ApplyHostnameModeRequest, ApplyHostnameModeResponse, ApplyHostnameModeResponses, AppSettings, AppSettingsResponse, ArchiveApplicationData, ArchiveApplicationErrors, ArchiveApplicationResponse, ArchiveApplicationResponses, ArchiveConversationData, ArchiveConversationErrors, ArchiveConversationResponse, ArchiveConversationResponses, ArchiveFlagData, ArchiveFlagErrors, ArchiveFlagResponse, ArchiveFlagResponse2, ArchiveFlagResponses, ArchiveMode, ArchiveUserConversationData, ArchiveUserConversationErrors, ArchiveUserConversationResponse, ArchiveUserConversationResponses, AssignRoleData, AssignRoleErrors, AssignRoleRequest, AssignRoleResponses, AttachScheduleServicesData, AttachScheduleServicesError, AttachScheduleServicesErrors, AttachScheduleServicesRequest, AttachScheduleServicesResponse, AttachScheduleServicesResponse2, AttachScheduleServicesResponses, AuditLogIpInfo, AuditLogResponse, AuditLogUserInfo, AuthFlavorDto, AuthorizedEmailDomainProjectResponse, AuthorizeEmailDomainProjectData, AuthorizeEmailDomainProjectErrors, AuthorizeEmailDomainProjectResponse, AuthorizeEmailDomainProjectResponses, AuthResponse, AuthStatusResponse, AuthTokenResponse, AutofixerRunResponse, AutofixerRunWithLogsResponse, AutofixRunConfig, AutoWatchParams, AvailableAiProviderDto, AvailableContainerInfo, AvailablePermissions, BackupAlertListResponse, BackupAlertResponse, BackupResponse, BackupScheduleResponse, BitbucketAuthInput, BlobCopyData, BlobCopyError, BlobCopyErrors, BlobCopyResponse, BlobCopyResponses, BlobDeleteData, BlobDeleteError, BlobDeleteErrors, BlobDeleteResponse, BlobDeleteResponses, BlobDisableData, BlobDisableErrors, BlobDisableResponse, BlobDisableResponses, BlobDownloadData, BlobDownloadError, BlobDownloadErrors, BlobDownloadResponses, BlobEnableData, BlobEnableErrors, BlobEnableResponse, BlobEnableResponses, BlobHeadData, BlobHeadError, BlobHeadErrors, BlobHeadResponses, BlobListData, BlobListError, BlobListErrors, BlobListResponse, BlobListResponses, BlobPutData, BlobPutError, BlobPutErrors, BlobPutResponse, BlobPutResponses, BlobResponse, BlobStatusData, BlobStatusErrors, BlobStatusResponse, BlobStatusResponse2, BlobStatusResponses, BlobUpdateData, BlobUpdateErrors, BlobUpdateResponse, BlobUpdateResponses, BranchInfo, BranchListResponse, BrowserCount, BrowsersQuery, BuildConfiguration, BuildLimitsSettings, BulkActivationEstimateResponse, BulkActivationEtaState, BulkActivationJobProjectResponse, BulkActivationJobResponse, BulkActivationProjectEstimateResponse, BulkJobProjectStatus, BulkJobStatus, BulkJobTrigger, CancelBackupData, CancelBackupError, CancelBackupErrors, CancelBackupResponse, CancelBackupResponse2, CancelBackupResponses, CancelBulkActivationJobData, CancelBulkActivationJobError, CancelBulkActivationJobErrors, CancelBulkActivationJobResponse, CancelBulkActivationJobResponses, CancelData, CancelDeploymentData, CancelDeploymentErrors, CancelDeploymentResponse, CancelDeploymentResponses, CancelDomainOrderData, CancelDomainOrderErrors, CancelDomainOrderResponse, CancelDomainOrderResponses, CancelErrors, CancelPgUpgradeData, CancelPgUpgradeError, CancelPgUpgradeErrors, CancelPgUpgradeResponse, CancelPgUpgradeResponses, CancelResponses, CancelRunData, CancelRunErrors, CancelRunResponse, CancelRunResponses, CancelScheduleRunData, CancelScheduleRunError, CancelScheduleRunErrors, CancelScheduleRunResponse, CancelScheduleRunResponses, CertStatusResponse, ChallengeConfig, ChallengeError, ChallengeValidationStatus, ChangePasswordRequest, ChangePasswordSelfData, ChangePasswordSelfErrors, ChangePasswordSelfResponse, ChangePasswordSelfResponses, ChangeProjectSourceData, ChangeProjectSourceErrors, ChangeProjectSourceRequest, ChangeProjectSourceResponse, ChangeProjectSourceResponses, ChangeRequiredPasswordData, ChangeRequiredPasswordErrors, ChangeRequiredPasswordResponse, ChangeRequiredPasswordResponses, ChatAttachmentReference, ChatAttachmentResponse, ChatAttachmentUpload, ChatCompletionChoice, ChatCompletionRequest, ChatCompletionResponse, ChatCompletionsData, ChatCompletionsError, ChatCompletionsErrors, ChatCompletionsResponse, ChatCompletionsResponses, ChatMessage, ChatReadinessResponse, CheckAnalyticsHasEventsData, CheckAnalyticsHasEventsErrors, CheckAnalyticsHasEventsResponse, CheckAnalyticsHasEventsResponses, CheckCommitExistsData, CheckCommitExistsErrors, CheckCommitExistsResponse, CheckCommitExistsResponses, CheckDomainStatusData, CheckDomainStatusErrors, CheckDomainStatusResponse, CheckDomainStatusResponses, CheckExplorerSupportData, CheckExplorerSupportErrors, CheckExplorerSupportResponse, CheckExplorerSupportResponses, CheckForUpdateData, CheckForUpdateError, CheckForUpdateErrors, CheckForUpdateResponse, CheckForUpdateResponses, CheckIpBlockedData, CheckIpBlockedError, CheckIpBlockedErrors, CheckIpBlockedResponses, CheckProviderDeletionSafetyData, CheckProviderDeletionSafetyErrors, CheckProviderDeletionSafetyResponse, CheckProviderDeletionSafetyResponses, ChildBackupEntryResponse, ChildBackupListResponse, ChunkUploadOptionsData, ChunkUploadOptionsResponse, ChunkUploadOptionsResponses, CleanupExpiredBackupsData, CleanupExpiredBackupsError, CleanupExpiredBackupsErrors, CleanupExpiredBackupsRequest, CleanupExpiredBackupsResponse, CleanupExpiredBackupsResponses, ClearPreviewPasswordData, ClearPreviewPasswordErrors, ClearPreviewPasswordResponse, ClearPreviewPasswordResponses, CliDeviceApproveData, CliDeviceApproveErrors, CliDeviceApproveRequest, CliDeviceApproveResponse, CliDeviceApproveResponse2, CliDeviceApproveResponses, CliDeviceDenyData, CliDeviceDenyErrors, CliDeviceDenyResponse, CliDeviceDenyResponses, CliDeviceLookupData, CliDeviceLookupErrors, CliDeviceLookupResponse, CliDeviceLookupResponse2, CliDeviceLookupResponses, CliDevicePollData, CliDevicePollErrors, CliDevicePollRequest, CliDevicePollResponse, CliDevicePollResponse2, CliDevicePollResponses, CliDeviceStartData, CliDeviceStartErrors, CliDeviceStartRequest, CliDeviceStartResponse, CliDeviceStartResponse2, CliDeviceStartResponses, ClientOptions, CliLoginRequest, CliLogoutData, CliLogoutErrors, CliLogoutResponse, CliLogoutResponses, CloudAiCapability, CloudAnalyticsWriteMode, CloudBackfillStatusResponse, CloudCapability, CloudFeatureSwitchesRequest, CloudflareConfig, CloudProvider, CloudSettings, CloudStatus, CloudTelemetryBackfillStatus, CloudTelemetryFidelity, CloudTelemetryWriteMode, CloudTelemetryWriteStatusResponse, ClusterCapacity, ClusterDnsSettings, ClusterDnsStatusData, ClusterDnsStatusErrors, ClusterDnsStatusResponse, ClusterDnsStatusResponse2, ClusterDnsStatusResponses, ClusterHealthReportResponse, ClusterMemberHealthResponse, ClusterMemberRequest, ClusterNetworkSettings, CmdBody, CmdData, CmdErrors, CmdInner, CmdKillBody, CmdKillData, CmdKillErrors, CmdKillResponse, CmdKillResponses, CmdLogsData, CmdLogsErrors, CmdLogsResponses, CmdResponse, CmdResponse2, CmdResponses, CommitExistsResponse, CommitInfo, CommitListResponse, Comparator, ComposePortMapping, ComposePreviewRequest, ComposePreviewResponse, ComposePublicPort, ComposeServiceFamily, ComposeServicePreviewResponse, ConfirmPendingActionData, ConfirmPendingActionErrors, ConfirmPendingActionResponse, ConfirmPendingActionResponses, ConfirmUserPendingActionData, ConfirmUserPendingActionErrors, ConfirmUserPendingActionResponse, ConfirmUserPendingActionResponses, ConnectionLimitSettings, ConnectionListQuery, ConnectionListResponse, ConnectionResponse, ConnectionTestResult, ConsoleEventPayload, ContainerActionResponse, ContainerDetailResponse, ContainerEnvironmentVariableValueResponse, ContainerHistoryEntry, ContainerHistoryListResponse, ContainerInfoResponse, ContainerInventoryItem, ContainerListResponse, ContainerLogSettings, ContainerLogsQuery, ContainerMetricHistoryPoint, ContainerMetricsGetHistoryData, ContainerMetricsGetHistoryErrors, ContainerMetricsGetHistoryResponse, ContainerMetricsGetHistoryResponses, ContainerMetricsHistoryQuery, ContainerMetricsResponse, ContainerResponse, ContainerRuntimeInfo, ContainerStatsSample, ContentPart, ContextLine, ContextLogsRequest, ContextLogsResponse, ContinuousArchiveSourceResponse, ControlApplicationWorkspaceData, ControlApplicationWorkspaceErrors, ControlApplicationWorkspaceRequest, ControlApplicationWorkspaceResponse, ControlApplicationWorkspaceResponses, ConversationDetailResponse, ConversationListScope, ConversationListStatus, ConversationMessagePageResponse, ConversationResponse, ConversationsQueryParams, ConversationSummary, CopyBlobRequest, CostAnalysis, CreatableServiceTypeRoute, CreateAgentData, CreateAgentErrors, CreateAgentResponse, CreateAgentResponses, CreateAlertData, CreateAlertError, CreateAlertErrors, CreateAlertResponse, CreateAlertResponses, CreateAlertRuleData, CreateAlertRuleErrors, CreateAlertRuleRequest, CreateAlertRuleResponse, CreateAlertRuleResponses, CreateAnalyticsIngestKeyData, CreateAnalyticsIngestKeyErrors, CreateAnalyticsIngestKeyRequest, CreateAnalyticsIngestKeyResponse, CreateAnalyticsIngestKeyResponses, CreateApiKeyData, CreateApiKeyErrors, CreateApiKeyRequest, CreateApiKeyResponse, CreateApiKeyResponse2, CreateApiKeyResponses, CreateApplicationConversationData, CreateApplicationConversationErrors, CreateApplicationConversationRequest, CreateApplicationConversationResponse, CreateApplicationConversationResponses, CreateApplicationData, CreateApplicationErrors, CreateApplicationPreviewLinkData, CreateApplicationPreviewLinkErrors, CreateApplicationPreviewLinkRequest, CreateApplicationPreviewLinkResponse, CreateApplicationPreviewLinkResponses, CreateApplicationProjectData, CreateApplicationProjectErrors, CreateApplicationProjectRequest, CreateApplicationProjectResponse, CreateApplicationProjectResponses, CreateApplicationRequest, CreateApplicationResponse, CreateApplicationResponses, CreateBackupScheduleData, CreateBackupScheduleError, CreateBackupScheduleErrors, CreateBackupScheduleRequest, CreateBackupScheduleResponse, CreateBackupScheduleResponses, CreateBitbucketProviderData, CreateBitbucketProviderErrors, CreateBitbucketProviderResponse, CreateBitbucketProviderResponses, CreateBitbucketRequest, CreateBulkActivationJobData, CreateBulkActivationJobError, CreateBulkActivationJobErrors, CreateBulkActivationJobRequest, CreateBulkActivationJobResponse, CreateBulkActivationJobResponses, CreateCloudflareProviderData, CreateCloudflareProviderErrors, CreateCloudflareProviderRequest, CreateCloudflareProviderResponse, CreateCloudflareProviderResponses, CreateConversationData, CreateConversationErrors, CreateConversationRequest, CreateConversationResponse, CreateConversationResponses, CreateCustomDomainData, CreateCustomDomainErrors, CreateCustomDomainResponse, CreateCustomDomainResponses, CreateDashboardData, CreateDashboardError, CreateDashboardErrors, CreateDashboardRequest, CreateDashboardResponse, CreateDashboardResponses, CreateDeploymentTokenData, CreateDeploymentTokenErrors, CreateDeploymentTokenRequest, CreateDeploymentTokenResponse, CreateDeploymentTokenResponse2, CreateDeploymentTokenResponses, CreateDnsProviderData, CreateDnsProviderErrors, CreateDnsProviderRequest, CreateDnsProviderResponse, CreateDnsProviderResponses, CreateDomainData, CreateDomainErrors, CreateDomainRequest, CreateDomainResponse, CreateDomainResponses, CreatedResource, CreateDsnData, CreateDsnErrors, CreateDsnRequest, CreateDsnResponse, CreateDsnResponses, CreateEmailDomainData, CreateEmailDomainErrors, CreateEmailDomainRequest, CreateEmailDomainResponse, CreateEmailDomainResponses, CreateEmailProviderData, CreateEmailProviderErrors, CreateEmailProviderRequest, CreateEmailProviderResponse, CreateEmailProviderResponses, CreateEnvironmentData, CreateEnvironmentErrors, CreateEnvironmentRequest, CreateEnvironmentResponse, CreateEnvironmentResponses, CreateEnvironmentVariableData, CreateEnvironmentVariableErrors, CreateEnvironmentVariableRequest, CreateEnvironmentVariableResponse, CreateEnvironmentVariableResponses, CreateExternalServiceRequest, CreateFacetData, CreateFacetError, CreateFacetErrors, CreateFacetRequest, CreateFacetResponse, CreateFacetResponses, CreateFlagData, CreateFlagErrors, CreateFlagRequest, CreateFlagResponse, CreateFlagResponses, CreateFunnelData, CreateFunnelErrors, CreateFunnelRequest, CreateFunnelResponse, CreateFunnelResponse2, CreateFunnelResponses, CreateFunnelStep, CreateGenericProviderData, CreateGenericProviderErrors, CreateGenericProviderResponse, CreateGenericProviderResponses, CreateGenericRequest, CreateGiteaPatProviderData, CreateGiteaPatProviderErrors, CreateGiteaPatProviderResponse, CreateGiteaPatProviderResponses, CreateGiteaPatRequest, CreateGithubPatProviderData, CreateGithubPatProviderErrors, CreateGithubPatProviderResponse, CreateGithubPatProviderResponses, CreateGitHubPatRequest, CreateGitlabOauthProviderData, CreateGitlabOauthProviderErrors, CreateGitlabOauthProviderResponse, CreateGitlabOauthProviderResponses, CreateGitLabOAuthRequest, CreateGitlabPatProviderData, CreateGitlabPatProviderErrors, CreateGitlabPatProviderResponse, CreateGitlabPatProviderResponses, CreateGitLabPatRequest, CreateGitProviderData, CreateGitProviderErrors, CreateGitProviderResponse, CreateGitProviderResponses, CreateGlobalConversationData, CreateGlobalConversationErrors, CreateGlobalConversationRequest, CreateGlobalConversationResponse, CreateGlobalConversationResponses, CreateGlobalMcpData, CreateGlobalMcpErrors, CreateGlobalMcpResponse, CreateGlobalMcpResponses, CreateGlobalSkillData, CreateGlobalSkillErrors, CreateGlobalSkillResponse, CreateGlobalSkillResponses, CreateGlobalWorkspacePreviewLinkData, CreateGlobalWorkspacePreviewLinkErrors, CreateGlobalWorkspacePreviewLinkResponse, CreateGlobalWorkspacePreviewLinkResponses, CreateIncidentData, CreateIncidentErrors, CreateIncidentRequest, CreateIncidentResponse, CreateIncidentResponses, CreateIntegrationBody, CreateIpAccessControlData, CreateIpAccessControlError, CreateIpAccessControlErrors, CreateIpAccessControlRequest, CreateIpAccessControlResponse, CreateIpAccessControlResponses, CreateMcpData, CreateMcpErrors, CreateMcpRequest, CreateMcpResponse, CreateMcpResponses, CreateMetricAlertRequest, CreateMonitorData, CreateMonitorErrors, CreateMonitorRequest, CreateMonitorResponse, CreateMonitorResponses, CreateNotificationEmailProviderData, CreateNotificationEmailProviderErrors, CreateNotificationEmailProviderRequest, CreateNotificationEmailProviderResponse, CreateNotificationEmailProviderResponses, CreateNotificationProviderData, CreateNotificationProviderErrors, CreateNotificationProviderResponse, CreateNotificationProviderResponses, CreateNotificationRouteData, CreateNotificationRouteErrors, CreateNotificationRouteRequest, CreateNotificationRouteResponse, CreateNotificationRouteResponses, CreateOidcProviderData, CreateOidcProviderErrors, CreateOidcProviderRequest, CreateOidcProviderResponse, CreateOidcProviderResponses, CreateOidcRoleMappingData, CreateOidcRoleMappingRequest, CreateOidcRoleMappingResponse, CreateOidcRoleMappingResponses, CreateOrRecreateOrderData, CreateOrRecreateOrderErrors, CreateOrRecreateOrderResponse, CreateOrRecreateOrderResponses, CreatePlanData, CreatePlanErrors, CreatePlanRequest, CreatePlanResponse, CreatePlanResponse2, CreatePlanResponses, CreatePrData, CreatePrErrors, CreateProjectAccessRequest, CreateProjectData, CreateProjectErrors, CreateProjectFromTemplateData, CreateProjectFromTemplateErrors, CreateProjectFromTemplateRequest, CreateProjectFromTemplateResponse, CreateProjectFromTemplateResponse2, CreateProjectFromTemplateResponses, CreateProjectReleaseData, CreateProjectReleaseErrors, CreateProjectReleaseResponse, CreateProjectReleaseResponses, CreateProjectRequest, CreateProjectResponse, CreateProjectResponses, CreateProjectSecretData, CreateProjectSecretErrors, CreateProjectSecretRequest, CreateProjectSecretResponse, CreateProjectSecretResponses, CreateProviderKeyData, CreateProviderKeyError, CreateProviderKeyErrors, CreateProviderKeyRequest, CreateProviderKeyResponse, CreateProviderKeyResponses, CreateProviderRequest, CreatePrResponse, CreatePrResponse2, CreatePrResponses, CreateReleaseData, CreateReleaseErrors, CreateReleaseResponse, CreateReleaseResponses, CreateRouteData, CreateRouteErrors, CreateRouteRequest, CreateRouteResponse, CreateRouteResponses, CreateS3SourceData, CreateS3SourceError, CreateS3SourceErrors, CreateS3SourceRequest, CreateS3SourceResponse, CreateS3SourceResponses, CreateSandboxBody, CreateSandboxData, CreateSandboxErrors, CreateSandboxResponse, CreateSandboxResponses, CreateServiceData, CreateServiceErrors, CreateServiceResponse, CreateServiceResponses, CreateSkillData, CreateSkillErrors, CreateSkillRequest, CreateSkillResponse, CreateSkillResponses, CreateSlackProviderData, CreateSlackProviderErrors, CreateSlackProviderRequest, CreateSlackProviderResponse, CreateSlackProviderResponses, CreateSnapshotBody, CreateSnapshotData, CreateSnapshotErrors, CreateSnapshotResponse, CreateSnapshotResponses, CreateTeamData, CreateTeamErrors, CreateTeamMemberRequest, CreateTeamRequest, CreateTeamResponse, CreateTeamResponses, CreateThreadArtifactData, CreateThreadArtifactErrors, CreateThreadArtifactRequest, CreateThreadArtifactResponse, CreateThreadArtifactResponses, CreateUserData, CreateUserErrors, CreateUserRequest, CreateUserResponse, CreateUserResponses, CreateWebhookData, CreateWebhookErrors, CreateWebhookProviderData, CreateWebhookProviderErrors, CreateWebhookProviderRequest, CreateWebhookProviderResponse, CreateWebhookProviderResponses, CreateWebhookRequestBody, CreateWebhookResponse, CreateWebhookResponses, CronExecutionInfo, CronInfo, CrossProjectSiblingRef, CrossProjectTraceResponse, CurrentStatusResponse, CustomDomainRequest, CustomDomainResponse, CustomerMovementResponse, DashboardLayout, DashboardProjectsAnalyticsQuery, DashboardProjectsAnalyticsResponse, DashboardSection, DashboardTile, DatabaseMetricsResponse, DatabaseMetricsRow, DataImplication, DataImplicationSeverity, DeactivateApiKeyData, DeactivateApiKeyErrors, DeactivateApiKeyResponse, DeactivateApiKeyResponses, DeactivateConnectionData, DeactivateConnectionErrors, DeactivateConnectionResponses, DeactivateProviderData, DeactivateProviderErrors, DeactivateProviderResponses, DeauthorizeDiscoveredRouteCertData, DeauthorizeDiscoveredRouteCertError, DeauthorizeDiscoveredRouteCertErrors, DeauthorizeDiscoveredRouteCertResponse, DeauthorizeDiscoveredRouteCertResponses, DeleteAgentData, DeleteAgentErrors, DeleteAgentResponse, DeleteAgentResponses, DeleteAlertData, DeleteAlertError, DeleteAlertErrors, DeleteAlertResponse, DeleteAlertResponses, DeleteAlertRuleData, DeleteAlertRuleErrors, DeleteAlertRuleResponse, DeleteAlertRuleResponses, DeleteApiKeyData, DeleteApiKeyErrors, DeleteApiKeyResponse, DeleteApiKeyResponses, DeleteBackupData, DeleteBackupError, DeleteBackupErrors, DeleteBackupResponse, DeleteBackupResponses, DeleteBackupScheduleData, DeleteBackupScheduleError, DeleteBackupScheduleErrors, DeleteBackupScheduleResponse, DeleteBackupScheduleResponses, DeleteBlobRequest, DeleteBlobResponse, DeleteConnectionData, DeleteConnectionErrors, DeleteConnectionResponse, DeleteConnectionResponses, DeleteCustomDomainData, DeleteCustomDomainErrors, DeleteCustomDomainResponse, DeleteCustomDomainResponses, DeleteDashboardData, DeleteDashboardError, DeleteDashboardErrors, DeleteDashboardResponse, DeleteDashboardResponses, DeleteDeploymentTokenData, DeleteDeploymentTokenErrors, DeleteDeploymentTokenResponse, DeleteDeploymentTokenResponses, DeleteDnsProviderData, DeleteDnsProviderErrors, DeleteDnsProviderResponse, DeleteDnsProviderResponses, DeleteDomainData, DeleteDomainErrors, DeleteDomainResponse, DeleteDomainResponses, DeleteEmailDomainData, DeleteEmailDomainErrors, DeleteEmailDomainResponse, DeleteEmailDomainResponses, DeleteEmailProviderData, DeleteEmailProviderErrors, DeleteEmailProviderResponse, DeleteEmailProviderResponses, DeleteEnvironmentData, DeleteEnvironmentDomainData, DeleteEnvironmentDomainErrors, DeleteEnvironmentDomainResponse, DeleteEnvironmentDomainResponses, DeleteEnvironmentErrors, DeleteEnvironmentResponse, DeleteEnvironmentResponses, DeleteEnvironmentVariableData, DeleteEnvironmentVariableErrors, DeleteEnvironmentVariableResponse, DeleteEnvironmentVariableResponses, DeleteExternalImageData, DeleteExternalImageErrors, DeleteExternalImageResponse, DeleteExternalImageResponses, DeleteFacetData, DeleteFacetError, DeleteFacetErrors, DeleteFacetResponse, DeleteFacetResponses, DeleteFunnelData, DeleteFunnelErrors, DeleteFunnelResponses, DeleteGitProviderData, DeleteGitProviderErrors, DeleteGitProviderResponse, DeleteGitProviderResponses, DeleteGlobalMcpData, DeleteGlobalMcpErrors, DeleteGlobalMcpResponse, DeleteGlobalMcpResponses, DeleteGlobalSkillData, DeleteGlobalSkillErrors, DeleteGlobalSkillResponse, DeleteGlobalSkillResponses, DeleteIpAccessControlData, DeleteIpAccessControlError, DeleteIpAccessControlErrors, DeleteIpAccessControlResponse, DeleteIpAccessControlResponses, DeleteMcpData, DeleteMcpErrors, DeleteMcpResponse, DeleteMcpResponses, DeleteMonitorData, DeleteMonitorErrors, DeleteMonitorResponse, DeleteMonitorResponses, DeleteNotificationProviderData, DeleteNotificationProviderErrors, DeleteNotificationProviderResponse, DeleteNotificationProviderResponses, DeleteNotificationRouteData, DeleteNotificationRouteErrors, DeleteNotificationRouteResponse, DeleteNotificationRouteResponses, DeleteOidcProviderData, DeleteOidcProviderResponse, DeleteOidcProviderResponses, DeleteOidcRoleMappingData, DeleteOidcRoleMappingResponse, DeleteOidcRoleMappingResponses, DeletePreferencesData, DeletePreferencesErrors, DeletePreferencesResponse, DeletePreferencesResponses, DeleteProjectData, DeleteProjectErrors, DeleteProjectResponse, DeleteProjectResponses, DeleteProjectSecretData, DeleteProjectSecretErrors, DeleteProjectSecretResponse, DeleteProjectSecretResponses, DeleteProviderKeyData, DeleteProviderKeyError, DeleteProviderKeyErrors, DeleteProviderKeyResponse, DeleteProviderKeyResponses, DeleteProviderModelData, DeleteProviderModelError, DeleteProviderModelErrors, DeleteProviderModelResponse, DeleteProviderModelResponses, DeleteProviderSafelyData, DeleteProviderSafelyErrors, DeleteProviderSafelyResponse, DeleteProviderSafelyResponses, DeleteReleaseSourceFilesData, DeleteReleaseSourceFilesErrors, DeleteReleaseSourceFilesResponse, DeleteReleaseSourceFilesResponses, DeleteReleaseSourceMapsData, DeleteReleaseSourceMapsErrors, DeleteReleaseSourceMapsResponse, DeleteReleaseSourceMapsResponses, DeleteResponse, DeleteRouteData, DeleteRouteErrors, DeleteRouteResponse, DeleteRouteResponses, DeleteS3SourceData, DeleteS3SourceError, DeleteS3SourceErrors, DeleteS3SourceResponse, DeleteS3SourceResponses, DeleteScanData, DeleteScanError, DeleteScanErrors, DeleteScanResponse, DeleteScanResponses, DeleteSecretData, DeleteSecretErrors, DeleteSecretResponse, DeleteSecretResponses, DeleteServiceData, DeleteServiceErrors, DeleteServiceResponse, DeleteServiceResponses, DeleteSessionReplayData, DeleteSessionReplayError, DeleteSessionReplayErrors, DeleteSessionReplayResponses, DeleteSkillData, DeleteSkillErrors, DeleteSkillResponse, DeleteSkillResponses, DeleteSnapshotData, DeleteSnapshotErrors, DeleteSnapshotResponse, DeleteSnapshotResponses, DeleteSourceMapData, DeleteSourceMapErrors, DeleteSourceMapResponse, DeleteSourceMapResponses, DeleteStaticBundleData, DeleteStaticBundleErrors, DeleteStaticBundleResponse, DeleteStaticBundleResponses, DeleteTeamData, DeleteTeamErrors, DeleteTeamResponse, DeleteTeamResponses, DeleteUserData, DeleteUserErrors, DeleteUserResponse, DeleteUserResponses, DeleteWebhookData, DeleteWebhookErrors, DeleteWebhookResponse, DeleteWebhookResponses, DelRequest, DelResponse, DeployApplicationProjectRequest, DeployApplicationWorkspaceProjectData, DeployApplicationWorkspaceProjectErrors, DeployApplicationWorkspaceProjectResponse, DeployApplicationWorkspaceProjectResponses, DeployFromImageData, DeployFromImageErrors, DeployFromImageRequest, DeployFromImageResponse, DeployFromImageResponses, DeployFromImageUploadData, DeployFromImageUploadErrors, DeployFromImageUploadQuery, DeployFromImageUploadResponse, DeployFromImageUploadResponses, DeployFromStaticData, DeployFromStaticErrors, DeployFromStaticRequest, DeployFromStaticResponse, DeployFromStaticResponses, DeployFromUploadedSourceData, DeployFromUploadedSourceErrors, DeployFromUploadedSourceResponse, DeployFromUploadedSourceResponses, DeploymentConfig, DeploymentConfigSnapshot, DeploymentConfiguration, DeploymentContainerLogContentResponse, DeploymentContainerLogResponse, DeploymentContainerLogsListResponse, DeploymentEnvironmentResponse, DeploymentJobResponse, DeploymentJobsResponse, DeploymentListResponse, DeploymentMetadata, DeploymentMetricsGetLatestData, DeploymentMetricsGetLatestErrors, DeploymentMetricsGetLatestResponse, DeploymentMetricsGetLatestResponses, DeploymentMetricsGetRangeData, DeploymentMetricsGetRangeErrors, DeploymentMetricsGetRangeResponse, DeploymentMetricsGetRangeResponses, DeploymentMetricsToggleData, DeploymentMetricsToggleErrors, DeploymentMetricsToggleResponses, DeploymentResponse, DeploymentStateResponse, DeploymentStrategy, DeploymentTokenListResponse, DeploymentTokenResponse, DestroySandboxData, DestroySandboxErrors, DestroySandboxResponse, DestroySandboxResponses, DetachScheduleServiceData, DetachScheduleServiceError, DetachScheduleServiceErrors, DetachScheduleServiceResponse, DetachScheduleServiceResponses, DetectionConfig, DetectPublicEnvExampleData, DetectPublicEnvExampleErrors, DetectPublicEnvExampleResponse, DetectPublicEnvExampleResponses, DetectPublicPresetsData, DetectPublicPresetsErrors, DetectPublicPresetsResponse, DetectPublicPresetsResponses, DeviceCount, DigestSections, Direction, DisableBackupScheduleData, DisableBackupScheduleError, DisableBackupScheduleErrors, DisableBackupScheduleResponse, DisableBackupScheduleResponses, DisableBlobResponse, DisableKvResponse, DisableMfaData, DisableMfaErrors, DisableMfaRequest, DisableMfaResponse, DisableMfaResponses, DisconnectCloudData, DisconnectCloudResponse, DisconnectCloudResponses, DiscoverRequest, DiscoverResponse, DiscoverWorkloadsData, DiscoverWorkloadsErrors, DiscoverWorkloadsResponse, DiscoverWorkloadsResponses, DiskInfo, DiskSpaceAlert, DiskSpaceAlertSettings, DiskSpaceCheckResult, DnsAckRequest, DnsAckResponse, DnsChallengeRecordResult, DnsChangesResponse, DnsCompletionResponse, DnsLookupError, DnsLookupRequest, DnsLookupResponse, DnsProviderCredentials, DnsProviderResponse, DnsProviderSettings, DnsProviderSettingsMasked, DnsProviderType, DnsRecord, DnsRecordChange, DnsRecordContent, DnsRecordResponse, DnsRecordSetupResult, DnsRecordStatusResponse, DnsResolverHeartbeat, DnsZone, DockerComposePresetConfig, DockerfilePresetConfig, DockerfileVariant, DockerRegistrySettings, DockerRegistrySettingsMasked, DomainAction, DomainChallengeResponse, DomainData, DomainEnvironmentResponse, DomainError, DomainErrors, DomainPlan, DomainResponse, DomainResponse2, DomainResponses, DownloadApplicationWorkspaceFileData, DownloadApplicationWorkspaceFileErrors, DownloadApplicationWorkspaceFileResponse, DownloadApplicationWorkspaceFileResponses, DownloadGlobalSkillArchiveData, DownloadGlobalSkillArchiveErrors, DownloadGlobalSkillArchiveResponse, DownloadGlobalSkillArchiveResponses, DownloadGlobalWorkspaceFileData, DownloadGlobalWorkspaceFileErrors, DownloadGlobalWorkspaceFileResponse, DownloadGlobalWorkspaceFileResponses, DownloadObjectData, DownloadObjectErrors, DownloadObjectResponse, DownloadObjectResponses, DownloadSkillArchiveData, DownloadSkillArchiveErrors, DownloadSkillArchiveResponse, DownloadSkillArchiveResponses, DrainNodeResponse, DrainStatusResponse, DropArchiveUpload, DropInspectionResponse, DropOffPoint, DropPresetCandidate, EmailConfig, EmailDomainResponse, EmailDomainWithDnsResponse, EmailProviderResponse, EmailProviderTypeRoute, EmailRequest, EmailResponse, EmailStatsResponse, EmailStatusData, EmailStatusErrors, EmailStatusResponse, EmailStatusResponse2, EmailStatusResponses, EmailTrackingResponse, EmailTrackingSetupResponse, EmailTrackingStatusResponse, EmbeddingData, EmbeddingInput, EmbeddingRequest, EmbeddingResponse, EmbeddingsData, EmbeddingsError, EmbeddingsErrors, EmbeddingsResponse, EmbeddingsResponses, EmbeddingUsage, EnableBackupScheduleData, EnableBackupScheduleError, EnableBackupScheduleErrors, EnableBackupScheduleResponse, EnableBackupScheduleResponses, EnableBlobRequest, EnableBlobResponse, EnableKvRequest, EnableKvResponse, EnablePgStatStatementsResponse, EndpointDto, EnqueuedJob, EnrichVisitorData, EnrichVisitorErrors, EnrichVisitorRequest, EnrichVisitorResponse, EnrichVisitorResponse2, EnrichVisitorResponses, EnrollCloudData, EnrollCloudRequest, EnrollCloudResponse, EnrollCloudResponses, EnrollmentTokenInfo, EnrollmentTokenListResponse, EntityInfoResponse, EntityResponse, EnvExampleVariable, EnvExampleVariableResponse, EnvironmentConfiguration, EnvironmentDomainResponse, EnvironmentInfo, EnvironmentResponse, EnvironmentVariable, EnvironmentVariableInfo, EnvironmentVariableResponse, EnvironmentVariableValueResponse, EnvVarInput, EnvVarIntegrationInfo, EnvVarResponse, EnvVarTemplate, EnvVarTemplateResponse, ErrorDashboardStatsQuery, ErrorDashboardStatsResponse, ErrorEventResponse, ErrorGroupDeploymentResponse, ErrorGroupResponse, ErrorGroupStatsResponse, ErrorResponse, ErrorRow, ErrorTimeSeriesDataResponse, ErrorTimeSeriesQuery, EstimateBulkActivationData, EstimateBulkActivationError, EstimateBulkActivationErrors, EstimateBulkActivationRequest, EstimateBulkActivationResponse, EstimateBulkActivationResponses, EventActivityBucket, EventBreakdown, EventBrowserStats, EventCount, EventCountryStats, EventDetailQuery, EventDetailResponse, EventEntriesQuery, EventEntriesResponse, EventEntryInfo, EventKind, EventMetricsPayload, EventReferrerStats, EventsCountQuery, EventsResponse, EventTimeline, EventTimelineQuery, EventType, EventTypeBreakdown, EventTypeBreakdownQuery, EventTypeResponse, EventTypesResponse, EventVisitorInfo, EventVisitorsQuery, EventVisitorsResponse, ExecBody, ExecData, ExecDetachedData, ExecDetachedErrors, ExecDetachedResponse, ExecDetachedResponse2, ExecDetachedResponses, ExecErrors, ExecResponse, ExecResponse2, ExecResponses, ExecuteDeploymentOperationData, ExecuteDeploymentOperationErrors, ExecuteDeploymentOperationResponse, ExecuteDeploymentOperationResponses, ExecuteImportData, ExecuteImportErrors, ExecuteImportRequest, ExecuteImportResponse, ExecuteImportResponse2, ExecuteImportResponses, ExecuteOperationRequest, ExpireRequest, ExpireResponse, ExplorerSupportResponse, ExtendTimeoutBody, ExtendTimeoutData, ExtendTimeoutErrors, ExtendTimeoutResponse, ExtendTimeoutResponses, ExternalImageResponse, ExternalServiceBackupCapabilityResponse, ExternalServiceBackupResponse, ExternalServiceDetails, ExternalServiceEnablePgStatStatementsData, ExternalServiceEnablePgStatStatementsErrors, ExternalServiceEnablePgStatStatementsResponse, ExternalServiceEnablePgStatStatementsResponses, ExternalServiceInfo, ExternalServiceMetricsByDatabaseData, ExternalServiceMetricsByDatabaseErrors, ExternalServiceMetricsByDatabaseResponse, ExternalServiceMetricsByDatabaseResponses, ExternalServiceMetricsCreateAlertRuleData, ExternalServiceMetricsCreateAlertRuleErrors, ExternalServiceMetricsCreateAlertRuleResponse, ExternalServiceMetricsCreateAlertRuleResponses, ExternalServiceMetricsDeleteAlertRuleData, ExternalServiceMetricsDeleteAlertRuleErrors, ExternalServiceMetricsDeleteAlertRuleResponse, ExternalServiceMetricsDeleteAlertRuleResponses, ExternalServiceMetricsGetAlertRulesData, ExternalServiceMetricsGetAlertRulesErrors, ExternalServiceMetricsGetAlertRulesResponse, ExternalServiceMetricsGetAlertRulesResponses, ExternalServiceMetricsGetLatestData, ExternalServiceMetricsGetLatestErrors, ExternalServiceMetricsGetLatestResponse, ExternalServiceMetricsGetLatestResponses, ExternalServiceMetricsGetRangeData, ExternalServiceMetricsGetRangeErrors, ExternalServiceMetricsGetRangeResponse, ExternalServiceMetricsGetRangeResponses, ExternalServiceMetricsStatusData, ExternalServiceMetricsStatusErrors, ExternalServiceMetricsStatusResponse, ExternalServiceMetricsStatusResponses, ExternalServiceMetricsToggleData, ExternalServiceMetricsToggleErrors, ExternalServiceMetricsToggleResponses, ExternalServiceMetricsUpdateAlertRuleData, ExternalServiceMetricsUpdateAlertRuleErrors, ExternalServiceMetricsUpdateAlertRuleResponse, ExternalServiceMetricsUpdateAlertRuleResponses, ExternalServiceResetPgStatStatementsData, ExternalServiceResetPgStatStatementsErrors, ExternalServiceResetPgStatStatementsResponse, ExternalServiceResetPgStatStatementsResponses, ExternalServiceSummary, FacetBackendKind, FacetCapability, FacetInfo, FacetsResponse, FacetStatus, FailureReportPreviewResponse, FeatureMaturity, FieldResponse, FinalizeOrderData, FinalizeOrderErrors, FinalizeOrderResponse, FinalizeOrderResponses, FinalizeProjectReleaseData, FinalizeProjectReleaseErrors, FinalizeProjectReleaseResponse, FinalizeProjectReleaseResponses, FindConversationData, FindConversationErrors, FindConversationResponse, FindConversationResponses, FiringSeriesEntry, FlagEnvironmentResponse, FlagListResponse, FlagResponse, FlagSnapshot, FlagSnapshotResponse, FlagValueType, ForecastAlgorithm, ForecastParams, FullError, FullEvent, FullRequest, FunnelMetricsResponse, FunnelResponse, GatewayStatus, GenAiEvent, GenAiSpanDetail, GenAiTraceDetailResponse, GenAiTraceSummariesResponse, GenAiTraceSummary, GeneralStatsQuery, GeneralStatsResponse, GenerateDockerfileRequest, GenerateDockerfileResponse, GenerateJoinTokenData, GenerateJoinTokenErrors, GenerateJoinTokenResponse, GenerateJoinTokenResponse2, GenerateJoinTokenResponses, GeneratePresetDockerfileData, GeneratePresetDockerfileErrors, GeneratePresetDockerfileResponse, GeneratePresetDockerfileResponses, GeoLocationResponse, GeoRestrictionsConfig, GetAccessInfoData, GetAccessInfoErrors, GetAccessInfoResponse, GetAccessInfoResponses, GetActiveVisitorsData, GetActiveVisitorsErrors, GetActiveVisitorsResponse, GetActiveVisitorsResponses, GetActivityGraphData, GetActivityGraphError, GetActivityGraphErrors, GetActivityGraphResponse, GetActivityGraphResponses, GetAdminGateData, GetAdminGateErrors, GetAdminGateResponse, GetAdminGateResponses, GetAgentData, GetAgentErrors, GetAgentResponse, GetAgentResponses, GetAggregatedBucketsData, GetAggregatedBucketsErrors, GetAggregatedBucketsResponse, GetAggregatedBucketsResponses, GetAiAgentBreakdownData, GetAiAgentBreakdownError, GetAiAgentBreakdownErrors, GetAiAgentBreakdownResponse, GetAiAgentBreakdownResponses, GetAiAgentPagesData, GetAiAgentPagesError, GetAiAgentPagesErrors, GetAiAgentPagesResponse, GetAiAgentPagesResponses, GetAiAgentTimelineData, GetAiAgentTimelineError, GetAiAgentTimelineErrors, GetAiAgentTimelineResponse, GetAiAgentTimelineResponses, GetAiDataAccessData, GetAiDataAccessErrors, GetAiDataAccessResponse, GetAiDataAccessResponses, GetAiPageBreakdownData, GetAiPageBreakdownError, GetAiPageBreakdownErrors, GetAiPageBreakdownResponse, GetAiPageBreakdownResponses, GetAiProviderStatusData, GetAiProviderStatusError, GetAiProviderStatusErrors, GetAiProviderStatusResponse, GetAiProviderStatusResponses, GetAiStatusBreakdownData, GetAiStatusBreakdownError, GetAiStatusBreakdownErrors, GetAiStatusBreakdownResponse, GetAiStatusBreakdownResponses, GetAlertData, GetAlertError, GetAlertErrors, GetAlertResponse, GetAlertResponses, GetAlertRuleData, GetAlertRuleErrors, GetAlertRuleResponse, GetAlertRuleResponses, GetAllRepositoriesByNameData, GetAllRepositoriesByNameErrors, GetAllRepositoriesByNameResponse, GetAllRepositoriesByNameResponses, GetAnalyticsActiveVisitorsData, GetAnalyticsActiveVisitorsErrors, GetAnalyticsActiveVisitorsResponse, GetAnalyticsActiveVisitorsResponses, GetAnalyticsEventsCountData, GetAnalyticsEventsCountErrors, GetAnalyticsEventsCountResponse, GetAnalyticsEventsCountResponses, GetAnalyticsSessionEventsData, GetAnalyticsSessionEventsErrors, GetAnalyticsSessionEventsResponse, GetAnalyticsSessionEventsResponses, GetAnalyticsVisitorSessionsData, GetAnalyticsVisitorSessionsErrors, GetAnalyticsVisitorSessionsResponse, GetAnalyticsVisitorSessionsResponses, GetApiCallersData, GetApiCallersErrors, GetApiCallersResponse, GetApiCallersResponses, GetApiKeyData, GetApiKeyErrors, GetApiKeyPermissionsData, GetApiKeyPermissionsErrors, GetApiKeyPermissionsResponse, GetApiKeyPermissionsResponses, GetApiKeyResponse, GetApiKeyResponses, GetApiRoutesData, GetApiRoutesErrors, GetApiRoutesResponse, GetApiRoutesResponses, GetApiSummaryData, GetApiSummaryErrors, GetApiSummaryResponse, GetApiSummaryResponses, GetApiTimeseriesData, GetApiTimeseriesErrors, GetApiTimeseriesResponse, GetApiTimeseriesResponses, GetApiTrafficProxyLogAccessData, GetApiTrafficProxyLogAccessError, GetApiTrafficProxyLogAccessErrors, GetApiTrafficProxyLogAccessResponse, GetApiTrafficProxyLogAccessResponses, GetApplicationData, GetApplicationErrors, GetApplicationResponse, GetApplicationResponses, GetApplicationWorkspaceChangesData, GetApplicationWorkspaceChangesErrors, GetApplicationWorkspaceChangesResponse, GetApplicationWorkspaceChangesResponses, GetApplicationWorkspaceData, GetApplicationWorkspaceDiffData, GetApplicationWorkspaceDiffErrors, GetApplicationWorkspaceDiffResponse, GetApplicationWorkspaceDiffResponses, GetApplicationWorkspaceDirectoryData, GetApplicationWorkspaceDirectoryErrors, GetApplicationWorkspaceDirectoryResponse, GetApplicationWorkspaceDirectoryResponses, GetApplicationWorkspaceErrors, GetApplicationWorkspaceFileData, GetApplicationWorkspaceFileErrors, GetApplicationWorkspaceFileResponse, GetApplicationWorkspaceFileResponses, GetApplicationWorkspaceResponse, GetApplicationWorkspaceResponses, GetAuditLogData, GetAuditLogErrors, GetAuditLogResponse, GetAuditLogResponses, GetBackupData, GetBackupError, GetBackupErrors, GetBackupResponse, GetBackupResponses, GetBackupScheduleData, GetBackupScheduleError, GetBackupScheduleErrors, GetBackupScheduleResponse, GetBackupScheduleResponses, GetBranchesByRepositoryIdData, GetBranchesByRepositoryIdErrors, GetBranchesByRepositoryIdResponse, GetBranchesByRepositoryIdResponses, GetBucketedIncidentsData, GetBucketedIncidentsErrors, GetBucketedIncidentsResponse, GetBucketedIncidentsResponses, GetBucketedStatusData, GetBucketedStatusErrors, GetBucketedStatusResponse, GetBucketedStatusResponses, GetBulkActivationJobData, GetBulkActivationJobError, GetBulkActivationJobErrors, GetBulkActivationJobResponse, GetBulkActivationJobResponses, GetChallengeTokenData, GetChallengeTokenErrors, GetChallengeTokenResponse, GetChallengeTokenResponses, GetChatReadinessData, GetChatReadinessErrors, GetChatReadinessResponse, GetChatReadinessResponses, GetCliStatusData, GetCliStatusErrors, GetCliStatusResponses, GetCloudAiCapabilityData, GetCloudAiCapabilityResponse, GetCloudAiCapabilityResponses, GetCloudBackfillStatusData, GetCloudBackfillStatusError, GetCloudBackfillStatusErrors, GetCloudBackfillStatusResponse, GetCloudBackfillStatusResponses, GetCloudCapabilityData, GetCloudCapabilityResponse, GetCloudCapabilityResponses, GetCloudStatusData, GetCloudStatusResponse, GetCloudStatusResponses, GetCloudTelemetryStatusData, GetCloudTelemetryStatusError, GetCloudTelemetryStatusErrors, GetCloudTelemetryStatusResponse, GetCloudTelemetryStatusResponses, GetClusterHealthData, GetClusterHealthErrors, GetClusterHealthResponse, GetClusterHealthResponses, GetClusterMemberData, GetClusterMemberErrors, GetClusterMemberResponse, GetClusterMemberResponses, GetCmdData, GetCmdErrors, GetCmdResponse, GetCmdResponses, GetContainerDetailData, GetContainerDetailErrors, GetContainerDetailResponse, GetContainerDetailResponses, GetContainerEnvironmentVariableData, GetContainerEnvironmentVariableErrors, GetContainerEnvironmentVariableResponse, GetContainerEnvironmentVariableResponses, GetContainerLogsByIdData, GetContainerLogsByIdErrors, GetContainerLogsData, GetContainerLogsErrors, GetContainerMetricsData, GetContainerMetricsErrors, GetContainerMetricsResponse, GetContainerMetricsResponses, GetConversationData, GetConversationDetailData, GetConversationDetailError, GetConversationDetailErrors, GetConversationDetailResponse, GetConversationDetailResponses, GetConversationErrors, GetConversationResponse, GetConversationResponses, GetConversationsData, GetConversationsError, GetConversationsErrors, GetConversationsResponse, GetConversationsResponses, GetCronByIdData, GetCronByIdErrors, GetCronByIdResponse, GetCronByIdResponses, GetCronExecutionsData, GetCronExecutionsErrors, GetCronExecutionsResponse, GetCronExecutionsResponses, GetCrossProjectTraceSiblingsData, GetCrossProjectTraceSiblingsError, GetCrossProjectTraceSiblingsErrors, GetCrossProjectTraceSiblingsResponse, GetCrossProjectTraceSiblingsResponses, GetCurrentBulkActivationJobData, GetCurrentBulkActivationJobError, GetCurrentBulkActivationJobErrors, GetCurrentBulkActivationJobResponse, GetCurrentBulkActivationJobResponses, GetCurrentMonitorStatusData, GetCurrentMonitorStatusErrors, GetCurrentMonitorStatusResponse, GetCurrentMonitorStatusResponses, GetCurrentUserData, GetCurrentUserErrors, GetCurrentUserResponse, GetCurrentUserResponses, GetCustomDomainData, GetCustomDomainErrors, GetCustomDomainResponse, GetCustomDomainResponses, GetDashboardData, GetDashboardError, GetDashboardErrors, GetDashboardProjectsAnalyticsData, GetDashboardProjectsAnalyticsErrors, GetDashboardProjectsAnalyticsResponse, GetDashboardProjectsAnalyticsResponses, GetDashboardResponse, GetDashboardResponses, GetDeliveryData, GetDeliveryErrors, GetDeliveryResponse, GetDeliveryResponses, GetDeploymentContainerLogContentData, GetDeploymentContainerLogContentErrors, GetDeploymentContainerLogContentResponse, GetDeploymentContainerLogContentResponses, GetDeploymentData, GetDeploymentErrors, GetDeploymentJobLogsData, GetDeploymentJobLogsErrors, GetDeploymentJobLogsResponse, GetDeploymentJobLogsResponses, GetDeploymentJobsData, GetDeploymentJobsErrors, GetDeploymentJobsResponse, GetDeploymentJobsResponses, GetDeploymentOperationsData, GetDeploymentOperationsErrors, GetDeploymentOperationsResponse, GetDeploymentOperationsResponses, GetDeploymentOperationStatusData, GetDeploymentOperationStatusErrors, GetDeploymentOperationStatusResponse, GetDeploymentOperationStatusResponses, GetDeploymentResponse, GetDeploymentResponses, GetDeploymentsParams, GetDeploymentTokenData, GetDeploymentTokenErrors, GetDeploymentTokenResponse, GetDeploymentTokenResponses, GetDiskStatusData, GetDiskStatusErrors, GetDiskStatusResponse, GetDiskStatusResponses, GetDnsChangesData, GetDnsChangesErrors, GetDnsChangesResponse, GetDnsChangesResponses, GetDnsProviderData, GetDnsProviderErrors, GetDnsProviderResponse, GetDnsProviderResponses, GetDomainByHostData, GetDomainByHostErrors, GetDomainByHostResponse, GetDomainByHostResponses, GetDomainByIdData, GetDomainByIdErrors, GetDomainByIdResponse, GetDomainByIdResponses, GetDomainByNameData, GetDomainByNameErrors, GetDomainByNameResponse, GetDomainByNameResponses, GetDomainData, GetDomainDnsRecordsData, GetDomainDnsRecordsErrors, GetDomainDnsRecordsResponse, GetDomainDnsRecordsResponses, GetDomainErrors, GetDomainOrderData, GetDomainOrderErrors, GetDomainOrderResponse, GetDomainOrderResponses, GetDomainResponse, GetDomainResponses, GetEmailData, GetEmailErrors, GetEmailEventsData, GetEmailEventsErrors, GetEmailEventsResponse, GetEmailEventsResponses, GetEmailLinksData, GetEmailLinksErrors, GetEmailLinksResponse, GetEmailLinksResponses, GetEmailProviderData, GetEmailProviderErrors, GetEmailProviderResponse, GetEmailProviderResponses, GetEmailResponse, GetEmailResponses, GetEmailStatsData, GetEmailStatsErrors, GetEmailStatsResponse, GetEmailStatsResponses, GetEmailTrackingData, GetEmailTrackingErrors, GetEmailTrackingResponse, GetEmailTrackingResponses, GetEmailTrackingStatusData, GetEmailTrackingStatusErrors, GetEmailTrackingStatusResponse, GetEmailTrackingStatusResponses, GetEntityInfoData, GetEntityInfoErrors, GetEntityInfoResponse, GetEntityInfoResponses, GetEnvironmentCronsData, GetEnvironmentCronsErrors, GetEnvironmentCronsResponse, GetEnvironmentCronsResponses, GetEnvironmentData, GetEnvironmentDomainsData, GetEnvironmentDomainsErrors, GetEnvironmentDomainsResponse, GetEnvironmentDomainsResponses, GetEnvironmentErrors, GetEnvironmentResponse, GetEnvironmentResponses, GetEnvironmentsData, GetEnvironmentsErrors, GetEnvironmentsResponse, GetEnvironmentsResponses, GetEnvironmentVariablesData, GetEnvironmentVariablesErrors, GetEnvironmentVariablesQuery, GetEnvironmentVariablesResponse, GetEnvironmentVariablesResponses, GetEnvironmentVariableValueData, GetEnvironmentVariableValueErrors, GetEnvironmentVariableValueResponse, GetEnvironmentVariableValueResponses, GetErrorDashboardStatsData, GetErrorDashboardStatsErrors, GetErrorDashboardStatsResponse, GetErrorDashboardStatsResponses, GetErrorEventData, GetErrorEventErrors, GetErrorEventResponse, GetErrorEventResponses, GetErrorGroupData, GetErrorGroupErrors, GetErrorGroupResponse, GetErrorGroupResponses, GetErrorStatsData, GetErrorStatsErrors, GetErrorStatsResponse, GetErrorStatsResponses, GetErrorTimeSeriesData, GetErrorTimeSeriesErrors, GetErrorTimeSeriesResponse, GetErrorTimeSeriesResponses, GetEventDetailData, GetEventDetailErrors, GetEventDetailResponse, GetEventDetailResponses, GetEventEntriesData, GetEventEntriesErrors, GetEventEntriesResponse, GetEventEntriesResponses, GetEventsCountData, GetEventsCountErrors, GetEventsCountResponse, GetEventsCountResponses, GetEventsTimelineData, GetEventsTimelineErrors, GetEventsTimelineResponse, GetEventsTimelineResponses, GetEventTypeBreakdownData, GetEventTypeBreakdownErrors, GetEventTypeBreakdownResponse, GetEventTypeBreakdownResponses, GetEventVisitorsData, GetEventVisitorsErrors, GetEventVisitorsResponse, GetEventVisitorsResponses, GetExternalImageData, GetExternalImageErrors, GetExternalImageResponse, GetExternalImageResponses, GetExternalServiceBackupCapabilityData, GetExternalServiceBackupCapabilityError, GetExternalServiceBackupCapabilityErrors, GetExternalServiceBackupCapabilityResponse, GetExternalServiceBackupCapabilityResponses, GetFailureReportPreviewData, GetFailureReportPreviewErrors, GetFailureReportPreviewResponse, GetFailureReportPreviewResponses, GetFeatureMaturityData, GetFeatureMaturityErrors, GetFeatureMaturityResponse, GetFeatureMaturityResponses, GetFileData, GetFileErrors, GetFileResponse, GetFileResponses, GetFlagData, GetFlagErrors, GetFlagResponse, GetFlagResponses, GetFlagSnapshotData, GetFlagSnapshotErrors, GetFlagSnapshotResponse, GetFlagSnapshotResponses, GetFunnelMetricsData, GetFunnelMetricsErrors, GetFunnelMetricsQuery, GetFunnelMetricsResponse, GetFunnelMetricsResponses, GetGenaiTraceData, GetGenaiTraceError, GetGenaiTraceErrors, GetGenaiTraceResponse, GetGenaiTraceResponses, GetGeneralStatsData, GetGeneralStatsErrors, GetGeneralStatsResponse, GetGeneralStatsResponses, GetGitProviderData, GetGitProviderErrors, GetGitProviderResponse, GetGitProviderResponses, GetGlobalAiWorkspaceData, GetGlobalAiWorkspaceErrors, GetGlobalAiWorkspaceResponse, GetGlobalAiWorkspaceResponses, GetGlobalEventsData, GetGlobalEventsErrors, GetGlobalEventsResponse, GetGlobalEventsResponses, GetGlobalEventStatsData, GetGlobalEventStatsErrors, GetGlobalEventStatsResponse, GetGlobalEventStatsResponses, GetGlobalMcpData, GetGlobalMcpErrors, GetGlobalMcpResponse, GetGlobalMcpResponses, GetGlobalSandboxStatusData, GetGlobalSandboxStatusErrors, GetGlobalSandboxStatusResponse, GetGlobalSandboxStatusResponses, GetGlobalSkillData, GetGlobalSkillErrors, GetGlobalSkillResponse, GetGlobalSkillResponses, GetGlobalWorkspaceChangesData, GetGlobalWorkspaceChangesErrors, GetGlobalWorkspaceChangesResponse, GetGlobalWorkspaceChangesResponses, GetGlobalWorkspaceDiffData, GetGlobalWorkspaceDiffErrors, GetGlobalWorkspaceDiffResponse, GetGlobalWorkspaceDiffResponses, GetGlobalWorkspaceDirectoryData, GetGlobalWorkspaceDirectoryErrors, GetGlobalWorkspaceDirectoryResponse, GetGlobalWorkspaceDirectoryResponses, GetGlobalWorkspaceFileData, GetGlobalWorkspaceFileErrors, GetGlobalWorkspaceFileResponse, GetGlobalWorkspaceFileResponses, GetGroupedPageMetricsData, GetGroupedPageMetricsError, GetGroupedPageMetricsErrors, GetGroupedPageMetricsResponse, GetGroupedPageMetricsResponses, GetHealthData, GetHealthError, GetHealthErrors, GetHealthResponse, GetHealthResponses, GetHourlyVisitsData, GetHourlyVisitsErrors, GetHourlyVisitsResponse, GetHourlyVisitsResponses, GetHttpChallengeDebugData, GetHttpChallengeDebugErrors, GetHttpChallengeDebugResponse, GetHttpChallengeDebugResponses, GetImportStatusData, GetImportStatusErrors, GetImportStatusResponse, GetImportStatusResponses, GetIncidentData, GetIncidentErrors, GetIncidentResponse, GetIncidentResponses, GetIncidentUpdatesData, GetIncidentUpdatesErrors, GetIncidentUpdatesResponse, GetIncidentUpdatesResponses, GetIngestErrorsData, GetIngestErrorsError, GetIngestErrorsErrors, GetIngestErrorsResponse, GetIngestErrorsResponses, GetIpAccessControlData, GetIpAccessControlError, GetIpAccessControlErrors, GetIpAccessControlResponse, GetIpAccessControlResponses, GetIpGeolocationData, GetIpGeolocationError, GetIpGeolocationErrors, GetIpGeolocationResponse, GetIpGeolocationResponses, GetJoinTokenStatusData, GetJoinTokenStatusErrors, GetJoinTokenStatusResponse, GetJoinTokenStatusResponses, GetLastDeploymentData, GetLastDeploymentErrors, GetLastDeploymentResponse, GetLastDeploymentResponses, GetLatestDeploymentMediaData, GetLatestDeploymentMediaError, GetLatestDeploymentMediaErrors, GetLatestDeploymentMediaResponse, GetLatestDeploymentMediaResponses, GetLatestScanData, GetLatestScanError, GetLatestScanErrors, GetLatestScanResponse, GetLatestScanResponses, GetLatestScansPerEnvironmentData, GetLatestScansPerEnvironmentError, GetLatestScansPerEnvironmentErrors, GetLatestScansPerEnvironmentResponse, GetLatestScansPerEnvironmentResponses, GetLiveVisitorsListData, GetLiveVisitorsListErrors, GetLiveVisitorsListResponse, GetLiveVisitorsListResponses, GetLogContextData, GetLogContextError, GetLogContextErrors, GetLogContextResponse, GetLogContextResponses, GetMcpData, GetMcpErrors, GetMcpResponse, GetMcpResponses, GetMetricsOverTimeData, GetMetricsOverTimeError, GetMetricsOverTimeErrors, GetMetricsOverTimeResponse, GetMetricsOverTimeResponses, GetMonitorData, GetMonitorErrors, GetMonitorResponse, GetMonitorResponses, GetNotificationProviderData, GetNotificationProviderErrors, GetNotificationProviderResponse, GetNotificationProviderResponses, GetNotificationRouteData, GetNotificationRouteErrors, GetNotificationRouteResponse, GetNotificationRouteResponses, GetOnDemandCertStatusData, GetOnDemandCertStatusErrors, GetOnDemandCertStatusResponse, GetOnDemandCertStatusResponses, GetOrCreateDsnData, GetOrCreateDsnErrors, GetOrCreateDsnRequest, GetOrCreateDsnResponse, GetOrCreateDsnResponses, GetPageFlowData, GetPageFlowErrors, GetPageFlowResponse, GetPageFlowResponses, GetPageHourlySessionsData, GetPageHourlySessionsErrors, GetPageHourlySessionsResponse, GetPageHourlySessionsResponses, GetPagePathDetailData, GetPagePathDetailErrors, GetPagePathDetailResponse, GetPagePathDetailResponses, GetPagePathsData, GetPagePathsErrors, GetPagePathsResponse, GetPagePathsResponses, GetPagePathsSparklinesData, GetPagePathsSparklinesErrors, GetPagePathsSparklinesResponse, GetPagePathsSparklinesResponses, GetPagePathVisitorsData, GetPagePathVisitorsErrors, GetPagePathVisitorsResponse, GetPagePathVisitorsResponses, GetPendingActionData, GetPendingActionErrors, GetPendingActionResponse, GetPendingActionResponses, GetPerformanceMetricsData, GetPerformanceMetricsError, GetPerformanceMetricsErrors, GetPerformanceMetricsResponse, GetPerformanceMetricsResponses, GetPgUpgradeData, GetPgUpgradeError, GetPgUpgradeErrors, GetPgUpgradeLogsData, GetPgUpgradeLogsError, GetPgUpgradeLogsErrors, GetPgUpgradeLogsResponse, GetPgUpgradeLogsResponses, GetPgUpgradeResponse, GetPgUpgradeResponses, GetPipelineHistoryData, GetPipelineHistoryError, GetPipelineHistoryErrors, GetPipelineHistoryResponse, GetPipelineHistoryResponses, GetPipelineStatsData, GetPipelineStatsError, GetPipelineStatsErrors, GetPipelineStatsResponse, GetPipelineStatsResponses, GetPlatformInfoData, GetPlatformInfoErrors, GetPlatformInfoResponse, GetPlatformInfoResponses, GetPostgresWalHealthData, GetPostgresWalHealthErrors, GetPostgresWalHealthResponse, GetPostgresWalHealthResponses, GetPreferencesData, GetPreferencesErrors, GetPreferencesResponse, GetPreferencesResponses, GetPreviewGatewayLogsData, GetPreviewGatewayLogsError, GetPreviewGatewayLogsErrors, GetPreviewGatewayLogsResponse, GetPreviewGatewayLogsResponses, GetPreviewGatewaySettingsData, GetPreviewGatewaySettingsResponse, GetPreviewGatewaySettingsResponses, GetPreviewGatewayStatusData, GetPreviewGatewayStatusError, GetPreviewGatewayStatusErrors, GetPreviewGatewayStatusResponse, GetPreviewGatewayStatusResponses, GetPricingData, GetPricingError, GetPricingErrors, GetPricingResponse, GetPricingResponses, GetPrivateIpData, GetPrivateIpErrors, GetPrivateIpResponses, GetProjectAlarmsSummaryData, GetProjectAlarmsSummaryErrors, GetProjectAlarmsSummaryResponse, GetProjectAlarmsSummaryResponses, GetProjectBySlugData, GetProjectBySlugErrors, GetProjectBySlugResponse, GetProjectBySlugResponses, GetProjectCloudTelemetryData, GetProjectCloudTelemetryError, GetProjectCloudTelemetryErrors, GetProjectCloudTelemetryResponse, GetProjectCloudTelemetryResponses, GetProjectData, GetProjectDeploymentsData, GetProjectDeploymentsErrors, GetProjectDeploymentsResponse, GetProjectDeploymentsResponses, GetProjectErrors, GetProjectResponse, GetProjectResponses, GetProjectsData, GetProjectSecretsQuery, GetProjectsErrors, GetProjectServiceEnvironmentVariablesData, GetProjectServiceEnvironmentVariablesErrors, GetProjectServiceEnvironmentVariablesResponse, GetProjectServiceEnvironmentVariablesResponses, GetProjectServiceTemplateData, GetProjectServiceTemplateErrors, GetProjectServiceTemplateResponse, GetProjectServiceTemplateResponses, GetProjectSessionReplaysData, GetProjectSessionReplaysError, GetProjectSessionReplaysErrors, GetProjectSessionReplaysQuery, GetProjectSessionReplaysResponse, GetProjectSessionReplaysResponse2, GetProjectSessionReplaysResponses, GetProjectsHealthData, GetProjectsHealthError, GetProjectsHealthErrors, GetProjectsHealthResponse, GetProjectsHealthResponses, GetProjectsMonitorHealthData, GetProjectsMonitorHealthErrors, GetProjectsMonitorHealthResponse, GetProjectsMonitorHealthResponses, GetProjectsResponse, GetProjectsResponses, GetProjectStatisticsData, GetProjectStatisticsErrors, GetProjectStatisticsResponse, GetProjectStatisticsResponses, GetProjectTemplateData, GetProjectTemplateErrors, GetProjectTemplateResponse, GetProjectTemplateResponses, GetPropertyBreakdownData, GetPropertyBreakdownErrors, GetPropertyBreakdownResponse, GetPropertyBreakdownResponses, GetPropertyTimelineData, GetPropertyTimelineErrors, GetPropertyTimelineResponse, GetPropertyTimelineResponses, GetProviderConnectionsData, GetProviderConnectionsErrors, GetProviderConnectionsResponse, GetProviderConnectionsResponses, GetProviderKeyData, GetProviderKeyError, GetProviderKeyErrors, GetProviderKeyResponse, GetProviderKeyResponses, GetProviderMetadataData, GetProviderMetadataErrors, GetProviderMetadataResponse, GetProviderMetadataResponses, GetProvidersMetadataData, GetProvidersMetadataErrors, GetProvidersMetadataResponse, GetProvidersMetadataResponses, GetProxyLogByIdData, GetProxyLogByIdError, GetProxyLogByIdErrors, GetProxyLogByIdResponse, GetProxyLogByIdResponses, GetProxyLogByRequestIdData, GetProxyLogByRequestIdError, GetProxyLogByRequestIdErrors, GetProxyLogByRequestIdResponse, GetProxyLogByRequestIdResponses, GetProxyLogsData, GetProxyLogsError, GetProxyLogsErrors, GetProxyLogsResponse, GetProxyLogsResponses, GetPublicBranchesData, GetPublicBranchesErrors, GetPublicBranchesResponse, GetPublicBranchesResponses, GetPublicComposePreviewData, GetPublicComposePreviewErrors, GetPublicComposePreviewResponse, GetPublicComposePreviewResponses, GetPublicComposeServicesData, GetPublicComposeServicesErrors, GetPublicComposeServicesResponse, GetPublicComposeServicesResponses, GetPublicIpData, GetPublicIpErrors, GetPublicIpResponses, GetPublicRepositoryData, GetPublicRepositoryErrors, GetPublicRepositoryResponse, GetPublicRepositoryResponses, GetQueryContainerInfoData, GetQueryContainerInfoErrors, GetQueryContainerInfoResponse, GetQueryContainerInfoResponses, GetQuotaData, GetQuotaError, GetQuotaErrors, GetQuotaResponse, GetQuotaResponses, GetRecentActivityData, GetRecentActivityErrors, GetRecentActivityResponse, GetRecentActivityResponses, GetRemoteExternalImageData, GetRemoteExternalImageErrors, GetRemoteExternalImageResponse, GetRemoteExternalImageResponses, GetRepositoryBranchesData, GetRepositoryBranchesErrors, GetRepositoryBranchesResponse, GetRepositoryBranchesResponses, GetRepositoryByIdData, GetRepositoryByIdErrors, GetRepositoryByIdResponse, GetRepositoryByIdResponses, GetRepositoryByNameData, GetRepositoryByNameErrors, GetRepositoryByNameResponse, GetRepositoryByNameResponses, GetRepositoryComposePreviewData, GetRepositoryComposePreviewErrors, GetRepositoryComposePreviewResponse, GetRepositoryComposePreviewResponses, GetRepositoryComposeServicesLiveData, GetRepositoryComposeServicesLiveErrors, GetRepositoryComposeServicesLiveResponse, GetRepositoryComposeServicesLiveResponses, GetRepositoryEnvExampleLiveData, GetRepositoryEnvExampleLiveErrors, GetRepositoryEnvExampleLiveResponse, GetRepositoryEnvExampleLiveResponses, GetRepositoryPresetByNameData, GetRepositoryPresetByNameErrors, GetRepositoryPresetByNameResponse, GetRepositoryPresetByNameResponses, GetRepositoryPresetLiveData, GetRepositoryPresetLiveErrors, GetRepositoryPresetLiveResponse, GetRepositoryPresetLiveResponses, GetRepositoryTagsData, GetRepositoryTagsErrors, GetRepositoryTagsResponse, GetRepositoryTagsResponses, GetRequest, GetResolvedEnvironmentVariablesData, GetResolvedEnvironmentVariablesErrors, GetResolvedEnvironmentVariablesResponse, GetResolvedEnvironmentVariablesResponses, GetResolvedEnvironmentVariableValueData, GetResolvedEnvironmentVariableValueErrors, GetResolvedEnvironmentVariableValueResponse, GetResolvedEnvironmentVariableValueResponses, GetResponse, GetRestoreCapabilitiesData, GetRestoreCapabilitiesError, GetRestoreCapabilitiesErrors, GetRestoreCapabilitiesResponse, GetRestoreCapabilitiesResponses, GetRestoreRunData, GetRestoreRunError, GetRestoreRunErrors, GetRestoreRunResponse, GetRestoreRunResponses, GetRouteData, GetRouteErrors, GetRouteResponse, GetRouteResponses, GetRunData, GetRunErrors, GetRunResponse, GetRunResponses, GetRunWithLogsData, GetRunWithLogsErrors, GetRunWithLogsResponse, GetRunWithLogsResponses, GetS3CredentialsData, GetS3CredentialsErrors, GetS3CredentialsResponse, GetS3CredentialsResponses, GetS3SourceData, GetS3SourceError, GetS3SourceErrors, GetS3SourceResponse, GetS3SourceResponses, GetSandboxData, GetSandboxErrors, GetSandboxResponse, GetSandboxResponses, GetSandboxStatusData, GetSandboxStatusErrors, GetSandboxStatusResponse, GetSandboxStatusResponses, GetScanByDeploymentData, GetScanByDeploymentError, GetScanByDeploymentErrors, GetScanByDeploymentResponse, GetScanByDeploymentResponses, GetScanData, GetScanError, GetScanErrors, GetScanResponse, GetScanResponses, GetScanVulnerabilitiesData, GetScanVulnerabilitiesError, GetScanVulnerabilitiesErrors, GetScanVulnerabilitiesResponse, GetScanVulnerabilitiesResponses, GetServiceBySlugData, GetServiceBySlugErrors, GetServiceBySlugResponse, GetServiceBySlugResponses, GetServiceData, GetServiceEnvironmentVariableData, GetServiceEnvironmentVariableErrors, GetServiceEnvironmentVariableResponse, GetServiceEnvironmentVariableResponses, GetServiceEnvironmentVariablesData, GetServiceEnvironmentVariablesErrors, GetServiceEnvironmentVariablesResponse, GetServiceEnvironmentVariablesResponses, GetServiceErrors, GetServiceHealthStatusData, GetServiceHealthStatusErrors, GetServiceHealthStatusResponse, GetServiceHealthStatusResponses, GetServicePreviewEnvironmentVariableNamesData, GetServicePreviewEnvironmentVariableNamesErrors, GetServicePreviewEnvironmentVariableNamesResponse, GetServicePreviewEnvironmentVariableNamesResponses, GetServicePreviewEnvironmentVariablesMaskedData, GetServicePreviewEnvironmentVariablesMaskedErrors, GetServicePreviewEnvironmentVariablesMaskedResponse, GetServicePreviewEnvironmentVariablesMaskedResponses, GetServiceResponse, GetServiceResponses, GetServiceRuntimeData, GetServiceRuntimeErrors, GetServiceRuntimeResponse, GetServiceRuntimeResponses, GetServiceStatsData, GetServiceStatsErrors, GetServiceStatsResponse, GetServiceStatsResponses, GetServiceTypeParametersData, GetServiceTypeParametersErrors, GetServiceTypeParametersResponses, GetServiceTypesData, GetServiceTypesErrors, GetServiceTypesResponse, GetServiceTypesResponses, GetSessionDetailsData, GetSessionDetailsErrors, GetSessionDetailsResponse, GetSessionDetailsResponses, GetSessionEventsData, GetSessionEventsErrors, GetSessionEventsResponse, GetSessionEventsResponses, GetSessionLogsData, GetSessionLogsErrors, GetSessionLogsResponse, GetSessionLogsResponses, GetSessionReplayData, GetSessionReplayError, GetSessionReplayErrors, GetSessionReplayEventsData, GetSessionReplayEventsError, GetSessionReplayEventsErrors, GetSessionReplayEventsResponse, GetSessionReplayEventsResponses, GetSessionReplayResponse, GetSessionReplayResponse2, GetSessionReplayResponses, GetSettingsData, GetSettingsErrors, GetSettingsResponse, GetSettingsResponses, GetSkillData, GetSkillErrors, GetSkillResponse, GetSkillResponses, GetSlowQueriesData, GetSlowQueriesErrors, GetSlowQueriesResponse, GetSlowQueriesResponses, GetSnapshotData, GetSnapshotErrors, GetSnapshotResponse, GetSnapshotResponses, GetStaticBundleData, GetStaticBundleErrors, GetStaticBundleResponse, GetStaticBundleResponses, GetStatusOverviewData, GetStatusOverviewErrors, GetStatusOverviewResponse, GetStatusOverviewResponses, GetSystemAlarmsSummaryData, GetSystemAlarmsSummaryErrors, GetSystemAlarmsSummaryResponse, GetSystemAlarmsSummaryResponses, GetTagsByRepositoryIdData, GetTagsByRepositoryIdErrors, GetTagsByRepositoryIdResponse, GetTagsByRepositoryIdResponses, GetTeamData, GetTeamErrors, GetTeamResponse, GetTeamResponses, GetTimeBucketStatsData, GetTimeBucketStatsError, GetTimeBucketStatsErrors, GetTimeBucketStatsResponse, GetTimeBucketStatsResponses, GetTodayStatsData, GetTodayStatsError, GetTodayStatsErrors, GetTodayStatsResponse, GetTodayStatsResponses, GetTraceData, GetTraceError, GetTraceErrors, GetTraceResponse, GetTraceResponses, GetTraefikDiscoveryStatusData, GetTraefikDiscoveryStatusError, GetTraefikDiscoveryStatusErrors, GetTraefikDiscoveryStatusResponse, GetTraefikDiscoveryStatusResponses, GetUnifiedTraceData, GetUnifiedTraceError, GetUnifiedTraceErrors, GetUnifiedTraceResponse, GetUnifiedTraceResponses, GetUniqueCountsData, GetUniqueCountsErrors, GetUniqueCountsResponse, GetUniqueCountsResponses, GetUniqueEventsData, GetUniqueEventsErrors, GetUniqueEventsQuery, GetUniqueEventsResponse, GetUniqueEventsResponses, GetUpdateCapabilityData, GetUpdateCapabilityErrors, GetUpdateCapabilityResponse, GetUpdateCapabilityResponses, GetUpdateStatusData, GetUpdateStatusErrors, GetUpdateStatusResponse, GetUpdateStatusResponses, GetUptimeHistoryData, GetUptimeHistoryErrors, GetUptimeHistoryResponse, GetUptimeHistoryResponses, GetUsageByProviderData, GetUsageByProviderError, GetUsageByProviderErrors, GetUsageByProviderResponse, GetUsageByProviderResponses, GetUsageRecentData, GetUsageRecentError, GetUsageRecentErrors, GetUsageRecentResponse, GetUsageRecentResponses, GetUsageSummaryData, GetUsageSummaryError, GetUsageSummaryErrors, GetUsageSummaryResponse, GetUsageSummaryResponses, GetUsageTimeseriesData, GetUsageTimeseriesError, GetUsageTimeseriesErrors, GetUsageTimeseriesResponse, GetUsageTimeseriesResponses, GetUsageTopModelsData, GetUsageTopModelsError, GetUsageTopModelsErrors, GetUsageTopModelsResponse, GetUsageTopModelsResponses, GetUserConversationAttachmentData, GetUserConversationAttachmentErrors, GetUserConversationAttachmentResponse, GetUserConversationAttachmentResponses, GetUserConversationData, GetUserConversationErrors, GetUserConversationResponse, GetUserConversationResponses, GetUserPendingActionData, GetUserPendingActionErrors, GetUserPendingActionResponse, GetUserPendingActionResponses, GetVisibleCustomDomainByHostnameData, GetVisibleCustomDomainByHostnameErrors, GetVisibleCustomDomainByHostnameResponse, GetVisibleCustomDomainByHostnameResponses, GetVisitorByGuidData, GetVisitorByGuidErrors, GetVisitorByGuidResponse, GetVisitorByGuidResponses, GetVisitorByIdData, GetVisitorByIdErrors, GetVisitorByIdResponse, GetVisitorByIdResponses, GetVisitorDetailsData, GetVisitorDetailsErrors, GetVisitorDetailsResponse, GetVisitorDetailsResponses, GetVisitorFacetsData, GetVisitorFacetsErrors, GetVisitorFacetsResponse, GetVisitorFacetsResponses, GetVisitorInfoData, GetVisitorInfoErrors, GetVisitorInfoResponse, GetVisitorInfoResponses, GetVisitorJourneyData, GetVisitorJourneyErrors, GetVisitorJourneyResponse, GetVisitorJourneyResponses, GetVisitorsData, GetVisitorsErrors, GetVisitorSessionsData, GetVisitorSessionsError, GetVisitorSessionsErrors, GetVisitorSessionsQuery, GetVisitorSessionsResponse, GetVisitorSessionsResponse2, GetVisitorSessionsResponses, GetVisitorsResponse, GetVisitorsResponses, GetVisitorStatsData, GetVisitorStatsErrors, GetVisitorStatsResponse, GetVisitorStatsResponses, GetWebhookData, GetWebhookErrors, GetWebhookResponse, GetWebhookResponses, GetWorkspaceFileLimitsData, GetWorkspaceFileLimitsErrors, GetWorkspaceFileLimitsResponse, GetWorkspaceFileLimitsResponses, GitPushEvent, GitRef, GitRefResponse, GitSourcePlan, GlobalConversationResponse, GlobalEventStatsResponse, GlobalMrrResponse, GlobalRecentEventResponse, GlobalRevenueSummaryResponse, GrantProjectAccessData, GrantProjectAccessErrors, GrantProjectAccessResponse, GrantProjectAccessResponses, GroupedPageMetric, GroupedPageMetricsQuery, GroupedPageMetricsResponse, HandleGitProviderOauthCallbackData, HandleGitProviderOauthCallbackErrors, HasAnalyticsEventsData, HasAnalyticsEventsErrors, HasAnalyticsEventsResponse, HasAnalyticsEventsResponse2, HasAnalyticsEventsResponses, HasErrorGroupsData, HasErrorGroupsErrors, HasErrorGroupsResponse, HasErrorGroupsResponse2, HasErrorGroupsResponses, HasEventsQuery, HasEventsResponse, HasMetricsQuery, HasMetricsResponse, HasPerformanceMetricsData, HasPerformanceMetricsError, HasPerformanceMetricsErrors, HasPerformanceMetricsResponse, HasPerformanceMetricsResponses, HasTracesData, HasTracesError, HasTracesErrors, HasTracesResponse, HasTracesResponse2, HasTracesResponses, HealthCheckConfiguration, HealthCheckEntryResponse, HealthResponse, HealthStatus, HealthSummary, HeartbeatApiRequest, HeartbeatResponse, HierarchyLevel, HistogramSummary, HostnameChange, HostnamePreviewResponse, HourlyPageSessions, HourlyVisitsQuery, HttpChallengeDebugResponse, ImageRetentionSettings, ImageRuntimeConfig, ImportApplicationWorkspaceGitData, ImportApplicationWorkspaceGitErrors, ImportApplicationWorkspaceGitRequest, ImportApplicationWorkspaceGitResponse, ImportApplicationWorkspaceGitResponses, ImportCredentials, ImportedHostVerdict, ImportEmailDomainData, ImportEmailDomainErrors, ImportEmailDomainRequest, ImportEmailDomainResponse, ImportEmailDomainResponses, ImportExecutionStatus, ImportExternalServiceData, ImportExternalServiceErrors, ImportExternalServiceRequest, ImportExternalServiceResponse, ImportExternalServiceResponses, ImportLocalAiProviderCredentialData, ImportLocalAiProviderCredentialErrors, ImportLocalAiProviderCredentialResponse, ImportLocalAiProviderCredentialResponses, ImportLocalCredentialResponse, ImportOutcomeResponse, ImportPlan, ImportRowErrorResponse, ImportSelector, ImportSource, ImportSourceCapabilities, ImportSourceInfo, ImportStatusResponse, ImportTraefikAcmeJsonData, ImportTraefikAcmeJsonError, ImportTraefikAcmeJsonErrors, ImportTraefikAcmeJsonRequest, ImportTraefikAcmeJsonResponse, ImportTraefikAcmeJsonResponse2, ImportTraefikAcmeJsonResponses, IncidentBucket, IncidentBucketedResponse, IncidentResponse, IncidentUpdateResponse, IncrRequest, IncrResponse, IngestErrorsResponse, IngestErrorSummary, IngestLogsByPathData, IngestLogsByPathError, IngestLogsByPathErrors, IngestLogsByPathResponses, IngestLogsData, IngestLogsError, IngestLogsErrors, IngestLogsResponses, IngestMetricsByPathData, IngestMetricsByPathError, IngestMetricsByPathErrors, IngestMetricsByPathResponses, IngestMetricsData, IngestMetricsError, IngestMetricsErrors, IngestMetricsResponses, IngestSentryEnvelopeData, IngestSentryEnvelopeErrors, IngestSentryEnvelopeResponses, IngestSentryEventData, IngestSentryEventErrors, IngestSentryEventResponse, IngestSentryEventResponses, IngestTracesByPathData, IngestTracesByPathError, IngestTracesByPathErrors, IngestTracesByPathResponses, IngestTracesData, IngestTracesError, IngestTracesErrors, IngestTracesResponses, IngestTunneledEnvelopeData, IngestTunneledEnvelopeErrors, IngestTunneledEnvelopeResponse, IngestTunneledEnvelopeResponses, InitAuthResponse, InitSessionReplayData, InitSessionReplayError, InitSessionReplayErrors, InitSessionReplayResponse, InitSessionReplayResponses, Insight, InsightSeverity, InsightsResponse, InsightStatus, InspectDropArchiveData, InspectDropArchiveErrors, InspectDropArchiveResponse, InspectDropArchiveResponses, IntegrationResponse, IpAccessControlQuery, IpAccessControlResponse, IssueRuntimeCredentialsData, IssueRuntimeCredentialsErrors, IssueRuntimeCredentialsResponse, IssueRuntimeCredentialsResponses, JobLogsData, JobLogsErrors, JobLogsResponses, JobStatusData, JobStatusErrors, JobStatusResponse, JobStatusResponse2, JobStatusResponses, JobSummaryResponse, JoinTokenStatusResponse, JourneyEvent, JourneySession, KeysRequest, KeysResponse, KillJobBody, KillJobData, KillJobErrors, KillJobResponse, KillJobResponses, KnownAiAgentsResponse, KvDelData, KvDelErrors, KvDelResponse, KvDelResponses, KvDisableData, KvDisableErrors, KvDisableResponse, KvDisableResponses, KvEnableData, KvEnableErrors, KvEnableResponse, KvEnableResponses, KvExpireData, KvExpireErrors, KvExpireResponse, KvExpireResponses, KvGetData, KvGetErrors, KvGetResponse, KvGetResponses, KvIncrData, KvIncrErrors, KvIncrResponse, KvIncrResponses, KvKeysData, KvKeysErrors, KvKeysResponse, KvKeysResponses, KvSetData, KvSetErrors, KvSetResponse, KvSetResponses, KvStatusData, KvStatusErrors, KvStatusResponse, KvStatusResponse2, KvStatusResponses, KvTtlData, KvTtlErrors, KvTtlResponse, KvTtlResponses, KvUpdateData, KvUpdateErrors, KvUpdateResponse, KvUpdateResponses, LatestDeploymentMediaResponse, LatestDeploymentMediaResponseItem, LatestRunForSourceData, LatestRunForSourceErrors, LatestRunForSourceResponse, LatestRunForSourceResponses, LemonSqueezyConfig, LetsEncryptSettings, LineContext, LinkApplicationProjectData, LinkApplicationProjectErrors, LinkApplicationProjectRequest, LinkApplicationProjectResponse, LinkApplicationProjectResponses, LinkCustomDomainToCertificateData, LinkCustomDomainToCertificateErrors, LinkCustomDomainToCertificateResponse, LinkCustomDomainToCertificateResponses, LinkServiceRequest, LinkServiceToProjectData, LinkServiceToProjectErrors, LinkServiceToProjectResponse, LinkServiceToProjectResponses, ListAgentRunsData, ListAgentRunsErrors, ListAgentRunsResponse, ListAgentRunsResponses, ListAgentsData, ListAgentsErrors, ListAgentsResponse, ListAgentsResponse2, ListAgentsResponses, ListAiProvidersData, ListAiProvidersErrors, ListAiProvidersResponse, ListAiProvidersResponses, ListAlertRulesData, ListAlertRulesErrors, ListAlertRulesResponse, ListAlertRulesResponses, ListAlertsData, ListAlertsError, ListAlertsErrors, ListAlertsResponse, ListAlertsResponses, ListAllConversationsData, ListAllConversationsErrors, ListAllConversationsResponse, ListAllConversationsResponses, ListAllRunsData, ListAllRunsErrors, ListAllRunsResponse, ListAllRunsResponses, ListAnalyticsIngestKeysData, ListAnalyticsIngestKeysErrors, ListAnalyticsIngestKeysResponse, ListAnalyticsIngestKeysResponses, ListApiKeysData, ListApiKeysErrors, ListApiKeysQuery, ListApiKeysResponse, ListApiKeysResponses, ListApplicationConversationsData, ListApplicationConversationsErrors, ListApplicationConversationsResponse, ListApplicationConversationsResponses, ListApplicationsData, ListApplicationsErrors, ListApplicationsResponse, ListApplicationsResponses, ListAuditLogsData, ListAuditLogsErrors, ListAuditLogsQuery, ListAuditLogsResponse, ListAuditLogsResponses, ListAvailableContainersData, ListAvailableContainersErrors, ListAvailableContainersResponse, ListAvailableContainersResponses, ListBackupAlertsData, ListBackupAlertsError, ListBackupAlertsErrors, ListBackupAlertsResponse, ListBackupAlertsResponses, ListBackupChildrenData, ListBackupChildrenError, ListBackupChildrenErrors, ListBackupChildrenResponse, ListBackupChildrenResponses, ListBackupSchedulesData, ListBackupSchedulesError, ListBackupSchedulesErrors, ListBackupSchedulesResponse, ListBackupSchedulesResponses, ListBackupsForScheduleData, ListBackupsForScheduleError, ListBackupsForScheduleErrors, ListBackupsForScheduleResponse, ListBackupsForScheduleResponses, ListBlobsQuery, ListBlobsResponse, ListCommitsByRepositoryIdData, ListCommitsByRepositoryIdErrors, ListCommitsByRepositoryIdResponse, ListCommitsByRepositoryIdResponses, ListConnectionsData, ListConnectionsErrors, ListConnectionsResponse, ListConnectionsResponses, ListContainerHistoryData, ListContainerHistoryError, ListContainerHistoryErrors, ListContainerHistoryResponse, ListContainerHistoryResponses, ListContainersAtPathData, ListContainersAtPathErrors, ListContainersAtPathResponse, ListContainersAtPathResponses, ListContainersData, ListContainersErrors, ListContainersResponse, ListContainersResponses, ListConversationsData, ListConversationsErrors, ListConversationsResponse, ListConversationsResponses, ListCustomDomainsForProjectData, ListCustomDomainsForProjectErrors, ListCustomDomainsForProjectResponse, ListCustomDomainsForProjectResponses, ListCustomDomainsResponse, ListDashboardsData, ListDashboardsError, ListDashboardsErrors, ListDashboardsResponse, ListDashboardsResponses, ListDeliveriesData, ListDeliveriesErrors, ListDeliveriesResponse, ListDeliveriesResponses, ListDeploymentContainerLogsData, ListDeploymentContainerLogsErrors, ListDeploymentContainerLogsResponse, ListDeploymentContainerLogsResponses, ListDeploymentTokensData, ListDeploymentTokensErrors, ListDeploymentTokensQuery, ListDeploymentTokensResponse, ListDeploymentTokensResponses, ListDiscoverableDomainsData, ListDiscoverableDomainsErrors, ListDiscoverableDomainsResponse, ListDiscoverableDomainsResponses, ListDiscoveredRoutesQuery, ListDnsProvidersData, ListDnsProvidersErrors, ListDnsProvidersResponse, ListDnsProvidersResponses, ListDomainsData, ListDomainsErrors, ListDomainsResponse, ListDomainsResponse2, ListDomainsResponses, ListDsnsData, ListDsnsErrors, ListDsnsResponse, ListDsnsResponses, ListEmailDomainProjectsData, ListEmailDomainProjectsErrors, ListEmailDomainProjectsResponse, ListEmailDomainProjectsResponses, ListEmailDomainsData, ListEmailDomainsErrors, ListEmailDomainsResponse, ListEmailDomainsResponses, ListEmailProvidersData, ListEmailProvidersErrors, ListEmailProvidersResponse, ListEmailProvidersResponses, ListEmailsData, ListEmailsErrors, ListEmailsResponse, ListEmailsResponses, ListEnrollmentTokensData, ListEnrollmentTokensErrors, ListEnrollmentTokensResponse, ListEnrollmentTokensResponses, ListEntitiesData, ListEntitiesErrors, ListEntitiesQuery, ListEntitiesResponse, ListEntitiesResponses, ListErrorEventsData, ListErrorEventsErrors, ListErrorEventsQuery, ListErrorEventsResponse, ListErrorEventsResponses, ListErrorGroupsData, ListErrorGroupsErrors, ListErrorGroupsQuery, ListErrorGroupsResponse, ListErrorGroupsResponses, ListEventsData, ListEventsResponse, ListEventsResponses, ListEventTypesData, ListEventTypesResponse, ListEventTypesResponses, ListExternalImagesData, ListExternalImagesErrors, ListExternalImagesResponse, ListExternalImagesResponses, ListExternalPluginsData, ListExternalPluginsErrors, ListExternalPluginsResponse, ListExternalPluginsResponses, ListExternalServiceBackupsData, ListExternalServiceBackupsError, ListExternalServiceBackupsErrors, ListExternalServiceBackupsResponse, ListExternalServiceBackupsResponses, ListFacetsData, ListFacetsError, ListFacetsErrors, ListFacetsResponse, ListFacetsResponses, ListFlagsData, ListFlagsErrors, ListFlagsResponse, ListFlagsResponses, ListFunnelsData, ListFunnelsErrors, ListFunnelsResponse, ListFunnelsResponses, ListGitProvidersData, ListGitProvidersErrors, ListGitProvidersResponse, ListGitProvidersResponses, ListGlobalMcpsData, ListGlobalMcpsErrors, ListGlobalMcpsResponse, ListGlobalMcpsResponses, ListGlobalSkillsData, ListGlobalSkillsErrors, ListGlobalSkillsResponse, ListGlobalSkillsResponses, ListIncidentsData, ListIncidentsErrors, ListIncidentsResponses, ListInsightsData, ListInsightsError, ListInsightsErrors, ListInsightsResponse, ListInsightsResponses, ListIpAccessControlData, ListIpAccessControlError, ListIpAccessControlErrors, ListIpAccessControlResponse, ListIpAccessControlResponses, ListJobsData, ListJobsErrors, ListJobsResponse, ListJobsResponse2, ListJobsResponses, ListKnownAiAgentsData, ListKnownAiAgentsError, ListKnownAiAgentsErrors, ListKnownAiAgentsResponse, ListKnownAiAgentsResponses, ListManagedDomainsData, ListManagedDomainsErrors, ListManagedDomainsResponse, ListManagedDomainsResponses, ListManagedEnvironmentVariablesData, ListManagedEnvironmentVariablesErrors, ListManagedEnvironmentVariablesResponse, ListManagedEnvironmentVariablesResponses, ListMcpsData, ListMcpsErrors, ListMcpsResponse, ListMcpsResponse2, ListMcpsResponses, ListMetricLabelKeysData, ListMetricLabelKeysError, ListMetricLabelKeysErrors, ListMetricLabelKeysResponse, ListMetricLabelKeysResponses, ListMetricLabelValuesData, ListMetricLabelValuesError, ListMetricLabelValuesErrors, ListMetricLabelValuesResponse, ListMetricLabelValuesResponses, ListMetricNamesData, ListMetricNamesError, ListMetricNamesErrors, ListMetricNamesResponse, ListMetricNamesResponses, ListModelsData, ListModelsError, ListModelsErrors, ListModelsResponse, ListModelsResponses, ListMonitorsData, ListMonitorsErrors, ListMonitorsResponse, ListMonitorsResponses, ListNotificationProvidersData, ListNotificationProvidersErrors, ListNotificationProvidersResponse, ListNotificationProvidersResponses, ListNotificationRoutesData, ListNotificationRoutesErrors, ListNotificationRoutesResponse, ListNotificationRoutesResponses, ListOidcProvidersData, ListOidcProvidersResponse, ListOidcProvidersResponses, ListOidcProviderUsersData, ListOidcProviderUsersErrors, ListOidcProviderUsersResponse, ListOidcProviderUsersResponses, ListOidcRoleMappingsData, ListOidcRoleMappingsResponse, ListOidcRoleMappingsResponses, ListOnDemandCertsData, ListOnDemandCertsErrors, ListOnDemandCertsResponse, ListOnDemandCertsResponse2, ListOnDemandCertsResponses, ListOrdersData, ListOrdersErrors, ListOrdersResponse, ListOrdersResponse2, ListOrdersResponses, ListPeersData, ListPeersErrors, ListPeersResponse, ListPeersResponses, ListPendingActionsData, ListPendingActionsErrors, ListPendingActionsResponse, ListPendingActionsResponses, ListPgUpgradesData, ListPgUpgradesError, ListPgUpgradesErrors, ListPgUpgradesResponse, ListPgUpgradesResponses, ListPresetsData, ListPresetsErrors, ListPresetsResponse, ListPresetsResponse2, ListPresetsResponses, ListProjectAccessData, ListProjectAccessErrors, ListProjectAccessResponse, ListProjectAccessResponses, ListProjectAlarmsData, ListProjectAlarmsErrors, ListProjectAlarmsResponse, ListProjectAlarmsResponses, ListProjectScansData, ListProjectScansError, ListProjectScansErrors, ListProjectScansResponse, ListProjectScansResponses, ListProjectSecretsData, ListProjectSecretsErrors, ListProjectSecretsResponse, ListProjectSecretsResponses, ListProjectServicesData, ListProjectServicesErrors, ListProjectServicesResponse, ListProjectServicesResponses, ListProjectTemplatesData, ListProjectTemplatesErrors, ListProjectTemplatesResponse, ListProjectTemplatesResponses, ListProjectTemplateTagsData, ListProjectTemplateTagsErrors, ListProjectTemplateTagsResponse, ListProjectTemplateTagsResponses, ListProviderDomainsResponse, ListProviderKeysData, ListProviderKeysError, ListProviderKeysErrors, ListProviderKeysResponse, ListProviderKeysResponses, ListProviderZonesData, ListProviderZonesErrors, ListProviderZonesResponse, ListProviderZonesResponses, ListPublicProvidersData, ListPublicProvidersResponse, ListPublicProvidersResponses, ListReleaseFilesData, ListReleaseFilesErrors, ListReleaseFilesResponse, ListReleaseFilesResponses, ListReleasesData, ListReleasesErrors, ListReleasesResponse, ListReleasesResponses, ListRemoteExternalImagesData, ListRemoteExternalImagesErrors, ListRemoteExternalImagesResponse, ListRemoteExternalImagesResponses, ListRenewalAttemptsData, ListRenewalAttemptsErrors, ListRenewalAttemptsResponse, ListRenewalAttemptsResponse2, ListRenewalAttemptsResponses, ListRepositoriesByConnectionData, ListRepositoriesByConnectionErrors, ListRepositoriesByConnectionResponse, ListRepositoriesByConnectionResponses, ListRepositoriesByProviderData, ListRepositoriesByProviderErrors, ListRepositoriesByProviderResponse, ListRepositoriesByProviderResponses, ListRestoreRunsForServiceData, ListRestoreRunsForServiceError, ListRestoreRunsForServiceErrors, ListRestoreRunsForServiceResponse, ListRestoreRunsForServiceResponses, ListRootContainersData, ListRootContainersErrors, ListRootContainersResponse, ListRootContainersResponses, ListRoutesData, ListRoutesErrors, ListRoutesResponse, ListRoutesResponses, ListRunsResponse, ListS3SourcesData, ListS3SourcesError, ListS3SourcesErrors, ListS3SourcesResponse, ListS3SourcesResponses, ListSandboxesData, ListSandboxesErrors, ListSandboxesResponse, ListSandboxesResponse2, ListSandboxesResponses, ListScansQuery, ListScheduleRunJobsData, ListScheduleRunJobsError, ListScheduleRunJobsErrors, ListScheduleRunJobsResponse, ListScheduleRunJobsResponses, ListScheduleRunsData, ListScheduleRunsError, ListScheduleRunsErrors, ListScheduleRunsResponse, ListScheduleRunsResponses, ListScheduleServicesData, ListScheduleServicesError, ListScheduleServicesErrors, ListScheduleServicesResponse, ListScheduleServicesResponses, ListSecretsData, ListSecretsErrors, ListSecretsResponse, ListSecretsResponse2, ListSecretsResponses, ListServiceHealthStatusesData, ListServiceHealthStatusesErrors, ListServiceHealthStatusesResponse, ListServiceHealthStatusesResponses, ListServiceProjectsData, ListServiceProjectsErrors, ListServiceProjectsResponse, ListServiceProjectsResponses, ListServiceSchedulesData, ListServiceSchedulesError, ListServiceSchedulesErrors, ListServiceSchedulesResponse, ListServiceSchedulesResponses, ListServicesData, ListServicesErrors, ListServicesResponse, ListServicesResponses, ListSkillsData, ListSkillsErrors, ListSkillsResponse, ListSkillsResponse2, ListSkillsResponses, ListSnapshotsData, ListSnapshotsErrors, ListSnapshotsResponse, ListSnapshotsResponse2, ListSnapshotsResponses, ListSourceBackupsData, ListSourceBackupsError, ListSourceBackupsErrors, ListSourceBackupsResponse, ListSourceBackupsResponses, ListSourceFilesData, ListSourceFilesErrors, ListSourceFilesResponse, ListSourceFilesResponses, ListSourceMapsData, ListSourceMapsErrors, ListSourceMapsResponse, ListSourceMapsResponses, ListSourcesData, ListSourcesErrors, ListSourcesResponse, ListSourcesResponses, ListStaticBundlesData, ListStaticBundlesErrors, ListStaticBundlesResponse, ListStaticBundlesResponses, ListSyncedRepositoriesData, ListSyncedRepositoriesErrors, ListSyncedRepositoriesResponse, ListSyncedRepositoriesResponses, ListSystemAlarmsData, ListSystemAlarmsErrors, ListSystemAlarmsResponse, ListSystemAlarmsResponses, ListTagsResponse, ListTeamMembersData, ListTeamMembersErrors, ListTeamMembersResponse, ListTeamMembersResponses, ListTeamProjectsData, ListTeamProjectsErrors, ListTeamProjectsResponse, ListTeamProjectsResponses, ListTeamsData, ListTeamsErrors, ListTeamsResponse, ListTeamsResponses, ListTemplatesQuery, ListTemplatesResponse, ListThreadArtifactsData, ListThreadArtifactsErrors, ListThreadArtifactsResponse, ListThreadArtifactsResponses, ListTraefikDiscoveredRoutesData, ListTraefikDiscoveredRoutesError, ListTraefikDiscoveredRoutesErrors, ListTraefikDiscoveredRoutesResponse, ListTraefikDiscoveredRoutesResponses, ListUserPendingActionsData, ListUserPendingActionsErrors, ListUserPendingActionsResponse, ListUserPendingActionsResponses, ListUsersData, ListUsersErrors, ListUsersResponse, ListUsersResponses, ListVulnerabilitiesQuery, ListWebhooksData, ListWebhooksErrors, ListWebhooksResponse, ListWebhooksResponses, LiveVisitorInfo, LiveVisitorsListResponse, LocalCredentialDto, LocationCount, LocationGranularity, LocationInfo, LoginData, LoginErrors, LoginRequest, LoginResponse, LoginResponses, LogLevel, LogoutData, LogoutErrors, LogoutResponses, LogRecord, LogSearchLine, LogSeverity, LogSource, LogsQuery, LogsResponse, LogStream, LookupDnsARecordsData, LookupDnsARecordsError, LookupDnsARecordsErrors, LookupDnsARecordsResponse, LookupDnsARecordsResponses, ManagedBackupSetup, ManagedBackupSetupAction, ManagedBackupSetupStatus, ManagedDomainResponse, ManagedEnvironmentVariable, ManagedEnvironmentVariableSource, ManualAction, ManualActionTiming, Maturity, McpDefinitionResponse, McpServerSettings, MessageContent, MessagePart, MessageResponse, MeteredMode, MetricAggregation, MetricBucket, MetricDataPoint, MetricsOverTimeResponse, MetricsQuery, MetricsRangeQuery, MetricsStatusResponse, MetricsStoreKind, MetricsSummaryResponse, MetricType, MfaRequiredResponse, MfaSetupResponse, MfaVerificationRequest, MigrationStep, MigrationSummary, MintEnrollmentTokenData, MintEnrollmentTokenErrors, MintEnrollmentTokenRequest, MintEnrollmentTokenResponse, MintEnrollmentTokenResponse2, MintEnrollmentTokenResponses, MiscResult, MkdirBody, MkdirData, MkdirErrors, MkdirResponse, MkdirResponses, ModelCapability, ModelCatalogSource, ModelInfo, ModelListResponse, ModelPricing, ModelUsage, MonitoringSettings, MonitoringSettingsMasked, MonitorResponse, MonitorStatus, MrrBucketResponse, MultiNodeSettings, MultiNodeSettingsMasked, MxResult, NavEntry, NavSection, NetworkConfiguration, NetworkMode, NetworkPoolEntry, NixpacksPresetConfig, NixpacksProvider, NodeContainerListResponse, NodeContainerResponse, NodeCostInfo, NodeDnsStatusEntry, NodeHeartbeatData, NodeHeartbeatErrors, NodeHeartbeatResponse, NodeHeartbeatResponses, NodeInfoResponse, NodeListResponse, NodeMetricsGetAlertRulesData, NodeMetricsGetAlertRulesErrors, NodeMetricsGetAlertRulesResponse, NodeMetricsGetAlertRulesResponses, NodeMetricsGetRangeData, NodeMetricsGetRangeErrors, NodeMetricsGetRangeResponse, NodeMetricsGetRangeResponses, NodeMetricsUpdateAlertRuleData, NodeMetricsUpdateAlertRuleErrors, NodeMetricsUpdateAlertRuleResponse, NodeMetricsUpdateAlertRuleResponses, NotificationPreferencesResponse, NotificationProviderResponse, NotificationRoute, NotificationRoutePage, ObservabilityCompressionSettings, ObservabilityEvent, ObservabilityFullEventData, ObservabilityFullEventError, ObservabilityFullEventErrors, ObservabilityFullEventResponse, ObservabilityFullEventResponses, ObservabilityListEventsData, ObservabilityListEventsError, ObservabilityListEventsErrors, ObservabilityListEventsResponse, ObservabilityListEventsResponses, ObservabilityRetentionSettings, OidcCallbackData, OidcProviderResponse, OidcProvidersListResponse, OidcProviderSummary, OidcProviderUserResponse, OidcRoleMappingResponse, OidcTestConnectionResponse, OnDemandCertAttemptResponse, OnDemandCertRow, OnDemandTlsSettings, OpenAiError, OpenAiErrorResponse, OperatingSystemCount, OperationResultResponse, OperationResultsResponse, OtelDashboardResponse, OtelDashboardsResponse, OtelMetricAlertRuleResponse, OtelMetricAlertsResponse, OtelMetricLabelKeysResponse, OtelMetricLabelValuesResponse, OtelMetricNamesResponse, OtelMetricsResponse, OutlierAlgorithm, OutlierParams, OverprovisioningAssessment, OverprovisioningVerdict, PageActivityBucket, PageCountryStats, PageFlowEntry, PageFlowQuery, PageFlowResponse, PageHourlySessionsQuery, PageHourlySessionsResponse, PagePathDetailQuery, PagePathDetailResponse, PagePathInfo, PagePathSparkline, PagePathSparklinePoint, PagePathsQuery, PagePathsResponse, PagePathsSparklineQuery, PagePathsSparklineResponse, PagePathVisitorsQuery, PagePathVisitorsResponse, PageReferrerStats, PagesComparisonResponse, PageSessionComparison, PageSessionStats, PageSessionStatsQuery, PageTransition, PageVisit, PageVisitorSession, PaginatedEmailsResponse, PaginatedEntitiesResponse, PaginatedErrorEventsResponse, PaginatedErrorGroupsResponse, PaginatedEventsResponse, PaginatedExternalImagesResponse, PaginatedProjectList, PaginatedStaticBundlesResponse, Pagination, PaginationMeta, PaginationParams, PasswordProtectionConfig, PatchAdminGateData, PatchAdminGateErrors, PatchAdminGateResponse, PatchAdminGateResponses, PatchPreviewGatewaySettingsData, PatchPreviewGatewaySettingsError, PatchPreviewGatewaySettingsErrors, PatchPreviewGatewaySettingsResponse, PatchPreviewGatewaySettingsResponses, PatchSettingsRequest, PathVisitors, PathVisitorsAnalyticsQuery, PathVisitorsResponse, PauseDeploymentData, PauseDeploymentErrors, PauseDeploymentResponse, PauseDeploymentResponses, PauseSandboxData, PauseSandboxErrors, PauseSandboxResponse, PauseSandboxResponses, PeerEntry, PeerListResponse, PendingActionResponse, PerformanceMetricsQuery, PerformanceMetricsResponse, PermissionDecision, PermissionInfo, PermissionKind, PermissionRequest, PermissionRequestedEvent, PgUpgradeLogResponse, PgUpgradeResponse, PipelineHistoryPoint, PipelineHistoryResponse, PipelineSeries, PipelineStats, PipelineStatsResponse, PlanComplexity, PlanMetadata, PlanRestoreData, PlanRestoreError, PlanRestoreErrors, PlanRestoreResponse, PlanRestoreResponses, PlanSourceBackup, PlanTarget, PlatformInfo, PluginCapability, PluginManifest, PortMapping, PostDnsAckData, PostDnsAckErrors, PostDnsAckResponse, PostDnsAckResponses, PostgresWalHealth, PresetConfigSchema, PresetInfo, PresetResponse, PreviewAlertData, PreviewAlertError, PreviewAlertErrors, PreviewAlertResponse, PreviewAlertResponses, PreviewFunnelMetricsData, PreviewFunnelMetricsErrors, PreviewFunnelMetricsResponse, PreviewFunnelMetricsResponses, PreviewGatewayLogsResponse, PreviewGatewaySettings, PreviewGatewaySettingsMasked, PreviewGatewaySettingsResponse, PreviewHostnameModeData, PreviewHostnameModeErrors, PreviewHostnameModeResponse, PreviewHostnameModeResponses, PreviewShareLinkBody, PreviewShareLinkResponse, PricingResponse, ProblemDetails, ProjectAccessResponse, ProjectCloudTelemetryResponse, ProjectConfiguration, ProjectDashboardAnalytics, ProjectDsnResponse, ProjectEnvVarInput, ProjectHealthSummary, ProjectHourlyRequestCount, ProjectInfo, ProjectMonitorHealth, ProjectPresetResponse, ProjectQuery, ProjectRef, ProjectResponse, ProjectSecretEnvironmentInfo, ProjectSecretResponse, ProjectServiceInfo, ProjectsHealthResponse, ProjectsMonitorHealthResponse, ProjectStatisticsResponse, ProjectStatsBreakdown, ProjectTemplate, ProjectType, ProjectUsageInfoResponse, PromoteClusterMemberData, PromoteClusterMemberErrors, PromoteClusterMemberResponses, PromoteDeploymentData, PromoteDeploymentErrors, PromoteDeploymentRequest, PromoteDeploymentResponse, PromoteDeploymentResponses, PropertyBreakdownItem, PropertyBreakdownQuery, PropertyBreakdownResponse, PropertyColumn, PropertyTimelineItem, PropertyTimelineQuery, PropertyTimelineResponse, Protocol, ProviderCatalogDto, ProviderCatalogResponse, ProviderConfig, ProviderConfigMasked, ProviderDeletionCheckResponse, ProviderDescriptor, ProviderDetailResponse, ProviderDomainIdentityResponse, ProviderKeyResponse, ProviderMetadata, ProviderModelResponse, ProviderResponse, ProviderUsage, ProvisionDomainData, ProvisionDomainErrors, ProvisionDomainResponse, ProvisionDomainResponses, ProvisionResponse, ProxyLogAccessResponse, ProxyLogResponse, ProxyLogsPaginatedResponse, PublicComposePreviewRequest, PublicComposePreviewResponse, PublicComposeServicePreview, PublicComposeServicesResponse, PublicEnvExampleResponse, PublicHostnameStrategy, PublicPresetResponse, PublicRepositoryInfo, PurgeLogsRequest, PurgeProjectLogsData, PurgeProjectLogsError, PurgeProjectLogsErrors, PurgeProjectLogsResponses, PushedExternalImageResponse, PushExternalImageData, PushExternalImageErrors, PushExternalImageResponse, PushExternalImageResponses, PushImageRequest, QueryDataData, QueryDataErrors, QueryDataRequest, QueryDataResponse, QueryDataResponse2, QueryDataResponses, QueryGenaiTracesData, QueryGenaiTracesError, QueryGenaiTracesErrors, QueryGenaiTracesResponse, QueryGenaiTracesResponses, QueryLogsData, QueryLogsError, QueryLogsErrors, QueryLogsResponse, QueryLogsResponses, QueryMetricsData, QueryMetricsError, QueryMetricsErrors, QueryMetricsResponse, QueryMetricsResponses, QuerySpanStatsData, QuerySpanStatsError, QuerySpanStatsErrors, QuerySpanStatsResponse, QuerySpanStatsResponses, QueryTracesData, QueryTracesError, QueryTracesErrors, QueryTracesResponse, QueryTracesResponses, QueryTraceSummariesData, QueryTraceSummariesError, QueryTraceSummariesErrors, QueryTraceSummariesResponse, QueryTraceSummariesResponses, QuotaResponse, RateLimitConfig, RateLimitSettings, ReachabilityStatus, ReadEntityRowsData, ReadEntityRowsErrors, ReadEntityRowsResponse, ReadEntityRowsResponses, ReadFileData, ReadFileErrors, ReadFileResponse, ReadFileResponse2, ReadFileResponses, ReadRowsQuery, ReAnalyzeData, ReAnalyzeErrors, ReAnalyzeResponses, ReassignCustomDomainRequest, ReassignProjectCustomDomainData, ReassignProjectCustomDomainErrors, ReassignProjectCustomDomainResponse, ReassignProjectCustomDomainResponses, RecentActivityQuery, RecentActivityResponse, RecentEventResponse, RecentQueryParams, ReconcileCloudBackupSourceData, ReconcileCloudBackupSourceResponse, ReconcileCloudBackupSourceResponses, RecordConsoleEventData, RecordConsoleEventErrors, RecordConsoleEventResponses, RecordEventMetricsData, RecordEventMetricsErrors, RecordEventMetricsResponse, RecordEventMetricsResponses, RecordExposureRequest, RecordExposureResponse, RecordFlagExposureData, RecordFlagExposureErrors, RecordFlagExposureResponse, RecordFlagExposureResponses, RecordListResponse, RecordSpeedMetricsData, RecordSpeedMetricsError, RecordSpeedMetricsErrors, RecordSpeedMetricsResponse, RecordSpeedMetricsResponses, RecoveryTarget, ReferrerCount, ReferrersAnalyticsQuery, RefreshAiProviderModelsData, RefreshAiProviderModelsErrors, RefreshAiProviderModelsResponse, RefreshAiProviderModelsResponses, RefreshAiProviderStatusData, RefreshAiProviderStatusError, RefreshAiProviderStatusErrors, RefreshAiProviderStatusResponse, RefreshAiProviderStatusResponses, RefreshProviderModelsData, RefreshProviderModelsError, RefreshProviderModelsErrors, RefreshProviderModelsResponse, RefreshProviderModelsResponse2, RefreshProviderModelsResponses, RefreshRouteTableData, RefreshRouteTableErrors, RefreshRouteTableResponse, RefreshRouteTableResponses, RegenerateDsnData, RegenerateDsnErrors, RegenerateDsnRequest, RegenerateDsnResponse, RegenerateDsnResponses, RegisterExternalImageData, RegisterExternalImageErrors, RegisterExternalImageResponse, RegisterExternalImageResponses, RegisterImageRequest, RegisterNodeApiRequest, RegisterNodeData, RegisterNodeErrors, RegisterNodeResponse, RegisterNodeResponse2, RegisterNodeResponses, RegisterRequest, ReinstallGitlabWebhookData, ReinstallGitlabWebhookErrors, ReinstallGitlabWebhookResponse, ReinstallGitlabWebhookResponses, ReinstallWebhookResponse, RejectPendingActionData, RejectPendingActionErrors, RejectPendingActionResponse, RejectPendingActionResponses, RejectUserPendingActionData, RejectUserPendingActionErrors, RejectUserPendingActionResponse, RejectUserPendingActionResponses, ReleaseCheckResult, ReleaseListResponse, ReloadPluginsData, ReloadPluginsErrors, ReloadPluginsResponse, ReloadPluginsResponses, ReloadResponse, RemoteDeploymentResponse, RemoveClusterMemberData, RemoveClusterMemberErrors, RemoveClusterMemberResponse, RemoveClusterMemberResponses, RemoveManagedDomainData, RemoveManagedDomainErrors, RemoveManagedDomainResponse, RemoveManagedDomainResponses, RemoveNodeResponse, RemoveRoleData, RemoveRoleErrors, RemoveRoleResponse, RemoveRoleResponses, RemoveTeamMemberData, RemoveTeamMemberErrors, RemoveTeamMemberResponse, RemoveTeamMemberResponses, RenameConversationData, RenameConversationErrors, RenameConversationRequest, RenameConversationResponse, RenameConversationResponses, RenameUserConversationData, RenameUserConversationErrors, RenameUserConversationResponse, RenameUserConversationResponses, RenewalAttemptResponse, RenewDomainData, RenewDomainErrors, RenewDomainResponse, RenewDomainResponses, RepointContinuousArchiveSourceData, RepointContinuousArchiveSourceErrors, RepointContinuousArchiveSourceRequest, RepointContinuousArchiveSourceResponse, RepointContinuousArchiveSourceResponses, RepositoryComposeServicesResponse, RepositoryEnvExampleResponse, RepositoryListQuery, RepositoryListResponse, RepositoryPresetResponse, RepositoryResponse, RepositorySyncStartedResponse, RequestDiscoveredRouteCertData, RequestDiscoveredRouteCertError, RequestDiscoveredRouteCertErrors, RequestDiscoveredRouteCertRequest, RequestDiscoveredRouteCertResponses, RequestPasswordResetData, RequestPasswordResetErrors, RequestPasswordResetResponse, RequestPasswordResetResponses, RequestRow, RequestTimeoutSettings, RequiredPasswordChangeRequest, RequiredPasswordChangeResponse, ResetPasswordData, ResetPasswordErrors, ResetPasswordRequest, ResetPasswordResponse, ResetPasswordResponses, ResetPgStatStatementsRequest, ResetPgStatStatementsResponse, ResizeSandboxBody, ResizeSandboxData, ResizeSandboxErrors, ResizeSandboxResponse, ResizeSandboxResponses, ResolveAlarmData, ResolveAlarmErrors, ResolveAlarmResponses, ResolvedEnvVarResponse, ResolvedEnvVarSource, ResolvePermissionData, ResolvePermissionErrors, ResolvePermissionRequest, ResolvePermissionResponse, ResolvePermissionResponses, ResolveSystemAlarmData, ResolveSystemAlarmErrors, ResolveSystemAlarmResponses, ResolveUserPermissionData, ResolveUserPermissionErrors, ResolveUserPermissionResponse, ResolveUserPermissionResponses, ResourceCounts, ResourceFootprint, ResourceInfo, ResourceLimitApplyResult, ResourceLimits, ResourceLimitsResponse, ResourceLimitsUpdateResponse, ResourcesBody, RestartContainerData, RestartContainerErrors, RestartContainerResponse, RestartContainerResponses, RestartPreviewGatewayData, RestartPreviewGatewayError, RestartPreviewGatewayErrors, RestartPreviewGatewayResponse, RestartPreviewGatewayResponses, RestartSandboxData, RestartSandboxErrors, RestartSandboxResponse, RestartSandboxResponses, RestoreApplicationData, RestoreApplicationErrors, RestoreApplicationResponse, RestoreApplicationResponses, RestoreCapabilities, RestoreCapabilitiesResponse, RestoreFlagData, RestoreFlagErrors, RestoreFlagResponse, RestoreFlagResponses, RestorePlan, RestoreRequestMode, RestoreRunView, RestoreUserConversationData, RestoreUserConversationErrors, RestoreUserConversationResponse, RestoreUserConversationResponses, RestoreUserData, RestoreUserErrors, RestoreUserResponse, RestoreUserResponses, ResumeDeploymentData, ResumeDeploymentErrors, ResumeDeploymentResponse, ResumeDeploymentResponses, ResumeSandboxData, ResumeSandboxErrors, ResumeSandboxResponse, ResumeSandboxResponses, RetentionCleanupFailure, RetentionCleanupReport, RetryClusterData, RetryClusterErrors, RetryClusterRequest, RetryClusterResponse, RetryClusterResponses, RetryDeliveryData, RetryDeliveryErrors, RetryDeliveryResponse, RetryDeliveryResponses, RetryFacetBackfillData, RetryFacetBackfillError, RetryFacetBackfillErrors, RetryFacetBackfillResponse, RetryFacetBackfillResponses, RetryPgUpgradeData, RetryPgUpgradeError, RetryPgUpgradeErrors, RetryPgUpgradeResponse, RetryPgUpgradeResponses, RetryRunData, RetryRunErrors, RetryRunResponse, RetryRunResponses, RevealGlobalMcpConfigData, RevealGlobalMcpConfigErrors, RevealGlobalMcpConfigResponse, RevealGlobalMcpConfigResponses, RevealMcpConfigData, RevealMcpConfigErrors, RevealMcpConfigResponse, RevealMcpConfigResponses, RevealNotificationProviderConfigData, RevealNotificationProviderConfigErrors, RevealNotificationProviderConfigResponse, RevealNotificationProviderConfigResponses, RevealServiceEnvironmentVariablesData, RevealServiceEnvironmentVariablesErrors, RevealServiceEnvironmentVariablesResponse, RevealServiceEnvironmentVariablesResponses, RevealServiceParameterData, RevealServiceParameterErrors, RevealServiceParameterResponse, RevealServiceParameterResponses, RevenueCreateIntegrationData, RevenueCreateIntegrationErrors, RevenueCreateIntegrationResponse, RevenueCreateIntegrationResponses, RevenueDeleteIntegrationData, RevenueDeleteIntegrationResponse, RevenueDeleteIntegrationResponses, RevenueGlobalEventsData, RevenueGlobalEventsResponse, RevenueGlobalEventsResponses, RevenueImportInvoicesCsvData, RevenueImportInvoicesCsvErrors, RevenueImportInvoicesCsvResponse, RevenueImportInvoicesCsvResponses, RevenueImportSubscriptionsCsvData, RevenueImportSubscriptionsCsvErrors, RevenueImportSubscriptionsCsvResponse, RevenueImportSubscriptionsCsvResponses, RevenueListIntegrationsData, RevenueListIntegrationsResponse, RevenueListIntegrationsResponses, RevenueListProvidersData, RevenueListProvidersResponse, RevenueListProvidersResponses, RevenueMetricsCustomersData, RevenueMetricsCustomersResponse, RevenueMetricsCustomersResponses, RevenueMetricsGlobalMrrData, RevenueMetricsGlobalMrrResponse, RevenueMetricsGlobalMrrResponses, RevenueMetricsGlobalSummaryData, RevenueMetricsGlobalSummaryResponse, RevenueMetricsGlobalSummaryResponses, RevenueMetricsMrrData, RevenueMetricsMrrResponse, RevenueMetricsMrrResponses, RevenueMetricsSummaryData, RevenueMetricsSummaryResponse, RevenueMetricsSummaryResponses, RevenueRecentEventsData, RevenueRecentEventsResponse, RevenueRecentEventsResponses, RevenueRotateTokenData, RevenueRotateTokenResponse, RevenueRotateTokenResponses, RevenueRow, RevenueUpdateConfigData, RevenueUpdateConfigErrors, RevenueUpdateConfigResponse, RevenueUpdateConfigResponses, RevenueUpdateSecretData, RevenueUpdateSecretErrors, RevenueUpdateSecretResponse, RevenueUpdateSecretResponses, RevokeAnalyticsIngestKeyData, RevokeAnalyticsIngestKeyErrors, RevokeAnalyticsIngestKeyResponse, RevokeAnalyticsIngestKeyResponses, RevokeDsnData, RevokeDsnErrors, RevokeDsnResponse, RevokeDsnResponses, RevokeEmailDomainProjectData, RevokeEmailDomainProjectErrors, RevokeEmailDomainProjectResponse, RevokeEmailDomainProjectResponses, RevokeEnrollmentTokenData, RevokeEnrollmentTokenErrors, RevokeEnrollmentTokenResponse, RevokeEnrollmentTokenResponses, RevokeJoinTokenData, RevokeJoinTokenErrors, RevokeJoinTokenResponse, RevokeJoinTokenResponses, RevokeProjectAccessData, RevokeProjectAccessErrors, RevokeProjectAccessResponse, RevokeProjectAccessResponses, RiskLevel, RoleInfo, RollbackPgUpgradeData, RollbackPgUpgradeError, RollbackPgUpgradeErrors, RollbackPgUpgradeResponse, RollbackPgUpgradeResponses, RollbackToDeploymentData, RollbackToDeploymentErrors, RollbackToDeploymentResponse, RollbackToDeploymentResponses, RootfsCacheEntry, RootfsGcData, RootfsGcReport, RootfsGcResponses, RootfsReport, RootfsReportData, RootfsReportResponses, RootfsVmEntry, RotateAnalyticsIngestKeyData, RotateAnalyticsIngestKeyErrors, RotateAnalyticsIngestKeyResponse, RotateAnalyticsIngestKeyResponses, RotateApiKeyData, RotateApiKeyErrors, RotateApiKeyResponse, RotateApiKeyResponses, RotateClusterCaData, RotateClusterCaErrors, RotateClusterCaRequest, RotateClusterCaResponse, RotateClusterCaResponse2, RotateClusterCaResponses, RotateDeploymentTokenData, RotateDeploymentTokenErrors, RotateDeploymentTokenResponse, RotateDeploymentTokenResponses, RouteRefreshResponse, RouteResponse, RouteRole, RouteUser, RouteUserWithRoles, RunBackupForSourceData, RunBackupForSourceError, RunBackupForSourceErrors, RunBackupForSourceResponse, RunBackupForSourceResponses, RunBackupRequest, RunConnectionHealthCheckData, RunConnectionHealthCheckErrors, RunConnectionHealthCheckResponse, RunConnectionHealthCheckResponses, RunExternalServiceBackupData, RunExternalServiceBackupError, RunExternalServiceBackupErrors, RunExternalServiceBackupRequest, RunExternalServiceBackupResponse, RunExternalServiceBackupResponses, RunScheduleNowData, RunScheduleNowError, RunScheduleNowErrors, RunScheduleNowResponse, RunScheduleNowResponses, RuntimeCredentialsResponse, S3ConnectionTestResponse, S3CredentialsResponse, S3SourceResponse, S3SourceResponseWritable, SandboxCreatePreviewLinkData, SandboxCreatePreviewLinkErrors, SandboxCreatePreviewLinkResponse, SandboxCreatePreviewLinkResponses, SandboxDomainResponse, SandboxEvent, SandboxEventsResponse, SandboxInner, SandboxIssueRuntimeEnvironmentData, SandboxIssueRuntimeEnvironmentErrors, SandboxIssueRuntimeEnvironmentResponse, SandboxIssueRuntimeEnvironmentResponses, SandboxResponse, SandboxRoute, SandboxRuntimeEnvironmentResponse, SandboxStatusResponse, SaveAgentTokenData, SaveAgentTokenErrors, SaveAgentTokenRequest, SaveAgentTokenResponse, SaveAgentTokenResponse2, SaveAgentTokenResponses, SaveAiProviderCredentialData, SaveAiProviderCredentialErrors, SaveAiProviderCredentialResponse, SaveAiProviderCredentialResponses, SaveCredentialRequest, SaveCredentialResponse, ScalewayCredentialsRequest, ScanResponse, ScheduleRunEntry, ScheduleRunJobEntry, ScheduleRunListResponse, ScheduleRunResponse, ScheduleRunSummary, ScheduleRunSummaryList, ScreenshotSettings, SearchLogsData, SearchLogsError, SearchLogsErrors, SearchLogsRequest, SearchLogsResponse, SearchLogsResponse2, SearchLogsResponses, SearchMode, Seasonality, SecretResponse, SecurityConfig, SecurityHeadersConfig, SecurityHeadersSettings, SelectOption, SelfUpdateAttempt, SelfUpdateBlocker, SelfUpdatePhase, SelfUpdateRestartMode, SelfUpdateSettings, SelfUpdateStatus, SendEmailData, SendEmailErrors, SendEmailRequestBody, SendEmailResponse, SendEmailResponseBody, SendEmailResponses, SendFailureReportData, SendFailureReportErrors, SendFailureReportRequest, SendFailureReportResponse, SendFailureReportResponses, SendMessageAcceptedResponse, SendMessageRequest, SendProjectAiMessageData, SendProjectAiMessageErrors, SendProjectAiMessageResponse, SendProjectAiMessageResponses, SendUserMessageData, SendUserMessageErrors, SendUserMessageResponse, SendUserMessageResponses, SensitiveConfigValueResponse, SensitiveMcpConfigValueResponse, SensitiveValueResponse, SentryChunkUploadResponse, SentryCreateReleaseRequest, SentryEventRequest, SentryEventResponse, SentryReleaseFileResponse, SentryReleaseProjectRef, SentryReleaseResponse, SeriesStateEntry, ServiceAccessInfo, ServiceAction, ServiceAlertRuleResponse, ServiceBackupEntryResponse, ServiceBackupListResponse, ServiceCreateAlertRuleRequest, ServiceHealthResponse, ServiceHealthStatusBatchResponse, ServiceHealthStatusEntryResponse, ServiceMemberInfo, ServiceParameter, ServicePlan, ServiceResourceLimits, ServiceRuntimeReport, ServiceStatsReport, ServiceTemplateChangeKind, ServiceTemplateInstance, ServiceTemplateInstanceResponse, ServiceTemplateUpgradeChange, ServiceTypeInfo, ServiceTypeRoute, ServiceUpdateAlertRuleRequest, SesCredentialsRequest, SessionDetails, SessionDetailsQuery, SessionEvent, SessionEventDto, SessionEventsQuery, SessionEventsResponse, SessionLogsQuery, SessionLogsResponse, SessionReplayEventsRequest, SessionReplayInfoDto, SessionReplayInitRequest, SessionReplayInitResponse, SessionReplayWithEventsDto, SessionReplayWithVisitorDto, SessionRequestLog, SessionSummary, SetAiDataAccessData, SetAiDataAccessErrors, SetAiDataAccessResponse, SetAiDataAccessResponses, SetAlternateSourcesData, SetAlternateSourcesErrors, SetAlternateSourcesRequest, SetAlternateSourcesResponse, SetAlternateSourcesResponses, SetApplicationPrimaryProjectData, SetApplicationPrimaryProjectErrors, SetApplicationPrimaryProjectResponse, SetApplicationPrimaryProjectResponses, SetDefaultS3SourceData, SetDefaultS3SourceError, SetDefaultS3SourceErrors, SetDefaultS3SourceResponse, SetDefaultS3SourceResponses, SetFlagEnvironmentData, SetFlagEnvironmentErrors, SetFlagEnvironmentRequest, SetFlagEnvironmentResponse, SetFlagEnvironmentResponses, SetPreviewPasswordBody, SetPreviewPasswordData, SetPreviewPasswordErrors, SetPreviewPasswordResponse, SetPreviewPasswordResponse2, SetPreviewPasswordResponses, SetRequest, SetResponse, SettingsUpdateResponse, SetTraefikDiscoveredRouteEnabledData, SetTraefikDiscoveredRouteEnabledError, SetTraefikDiscoveredRouteEnabledErrors, SetTraefikDiscoveredRouteEnabledResponse, SetTraefikDiscoveredRouteEnabledResponses, SetupDnsChallengeData, SetupDnsChallengeErrors, SetupDnsChallengeRequest, SetupDnsChallengeResponse, SetupDnsChallengeResponse2, SetupDnsChallengeResponses, SetupDnsData, SetupDnsErrors, SetupDnsRequest, SetupDnsResponse, SetupDnsResponse2, SetupDnsResponses, SetupEmailTrackingData, SetupEmailTrackingErrors, SetupEmailTrackingResponse, SetupEmailTrackingResponses, SetupMfaData, SetupMfaErrors, SetupMfaRequest, SetupMfaResponse, SetupMfaResponses, SiblingRef, SilenceAlarmData, SilenceAlarmErrors, SilenceAlarmRequest, SilenceAlarmResponses, SilenceSystemAlarmData, SilenceSystemAlarmErrors, SilenceSystemAlarmResponses, SkillDefinitionResponse, SlackConfig, SleepEnvironmentData, SleepEnvironmentErrors, SleepEnvironmentResponse, SleepEnvironmentResponses, SlowQueriesResponse, SlowQueryRow, SmartFilter, SmokeTestAgentData, SmokeTestAgentErrors, SmokeTestAgentResponse, SmokeTestAgentResponses, SmokeTestResponse, SmtpCredentialsRequest, SmtpEncryptionRoute, SmtpResult, SnapshotResponse, SourceArchiveUpload, SourceBackupEntry, SourceBackupIndexResponse, SourceBody, SourceFileListResponse, SourceFileResponse, SourceMapListResponse, SourceMapResponse, SourceSandboxData, SourceSandboxErrors, SourceSandboxResponse, SourceSandboxResponses, SourceType, SpanEvent, SpanKind, SpanRecord, SpanRow, SpanStats, SpanStatsResponse, SpanStatusCode, SpeedMetricsPayload, SpeedSegmentFilters, StaleSlot, StartAnalysisData, StartAnalysisErrors, StartAnalysisRequest, StartAnalysisResponse, StartAnalysisResponses, StartContainerData, StartContainerErrors, StartContainerResponse, StartContainerResponses, StartFixData, StartFixErrors, StartFixResponses, StartGitProviderOauthData, StartGitProviderOauthErrors, StartOidcLoginBySlugData, StartOidcLoginBySlugErrors, StartPgUpgradeData, StartPgUpgradeError, StartPgUpgradeErrors, StartPgUpgradeRequest, StartPgUpgradeResponse, StartPgUpgradeResponses, StartRestoreData, StartRestoreError, StartRestoreErrors, StartRestoreRequest, StartRestoreResponse, StartRestoreResponses, StartServiceData, StartServiceErrors, StartServiceResponse, StartServiceResponses, StartUpdateData, StartUpdateError, StartUpdateErrors, StartUpdateRequest, StartUpdateResponse, StartUpdateResponse2, StartUpdateResponses, StaticBundleResponse, StaticParams, StaticPresetConfig, StatPathData, StatPathErrors, StatPathResponse, StatPathResponses, StatResponse, StatsFilters, StatusBucket, StatusBucketedResponse, StatusCodeCount, StatusCodesQuery, StatusPageOverview, StepConversionResponse, StepResourceType, StepResult, StepUpResponse, StopContainerData, StopContainerErrors, StopContainerResponse, StopContainerResponses, StopSandboxData, StopSandboxErrors, StopSandboxResponse, StopSandboxResponses, StopSequence, StopServiceData, StopServiceErrors, StopServiceResponse, StopServiceResponses, StopTurnData, StopTurnErrors, StopTurnResponse, StopTurnResponses, StopUserTurnData, StopUserTurnErrors, StopUserTurnResponse, StopUserTurnResponses, StorageQuota, StorageSummary, StorageSummaryData, StorageSummaryErrors, StorageSummaryResponse, StorageSummaryResponses, StreamContainerMetricsData, StreamContainerMetricsErrors, StreamContainerMetricsResponses, StreamEventsData, StreamEventsErrors, StreamEventsResponses, StreamRunEventsData, StreamRunEventsErrors, StreamRunEventsResponses, StreamStructuredOutputRequest, StripeConfig, SupervisorKind, SyncedRepositoryListQuery, SyncRepositoriesData, SyncRepositoriesErrors, SyncRepositoriesResponse, SyncRepositoriesResponses, SyntaxResult, TagInfo, TagListResponse, TailDeploymentJobLogsData, TailDeploymentJobLogsErrors, TailLogsData, TailLogsError, TailLogsErrors, TailLogsRequest, TailLogsResponses, TargetRecommendation, TeamListResponse, TeamMemberResponse, TeamResponse, TeamRole, TeardownDeploymentData, TeardownDeploymentErrors, TeardownDeploymentResponse, TeardownDeploymentResponses, TeardownEnvironmentData, TeardownEnvironmentErrors, TeardownEnvironmentResponse, TeardownEnvironmentResponses, TelemetryGapWindowResponse, TelemetryWriteIntervalReason, TelemetryWriteIntervalResponse, TemplateKind, TemplateResources, TemplateResponse, TenantResourceCeilings, TerminalData, TerminalErrors, TestEmailRequest, TestEmailResponse, TestNotificationProviderData, TestNotificationProviderErrors, TestNotificationProviderResponse, TestNotificationProviderResponses, TestOidcProviderData, TestOidcProviderResponse, TestOidcProviderResponses, TestProviderConnectionData, TestProviderConnectionErrors, TestProviderConnectionResponse, TestProviderConnectionResponses, TestProviderData, TestProviderErrors, TestProviderKeyByIdData, TestProviderKeyByIdError, TestProviderKeyByIdErrors, TestProviderKeyByIdResponse, TestProviderKeyByIdResponses, TestProviderKeyInlineData, TestProviderKeyInlineError, TestProviderKeyInlineErrors, TestProviderKeyInlineResponse, TestProviderKeyInlineResponses, TestProviderKeyRequest, TestProviderKeyResponse, TestProviderResponse, TestProviderResponse2, TestProviderResponses, TestS3ConnectionPreviewData, TestS3ConnectionPreviewError, TestS3ConnectionPreviewErrors, TestS3ConnectionPreviewResponse, TestS3ConnectionPreviewResponses, TestS3SourceConnectionData, TestS3SourceConnectionError, TestS3SourceConnectionErrors, TestS3SourceConnectionResponse, TestS3SourceConnectionResponses, ThreadArtifactResponse, TimeBucketStats, TimeBucketStatsResponse, TimeseriesBucket, TimeseriesQueryParams, TlsMode, TodayStatsResponse, ToggleAiDataAccessRequest, ToggleDeploymentMetricsRequest, ToggleServiceMetricsRequest, TokenRenewalRequest, ToolCallEvent, ToolInfo, ToolResultEvent, TopModelsQueryParams, TraceProjectRef, TracesResponse, TraceSummariesResponse, TraceSummary, TrackClickData, TrackClickErrors, TrackedLinkResponse, TrackingEventResponse, TrackOpenData, TrackOpenErrors, TrackOpenResponses, TraefikDiscoveredRouteListResponse, TraefikDiscoveredRouteResponse, TraefikDiscoveryConflictResponse, TraefikDiscoverySetupResponse, TraefikDiscoveryStatusResponse, TraefikReconciliationResponse, TraefikRouteTlsBlock, TrafficAggregationRequest, TrafficAggregationResponse, TrafficAggregationRow, TrafficDimension, TrafficDimensionValue, TrafficFilter, TrafficFilterOperator, TrafficMetric, TrafficMetricValues, TrafficOrderBy, TrafficOrderField, TrafficSortDirection, TriggerAgentData, TriggerAgentErrors, TriggerAgentRequest, TriggerAgentResponse, TriggerAgentResponses, TriggerDigestResponse, TriggerPipelinePayload, TriggerPipelineResponse, TriggerProjectPipelineData, TriggerProjectPipelineErrors, TriggerProjectPipelineResponse, TriggerProjectPipelineResponses, TriggerScanData, TriggerScanError, TriggerScanErrors, TriggerScanRequest, TriggerScanResponse, TriggerScanResponse2, TriggerScanResponses, TriggerServiceHealthCheckData, TriggerServiceHealthCheckErrors, TriggerServiceHealthCheckResponse, TriggerServiceHealthCheckResponses, TriggerWeeklyDigestData, TriggerWeeklyDigestErrors, TriggerWeeklyDigestResponse, TriggerWeeklyDigestResponses, TtlRequest, TtlResponse, TxtRecord, UiManifest, UiRoute, UndrainNodeResponse, UnifiedTrace, UniqueCountsQuery, UniqueCountsResponse, UnlinkApplicationProjectData, UnlinkApplicationProjectErrors, UnlinkApplicationProjectResponse, UnlinkApplicationProjectResponses, UnlinkServiceFromProjectData, UnlinkServiceFromProjectErrors, UnlinkServiceFromProjectResponse, UnlinkServiceFromProjectResponses, UnsupportedFeature, UpdateAdminGateRequest, UpdateAgentData, UpdateAgentErrors, UpdateAgentResponse, UpdateAgentResponses, UpdateAiProviderData, UpdateAiProviderErrors, UpdateAiProviderRequest, UpdateAiProviderResponse, UpdateAiProviderResponse2, UpdateAiProviderResponses, UpdateAiSummaryPreferenceData, UpdateAiSummaryPreferenceError, UpdateAiSummaryPreferenceErrors, UpdateAiSummaryPreferenceRequest, UpdateAiSummaryPreferenceResponse, UpdateAiSummaryPreferenceResponses, UpdateAlertData, UpdateAlertError, UpdateAlertErrors, UpdateAlertResponse, UpdateAlertResponses, UpdateAlertRuleData, UpdateAlertRuleErrors, UpdateAlertRuleRequest, UpdateAlertRuleResponse, UpdateAlertRuleResponses, UpdateAnalyticsIngestKeyData, UpdateAnalyticsIngestKeyErrors, UpdateAnalyticsIngestKeyRequest, UpdateAnalyticsIngestKeyResponse, UpdateAnalyticsIngestKeyResponses, UpdateApiKeyData, UpdateApiKeyErrors, UpdateApiKeyRequest, UpdateApiKeyResponse, UpdateApiKeyResponses, UpdateApplicationWorkspaceData, UpdateApplicationWorkspaceErrors, UpdateApplicationWorkspaceRequest, UpdateApplicationWorkspaceResponse, UpdateApplicationWorkspaceResponses, UpdateAutomaticDeployData, UpdateAutomaticDeployErrors, UpdateAutomaticDeployRequest, UpdateAutomaticDeployResponse, UpdateAutomaticDeployResponses, UpdateBackupScheduleData, UpdateBackupScheduleError, UpdateBackupScheduleErrors, UpdateBackupScheduleRequest, UpdateBackupScheduleResponse, UpdateBackupScheduleResponses, UpdateBlobRequest, UpdateBlobResponse, UpdateCapabilityResponse, UpdateCloudFeaturesData, UpdateCloudFeaturesResponse, UpdateCloudFeaturesResponses, UpdateCloudflareProviderData, UpdateCloudflareProviderErrors, UpdateCloudflareProviderRequest, UpdateCloudflareProviderResponse, UpdateCloudflareProviderResponses, UpdateConfigBody, UpdateConnectionTokenData, UpdateConnectionTokenErrors, UpdateConnectionTokenResponse, UpdateConnectionTokenResponses, UpdateCustomDomainData, UpdateCustomDomainErrors, UpdateCustomDomainRequest, UpdateCustomDomainResponse, UpdateCustomDomainResponses, UpdateDashboardData, UpdateDashboardError, UpdateDashboardErrors, UpdateDashboardRequest, UpdateDashboardResponse, UpdateDashboardResponses, UpdateDeploymentConfigRequest, UpdateDeploymentTokenData, UpdateDeploymentTokenErrors, UpdateDeploymentTokenRequest, UpdateDeploymentTokenResponse, UpdateDeploymentTokenResponses, UpdateDnsProviderRequest, UpdateEmailProviderData, UpdateEmailProviderErrors, UpdateEmailProviderRequest, UpdateEmailProviderResponse, UpdateEmailProviderResponses, UpdateEnvironmentSettingsData, UpdateEnvironmentSettingsErrors, UpdateEnvironmentSettingsRequest, UpdateEnvironmentSettingsResponse, UpdateEnvironmentSettingsResponses, UpdateEnvironmentSubdomainData, UpdateEnvironmentSubdomainErrors, UpdateEnvironmentSubdomainRequest, UpdateEnvironmentSubdomainResponse, UpdateEnvironmentSubdomainResponses, UpdateEnvironmentVariableData, UpdateEnvironmentVariableErrors, UpdateEnvironmentVariableRequest, UpdateEnvironmentVariableResponse, UpdateEnvironmentVariableResponses, UpdateErrorGroupData, UpdateErrorGroupErrors, UpdateErrorGroupRequest, UpdateErrorGroupResponses, UpdateExternalServiceRequest, UpdateFlagData, UpdateFlagErrors, UpdateFlagRequest, UpdateFlagResponse, UpdateFlagResponses, UpdateFunnelData, UpdateFunnelErrors, UpdateFunnelResponses, UpdateGitProviderCredentialsData, UpdateGitProviderCredentialsErrors, UpdateGitProviderCredentialsResponse, UpdateGitProviderCredentialsResponses, UpdateGitSettingsData, UpdateGitSettingsErrors, UpdateGitSettingsRequest, UpdateGitSettingsResponse, UpdateGitSettingsResponses, UpdateGlobalMcpData, UpdateGlobalMcpErrors, UpdateGlobalMcpResponse, UpdateGlobalMcpResponses, UpdateGlobalSkillData, UpdateGlobalSkillErrors, UpdateGlobalSkillResponse, UpdateGlobalSkillResponses, UpdateIncidentStatusData, UpdateIncidentStatusErrors, UpdateIncidentStatusRequest, UpdateIncidentStatusResponse, UpdateIncidentStatusResponses, UpdateIpAccessControlData, UpdateIpAccessControlError, UpdateIpAccessControlErrors, UpdateIpAccessControlRequest, UpdateIpAccessControlResponse, UpdateIpAccessControlResponses, UpdateKvRequest, UpdateKvResponse, UpdateManagedDomainApiRequest, UpdateManagedDomainData, UpdateManagedDomainErrors, UpdateManagedDomainResponse, UpdateManagedDomainResponses, UpdateMcpData, UpdateMcpErrors, UpdateMcpRequest, UpdateMcpResponse, UpdateMcpResponses, UpdateMemberRoleRequest, UpdateMetricAlertRequest, UpdateNotificationEmailProviderData, UpdateNotificationEmailProviderErrors, UpdateNotificationEmailProviderRequest, UpdateNotificationEmailProviderResponse, UpdateNotificationEmailProviderResponses, UpdateNotificationProviderData, UpdateNotificationProviderErrors, UpdateNotificationProviderResponse, UpdateNotificationProviderResponses, UpdateNotificationRouteData, UpdateNotificationRouteErrors, UpdateNotificationRouteRequest, UpdateNotificationRouteResponse, UpdateNotificationRouteResponses, UpdateOidcProviderData, UpdateOidcProviderRequest, UpdateOidcProviderResponse, UpdateOidcProviderResponses, UpdatePermissionModeData, UpdatePermissionModeErrors, UpdatePermissionModeRequest, UpdatePermissionModeResponse, UpdatePermissionModeResponses, UpdatePreferencesData, UpdatePreferencesErrors, UpdatePreferencesRequest, UpdatePreferencesResponse, UpdatePreferencesResponses, UpdateProjectCloudTelemetryData, UpdateProjectCloudTelemetryError, UpdateProjectCloudTelemetryErrors, UpdateProjectCloudTelemetryRequest, UpdateProjectCloudTelemetryResponse, UpdateProjectCloudTelemetryResponses, UpdateProjectData, UpdateProjectDeploymentConfigData, UpdateProjectDeploymentConfigErrors, UpdateProjectDeploymentConfigResponse, UpdateProjectDeploymentConfigResponses, UpdateProjectErrors, UpdateProjectResponse, UpdateProjectResponses, UpdateProjectSecretData, UpdateProjectSecretErrors, UpdateProjectSecretRequest, UpdateProjectSecretResponse, UpdateProjectSecretResponses, UpdateProjectSettingsData, UpdateProjectSettingsErrors, UpdateProjectSettingsRequest, UpdateProjectSettingsResponse, UpdateProjectSettingsResponses, UpdateProviderCredentialsRequest, UpdateProviderData, UpdateProviderErrors, UpdateProviderKeyData, UpdateProviderKeyError, UpdateProviderKeyErrors, UpdateProviderKeyRequest, UpdateProviderKeyResponse, UpdateProviderKeyResponses, UpdateProviderModelData, UpdateProviderModelError, UpdateProviderModelErrors, UpdateProviderModelRequest, UpdateProviderModelResponse, UpdateProviderModelResponses, UpdateProviderRequest, UpdateProviderResponse, UpdateProviderResponses, UpdateRouteData, UpdateRouteErrors, UpdateRouteRequest, UpdateRouteResponse, UpdateRouteResponses, UpdateS3SourceData, UpdateS3SourceError, UpdateS3SourceErrors, UpdateS3SourceRequest, UpdateS3SourceResponse, UpdateS3SourceResponses, UpdateSecretBody, UpdateSelfData, UpdateSelfErrors, UpdateSelfRequest, UpdateSelfResponse, UpdateSelfResponses, UpdateServiceData, UpdateServiceErrors, UpdateServiceResourcesData, UpdateServiceResourcesErrors, UpdateServiceResourcesResponse, UpdateServiceResourcesResponses, UpdateServiceResponse, UpdateServiceResponses, UpdateServiceTemplateRuntimeData, UpdateServiceTemplateRuntimeErrors, UpdateServiceTemplateRuntimeRequest, UpdateServiceTemplateRuntimeResponse, UpdateServiceTemplateRuntimeResponses, UpdateSessionDurationData, UpdateSessionDurationError, UpdateSessionDurationErrors, UpdateSessionDurationRequest, UpdateSessionDurationResponse, UpdateSessionDurationResponse2, UpdateSessionDurationResponses, UpdateSettingsData, UpdateSettingsErrors, UpdateSettingsResponse, UpdateSettingsResponses, UpdateSkillData, UpdateSkillErrors, UpdateSkillRequest, UpdateSkillResponse, UpdateSkillResponses, UpdateSlackProviderData, UpdateSlackProviderErrors, UpdateSlackProviderRequest, UpdateSlackProviderResponse, UpdateSlackProviderResponses, UpdateSpeedMetricsData, UpdateSpeedMetricsError, UpdateSpeedMetricsErrors, UpdateSpeedMetricsPayload, UpdateSpeedMetricsResponse, UpdateSpeedMetricsResponses, UpdateStatusResponse, UpdateTeamData, UpdateTeamErrors, UpdateTeamMemberRoleData, UpdateTeamMemberRoleErrors, UpdateTeamMemberRoleResponse, UpdateTeamMemberRoleResponses, UpdateTeamRequest, UpdateTeamResponse, UpdateTeamResponses, UpdateTokenRequest, UpdateTokenResponse, UpdateTraefikRouteEnabledRequest, UpdateUserData, UpdateUserErrors, UpdateUserPermissionModeData, UpdateUserPermissionModeErrors, UpdateUserPermissionModeResponse, UpdateUserPermissionModeResponses, UpdateUserRequest, UpdateUserResponse, UpdateUserResponses, UpdateWebhookData, UpdateWebhookErrors, UpdateWebhookProviderData, UpdateWebhookProviderErrors, UpdateWebhookProviderRequest, UpdateWebhookProviderResponse, UpdateWebhookProviderResponses, UpdateWebhookRequestBody, UpdateWebhookResponse, UpdateWebhookResponses, UpgradeExternalServiceRequest, UpgradePreviewGatewayData, UpgradePreviewGatewayError, UpgradePreviewGatewayErrors, UpgradePreviewGatewayResponse, UpgradePreviewGatewayResponses, UpgradeProjectServiceTemplateData, UpgradeProjectServiceTemplateErrors, UpgradeProjectServiceTemplateResponse, UpgradeProjectServiceTemplateResponses, UpgradeRequest, UpgradeServiceData, UpgradeServiceErrors, UpgradeServiceResponse, UpgradeServiceResponses, UpgradeServiceTemplateRequest, UploadApplicationWorkspaceFilesData, UploadApplicationWorkspaceFilesErrors, UploadApplicationWorkspaceFilesResponse, UploadApplicationWorkspaceFilesResponses, UploadGlobalSkillData, UploadGlobalSkillErrors, UploadGlobalSkillResponse, UploadGlobalSkillResponses, UploadGlobalWorkspaceFilesData, UploadGlobalWorkspaceFilesErrors, UploadGlobalWorkspaceFilesResponse, UploadGlobalWorkspaceFilesResponses, UploadReleaseFileData, UploadReleaseFileErrors, UploadReleaseFileResponse, UploadReleaseFileResponses, UploadSkillData, UploadSkillErrors, UploadSkillResponse, UploadSkillResponses, UploadSourceFileData, UploadSourceFileErrors, UploadSourceFileResponse, UploadSourceFileResponses, UploadSourceMapData, UploadSourceMapErrors, UploadSourceMapResponse, UploadSourceMapResponses, UploadStaticBundleData, UploadStaticBundleErrors, UploadStaticBundleResponse, UploadStaticBundleResponses, UploadUserConversationAttachmentData, UploadUserConversationAttachmentErrors, UploadUserConversationAttachmentResponse, UploadUserConversationAttachmentResponses, UpsertAgentRequest, UpsertSecretData, UpsertSecretErrors, UpsertSecretRequest, UpsertSecretResponse, UpsertSecretResponses, UptimeDataPoint, UptimeHistoryResponse, UsageFilter, UsageInfo, UsageLogEntry, UsageLogPage, UsageQueryParams, UsageSource, UsageSummary, UserResponse, ValidateConnectionData, ValidateConnectionErrors, ValidateConnectionResponse, ValidateConnectionResponses, ValidateEmailData, ValidateEmailErrors, ValidateEmailRequest, ValidateEmailResponse, ValidateEmailResponse2, ValidateEmailResponses, ValidationLevel, ValidationReport, ValidationResponse, ValidationResult, ValidationStatus, ValidationSummary, VerifyAndEnableMfaData, VerifyAndEnableMfaErrors, VerifyAndEnableMfaResponse, VerifyAndEnableMfaResponses, VerifyDomainData, VerifyDomainErrors, VerifyDomainResponse, VerifyDomainResponses, VerifyEmailData, VerifyEmailErrors, VerifyEmailResponse, VerifyEmailResponses, VerifyManagedDomainData, VerifyManagedDomainErrors, VerifyManagedDomainResponse, VerifyManagedDomainResponses, VerifyMfaChallengeData, VerifyMfaChallengeErrors, VerifyMfaChallengeResponse, VerifyMfaChallengeResponses, VerifyMfaRequest, VerifyStepUpData, VerifyStepUpErrors, VerifyStepUpRequest, VerifyStepUpResponse, VerifyStepUpResponses, ViewItem, ViewsOverTime, ViewsOverTimeQuery, VisitorDetails, VisitorFacets, VisitorFacetsQuery, VisitorFacetValue, VisitorInfo, VisitorJourneyQuery, VisitorJourneyResponse, VisitorLocationsQuery, VisitorRecord, VisitorSegmentFilters, VisitorSessionsQuery, VisitorSessionsResponse, VisitorsListQuery, VisitorsResponse, VisitorStats, VisitorWithGeolocation, VolumeMount, VolumeType, VulnerabilityResponse, WakeEnvironmentData, WakeEnvironmentErrors, WakeEnvironmentResponse, WakeEnvironmentResponses, WalWarning, WalWarningSeverity, WebhookConfig, WebhookDeliveryResponse, WebhookResponse, WebhookTriggerData, WebhookTriggerErrors, WebhookTriggerRequest, WebhookTriggerResponse, WebhookTriggerResponse2, WebhookTriggerResponses, WorkflowDryRunData, WorkflowDryRunErrors, WorkflowDryRunRequest, WorkflowDryRunResponse, WorkflowDryRunResponses, WorkloadDescriptor, WorkloadId, WorkloadStatus, WorkloadType, WriteApplicationWorkspaceFilesData, WriteApplicationWorkspaceFilesErrors, WriteApplicationWorkspaceFilesRequest, WriteApplicationWorkspaceFilesResponse, WriteApplicationWorkspaceFilesResponse2, WriteApplicationWorkspaceFilesResponses, WriteFileBody, WriteFileData, WriteFileErrors, WriteFileResponse, WriteFileResponses, WriteFilesBody, WriteFilesData, WriteFilesErrors, WriteFilesResponse, WriteFilesResponse2, WriteFilesResponses, ZoneListResponse } from './types.gen'; diff --git a/web/src/api/client/sdk.gen.ts b/web/src/api/client/sdk.gen.ts index 509242f94..b28b61e03 100644 --- a/web/src/api/client/sdk.gen.ts +++ b/web/src/api/client/sdk.gen.ts @@ -5,7 +5,7 @@ import { type Client, type ClientMeta, formDataBodySerializer, type Options as Options2, type RequestResult, type ServerSentEventsResult, type TDataShape } from './client'; import { client } from './client.gen'; -import type { AcknowledgeAlarmData, AcknowledgeAlarmErrors, AcknowledgeAlarmResponses, AcknowledgeSystemAlarmData, AcknowledgeSystemAlarmErrors, AcknowledgeSystemAlarmResponses, ActivateAiProviderData, ActivateAiProviderErrors, ActivateAiProviderResponses, ActivateApiKeyData, ActivateApiKeyErrors, ActivateApiKeyResponses, ActivateConnectionData, ActivateConnectionErrors, ActivateConnectionResponses, ActivateProviderData, ActivateProviderErrors, ActivateProviderResponses, AddClusterMemberData, AddClusterMemberErrors, AddClusterMemberResponses, AddContextData, AddContextErrors, AddContextResponses, AddEnvironmentDomainData, AddEnvironmentDomainErrors, AddEnvironmentDomainResponses, AddEventsData, AddEventsErrors, AddEventsResponses, AddManagedDomainData, AddManagedDomainErrors, AddManagedDomainResponses, AddProviderModelData, AddProviderModelErrors, AddProviderModelResponses, AddSessionReplayEventsData, AddSessionReplayEventsErrors, AddSessionReplayEventsResponses, AddTeamMemberData, AddTeamMemberErrors, AddTeamMemberResponses, AdminDrainNodeData, AdminDrainNodeErrors, AdminDrainNodeResponses, AdminDrainStatusData, AdminDrainStatusErrors, AdminDrainStatusResponses, AdminGetNodeData, AdminGetNodeErrors, AdminGetNodeResponses, AdminListNodeContainersData, AdminListNodeContainersErrors, AdminListNodeContainersResponses, AdminListNodesData, AdminListNodesErrors, AdminListNodesResponses, AdminRemoveNodeData, AdminRemoveNodeErrors, AdminRemoveNodeResponses, AdminUndrainNodeData, AdminUndrainNodeErrors, AdminUndrainNodeResponses, AggregateApiTrafficData, AggregateApiTrafficErrors, AggregateApiTrafficResponses, ApplyHostnameModeData, ApplyHostnameModeErrors, ApplyHostnameModeResponses, ArchiveApplicationData, ArchiveApplicationErrors, ArchiveApplicationResponses, ArchiveConversationData, ArchiveConversationErrors, ArchiveConversationResponses, ArchiveFlagData, ArchiveFlagErrors, ArchiveFlagResponses, ArchiveUserConversationData, ArchiveUserConversationErrors, ArchiveUserConversationResponses, AssignRoleData, AssignRoleErrors, AssignRoleResponses, AttachScheduleServicesData, AttachScheduleServicesErrors, AttachScheduleServicesResponses, AuthorizeEmailDomainProjectData, AuthorizeEmailDomainProjectErrors, AuthorizeEmailDomainProjectResponses, BlobCopyData, BlobCopyErrors, BlobCopyResponses, BlobDeleteData, BlobDeleteErrors, BlobDeleteResponses, BlobDisableData, BlobDisableErrors, BlobDisableResponses, BlobDownloadData, BlobDownloadErrors, BlobDownloadResponses, BlobEnableData, BlobEnableErrors, BlobEnableResponses, BlobHeadData, BlobHeadErrors, BlobHeadResponses, BlobListData, BlobListErrors, BlobListResponses, BlobPutData, BlobPutErrors, BlobPutResponses, BlobStatusData, BlobStatusErrors, BlobStatusResponses, BlobUpdateData, BlobUpdateErrors, BlobUpdateResponses, CancelBackupData, CancelBackupErrors, CancelBackupResponses, CancelBulkActivationJobData, CancelBulkActivationJobErrors, CancelBulkActivationJobResponses, CancelData, CancelDeploymentData, CancelDeploymentErrors, CancelDeploymentResponses, CancelDomainOrderData, CancelDomainOrderErrors, CancelDomainOrderResponses, CancelErrors, CancelPgUpgradeData, CancelPgUpgradeErrors, CancelPgUpgradeResponses, CancelResponses, CancelRunData, CancelRunErrors, CancelRunResponses, CancelScheduleRunData, CancelScheduleRunErrors, CancelScheduleRunResponses, ChangePasswordSelfData, ChangePasswordSelfErrors, ChangePasswordSelfResponses, ChangeProjectSourceData, ChangeProjectSourceErrors, ChangeProjectSourceResponses, ChangeRequiredPasswordData, ChangeRequiredPasswordErrors, ChangeRequiredPasswordResponses, ChatCompletionsData, ChatCompletionsErrors, ChatCompletionsResponses, CheckAnalyticsHasEventsData, CheckAnalyticsHasEventsErrors, CheckAnalyticsHasEventsResponses, CheckCommitExistsData, CheckCommitExistsErrors, CheckCommitExistsResponses, CheckDomainStatusData, CheckDomainStatusErrors, CheckDomainStatusResponses, CheckExplorerSupportData, CheckExplorerSupportErrors, CheckExplorerSupportResponses, CheckForUpdateData, CheckForUpdateErrors, CheckForUpdateResponses, CheckIpBlockedData, CheckIpBlockedErrors, CheckIpBlockedResponses, CheckProviderDeletionSafetyData, CheckProviderDeletionSafetyErrors, CheckProviderDeletionSafetyResponses, ChunkUploadOptionsData, ChunkUploadOptionsResponses, CleanupExpiredBackupsData, CleanupExpiredBackupsErrors, CleanupExpiredBackupsResponses, ClearPreviewPasswordData, ClearPreviewPasswordErrors, ClearPreviewPasswordResponses, CliDeviceApproveData, CliDeviceApproveErrors, CliDeviceApproveResponses, CliDeviceDenyData, CliDeviceDenyErrors, CliDeviceDenyResponses, CliDeviceLookupData, CliDeviceLookupErrors, CliDeviceLookupResponses, CliDevicePollData, CliDevicePollErrors, CliDevicePollResponses, CliDeviceStartData, CliDeviceStartErrors, CliDeviceStartResponses, CliLogoutData, CliLogoutErrors, CliLogoutResponses, ClusterDnsStatusData, ClusterDnsStatusErrors, ClusterDnsStatusResponses, CmdData, CmdErrors, CmdKillData, CmdKillErrors, CmdKillResponses, CmdLogsData, CmdLogsErrors, CmdLogsResponses, CmdResponses, ConfirmPendingActionData, ConfirmPendingActionErrors, ConfirmPendingActionResponses, ConfirmUserPendingActionData, ConfirmUserPendingActionErrors, ConfirmUserPendingActionResponses, ContainerMetricsGetHistoryData, ContainerMetricsGetHistoryErrors, ContainerMetricsGetHistoryResponses, ControlApplicationWorkspaceData, ControlApplicationWorkspaceErrors, ControlApplicationWorkspaceResponses, CreateAgentData, CreateAgentErrors, CreateAgentResponses, CreateAlertData, CreateAlertErrors, CreateAlertResponses, CreateAlertRuleData, CreateAlertRuleErrors, CreateAlertRuleResponses, CreateAnalyticsIngestKeyData, CreateAnalyticsIngestKeyErrors, CreateAnalyticsIngestKeyResponses, CreateApiKeyData, CreateApiKeyErrors, CreateApiKeyResponses, CreateApplicationConversationData, CreateApplicationConversationErrors, CreateApplicationConversationResponses, CreateApplicationData, CreateApplicationErrors, CreateApplicationPreviewLinkData, CreateApplicationPreviewLinkErrors, CreateApplicationPreviewLinkResponses, CreateApplicationProjectData, CreateApplicationProjectErrors, CreateApplicationProjectResponses, CreateApplicationResponses, CreateBackupScheduleData, CreateBackupScheduleErrors, CreateBackupScheduleResponses, CreateBitbucketProviderData, CreateBitbucketProviderErrors, CreateBitbucketProviderResponses, CreateBulkActivationJobData, CreateBulkActivationJobErrors, CreateBulkActivationJobResponses, CreateCloudflareProviderData, CreateCloudflareProviderErrors, CreateCloudflareProviderResponses, CreateConversationData, CreateConversationErrors, CreateConversationResponses, CreateCustomDomainData, CreateCustomDomainErrors, CreateCustomDomainResponses, CreateDashboardData, CreateDashboardErrors, CreateDashboardResponses, CreateDeploymentTokenData, CreateDeploymentTokenErrors, CreateDeploymentTokenResponses, CreateDnsProviderData, CreateDnsProviderErrors, CreateDnsProviderResponses, CreateDomainData, CreateDomainErrors, CreateDomainResponses, CreateDsnData, CreateDsnErrors, CreateDsnResponses, CreateEmailDomainData, CreateEmailDomainErrors, CreateEmailDomainResponses, CreateEmailProviderData, CreateEmailProviderErrors, CreateEmailProviderResponses, CreateEnvironmentData, CreateEnvironmentErrors, CreateEnvironmentResponses, CreateEnvironmentVariableData, CreateEnvironmentVariableErrors, CreateEnvironmentVariableResponses, CreateFacetData, CreateFacetErrors, CreateFacetResponses, CreateFlagData, CreateFlagErrors, CreateFlagResponses, CreateFunnelData, CreateFunnelErrors, CreateFunnelResponses, CreateGenericProviderData, CreateGenericProviderErrors, CreateGenericProviderResponses, CreateGiteaPatProviderData, CreateGiteaPatProviderErrors, CreateGiteaPatProviderResponses, CreateGithubPatProviderData, CreateGithubPatProviderErrors, CreateGithubPatProviderResponses, CreateGitlabOauthProviderData, CreateGitlabOauthProviderErrors, CreateGitlabOauthProviderResponses, CreateGitlabPatProviderData, CreateGitlabPatProviderErrors, CreateGitlabPatProviderResponses, CreateGitProviderData, CreateGitProviderErrors, CreateGitProviderResponses, CreateGlobalConversationData, CreateGlobalConversationErrors, CreateGlobalConversationResponses, CreateGlobalMcpData, CreateGlobalMcpErrors, CreateGlobalMcpResponses, CreateGlobalSkillData, CreateGlobalSkillErrors, CreateGlobalSkillResponses, CreateGlobalWorkspacePreviewLinkData, CreateGlobalWorkspacePreviewLinkErrors, CreateGlobalWorkspacePreviewLinkResponses, CreateIncidentData, CreateIncidentErrors, CreateIncidentResponses, CreateIpAccessControlData, CreateIpAccessControlErrors, CreateIpAccessControlResponses, CreateMcpData, CreateMcpErrors, CreateMcpResponses, CreateMonitorData, CreateMonitorErrors, CreateMonitorResponses, CreateNotificationEmailProviderData, CreateNotificationEmailProviderErrors, CreateNotificationEmailProviderResponses, CreateNotificationProviderData, CreateNotificationProviderErrors, CreateNotificationProviderResponses, CreateNotificationRouteData, CreateNotificationRouteErrors, CreateNotificationRouteResponses, CreateOidcProviderData, CreateOidcProviderErrors, CreateOidcProviderResponses, CreateOidcRoleMappingData, CreateOidcRoleMappingResponses, CreateOrRecreateOrderData, CreateOrRecreateOrderErrors, CreateOrRecreateOrderResponses, CreatePlanData, CreatePlanErrors, CreatePlanResponses, CreatePrData, CreatePrErrors, CreateProjectData, CreateProjectErrors, CreateProjectFromTemplateData, CreateProjectFromTemplateErrors, CreateProjectFromTemplateResponses, CreateProjectReleaseData, CreateProjectReleaseErrors, CreateProjectReleaseResponses, CreateProjectResponses, CreateProjectSecretData, CreateProjectSecretErrors, CreateProjectSecretResponses, CreateProviderKeyData, CreateProviderKeyErrors, CreateProviderKeyResponses, CreatePrResponses, CreateReleaseData, CreateReleaseErrors, CreateReleaseResponses, CreateRouteData, CreateRouteErrors, CreateRouteResponses, CreateS3SourceData, CreateS3SourceErrors, CreateS3SourceResponses, CreateSandboxData, CreateSandboxErrors, CreateSandboxResponses, CreateServiceData, CreateServiceErrors, CreateServiceResponses, CreateSkillData, CreateSkillErrors, CreateSkillResponses, CreateSlackProviderData, CreateSlackProviderErrors, CreateSlackProviderResponses, CreateSnapshotData, CreateSnapshotErrors, CreateSnapshotResponses, CreateTeamData, CreateTeamErrors, CreateTeamResponses, CreateThreadArtifactData, CreateThreadArtifactErrors, CreateThreadArtifactResponses, CreateUserData, CreateUserErrors, CreateUserResponses, CreateWebhookData, CreateWebhookErrors, CreateWebhookProviderData, CreateWebhookProviderErrors, CreateWebhookProviderResponses, CreateWebhookResponses, DeactivateApiKeyData, DeactivateApiKeyErrors, DeactivateApiKeyResponses, DeactivateConnectionData, DeactivateConnectionErrors, DeactivateConnectionResponses, DeactivateProviderData, DeactivateProviderErrors, DeactivateProviderResponses, DeauthorizeDiscoveredRouteCertData, DeauthorizeDiscoveredRouteCertErrors, DeauthorizeDiscoveredRouteCertResponses, DeleteAgentData, DeleteAgentErrors, DeleteAgentResponses, DeleteAlertData, DeleteAlertErrors, DeleteAlertResponses, DeleteAlertRuleData, DeleteAlertRuleErrors, DeleteAlertRuleResponses, DeleteApiKeyData, DeleteApiKeyErrors, DeleteApiKeyResponses, DeleteBackupData, DeleteBackupErrors, DeleteBackupResponses, DeleteBackupScheduleData, DeleteBackupScheduleErrors, DeleteBackupScheduleResponses, DeleteConnectionData, DeleteConnectionErrors, DeleteConnectionResponses, DeleteCustomDomainData, DeleteCustomDomainErrors, DeleteCustomDomainResponses, DeleteDashboardData, DeleteDashboardErrors, DeleteDashboardResponses, DeleteDeploymentTokenData, DeleteDeploymentTokenErrors, DeleteDeploymentTokenResponses, DeleteDnsProviderData, DeleteDnsProviderErrors, DeleteDnsProviderResponses, DeleteDomainData, DeleteDomainErrors, DeleteDomainResponses, DeleteEmailDomainData, DeleteEmailDomainErrors, DeleteEmailDomainResponses, DeleteEmailProviderData, DeleteEmailProviderErrors, DeleteEmailProviderResponses, DeleteEnvironmentData, DeleteEnvironmentDomainData, DeleteEnvironmentDomainErrors, DeleteEnvironmentDomainResponses, DeleteEnvironmentErrors, DeleteEnvironmentResponses, DeleteEnvironmentVariableData, DeleteEnvironmentVariableErrors, DeleteEnvironmentVariableResponses, DeleteExternalImageData, DeleteExternalImageErrors, DeleteExternalImageResponses, DeleteFacetData, DeleteFacetErrors, DeleteFacetResponses, DeleteFunnelData, DeleteFunnelErrors, DeleteFunnelResponses, DeleteGitProviderData, DeleteGitProviderErrors, DeleteGitProviderResponses, DeleteGlobalMcpData, DeleteGlobalMcpErrors, DeleteGlobalMcpResponses, DeleteGlobalSkillData, DeleteGlobalSkillErrors, DeleteGlobalSkillResponses, DeleteIpAccessControlData, DeleteIpAccessControlErrors, DeleteIpAccessControlResponses, DeleteMcpData, DeleteMcpErrors, DeleteMcpResponses, DeleteMonitorData, DeleteMonitorErrors, DeleteMonitorResponses, DeleteNotificationProviderData, DeleteNotificationProviderErrors, DeleteNotificationProviderResponses, DeleteNotificationRouteData, DeleteNotificationRouteErrors, DeleteNotificationRouteResponses, DeleteOidcProviderData, DeleteOidcProviderResponses, DeleteOidcRoleMappingData, DeleteOidcRoleMappingResponses, DeletePreferencesData, DeletePreferencesErrors, DeletePreferencesResponses, DeleteProjectData, DeleteProjectErrors, DeleteProjectResponses, DeleteProjectSecretData, DeleteProjectSecretErrors, DeleteProjectSecretResponses, DeleteProviderKeyData, DeleteProviderKeyErrors, DeleteProviderKeyResponses, DeleteProviderModelData, DeleteProviderModelErrors, DeleteProviderModelResponses, DeleteProviderSafelyData, DeleteProviderSafelyErrors, DeleteProviderSafelyResponses, DeleteReleaseSourceFilesData, DeleteReleaseSourceFilesErrors, DeleteReleaseSourceFilesResponses, DeleteReleaseSourceMapsData, DeleteReleaseSourceMapsErrors, DeleteReleaseSourceMapsResponses, DeleteRouteData, DeleteRouteErrors, DeleteRouteResponses, DeleteS3SourceData, DeleteS3SourceErrors, DeleteS3SourceResponses, DeleteScanData, DeleteScanErrors, DeleteScanResponses, DeleteSecretData, DeleteSecretErrors, DeleteSecretResponses, DeleteServiceData, DeleteServiceErrors, DeleteServiceResponses, DeleteSessionReplayData, DeleteSessionReplayErrors, DeleteSessionReplayResponses, DeleteSkillData, DeleteSkillErrors, DeleteSkillResponses, DeleteSnapshotData, DeleteSnapshotErrors, DeleteSnapshotResponses, DeleteSourceMapData, DeleteSourceMapErrors, DeleteSourceMapResponses, DeleteStaticBundleData, DeleteStaticBundleErrors, DeleteStaticBundleResponses, DeleteTeamData, DeleteTeamErrors, DeleteTeamResponses, DeleteUserData, DeleteUserErrors, DeleteUserResponses, DeleteWebhookData, DeleteWebhookErrors, DeleteWebhookResponses, DeployApplicationWorkspaceProjectData, DeployApplicationWorkspaceProjectErrors, DeployApplicationWorkspaceProjectResponses, DeployFromImageData, DeployFromImageErrors, DeployFromImageResponses, DeployFromImageUploadData, DeployFromImageUploadErrors, DeployFromImageUploadResponses, DeployFromStaticData, DeployFromStaticErrors, DeployFromStaticResponses, DeployFromUploadedSourceData, DeployFromUploadedSourceErrors, DeployFromUploadedSourceResponses, DeploymentMetricsGetLatestData, DeploymentMetricsGetLatestErrors, DeploymentMetricsGetLatestResponses, DeploymentMetricsGetRangeData, DeploymentMetricsGetRangeErrors, DeploymentMetricsGetRangeResponses, DeploymentMetricsToggleData, DeploymentMetricsToggleErrors, DeploymentMetricsToggleResponses, DestroySandboxData, DestroySandboxErrors, DestroySandboxResponses, DetachScheduleServiceData, DetachScheduleServiceErrors, DetachScheduleServiceResponses, DetectPublicEnvExampleData, DetectPublicEnvExampleErrors, DetectPublicEnvExampleResponses, DetectPublicPresetsData, DetectPublicPresetsErrors, DetectPublicPresetsResponses, DisableBackupScheduleData, DisableBackupScheduleErrors, DisableBackupScheduleResponses, DisableMfaData, DisableMfaErrors, DisableMfaResponses, DisconnectCloudData, DisconnectCloudResponses, DiscoverWorkloadsData, DiscoverWorkloadsErrors, DiscoverWorkloadsResponses, DomainData, DomainErrors, DomainResponses, DownloadApplicationWorkspaceFileData, DownloadApplicationWorkspaceFileErrors, DownloadApplicationWorkspaceFileResponses, DownloadGlobalSkillArchiveData, DownloadGlobalSkillArchiveErrors, DownloadGlobalSkillArchiveResponses, DownloadGlobalWorkspaceFileData, DownloadGlobalWorkspaceFileErrors, DownloadGlobalWorkspaceFileResponses, DownloadObjectData, DownloadObjectErrors, DownloadObjectResponses, DownloadSkillArchiveData, DownloadSkillArchiveErrors, DownloadSkillArchiveResponses, EmailStatusData, EmailStatusErrors, EmailStatusResponses, EmbeddingsData, EmbeddingsErrors, EmbeddingsResponses, EnableBackupScheduleData, EnableBackupScheduleErrors, EnableBackupScheduleResponses, EnrichVisitorData, EnrichVisitorErrors, EnrichVisitorResponses, EnrollCloudData, EnrollCloudResponses, EstimateBulkActivationData, EstimateBulkActivationErrors, EstimateBulkActivationResponses, ExecData, ExecDetachedData, ExecDetachedErrors, ExecDetachedResponses, ExecErrors, ExecResponses, ExecuteDeploymentOperationData, ExecuteDeploymentOperationErrors, ExecuteDeploymentOperationResponses, ExecuteImportData, ExecuteImportErrors, ExecuteImportResponses, ExtendTimeoutData, ExtendTimeoutErrors, ExtendTimeoutResponses, ExternalServiceEnablePgStatStatementsData, ExternalServiceEnablePgStatStatementsErrors, ExternalServiceEnablePgStatStatementsResponses, ExternalServiceMetricsByDatabaseData, ExternalServiceMetricsByDatabaseErrors, ExternalServiceMetricsByDatabaseResponses, ExternalServiceMetricsCreateAlertRuleData, ExternalServiceMetricsCreateAlertRuleErrors, ExternalServiceMetricsCreateAlertRuleResponses, ExternalServiceMetricsDeleteAlertRuleData, ExternalServiceMetricsDeleteAlertRuleErrors, ExternalServiceMetricsDeleteAlertRuleResponses, ExternalServiceMetricsGetAlertRulesData, ExternalServiceMetricsGetAlertRulesErrors, ExternalServiceMetricsGetAlertRulesResponses, ExternalServiceMetricsGetLatestData, ExternalServiceMetricsGetLatestErrors, ExternalServiceMetricsGetLatestResponses, ExternalServiceMetricsGetRangeData, ExternalServiceMetricsGetRangeErrors, ExternalServiceMetricsGetRangeResponses, ExternalServiceMetricsStatusData, ExternalServiceMetricsStatusErrors, ExternalServiceMetricsStatusResponses, ExternalServiceMetricsToggleData, ExternalServiceMetricsToggleErrors, ExternalServiceMetricsToggleResponses, ExternalServiceMetricsUpdateAlertRuleData, ExternalServiceMetricsUpdateAlertRuleErrors, ExternalServiceMetricsUpdateAlertRuleResponses, ExternalServiceResetPgStatStatementsData, ExternalServiceResetPgStatStatementsErrors, ExternalServiceResetPgStatStatementsResponses, FinalizeOrderData, FinalizeOrderErrors, FinalizeOrderResponses, FinalizeProjectReleaseData, FinalizeProjectReleaseErrors, FinalizeProjectReleaseResponses, FindConversationData, FindConversationErrors, FindConversationResponses, GenerateJoinTokenData, GenerateJoinTokenErrors, GenerateJoinTokenResponses, GeneratePresetDockerfileData, GeneratePresetDockerfileErrors, GeneratePresetDockerfileResponses, GetAccessInfoData, GetAccessInfoErrors, GetAccessInfoResponses, GetActiveVisitorsData, GetActiveVisitorsErrors, GetActiveVisitorsResponses, GetActivityGraphData, GetActivityGraphErrors, GetActivityGraphResponses, GetAdminGateData, GetAdminGateErrors, GetAdminGateResponses, GetAgentData, GetAgentErrors, GetAgentResponses, GetAggregatedBucketsData, GetAggregatedBucketsErrors, GetAggregatedBucketsResponses, GetAiAgentBreakdownData, GetAiAgentBreakdownErrors, GetAiAgentBreakdownResponses, GetAiAgentPagesData, GetAiAgentPagesErrors, GetAiAgentPagesResponses, GetAiAgentTimelineData, GetAiAgentTimelineErrors, GetAiAgentTimelineResponses, GetAiDataAccessData, GetAiDataAccessErrors, GetAiDataAccessResponses, GetAiPageBreakdownData, GetAiPageBreakdownErrors, GetAiPageBreakdownResponses, GetAiProviderStatusData, GetAiProviderStatusErrors, GetAiProviderStatusResponses, GetAiStatusBreakdownData, GetAiStatusBreakdownErrors, GetAiStatusBreakdownResponses, GetAlertData, GetAlertErrors, GetAlertResponses, GetAlertRuleData, GetAlertRuleErrors, GetAlertRuleResponses, GetAllRepositoriesByNameData, GetAllRepositoriesByNameErrors, GetAllRepositoriesByNameResponses, GetAnalyticsActiveVisitorsData, GetAnalyticsActiveVisitorsErrors, GetAnalyticsActiveVisitorsResponses, GetAnalyticsEventsCountData, GetAnalyticsEventsCountErrors, GetAnalyticsEventsCountResponses, GetAnalyticsSessionEventsData, GetAnalyticsSessionEventsErrors, GetAnalyticsSessionEventsResponses, GetAnalyticsVisitorSessionsData, GetAnalyticsVisitorSessionsErrors, GetAnalyticsVisitorSessionsResponses, GetApiCallersData, GetApiCallersErrors, GetApiCallersResponses, GetApiKeyData, GetApiKeyErrors, GetApiKeyPermissionsData, GetApiKeyPermissionsErrors, GetApiKeyPermissionsResponses, GetApiKeyResponses, GetApiRoutesData, GetApiRoutesErrors, GetApiRoutesResponses, GetApiSummaryData, GetApiSummaryErrors, GetApiSummaryResponses, GetApiTimeseriesData, GetApiTimeseriesErrors, GetApiTimeseriesResponses, GetApiTrafficProxyLogAccessData, GetApiTrafficProxyLogAccessErrors, GetApiTrafficProxyLogAccessResponses, GetApplicationData, GetApplicationErrors, GetApplicationResponses, GetApplicationWorkspaceChangesData, GetApplicationWorkspaceChangesErrors, GetApplicationWorkspaceChangesResponses, GetApplicationWorkspaceData, GetApplicationWorkspaceDiffData, GetApplicationWorkspaceDiffErrors, GetApplicationWorkspaceDiffResponses, GetApplicationWorkspaceDirectoryData, GetApplicationWorkspaceDirectoryErrors, GetApplicationWorkspaceDirectoryResponses, GetApplicationWorkspaceErrors, GetApplicationWorkspaceFileData, GetApplicationWorkspaceFileErrors, GetApplicationWorkspaceFileResponses, GetApplicationWorkspaceResponses, GetAuditLogData, GetAuditLogErrors, GetAuditLogResponses, GetBackupData, GetBackupErrors, GetBackupResponses, GetBackupScheduleData, GetBackupScheduleErrors, GetBackupScheduleResponses, GetBranchesByRepositoryIdData, GetBranchesByRepositoryIdErrors, GetBranchesByRepositoryIdResponses, GetBucketedIncidentsData, GetBucketedIncidentsErrors, GetBucketedIncidentsResponses, GetBucketedStatusData, GetBucketedStatusErrors, GetBucketedStatusResponses, GetBulkActivationJobData, GetBulkActivationJobErrors, GetBulkActivationJobResponses, GetChallengeTokenData, GetChallengeTokenErrors, GetChallengeTokenResponses, GetChatReadinessData, GetChatReadinessErrors, GetChatReadinessResponses, GetCliStatusData, GetCliStatusErrors, GetCliStatusResponses, GetCloudAiCapabilityData, GetCloudAiCapabilityResponses, GetCloudBackfillStatusData, GetCloudBackfillStatusErrors, GetCloudBackfillStatusResponses, GetCloudCapabilityData, GetCloudCapabilityResponses, GetCloudStatusData, GetCloudStatusResponses, GetCloudTelemetryStatusData, GetCloudTelemetryStatusErrors, GetCloudTelemetryStatusResponses, GetClusterHealthData, GetClusterHealthErrors, GetClusterHealthResponses, GetClusterMemberData, GetClusterMemberErrors, GetClusterMemberResponses, GetCmdData, GetCmdErrors, GetCmdResponses, GetContainerDetailData, GetContainerDetailErrors, GetContainerDetailResponses, GetContainerEnvironmentVariableData, GetContainerEnvironmentVariableErrors, GetContainerEnvironmentVariableResponses, GetContainerLogsByIdData, GetContainerLogsByIdErrors, GetContainerLogsData, GetContainerLogsErrors, GetContainerMetricsData, GetContainerMetricsErrors, GetContainerMetricsResponses, GetConversationData, GetConversationDetailData, GetConversationDetailErrors, GetConversationDetailResponses, GetConversationErrors, GetConversationResponses, GetConversationsData, GetConversationsErrors, GetConversationsResponses, GetCronByIdData, GetCronByIdErrors, GetCronByIdResponses, GetCronExecutionsData, GetCronExecutionsErrors, GetCronExecutionsResponses, GetCrossProjectTraceSiblingsData, GetCrossProjectTraceSiblingsErrors, GetCrossProjectTraceSiblingsResponses, GetCurrentBulkActivationJobData, GetCurrentBulkActivationJobErrors, GetCurrentBulkActivationJobResponses, GetCurrentMonitorStatusData, GetCurrentMonitorStatusErrors, GetCurrentMonitorStatusResponses, GetCurrentUserData, GetCurrentUserErrors, GetCurrentUserResponses, GetCustomDomainData, GetCustomDomainErrors, GetCustomDomainResponses, GetDashboardData, GetDashboardErrors, GetDashboardProjectsAnalyticsData, GetDashboardProjectsAnalyticsErrors, GetDashboardProjectsAnalyticsResponses, GetDashboardResponses, GetDeliveryData, GetDeliveryErrors, GetDeliveryResponses, GetDeploymentContainerLogContentData, GetDeploymentContainerLogContentErrors, GetDeploymentContainerLogContentResponses, GetDeploymentData, GetDeploymentErrors, GetDeploymentJobLogsData, GetDeploymentJobLogsErrors, GetDeploymentJobLogsResponses, GetDeploymentJobsData, GetDeploymentJobsErrors, GetDeploymentJobsResponses, GetDeploymentOperationsData, GetDeploymentOperationsErrors, GetDeploymentOperationsResponses, GetDeploymentOperationStatusData, GetDeploymentOperationStatusErrors, GetDeploymentOperationStatusResponses, GetDeploymentResponses, GetDeploymentTokenData, GetDeploymentTokenErrors, GetDeploymentTokenResponses, GetDiskStatusData, GetDiskStatusErrors, GetDiskStatusResponses, GetDnsChangesData, GetDnsChangesErrors, GetDnsChangesResponses, GetDnsProviderData, GetDnsProviderErrors, GetDnsProviderResponses, GetDomainByHostData, GetDomainByHostErrors, GetDomainByHostResponses, GetDomainByIdData, GetDomainByIdErrors, GetDomainByIdResponses, GetDomainByNameData, GetDomainByNameErrors, GetDomainByNameResponses, GetDomainData, GetDomainDnsRecordsData, GetDomainDnsRecordsErrors, GetDomainDnsRecordsResponses, GetDomainErrors, GetDomainOrderData, GetDomainOrderErrors, GetDomainOrderResponses, GetDomainResponses, GetEmailData, GetEmailErrors, GetEmailEventsData, GetEmailEventsErrors, GetEmailEventsResponses, GetEmailLinksData, GetEmailLinksErrors, GetEmailLinksResponses, GetEmailProviderData, GetEmailProviderErrors, GetEmailProviderResponses, GetEmailResponses, GetEmailStatsData, GetEmailStatsErrors, GetEmailStatsResponses, GetEmailTrackingData, GetEmailTrackingErrors, GetEmailTrackingResponses, GetEmailTrackingStatusData, GetEmailTrackingStatusErrors, GetEmailTrackingStatusResponses, GetEntityInfoData, GetEntityInfoErrors, GetEntityInfoResponses, GetEnvironmentCronsData, GetEnvironmentCronsErrors, GetEnvironmentCronsResponses, GetEnvironmentData, GetEnvironmentDomainsData, GetEnvironmentDomainsErrors, GetEnvironmentDomainsResponses, GetEnvironmentErrors, GetEnvironmentResponses, GetEnvironmentsData, GetEnvironmentsErrors, GetEnvironmentsResponses, GetEnvironmentVariablesData, GetEnvironmentVariablesErrors, GetEnvironmentVariablesResponses, GetEnvironmentVariableValueData, GetEnvironmentVariableValueErrors, GetEnvironmentVariableValueResponses, GetErrorDashboardStatsData, GetErrorDashboardStatsErrors, GetErrorDashboardStatsResponses, GetErrorEventData, GetErrorEventErrors, GetErrorEventResponses, GetErrorGroupData, GetErrorGroupErrors, GetErrorGroupResponses, GetErrorStatsData, GetErrorStatsErrors, GetErrorStatsResponses, GetErrorTimeSeriesData, GetErrorTimeSeriesErrors, GetErrorTimeSeriesResponses, GetEventDetailData, GetEventDetailErrors, GetEventDetailResponses, GetEventEntriesData, GetEventEntriesErrors, GetEventEntriesResponses, GetEventsCountData, GetEventsCountErrors, GetEventsCountResponses, GetEventsTimelineData, GetEventsTimelineErrors, GetEventsTimelineResponses, GetEventTypeBreakdownData, GetEventTypeBreakdownErrors, GetEventTypeBreakdownResponses, GetEventVisitorsData, GetEventVisitorsErrors, GetEventVisitorsResponses, GetExternalImageData, GetExternalImageErrors, GetExternalImageResponses, GetExternalServiceBackupCapabilityData, GetExternalServiceBackupCapabilityErrors, GetExternalServiceBackupCapabilityResponses, GetFailureReportPreviewData, GetFailureReportPreviewErrors, GetFailureReportPreviewResponses, GetFeatureMaturityData, GetFeatureMaturityErrors, GetFeatureMaturityResponses, GetFileData, GetFileErrors, GetFileResponses, GetFlagData, GetFlagErrors, GetFlagResponses, GetFlagSnapshotData, GetFlagSnapshotErrors, GetFlagSnapshotResponses, GetFunnelMetricsData, GetFunnelMetricsErrors, GetFunnelMetricsResponses, GetGenaiTraceData, GetGenaiTraceErrors, GetGenaiTraceResponses, GetGeneralStatsData, GetGeneralStatsErrors, GetGeneralStatsResponses, GetGitProviderData, GetGitProviderErrors, GetGitProviderResponses, GetGlobalAiWorkspaceData, GetGlobalAiWorkspaceErrors, GetGlobalAiWorkspaceResponses, GetGlobalEventsData, GetGlobalEventsErrors, GetGlobalEventsResponses, GetGlobalEventStatsData, GetGlobalEventStatsErrors, GetGlobalEventStatsResponses, GetGlobalMcpData, GetGlobalMcpErrors, GetGlobalMcpResponses, GetGlobalSandboxStatusData, GetGlobalSandboxStatusErrors, GetGlobalSandboxStatusResponses, GetGlobalSkillData, GetGlobalSkillErrors, GetGlobalSkillResponses, GetGlobalWorkspaceChangesData, GetGlobalWorkspaceChangesErrors, GetGlobalWorkspaceChangesResponses, GetGlobalWorkspaceDiffData, GetGlobalWorkspaceDiffErrors, GetGlobalWorkspaceDiffResponses, GetGlobalWorkspaceDirectoryData, GetGlobalWorkspaceDirectoryErrors, GetGlobalWorkspaceDirectoryResponses, GetGlobalWorkspaceFileData, GetGlobalWorkspaceFileErrors, GetGlobalWorkspaceFileResponses, GetGroupedPageMetricsData, GetGroupedPageMetricsErrors, GetGroupedPageMetricsResponses, GetHealthData, GetHealthErrors, GetHealthResponses, GetHourlyVisitsData, GetHourlyVisitsErrors, GetHourlyVisitsResponses, GetHttpChallengeDebugData, GetHttpChallengeDebugErrors, GetHttpChallengeDebugResponses, GetImportStatusData, GetImportStatusErrors, GetImportStatusResponses, GetIncidentData, GetIncidentErrors, GetIncidentResponses, GetIncidentUpdatesData, GetIncidentUpdatesErrors, GetIncidentUpdatesResponses, GetIngestErrorsData, GetIngestErrorsErrors, GetIngestErrorsResponses, GetIpAccessControlData, GetIpAccessControlErrors, GetIpAccessControlResponses, GetIpGeolocationData, GetIpGeolocationErrors, GetIpGeolocationResponses, GetJoinTokenStatusData, GetJoinTokenStatusErrors, GetJoinTokenStatusResponses, GetLastDeploymentData, GetLastDeploymentErrors, GetLastDeploymentResponses, GetLatestDeploymentMediaData, GetLatestDeploymentMediaErrors, GetLatestDeploymentMediaResponses, GetLatestScanData, GetLatestScanErrors, GetLatestScanResponses, GetLatestScansPerEnvironmentData, GetLatestScansPerEnvironmentErrors, GetLatestScansPerEnvironmentResponses, GetLiveVisitorsListData, GetLiveVisitorsListErrors, GetLiveVisitorsListResponses, GetLogContextData, GetLogContextErrors, GetLogContextResponses, GetMcpData, GetMcpErrors, GetMcpResponses, GetMetricsOverTimeData, GetMetricsOverTimeErrors, GetMetricsOverTimeResponses, GetMonitorData, GetMonitorErrors, GetMonitorResponses, GetNotificationProviderData, GetNotificationProviderErrors, GetNotificationProviderResponses, GetNotificationRouteData, GetNotificationRouteErrors, GetNotificationRouteResponses, GetOnDemandCertStatusData, GetOnDemandCertStatusErrors, GetOnDemandCertStatusResponses, GetOrCreateDsnData, GetOrCreateDsnErrors, GetOrCreateDsnResponses, GetPageFlowData, GetPageFlowErrors, GetPageFlowResponses, GetPageHourlySessionsData, GetPageHourlySessionsErrors, GetPageHourlySessionsResponses, GetPagePathDetailData, GetPagePathDetailErrors, GetPagePathDetailResponses, GetPagePathsData, GetPagePathsErrors, GetPagePathsResponses, GetPagePathsSparklinesData, GetPagePathsSparklinesErrors, GetPagePathsSparklinesResponses, GetPagePathVisitorsData, GetPagePathVisitorsErrors, GetPagePathVisitorsResponses, GetPendingActionData, GetPendingActionErrors, GetPendingActionResponses, GetPerformanceMetricsData, GetPerformanceMetricsErrors, GetPerformanceMetricsResponses, GetPgUpgradeData, GetPgUpgradeErrors, GetPgUpgradeLogsData, GetPgUpgradeLogsErrors, GetPgUpgradeLogsResponses, GetPgUpgradeResponses, GetPipelineHistoryData, GetPipelineHistoryErrors, GetPipelineHistoryResponses, GetPipelineStatsData, GetPipelineStatsErrors, GetPipelineStatsResponses, GetPlatformInfoData, GetPlatformInfoErrors, GetPlatformInfoResponses, GetPostgresWalHealthData, GetPostgresWalHealthErrors, GetPostgresWalHealthResponses, GetPreferencesData, GetPreferencesErrors, GetPreferencesResponses, GetPreviewGatewayLogsData, GetPreviewGatewayLogsErrors, GetPreviewGatewayLogsResponses, GetPreviewGatewaySettingsData, GetPreviewGatewaySettingsResponses, GetPreviewGatewayStatusData, GetPreviewGatewayStatusErrors, GetPreviewGatewayStatusResponses, GetPricingData, GetPricingErrors, GetPricingResponses, GetPrivateIpData, GetPrivateIpErrors, GetPrivateIpResponses, GetProjectAlarmsSummaryData, GetProjectAlarmsSummaryErrors, GetProjectAlarmsSummaryResponses, GetProjectBySlugData, GetProjectBySlugErrors, GetProjectBySlugResponses, GetProjectCloudTelemetryData, GetProjectCloudTelemetryErrors, GetProjectCloudTelemetryResponses, GetProjectData, GetProjectDeploymentsData, GetProjectDeploymentsErrors, GetProjectDeploymentsResponses, GetProjectErrors, GetProjectResponses, GetProjectsData, GetProjectsErrors, GetProjectServiceEnvironmentVariablesData, GetProjectServiceEnvironmentVariablesErrors, GetProjectServiceEnvironmentVariablesResponses, GetProjectServiceTemplateData, GetProjectServiceTemplateErrors, GetProjectServiceTemplateResponses, GetProjectSessionReplaysData, GetProjectSessionReplaysErrors, GetProjectSessionReplaysResponses, GetProjectsHealthData, GetProjectsHealthErrors, GetProjectsHealthResponses, GetProjectsMonitorHealthData, GetProjectsMonitorHealthErrors, GetProjectsMonitorHealthResponses, GetProjectsResponses, GetProjectStatisticsData, GetProjectStatisticsErrors, GetProjectStatisticsResponses, GetProjectTemplateData, GetProjectTemplateErrors, GetProjectTemplateResponses, GetPropertyBreakdownData, GetPropertyBreakdownErrors, GetPropertyBreakdownResponses, GetPropertyTimelineData, GetPropertyTimelineErrors, GetPropertyTimelineResponses, GetProviderConnectionsData, GetProviderConnectionsErrors, GetProviderConnectionsResponses, GetProviderKeyData, GetProviderKeyErrors, GetProviderKeyResponses, GetProviderMetadataData, GetProviderMetadataErrors, GetProviderMetadataResponses, GetProvidersMetadataData, GetProvidersMetadataErrors, GetProvidersMetadataResponses, GetProxyLogByIdData, GetProxyLogByIdErrors, GetProxyLogByIdResponses, GetProxyLogByRequestIdData, GetProxyLogByRequestIdErrors, GetProxyLogByRequestIdResponses, GetProxyLogsData, GetProxyLogsErrors, GetProxyLogsResponses, GetPublicBranchesData, GetPublicBranchesErrors, GetPublicBranchesResponses, GetPublicComposePreviewData, GetPublicComposePreviewErrors, GetPublicComposePreviewResponses, GetPublicComposeServicesData, GetPublicComposeServicesErrors, GetPublicComposeServicesResponses, GetPublicIpData, GetPublicIpErrors, GetPublicIpResponses, GetPublicRepositoryData, GetPublicRepositoryErrors, GetPublicRepositoryResponses, GetQueryContainerInfoData, GetQueryContainerInfoErrors, GetQueryContainerInfoResponses, GetQuotaData, GetQuotaErrors, GetQuotaResponses, GetRecentActivityData, GetRecentActivityErrors, GetRecentActivityResponses, GetRemoteExternalImageData, GetRemoteExternalImageErrors, GetRemoteExternalImageResponses, GetRepositoryBranchesData, GetRepositoryBranchesErrors, GetRepositoryBranchesResponses, GetRepositoryByIdData, GetRepositoryByIdErrors, GetRepositoryByIdResponses, GetRepositoryByNameData, GetRepositoryByNameErrors, GetRepositoryByNameResponses, GetRepositoryComposePreviewData, GetRepositoryComposePreviewErrors, GetRepositoryComposePreviewResponses, GetRepositoryComposeServicesLiveData, GetRepositoryComposeServicesLiveErrors, GetRepositoryComposeServicesLiveResponses, GetRepositoryEnvExampleLiveData, GetRepositoryEnvExampleLiveErrors, GetRepositoryEnvExampleLiveResponses, GetRepositoryPresetByNameData, GetRepositoryPresetByNameErrors, GetRepositoryPresetByNameResponses, GetRepositoryPresetLiveData, GetRepositoryPresetLiveErrors, GetRepositoryPresetLiveResponses, GetRepositoryTagsData, GetRepositoryTagsErrors, GetRepositoryTagsResponses, GetResolvedEnvironmentVariablesData, GetResolvedEnvironmentVariablesErrors, GetResolvedEnvironmentVariablesResponses, GetResolvedEnvironmentVariableValueData, GetResolvedEnvironmentVariableValueErrors, GetResolvedEnvironmentVariableValueResponses, GetRestoreCapabilitiesData, GetRestoreCapabilitiesErrors, GetRestoreCapabilitiesResponses, GetRestoreRunData, GetRestoreRunErrors, GetRestoreRunResponses, GetRouteData, GetRouteErrors, GetRouteResponses, GetRunData, GetRunErrors, GetRunResponses, GetRunWithLogsData, GetRunWithLogsErrors, GetRunWithLogsResponses, GetS3CredentialsData, GetS3CredentialsErrors, GetS3CredentialsResponses, GetS3SourceData, GetS3SourceErrors, GetS3SourceResponses, GetSandboxData, GetSandboxErrors, GetSandboxResponses, GetSandboxStatusData, GetSandboxStatusErrors, GetSandboxStatusResponses, GetScanByDeploymentData, GetScanByDeploymentErrors, GetScanByDeploymentResponses, GetScanData, GetScanErrors, GetScanResponses, GetScanVulnerabilitiesData, GetScanVulnerabilitiesErrors, GetScanVulnerabilitiesResponses, GetServiceBySlugData, GetServiceBySlugErrors, GetServiceBySlugResponses, GetServiceData, GetServiceEnvironmentVariableData, GetServiceEnvironmentVariableErrors, GetServiceEnvironmentVariableResponses, GetServiceEnvironmentVariablesData, GetServiceEnvironmentVariablesErrors, GetServiceEnvironmentVariablesResponses, GetServiceErrors, GetServiceHealthStatusData, GetServiceHealthStatusErrors, GetServiceHealthStatusResponses, GetServicePreviewEnvironmentVariableNamesData, GetServicePreviewEnvironmentVariableNamesErrors, GetServicePreviewEnvironmentVariableNamesResponses, GetServicePreviewEnvironmentVariablesMaskedData, GetServicePreviewEnvironmentVariablesMaskedErrors, GetServicePreviewEnvironmentVariablesMaskedResponses, GetServiceResponses, GetServiceRuntimeData, GetServiceRuntimeErrors, GetServiceRuntimeResponses, GetServiceStatsData, GetServiceStatsErrors, GetServiceStatsResponses, GetServiceTypeParametersData, GetServiceTypeParametersErrors, GetServiceTypeParametersResponses, GetServiceTypesData, GetServiceTypesErrors, GetServiceTypesResponses, GetSessionDetailsData, GetSessionDetailsErrors, GetSessionDetailsResponses, GetSessionEventsData, GetSessionEventsErrors, GetSessionEventsResponses, GetSessionLogsData, GetSessionLogsErrors, GetSessionLogsResponses, GetSessionReplayData, GetSessionReplayErrors, GetSessionReplayEventsData, GetSessionReplayEventsErrors, GetSessionReplayEventsResponses, GetSessionReplayResponses, GetSettingsData, GetSettingsErrors, GetSettingsResponses, GetSkillData, GetSkillErrors, GetSkillResponses, GetSlowQueriesData, GetSlowQueriesErrors, GetSlowQueriesResponses, GetSnapshotData, GetSnapshotErrors, GetSnapshotResponses, GetStaticBundleData, GetStaticBundleErrors, GetStaticBundleResponses, GetStatusOverviewData, GetStatusOverviewErrors, GetStatusOverviewResponses, GetSystemAlarmsSummaryData, GetSystemAlarmsSummaryErrors, GetSystemAlarmsSummaryResponses, GetTagsByRepositoryIdData, GetTagsByRepositoryIdErrors, GetTagsByRepositoryIdResponses, GetTeamData, GetTeamErrors, GetTeamResponses, GetTimeBucketStatsData, GetTimeBucketStatsErrors, GetTimeBucketStatsResponses, GetTodayStatsData, GetTodayStatsErrors, GetTodayStatsResponses, GetTraceData, GetTraceErrors, GetTraceResponses, GetTraefikDiscoveryStatusData, GetTraefikDiscoveryStatusErrors, GetTraefikDiscoveryStatusResponses, GetUnifiedTraceData, GetUnifiedTraceErrors, GetUnifiedTraceResponses, GetUniqueCountsData, GetUniqueCountsErrors, GetUniqueCountsResponses, GetUniqueEventsData, GetUniqueEventsErrors, GetUniqueEventsResponses, GetUpdateCapabilityData, GetUpdateCapabilityErrors, GetUpdateCapabilityResponses, GetUpdateStatusData, GetUpdateStatusErrors, GetUpdateStatusResponses, GetUptimeHistoryData, GetUptimeHistoryErrors, GetUptimeHistoryResponses, GetUsageByProviderData, GetUsageByProviderErrors, GetUsageByProviderResponses, GetUsageRecentData, GetUsageRecentErrors, GetUsageRecentResponses, GetUsageSummaryData, GetUsageSummaryErrors, GetUsageSummaryResponses, GetUsageTimeseriesData, GetUsageTimeseriesErrors, GetUsageTimeseriesResponses, GetUsageTopModelsData, GetUsageTopModelsErrors, GetUsageTopModelsResponses, GetUserConversationAttachmentData, GetUserConversationAttachmentErrors, GetUserConversationAttachmentResponses, GetUserConversationData, GetUserConversationErrors, GetUserConversationResponses, GetUserPendingActionData, GetUserPendingActionErrors, GetUserPendingActionResponses, GetVisibleCustomDomainByHostnameData, GetVisibleCustomDomainByHostnameErrors, GetVisibleCustomDomainByHostnameResponses, GetVisitorByGuidData, GetVisitorByGuidErrors, GetVisitorByGuidResponses, GetVisitorByIdData, GetVisitorByIdErrors, GetVisitorByIdResponses, GetVisitorDetailsData, GetVisitorDetailsErrors, GetVisitorDetailsResponses, GetVisitorFacetsData, GetVisitorFacetsErrors, GetVisitorFacetsResponses, GetVisitorInfoData, GetVisitorInfoErrors, GetVisitorInfoResponses, GetVisitorJourneyData, GetVisitorJourneyErrors, GetVisitorJourneyResponses, GetVisitorsData, GetVisitorsErrors, GetVisitorSessionsData, GetVisitorSessionsErrors, GetVisitorSessionsResponses, GetVisitorsResponses, GetVisitorStatsData, GetVisitorStatsErrors, GetVisitorStatsResponses, GetWebhookData, GetWebhookErrors, GetWebhookResponses, GetWorkspaceFileLimitsData, GetWorkspaceFileLimitsErrors, GetWorkspaceFileLimitsResponses, GrantProjectAccessData, GrantProjectAccessErrors, GrantProjectAccessResponses, HandleGitProviderOauthCallbackData, HandleGitProviderOauthCallbackErrors, HasAnalyticsEventsData, HasAnalyticsEventsErrors, HasAnalyticsEventsResponses, HasErrorGroupsData, HasErrorGroupsErrors, HasErrorGroupsResponses, HasPerformanceMetricsData, HasPerformanceMetricsErrors, HasPerformanceMetricsResponses, HasTracesData, HasTracesErrors, HasTracesResponses, ImportApplicationWorkspaceGitData, ImportApplicationWorkspaceGitErrors, ImportApplicationWorkspaceGitResponses, ImportEmailDomainData, ImportEmailDomainErrors, ImportEmailDomainResponses, ImportExternalServiceData, ImportExternalServiceErrors, ImportExternalServiceResponses, ImportTraefikAcmeJsonData, ImportTraefikAcmeJsonErrors, ImportTraefikAcmeJsonResponses, IngestLogsByPathData, IngestLogsByPathErrors, IngestLogsByPathResponses, IngestLogsData, IngestLogsErrors, IngestLogsResponses, IngestMetricsByPathData, IngestMetricsByPathErrors, IngestMetricsByPathResponses, IngestMetricsData, IngestMetricsErrors, IngestMetricsResponses, IngestSentryEnvelopeData, IngestSentryEnvelopeErrors, IngestSentryEnvelopeResponses, IngestSentryEventData, IngestSentryEventErrors, IngestSentryEventResponses, IngestTracesByPathData, IngestTracesByPathErrors, IngestTracesByPathResponses, IngestTracesData, IngestTracesErrors, IngestTracesResponses, IngestTunneledEnvelopeData, IngestTunneledEnvelopeErrors, IngestTunneledEnvelopeResponses, InitSessionReplayData, InitSessionReplayErrors, InitSessionReplayResponses, InspectDropArchiveData, InspectDropArchiveErrors, InspectDropArchiveResponses, IssueRuntimeCredentialsData, IssueRuntimeCredentialsErrors, IssueRuntimeCredentialsResponses, JobLogsData, JobLogsErrors, JobLogsResponses, JobStatusData, JobStatusErrors, JobStatusResponses, KillJobData, KillJobErrors, KillJobResponses, KvDelData, KvDelErrors, KvDelResponses, KvDisableData, KvDisableErrors, KvDisableResponses, KvEnableData, KvEnableErrors, KvEnableResponses, KvExpireData, KvExpireErrors, KvExpireResponses, KvGetData, KvGetErrors, KvGetResponses, KvIncrData, KvIncrErrors, KvIncrResponses, KvKeysData, KvKeysErrors, KvKeysResponses, KvSetData, KvSetErrors, KvSetResponses, KvStatusData, KvStatusErrors, KvStatusResponses, KvTtlData, KvTtlErrors, KvTtlResponses, KvUpdateData, KvUpdateErrors, KvUpdateResponses, LatestRunForSourceData, LatestRunForSourceErrors, LatestRunForSourceResponses, LinkApplicationProjectData, LinkApplicationProjectErrors, LinkApplicationProjectResponses, LinkCustomDomainToCertificateData, LinkCustomDomainToCertificateErrors, LinkCustomDomainToCertificateResponses, LinkServiceToProjectData, LinkServiceToProjectErrors, LinkServiceToProjectResponses, ListAgentRunsData, ListAgentRunsErrors, ListAgentRunsResponses, ListAgentsData, ListAgentsErrors, ListAgentsResponses, ListAiProvidersData, ListAiProvidersErrors, ListAiProvidersResponses, ListAlertRulesData, ListAlertRulesErrors, ListAlertRulesResponses, ListAlertsData, ListAlertsErrors, ListAlertsResponses, ListAllConversationsData, ListAllConversationsErrors, ListAllConversationsResponses, ListAllRunsData, ListAllRunsErrors, ListAllRunsResponses, ListAnalyticsIngestKeysData, ListAnalyticsIngestKeysErrors, ListAnalyticsIngestKeysResponses, ListApiKeysData, ListApiKeysErrors, ListApiKeysResponses, ListApplicationConversationsData, ListApplicationConversationsErrors, ListApplicationConversationsResponses, ListApplicationsData, ListApplicationsErrors, ListApplicationsResponses, ListAuditLogsData, ListAuditLogsErrors, ListAuditLogsResponses, ListAvailableContainersData, ListAvailableContainersErrors, ListAvailableContainersResponses, ListBackupAlertsData, ListBackupAlertsErrors, ListBackupAlertsResponses, ListBackupChildrenData, ListBackupChildrenErrors, ListBackupChildrenResponses, ListBackupSchedulesData, ListBackupSchedulesErrors, ListBackupSchedulesResponses, ListBackupsForScheduleData, ListBackupsForScheduleErrors, ListBackupsForScheduleResponses, ListCommitsByRepositoryIdData, ListCommitsByRepositoryIdErrors, ListCommitsByRepositoryIdResponses, ListConnectionsData, ListConnectionsErrors, ListConnectionsResponses, ListContainerHistoryData, ListContainerHistoryErrors, ListContainerHistoryResponses, ListContainersAtPathData, ListContainersAtPathErrors, ListContainersAtPathResponses, ListContainersData, ListContainersErrors, ListContainersResponses, ListConversationsData, ListConversationsErrors, ListConversationsResponses, ListCustomDomainsForProjectData, ListCustomDomainsForProjectErrors, ListCustomDomainsForProjectResponses, ListDashboardsData, ListDashboardsErrors, ListDashboardsResponses, ListDeliveriesData, ListDeliveriesErrors, ListDeliveriesResponses, ListDeploymentContainerLogsData, ListDeploymentContainerLogsErrors, ListDeploymentContainerLogsResponses, ListDeploymentTokensData, ListDeploymentTokensErrors, ListDeploymentTokensResponses, ListDiscoverableDomainsData, ListDiscoverableDomainsErrors, ListDiscoverableDomainsResponses, ListDnsProvidersData, ListDnsProvidersErrors, ListDnsProvidersResponses, ListDomainsData, ListDomainsErrors, ListDomainsResponses, ListDsnsData, ListDsnsErrors, ListDsnsResponses, ListEmailDomainProjectsData, ListEmailDomainProjectsErrors, ListEmailDomainProjectsResponses, ListEmailDomainsData, ListEmailDomainsErrors, ListEmailDomainsResponses, ListEmailProvidersData, ListEmailProvidersErrors, ListEmailProvidersResponses, ListEmailsData, ListEmailsErrors, ListEmailsResponses, ListEnrollmentTokensData, ListEnrollmentTokensErrors, ListEnrollmentTokensResponses, ListEntitiesData, ListEntitiesErrors, ListEntitiesResponses, ListErrorEventsData, ListErrorEventsErrors, ListErrorEventsResponses, ListErrorGroupsData, ListErrorGroupsErrors, ListErrorGroupsResponses, ListEventsData, ListEventsResponses, ListEventTypesData, ListEventTypesResponses, ListExternalImagesData, ListExternalImagesErrors, ListExternalImagesResponses, ListExternalPluginsData, ListExternalPluginsErrors, ListExternalPluginsResponses, ListExternalServiceBackupsData, ListExternalServiceBackupsErrors, ListExternalServiceBackupsResponses, ListFacetsData, ListFacetsErrors, ListFacetsResponses, ListFlagsData, ListFlagsErrors, ListFlagsResponses, ListFunnelsData, ListFunnelsErrors, ListFunnelsResponses, ListGitProvidersData, ListGitProvidersErrors, ListGitProvidersResponses, ListGlobalMcpsData, ListGlobalMcpsErrors, ListGlobalMcpsResponses, ListGlobalSkillsData, ListGlobalSkillsErrors, ListGlobalSkillsResponses, ListIncidentsData, ListIncidentsErrors, ListIncidentsResponses, ListInsightsData, ListInsightsErrors, ListInsightsResponses, ListIpAccessControlData, ListIpAccessControlErrors, ListIpAccessControlResponses, ListJobsData, ListJobsErrors, ListJobsResponses, ListKnownAiAgentsData, ListKnownAiAgentsErrors, ListKnownAiAgentsResponses, ListManagedDomainsData, ListManagedDomainsErrors, ListManagedDomainsResponses, ListManagedEnvironmentVariablesData, ListManagedEnvironmentVariablesErrors, ListManagedEnvironmentVariablesResponses, ListMcpsData, ListMcpsErrors, ListMcpsResponses, ListMetricLabelKeysData, ListMetricLabelKeysErrors, ListMetricLabelKeysResponses, ListMetricLabelValuesData, ListMetricLabelValuesErrors, ListMetricLabelValuesResponses, ListMetricNamesData, ListMetricNamesErrors, ListMetricNamesResponses, ListModelsData, ListModelsErrors, ListModelsResponses, ListMonitorsData, ListMonitorsErrors, ListMonitorsResponses, ListNotificationProvidersData, ListNotificationProvidersErrors, ListNotificationProvidersResponses, ListNotificationRoutesData, ListNotificationRoutesErrors, ListNotificationRoutesResponses, ListOidcProvidersData, ListOidcProvidersResponses, ListOidcProviderUsersData, ListOidcProviderUsersErrors, ListOidcProviderUsersResponses, ListOidcRoleMappingsData, ListOidcRoleMappingsResponses, ListOnDemandCertsData, ListOnDemandCertsErrors, ListOnDemandCertsResponses, ListOrdersData, ListOrdersErrors, ListOrdersResponses, ListPeersData, ListPeersErrors, ListPeersResponses, ListPendingActionsData, ListPendingActionsErrors, ListPendingActionsResponses, ListPgUpgradesData, ListPgUpgradesErrors, ListPgUpgradesResponses, ListPresetsData, ListPresetsErrors, ListPresetsResponses, ListProjectAccessData, ListProjectAccessErrors, ListProjectAccessResponses, ListProjectAlarmsData, ListProjectAlarmsErrors, ListProjectAlarmsResponses, ListProjectScansData, ListProjectScansErrors, ListProjectScansResponses, ListProjectSecretsData, ListProjectSecretsErrors, ListProjectSecretsResponses, ListProjectServicesData, ListProjectServicesErrors, ListProjectServicesResponses, ListProjectTemplatesData, ListProjectTemplatesErrors, ListProjectTemplatesResponses, ListProjectTemplateTagsData, ListProjectTemplateTagsErrors, ListProjectTemplateTagsResponses, ListProviderKeysData, ListProviderKeysErrors, ListProviderKeysResponses, ListProviderZonesData, ListProviderZonesErrors, ListProviderZonesResponses, ListPublicProvidersData, ListPublicProvidersResponses, ListReleaseFilesData, ListReleaseFilesErrors, ListReleaseFilesResponses, ListReleasesData, ListReleasesErrors, ListReleasesResponses, ListRemoteExternalImagesData, ListRemoteExternalImagesErrors, ListRemoteExternalImagesResponses, ListRenewalAttemptsData, ListRenewalAttemptsErrors, ListRenewalAttemptsResponses, ListRepositoriesByConnectionData, ListRepositoriesByConnectionErrors, ListRepositoriesByConnectionResponses, ListRepositoriesByProviderData, ListRepositoriesByProviderErrors, ListRepositoriesByProviderResponses, ListRestoreRunsForServiceData, ListRestoreRunsForServiceErrors, ListRestoreRunsForServiceResponses, ListRootContainersData, ListRootContainersErrors, ListRootContainersResponses, ListRoutesData, ListRoutesErrors, ListRoutesResponses, ListS3SourcesData, ListS3SourcesErrors, ListS3SourcesResponses, ListSandboxesData, ListSandboxesErrors, ListSandboxesResponses, ListScheduleRunJobsData, ListScheduleRunJobsErrors, ListScheduleRunJobsResponses, ListScheduleRunsData, ListScheduleRunsErrors, ListScheduleRunsResponses, ListScheduleServicesData, ListScheduleServicesErrors, ListScheduleServicesResponses, ListSecretsData, ListSecretsErrors, ListSecretsResponses, ListServiceHealthStatusesData, ListServiceHealthStatusesErrors, ListServiceHealthStatusesResponses, ListServiceProjectsData, ListServiceProjectsErrors, ListServiceProjectsResponses, ListServiceSchedulesData, ListServiceSchedulesErrors, ListServiceSchedulesResponses, ListServicesData, ListServicesErrors, ListServicesResponses, ListSkillsData, ListSkillsErrors, ListSkillsResponses, ListSnapshotsData, ListSnapshotsErrors, ListSnapshotsResponses, ListSourceBackupsData, ListSourceBackupsErrors, ListSourceBackupsResponses, ListSourceFilesData, ListSourceFilesErrors, ListSourceFilesResponses, ListSourceMapsData, ListSourceMapsErrors, ListSourceMapsResponses, ListSourcesData, ListSourcesErrors, ListSourcesResponses, ListStaticBundlesData, ListStaticBundlesErrors, ListStaticBundlesResponses, ListSyncedRepositoriesData, ListSyncedRepositoriesErrors, ListSyncedRepositoriesResponses, ListSystemAlarmsData, ListSystemAlarmsErrors, ListSystemAlarmsResponses, ListTeamMembersData, ListTeamMembersErrors, ListTeamMembersResponses, ListTeamProjectsData, ListTeamProjectsErrors, ListTeamProjectsResponses, ListTeamsData, ListTeamsErrors, ListTeamsResponses, ListThreadArtifactsData, ListThreadArtifactsErrors, ListThreadArtifactsResponses, ListTraefikDiscoveredRoutesData, ListTraefikDiscoveredRoutesErrors, ListTraefikDiscoveredRoutesResponses, ListUserPendingActionsData, ListUserPendingActionsErrors, ListUserPendingActionsResponses, ListUsersData, ListUsersErrors, ListUsersResponses, ListWebhooksData, ListWebhooksErrors, ListWebhooksResponses, LoginData, LoginErrors, LoginResponses, LogoutData, LogoutErrors, LogoutResponses, LookupDnsARecordsData, LookupDnsARecordsErrors, LookupDnsARecordsResponses, MintEnrollmentTokenData, MintEnrollmentTokenErrors, MintEnrollmentTokenResponses, MkdirData, MkdirErrors, MkdirResponses, NodeHeartbeatData, NodeHeartbeatErrors, NodeHeartbeatResponses, NodeMetricsGetAlertRulesData, NodeMetricsGetAlertRulesErrors, NodeMetricsGetAlertRulesResponses, NodeMetricsGetRangeData, NodeMetricsGetRangeErrors, NodeMetricsGetRangeResponses, NodeMetricsUpdateAlertRuleData, NodeMetricsUpdateAlertRuleErrors, NodeMetricsUpdateAlertRuleResponses, ObservabilityFullEventData, ObservabilityFullEventErrors, ObservabilityFullEventResponses, ObservabilityListEventsData, ObservabilityListEventsErrors, ObservabilityListEventsResponses, OidcCallbackData, PatchAdminGateData, PatchAdminGateErrors, PatchAdminGateResponses, PatchPreviewGatewaySettingsData, PatchPreviewGatewaySettingsErrors, PatchPreviewGatewaySettingsResponses, PauseDeploymentData, PauseDeploymentErrors, PauseDeploymentResponses, PauseSandboxData, PauseSandboxErrors, PauseSandboxResponses, PlanRestoreData, PlanRestoreErrors, PlanRestoreResponses, PostDnsAckData, PostDnsAckErrors, PostDnsAckResponses, PreviewAlertData, PreviewAlertErrors, PreviewAlertResponses, PreviewFunnelMetricsData, PreviewFunnelMetricsErrors, PreviewFunnelMetricsResponses, PreviewHostnameModeData, PreviewHostnameModeErrors, PreviewHostnameModeResponses, PromoteClusterMemberData, PromoteClusterMemberErrors, PromoteClusterMemberResponses, PromoteDeploymentData, PromoteDeploymentErrors, PromoteDeploymentResponses, ProvisionDomainData, ProvisionDomainErrors, ProvisionDomainResponses, PurgeProjectLogsData, PurgeProjectLogsErrors, PurgeProjectLogsResponses, PushExternalImageData, PushExternalImageErrors, PushExternalImageResponses, QueryDataData, QueryDataErrors, QueryDataResponses, QueryGenaiTracesData, QueryGenaiTracesErrors, QueryGenaiTracesResponses, QueryLogsData, QueryLogsErrors, QueryLogsResponses, QueryMetricsData, QueryMetricsErrors, QueryMetricsResponses, QuerySpanStatsData, QuerySpanStatsErrors, QuerySpanStatsResponses, QueryTracesData, QueryTracesErrors, QueryTracesResponses, QueryTraceSummariesData, QueryTraceSummariesErrors, QueryTraceSummariesResponses, ReadEntityRowsData, ReadEntityRowsErrors, ReadEntityRowsResponses, ReadFileData, ReadFileErrors, ReadFileResponses, ReAnalyzeData, ReAnalyzeErrors, ReAnalyzeResponses, ReassignProjectCustomDomainData, ReassignProjectCustomDomainErrors, ReassignProjectCustomDomainResponses, ReconcileCloudBackupSourceData, ReconcileCloudBackupSourceResponses, RecordConsoleEventData, RecordConsoleEventErrors, RecordConsoleEventResponses, RecordEventMetricsData, RecordEventMetricsErrors, RecordEventMetricsResponses, RecordFlagExposureData, RecordFlagExposureErrors, RecordFlagExposureResponses, RecordSpeedMetricsData, RecordSpeedMetricsErrors, RecordSpeedMetricsResponses, RefreshAiProviderStatusData, RefreshAiProviderStatusErrors, RefreshAiProviderStatusResponses, RefreshProviderModelsData, RefreshProviderModelsErrors, RefreshProviderModelsResponses, RefreshRouteTableData, RefreshRouteTableErrors, RefreshRouteTableResponses, RegenerateDsnData, RegenerateDsnErrors, RegenerateDsnResponses, RegisterExternalImageData, RegisterExternalImageErrors, RegisterExternalImageResponses, RegisterNodeData, RegisterNodeErrors, RegisterNodeResponses, ReinstallGitlabWebhookData, ReinstallGitlabWebhookErrors, ReinstallGitlabWebhookResponses, RejectPendingActionData, RejectPendingActionErrors, RejectPendingActionResponses, RejectUserPendingActionData, RejectUserPendingActionErrors, RejectUserPendingActionResponses, ReloadPluginsData, ReloadPluginsErrors, ReloadPluginsResponses, RemoveClusterMemberData, RemoveClusterMemberErrors, RemoveClusterMemberResponses, RemoveManagedDomainData, RemoveManagedDomainErrors, RemoveManagedDomainResponses, RemoveRoleData, RemoveRoleErrors, RemoveRoleResponses, RemoveTeamMemberData, RemoveTeamMemberErrors, RemoveTeamMemberResponses, RenameConversationData, RenameConversationErrors, RenameConversationResponses, RenameUserConversationData, RenameUserConversationErrors, RenameUserConversationResponses, RenewDomainData, RenewDomainErrors, RenewDomainResponses, RepointContinuousArchiveSourceData, RepointContinuousArchiveSourceErrors, RepointContinuousArchiveSourceResponses, RequestDiscoveredRouteCertData, RequestDiscoveredRouteCertErrors, RequestDiscoveredRouteCertResponses, RequestPasswordResetData, RequestPasswordResetErrors, RequestPasswordResetResponses, ResetPasswordData, ResetPasswordErrors, ResetPasswordResponses, ResizeSandboxData, ResizeSandboxErrors, ResizeSandboxResponses, ResolveAlarmData, ResolveAlarmErrors, ResolveAlarmResponses, ResolvePermissionData, ResolvePermissionErrors, ResolvePermissionResponses, ResolveSystemAlarmData, ResolveSystemAlarmErrors, ResolveSystemAlarmResponses, ResolveUserPermissionData, ResolveUserPermissionErrors, ResolveUserPermissionResponses, RestartContainerData, RestartContainerErrors, RestartContainerResponses, RestartPreviewGatewayData, RestartPreviewGatewayErrors, RestartPreviewGatewayResponses, RestartSandboxData, RestartSandboxErrors, RestartSandboxResponses, RestoreApplicationData, RestoreApplicationErrors, RestoreApplicationResponses, RestoreFlagData, RestoreFlagErrors, RestoreFlagResponses, RestoreUserConversationData, RestoreUserConversationErrors, RestoreUserConversationResponses, RestoreUserData, RestoreUserErrors, RestoreUserResponses, ResumeDeploymentData, ResumeDeploymentErrors, ResumeDeploymentResponses, ResumeSandboxData, ResumeSandboxErrors, ResumeSandboxResponses, RetryClusterData, RetryClusterErrors, RetryClusterResponses, RetryDeliveryData, RetryDeliveryErrors, RetryDeliveryResponses, RetryFacetBackfillData, RetryFacetBackfillErrors, RetryFacetBackfillResponses, RetryPgUpgradeData, RetryPgUpgradeErrors, RetryPgUpgradeResponses, RetryRunData, RetryRunErrors, RetryRunResponses, RevealGlobalMcpConfigData, RevealGlobalMcpConfigErrors, RevealGlobalMcpConfigResponses, RevealMcpConfigData, RevealMcpConfigErrors, RevealMcpConfigResponses, RevealNotificationProviderConfigData, RevealNotificationProviderConfigErrors, RevealNotificationProviderConfigResponses, RevealServiceEnvironmentVariablesData, RevealServiceEnvironmentVariablesErrors, RevealServiceEnvironmentVariablesResponses, RevealServiceParameterData, RevealServiceParameterErrors, RevealServiceParameterResponses, RevenueCreateIntegrationData, RevenueCreateIntegrationErrors, RevenueCreateIntegrationResponses, RevenueDeleteIntegrationData, RevenueDeleteIntegrationResponses, RevenueGlobalEventsData, RevenueGlobalEventsResponses, RevenueImportInvoicesCsvData, RevenueImportInvoicesCsvErrors, RevenueImportInvoicesCsvResponses, RevenueImportSubscriptionsCsvData, RevenueImportSubscriptionsCsvErrors, RevenueImportSubscriptionsCsvResponses, RevenueListIntegrationsData, RevenueListIntegrationsResponses, RevenueListProvidersData, RevenueListProvidersResponses, RevenueMetricsCustomersData, RevenueMetricsCustomersResponses, RevenueMetricsGlobalMrrData, RevenueMetricsGlobalMrrResponses, RevenueMetricsGlobalSummaryData, RevenueMetricsGlobalSummaryResponses, RevenueMetricsMrrData, RevenueMetricsMrrResponses, RevenueMetricsSummaryData, RevenueMetricsSummaryResponses, RevenueRecentEventsData, RevenueRecentEventsResponses, RevenueRotateTokenData, RevenueRotateTokenResponses, RevenueUpdateConfigData, RevenueUpdateConfigErrors, RevenueUpdateConfigResponses, RevenueUpdateSecretData, RevenueUpdateSecretErrors, RevenueUpdateSecretResponses, RevokeAnalyticsIngestKeyData, RevokeAnalyticsIngestKeyErrors, RevokeAnalyticsIngestKeyResponses, RevokeDsnData, RevokeDsnErrors, RevokeDsnResponses, RevokeEmailDomainProjectData, RevokeEmailDomainProjectErrors, RevokeEmailDomainProjectResponses, RevokeEnrollmentTokenData, RevokeEnrollmentTokenErrors, RevokeEnrollmentTokenResponses, RevokeJoinTokenData, RevokeJoinTokenErrors, RevokeJoinTokenResponses, RevokeProjectAccessData, RevokeProjectAccessErrors, RevokeProjectAccessResponses, RollbackPgUpgradeData, RollbackPgUpgradeErrors, RollbackPgUpgradeResponses, RollbackToDeploymentData, RollbackToDeploymentErrors, RollbackToDeploymentResponses, RootfsGcData, RootfsGcResponses, RootfsReportData, RootfsReportResponses, RotateAnalyticsIngestKeyData, RotateAnalyticsIngestKeyErrors, RotateAnalyticsIngestKeyResponses, RotateApiKeyData, RotateApiKeyErrors, RotateApiKeyResponses, RotateClusterCaData, RotateClusterCaErrors, RotateClusterCaResponses, RotateDeploymentTokenData, RotateDeploymentTokenErrors, RotateDeploymentTokenResponses, RunBackupForSourceData, RunBackupForSourceErrors, RunBackupForSourceResponses, RunConnectionHealthCheckData, RunConnectionHealthCheckErrors, RunConnectionHealthCheckResponses, RunExternalServiceBackupData, RunExternalServiceBackupErrors, RunExternalServiceBackupResponses, RunScheduleNowData, RunScheduleNowErrors, RunScheduleNowResponses, SandboxCreatePreviewLinkData, SandboxCreatePreviewLinkErrors, SandboxCreatePreviewLinkResponses, SaveAgentTokenData, SaveAgentTokenErrors, SaveAgentTokenResponses, SaveAiProviderCredentialData, SaveAiProviderCredentialErrors, SaveAiProviderCredentialResponses, SearchLogsData, SearchLogsErrors, SearchLogsResponses, SendEmailData, SendEmailErrors, SendEmailResponses, SendFailureReportData, SendFailureReportErrors, SendFailureReportResponses, SendProjectAiMessageData, SendProjectAiMessageErrors, SendProjectAiMessageResponses, SendUserMessageData, SendUserMessageErrors, SendUserMessageResponses, SetAiDataAccessData, SetAiDataAccessErrors, SetAiDataAccessResponses, SetAlternateSourcesData, SetAlternateSourcesErrors, SetAlternateSourcesResponses, SetApplicationPrimaryProjectData, SetApplicationPrimaryProjectErrors, SetApplicationPrimaryProjectResponses, SetDefaultS3SourceData, SetDefaultS3SourceErrors, SetDefaultS3SourceResponses, SetFlagEnvironmentData, SetFlagEnvironmentErrors, SetFlagEnvironmentResponses, SetPreviewPasswordData, SetPreviewPasswordErrors, SetPreviewPasswordResponses, SetTraefikDiscoveredRouteEnabledData, SetTraefikDiscoveredRouteEnabledErrors, SetTraefikDiscoveredRouteEnabledResponses, SetupDnsChallengeData, SetupDnsChallengeErrors, SetupDnsChallengeResponses, SetupDnsData, SetupDnsErrors, SetupDnsResponses, SetupEmailTrackingData, SetupEmailTrackingErrors, SetupEmailTrackingResponses, SetupMfaData, SetupMfaErrors, SetupMfaResponses, SilenceAlarmData, SilenceAlarmErrors, SilenceAlarmResponses, SilenceSystemAlarmData, SilenceSystemAlarmErrors, SilenceSystemAlarmResponses, SleepEnvironmentData, SleepEnvironmentErrors, SleepEnvironmentResponses, SmokeTestAgentData, SmokeTestAgentErrors, SmokeTestAgentResponses, SourceSandboxData, SourceSandboxErrors, SourceSandboxResponses, StartAnalysisData, StartAnalysisErrors, StartAnalysisResponses, StartContainerData, StartContainerErrors, StartContainerResponses, StartFixData, StartFixErrors, StartFixResponses, StartGitProviderOauthData, StartGitProviderOauthErrors, StartOidcLoginBySlugData, StartOidcLoginBySlugErrors, StartPgUpgradeData, StartPgUpgradeErrors, StartPgUpgradeResponses, StartRestoreData, StartRestoreErrors, StartRestoreResponses, StartServiceData, StartServiceErrors, StartServiceResponses, StartUpdateData, StartUpdateErrors, StartUpdateResponses, StatPathData, StatPathErrors, StatPathResponses, StopContainerData, StopContainerErrors, StopContainerResponses, StopSandboxData, StopSandboxErrors, StopSandboxResponses, StopServiceData, StopServiceErrors, StopServiceResponses, StopTurnData, StopTurnErrors, StopTurnResponses, StopUserTurnData, StopUserTurnErrors, StopUserTurnResponses, StorageSummaryData, StorageSummaryErrors, StorageSummaryResponses, StreamContainerMetricsData, StreamContainerMetricsErrors, StreamContainerMetricsResponses, StreamEventsData, StreamEventsErrors, StreamEventsResponses, StreamRunEventsData, StreamRunEventsErrors, StreamRunEventsResponses, SyncRepositoriesData, SyncRepositoriesErrors, SyncRepositoriesResponses, TailDeploymentJobLogsData, TailDeploymentJobLogsErrors, TailLogsData, TailLogsErrors, TailLogsResponses, TeardownDeploymentData, TeardownDeploymentErrors, TeardownDeploymentResponses, TeardownEnvironmentData, TeardownEnvironmentErrors, TeardownEnvironmentResponses, TerminalData, TerminalErrors, TestNotificationProviderData, TestNotificationProviderErrors, TestNotificationProviderResponses, TestOidcProviderData, TestOidcProviderResponses, TestProviderConnectionData, TestProviderConnectionErrors, TestProviderConnectionResponses, TestProviderData, TestProviderErrors, TestProviderKeyByIdData, TestProviderKeyByIdErrors, TestProviderKeyByIdResponses, TestProviderKeyInlineData, TestProviderKeyInlineErrors, TestProviderKeyInlineResponses, TestProviderResponses, TestS3ConnectionPreviewData, TestS3ConnectionPreviewErrors, TestS3ConnectionPreviewResponses, TestS3SourceConnectionData, TestS3SourceConnectionErrors, TestS3SourceConnectionResponses, TrackClickData, TrackClickErrors, TrackOpenData, TrackOpenErrors, TrackOpenResponses, TriggerAgentData, TriggerAgentErrors, TriggerAgentResponses, TriggerProjectPipelineData, TriggerProjectPipelineErrors, TriggerProjectPipelineResponses, TriggerScanData, TriggerScanErrors, TriggerScanResponses, TriggerServiceHealthCheckData, TriggerServiceHealthCheckErrors, TriggerServiceHealthCheckResponses, TriggerWeeklyDigestData, TriggerWeeklyDigestErrors, TriggerWeeklyDigestResponses, UnlinkApplicationProjectData, UnlinkApplicationProjectErrors, UnlinkApplicationProjectResponses, UnlinkServiceFromProjectData, UnlinkServiceFromProjectErrors, UnlinkServiceFromProjectResponses, UpdateAgentData, UpdateAgentErrors, UpdateAgentResponses, UpdateAiProviderData, UpdateAiProviderErrors, UpdateAiProviderPreferenceData, UpdateAiProviderPreferenceErrors, UpdateAiProviderPreferenceResponses, UpdateAiProviderResponses, UpdateAiSummaryPreferenceData, UpdateAiSummaryPreferenceErrors, UpdateAiSummaryPreferenceResponses, UpdateAlertData, UpdateAlertErrors, UpdateAlertResponses, UpdateAlertRuleData, UpdateAlertRuleErrors, UpdateAlertRuleResponses, UpdateAnalyticsIngestKeyData, UpdateAnalyticsIngestKeyErrors, UpdateAnalyticsIngestKeyResponses, UpdateApiKeyData, UpdateApiKeyErrors, UpdateApiKeyResponses, UpdateApplicationWorkspaceData, UpdateApplicationWorkspaceErrors, UpdateApplicationWorkspaceResponses, UpdateAutomaticDeployData, UpdateAutomaticDeployErrors, UpdateAutomaticDeployResponses, UpdateBackupScheduleData, UpdateBackupScheduleErrors, UpdateBackupScheduleResponses, UpdateCloudFeaturesData, UpdateCloudFeaturesResponses, UpdateCloudflareProviderData, UpdateCloudflareProviderErrors, UpdateCloudflareProviderResponses, UpdateConnectionTokenData, UpdateConnectionTokenErrors, UpdateConnectionTokenResponses, UpdateCustomDomainData, UpdateCustomDomainErrors, UpdateCustomDomainResponses, UpdateDashboardData, UpdateDashboardErrors, UpdateDashboardResponses, UpdateDeploymentTokenData, UpdateDeploymentTokenErrors, UpdateDeploymentTokenResponses, UpdateEmailProviderData, UpdateEmailProviderErrors, UpdateEmailProviderResponses, UpdateEnvironmentSettingsData, UpdateEnvironmentSettingsErrors, UpdateEnvironmentSettingsResponses, UpdateEnvironmentSubdomainData, UpdateEnvironmentSubdomainErrors, UpdateEnvironmentSubdomainResponses, UpdateEnvironmentVariableData, UpdateEnvironmentVariableErrors, UpdateEnvironmentVariableResponses, UpdateErrorGroupData, UpdateErrorGroupErrors, UpdateErrorGroupResponses, UpdateFlagData, UpdateFlagErrors, UpdateFlagResponses, UpdateFunnelData, UpdateFunnelErrors, UpdateFunnelResponses, UpdateGitProviderCredentialsData, UpdateGitProviderCredentialsErrors, UpdateGitProviderCredentialsResponses, UpdateGitSettingsData, UpdateGitSettingsErrors, UpdateGitSettingsResponses, UpdateGlobalMcpData, UpdateGlobalMcpErrors, UpdateGlobalMcpResponses, UpdateGlobalSkillData, UpdateGlobalSkillErrors, UpdateGlobalSkillResponses, UpdateIncidentStatusData, UpdateIncidentStatusErrors, UpdateIncidentStatusResponses, UpdateIpAccessControlData, UpdateIpAccessControlErrors, UpdateIpAccessControlResponses, UpdateManagedDomainData, UpdateManagedDomainErrors, UpdateManagedDomainResponses, UpdateMcpData, UpdateMcpErrors, UpdateMcpResponses, UpdateNotificationEmailProviderData, UpdateNotificationEmailProviderErrors, UpdateNotificationEmailProviderResponses, UpdateNotificationProviderData, UpdateNotificationProviderErrors, UpdateNotificationProviderResponses, UpdateNotificationRouteData, UpdateNotificationRouteErrors, UpdateNotificationRouteResponses, UpdateOidcProviderData, UpdateOidcProviderResponses, UpdatePermissionModeData, UpdatePermissionModeErrors, UpdatePermissionModeResponses, UpdatePreferencesData, UpdatePreferencesErrors, UpdatePreferencesResponses, UpdateProjectCloudTelemetryData, UpdateProjectCloudTelemetryErrors, UpdateProjectCloudTelemetryResponses, UpdateProjectData, UpdateProjectDeploymentConfigData, UpdateProjectDeploymentConfigErrors, UpdateProjectDeploymentConfigResponses, UpdateProjectErrors, UpdateProjectResponses, UpdateProjectSecretData, UpdateProjectSecretErrors, UpdateProjectSecretResponses, UpdateProjectSettingsData, UpdateProjectSettingsErrors, UpdateProjectSettingsResponses, UpdateProviderData, UpdateProviderErrors, UpdateProviderKeyData, UpdateProviderKeyErrors, UpdateProviderKeyResponses, UpdateProviderModelData, UpdateProviderModelErrors, UpdateProviderModelResponses, UpdateProviderResponses, UpdateRouteData, UpdateRouteErrors, UpdateRouteResponses, UpdateS3SourceData, UpdateS3SourceErrors, UpdateS3SourceResponses, UpdateSelfData, UpdateSelfErrors, UpdateSelfResponses, UpdateServiceData, UpdateServiceErrors, UpdateServiceResourcesData, UpdateServiceResourcesErrors, UpdateServiceResourcesResponses, UpdateServiceResponses, UpdateServiceTemplateRuntimeData, UpdateServiceTemplateRuntimeErrors, UpdateServiceTemplateRuntimeResponses, UpdateSessionDurationData, UpdateSessionDurationErrors, UpdateSessionDurationResponses, UpdateSettingsData, UpdateSettingsErrors, UpdateSettingsResponses, UpdateSkillData, UpdateSkillErrors, UpdateSkillResponses, UpdateSlackProviderData, UpdateSlackProviderErrors, UpdateSlackProviderResponses, UpdateSpeedMetricsData, UpdateSpeedMetricsErrors, UpdateSpeedMetricsResponses, UpdateTeamData, UpdateTeamErrors, UpdateTeamMemberRoleData, UpdateTeamMemberRoleErrors, UpdateTeamMemberRoleResponses, UpdateTeamResponses, UpdateUserData, UpdateUserErrors, UpdateUserPermissionModeData, UpdateUserPermissionModeErrors, UpdateUserPermissionModeResponses, UpdateUserResponses, UpdateWebhookData, UpdateWebhookErrors, UpdateWebhookProviderData, UpdateWebhookProviderErrors, UpdateWebhookProviderResponses, UpdateWebhookResponses, UpgradePreviewGatewayData, UpgradePreviewGatewayErrors, UpgradePreviewGatewayResponses, UpgradeProjectServiceTemplateData, UpgradeProjectServiceTemplateErrors, UpgradeProjectServiceTemplateResponses, UpgradeServiceData, UpgradeServiceErrors, UpgradeServiceResponses, UploadApplicationWorkspaceFilesData, UploadApplicationWorkspaceFilesErrors, UploadApplicationWorkspaceFilesResponses, UploadGlobalSkillData, UploadGlobalSkillErrors, UploadGlobalSkillResponses, UploadGlobalWorkspaceFilesData, UploadGlobalWorkspaceFilesErrors, UploadGlobalWorkspaceFilesResponses, UploadReleaseFileData, UploadReleaseFileErrors, UploadReleaseFileResponses, UploadSkillData, UploadSkillErrors, UploadSkillResponses, UploadSourceFileData, UploadSourceFileErrors, UploadSourceFileResponses, UploadSourceMapData, UploadSourceMapErrors, UploadSourceMapResponses, UploadStaticBundleData, UploadStaticBundleErrors, UploadStaticBundleResponses, UploadUserConversationAttachmentData, UploadUserConversationAttachmentErrors, UploadUserConversationAttachmentResponses, UpsertSecretData, UpsertSecretErrors, UpsertSecretResponses, ValidateConnectionData, ValidateConnectionErrors, ValidateConnectionResponses, ValidateEmailData, ValidateEmailErrors, ValidateEmailResponses, VerifyAndEnableMfaData, VerifyAndEnableMfaErrors, VerifyAndEnableMfaResponses, VerifyDomainData, VerifyDomainErrors, VerifyDomainResponses, VerifyEmailData, VerifyEmailErrors, VerifyEmailResponses, VerifyManagedDomainData, VerifyManagedDomainErrors, VerifyManagedDomainResponses, VerifyMfaChallengeData, VerifyMfaChallengeErrors, VerifyMfaChallengeResponses, VerifyStepUpData, VerifyStepUpErrors, VerifyStepUpResponses, WakeEnvironmentData, WakeEnvironmentErrors, WakeEnvironmentResponses, WebhookTriggerData, WebhookTriggerErrors, WebhookTriggerResponses, WorkflowDryRunData, WorkflowDryRunErrors, WorkflowDryRunResponses, WriteApplicationWorkspaceFilesData, WriteApplicationWorkspaceFilesErrors, WriteApplicationWorkspaceFilesResponses, WriteFileData, WriteFileErrors, WriteFileResponses, WriteFilesData, WriteFilesErrors, WriteFilesResponses } from './types.gen'; +import type { AcknowledgeAlarmData, AcknowledgeAlarmErrors, AcknowledgeAlarmResponses, AcknowledgeSystemAlarmData, AcknowledgeSystemAlarmErrors, AcknowledgeSystemAlarmResponses, ActivateAiProviderData, ActivateAiProviderErrors, ActivateAiProviderResponses, ActivateApiKeyData, ActivateApiKeyErrors, ActivateApiKeyResponses, ActivateConnectionData, ActivateConnectionErrors, ActivateConnectionResponses, ActivateProviderData, ActivateProviderErrors, ActivateProviderResponses, AddClusterMemberData, AddClusterMemberErrors, AddClusterMemberResponses, AddContextData, AddContextErrors, AddContextResponses, AddEnvironmentDomainData, AddEnvironmentDomainErrors, AddEnvironmentDomainResponses, AddEventsData, AddEventsErrors, AddEventsResponses, AddManagedDomainData, AddManagedDomainErrors, AddManagedDomainResponses, AddProviderModelData, AddProviderModelErrors, AddProviderModelResponses, AddSessionReplayEventsData, AddSessionReplayEventsErrors, AddSessionReplayEventsResponses, AddTeamMemberData, AddTeamMemberErrors, AddTeamMemberResponses, AdminDrainNodeData, AdminDrainNodeErrors, AdminDrainNodeResponses, AdminDrainStatusData, AdminDrainStatusErrors, AdminDrainStatusResponses, AdminGetNodeData, AdminGetNodeErrors, AdminGetNodeResponses, AdminListNodeContainersData, AdminListNodeContainersErrors, AdminListNodeContainersResponses, AdminListNodesData, AdminListNodesErrors, AdminListNodesResponses, AdminRemoveNodeData, AdminRemoveNodeErrors, AdminRemoveNodeResponses, AdminUndrainNodeData, AdminUndrainNodeErrors, AdminUndrainNodeResponses, AggregateApiTrafficData, AggregateApiTrafficErrors, AggregateApiTrafficResponses, ApplyHostnameModeData, ApplyHostnameModeErrors, ApplyHostnameModeResponses, ArchiveApplicationData, ArchiveApplicationErrors, ArchiveApplicationResponses, ArchiveConversationData, ArchiveConversationErrors, ArchiveConversationResponses, ArchiveFlagData, ArchiveFlagErrors, ArchiveFlagResponses, ArchiveUserConversationData, ArchiveUserConversationErrors, ArchiveUserConversationResponses, AssignRoleData, AssignRoleErrors, AssignRoleResponses, AttachScheduleServicesData, AttachScheduleServicesErrors, AttachScheduleServicesResponses, AuthorizeEmailDomainProjectData, AuthorizeEmailDomainProjectErrors, AuthorizeEmailDomainProjectResponses, BlobCopyData, BlobCopyErrors, BlobCopyResponses, BlobDeleteData, BlobDeleteErrors, BlobDeleteResponses, BlobDisableData, BlobDisableErrors, BlobDisableResponses, BlobDownloadData, BlobDownloadErrors, BlobDownloadResponses, BlobEnableData, BlobEnableErrors, BlobEnableResponses, BlobHeadData, BlobHeadErrors, BlobHeadResponses, BlobListData, BlobListErrors, BlobListResponses, BlobPutData, BlobPutErrors, BlobPutResponses, BlobStatusData, BlobStatusErrors, BlobStatusResponses, BlobUpdateData, BlobUpdateErrors, BlobUpdateResponses, CancelBackupData, CancelBackupErrors, CancelBackupResponses, CancelBulkActivationJobData, CancelBulkActivationJobErrors, CancelBulkActivationJobResponses, CancelData, CancelDeploymentData, CancelDeploymentErrors, CancelDeploymentResponses, CancelDomainOrderData, CancelDomainOrderErrors, CancelDomainOrderResponses, CancelErrors, CancelPgUpgradeData, CancelPgUpgradeErrors, CancelPgUpgradeResponses, CancelResponses, CancelRunData, CancelRunErrors, CancelRunResponses, CancelScheduleRunData, CancelScheduleRunErrors, CancelScheduleRunResponses, ChangePasswordSelfData, ChangePasswordSelfErrors, ChangePasswordSelfResponses, ChangeProjectSourceData, ChangeProjectSourceErrors, ChangeProjectSourceResponses, ChangeRequiredPasswordData, ChangeRequiredPasswordErrors, ChangeRequiredPasswordResponses, ChatCompletionsData, ChatCompletionsErrors, ChatCompletionsResponses, CheckAnalyticsHasEventsData, CheckAnalyticsHasEventsErrors, CheckAnalyticsHasEventsResponses, CheckCommitExistsData, CheckCommitExistsErrors, CheckCommitExistsResponses, CheckDomainStatusData, CheckDomainStatusErrors, CheckDomainStatusResponses, CheckExplorerSupportData, CheckExplorerSupportErrors, CheckExplorerSupportResponses, CheckForUpdateData, CheckForUpdateErrors, CheckForUpdateResponses, CheckIpBlockedData, CheckIpBlockedErrors, CheckIpBlockedResponses, CheckProviderDeletionSafetyData, CheckProviderDeletionSafetyErrors, CheckProviderDeletionSafetyResponses, ChunkUploadOptionsData, ChunkUploadOptionsResponses, CleanupExpiredBackupsData, CleanupExpiredBackupsErrors, CleanupExpiredBackupsResponses, ClearPreviewPasswordData, ClearPreviewPasswordErrors, ClearPreviewPasswordResponses, CliDeviceApproveData, CliDeviceApproveErrors, CliDeviceApproveResponses, CliDeviceDenyData, CliDeviceDenyErrors, CliDeviceDenyResponses, CliDeviceLookupData, CliDeviceLookupErrors, CliDeviceLookupResponses, CliDevicePollData, CliDevicePollErrors, CliDevicePollResponses, CliDeviceStartData, CliDeviceStartErrors, CliDeviceStartResponses, CliLogoutData, CliLogoutErrors, CliLogoutResponses, ClusterDnsStatusData, ClusterDnsStatusErrors, ClusterDnsStatusResponses, CmdData, CmdErrors, CmdKillData, CmdKillErrors, CmdKillResponses, CmdLogsData, CmdLogsErrors, CmdLogsResponses, CmdResponses, ConfirmPendingActionData, ConfirmPendingActionErrors, ConfirmPendingActionResponses, ConfirmUserPendingActionData, ConfirmUserPendingActionErrors, ConfirmUserPendingActionResponses, ContainerMetricsGetHistoryData, ContainerMetricsGetHistoryErrors, ContainerMetricsGetHistoryResponses, ControlApplicationWorkspaceData, ControlApplicationWorkspaceErrors, ControlApplicationWorkspaceResponses, CreateAgentData, CreateAgentErrors, CreateAgentResponses, CreateAlertData, CreateAlertErrors, CreateAlertResponses, CreateAlertRuleData, CreateAlertRuleErrors, CreateAlertRuleResponses, CreateAnalyticsIngestKeyData, CreateAnalyticsIngestKeyErrors, CreateAnalyticsIngestKeyResponses, CreateApiKeyData, CreateApiKeyErrors, CreateApiKeyResponses, CreateApplicationConversationData, CreateApplicationConversationErrors, CreateApplicationConversationResponses, CreateApplicationData, CreateApplicationErrors, CreateApplicationPreviewLinkData, CreateApplicationPreviewLinkErrors, CreateApplicationPreviewLinkResponses, CreateApplicationProjectData, CreateApplicationProjectErrors, CreateApplicationProjectResponses, CreateApplicationResponses, CreateBackupScheduleData, CreateBackupScheduleErrors, CreateBackupScheduleResponses, CreateBitbucketProviderData, CreateBitbucketProviderErrors, CreateBitbucketProviderResponses, CreateBulkActivationJobData, CreateBulkActivationJobErrors, CreateBulkActivationJobResponses, CreateCloudflareProviderData, CreateCloudflareProviderErrors, CreateCloudflareProviderResponses, CreateConversationData, CreateConversationErrors, CreateConversationResponses, CreateCustomDomainData, CreateCustomDomainErrors, CreateCustomDomainResponses, CreateDashboardData, CreateDashboardErrors, CreateDashboardResponses, CreateDeploymentTokenData, CreateDeploymentTokenErrors, CreateDeploymentTokenResponses, CreateDnsProviderData, CreateDnsProviderErrors, CreateDnsProviderResponses, CreateDomainData, CreateDomainErrors, CreateDomainResponses, CreateDsnData, CreateDsnErrors, CreateDsnResponses, CreateEmailDomainData, CreateEmailDomainErrors, CreateEmailDomainResponses, CreateEmailProviderData, CreateEmailProviderErrors, CreateEmailProviderResponses, CreateEnvironmentData, CreateEnvironmentErrors, CreateEnvironmentResponses, CreateEnvironmentVariableData, CreateEnvironmentVariableErrors, CreateEnvironmentVariableResponses, CreateFacetData, CreateFacetErrors, CreateFacetResponses, CreateFlagData, CreateFlagErrors, CreateFlagResponses, CreateFunnelData, CreateFunnelErrors, CreateFunnelResponses, CreateGenericProviderData, CreateGenericProviderErrors, CreateGenericProviderResponses, CreateGiteaPatProviderData, CreateGiteaPatProviderErrors, CreateGiteaPatProviderResponses, CreateGithubPatProviderData, CreateGithubPatProviderErrors, CreateGithubPatProviderResponses, CreateGitlabOauthProviderData, CreateGitlabOauthProviderErrors, CreateGitlabOauthProviderResponses, CreateGitlabPatProviderData, CreateGitlabPatProviderErrors, CreateGitlabPatProviderResponses, CreateGitProviderData, CreateGitProviderErrors, CreateGitProviderResponses, CreateGlobalConversationData, CreateGlobalConversationErrors, CreateGlobalConversationResponses, CreateGlobalMcpData, CreateGlobalMcpErrors, CreateGlobalMcpResponses, CreateGlobalSkillData, CreateGlobalSkillErrors, CreateGlobalSkillResponses, CreateGlobalWorkspacePreviewLinkData, CreateGlobalWorkspacePreviewLinkErrors, CreateGlobalWorkspacePreviewLinkResponses, CreateIncidentData, CreateIncidentErrors, CreateIncidentResponses, CreateIpAccessControlData, CreateIpAccessControlErrors, CreateIpAccessControlResponses, CreateMcpData, CreateMcpErrors, CreateMcpResponses, CreateMonitorData, CreateMonitorErrors, CreateMonitorResponses, CreateNotificationEmailProviderData, CreateNotificationEmailProviderErrors, CreateNotificationEmailProviderResponses, CreateNotificationProviderData, CreateNotificationProviderErrors, CreateNotificationProviderResponses, CreateNotificationRouteData, CreateNotificationRouteErrors, CreateNotificationRouteResponses, CreateOidcProviderData, CreateOidcProviderErrors, CreateOidcProviderResponses, CreateOidcRoleMappingData, CreateOidcRoleMappingResponses, CreateOrRecreateOrderData, CreateOrRecreateOrderErrors, CreateOrRecreateOrderResponses, CreatePlanData, CreatePlanErrors, CreatePlanResponses, CreatePrData, CreatePrErrors, CreateProjectData, CreateProjectErrors, CreateProjectFromTemplateData, CreateProjectFromTemplateErrors, CreateProjectFromTemplateResponses, CreateProjectReleaseData, CreateProjectReleaseErrors, CreateProjectReleaseResponses, CreateProjectResponses, CreateProjectSecretData, CreateProjectSecretErrors, CreateProjectSecretResponses, CreateProviderKeyData, CreateProviderKeyErrors, CreateProviderKeyResponses, CreatePrResponses, CreateReleaseData, CreateReleaseErrors, CreateReleaseResponses, CreateRouteData, CreateRouteErrors, CreateRouteResponses, CreateS3SourceData, CreateS3SourceErrors, CreateS3SourceResponses, CreateSandboxData, CreateSandboxErrors, CreateSandboxResponses, CreateServiceData, CreateServiceErrors, CreateServiceResponses, CreateSkillData, CreateSkillErrors, CreateSkillResponses, CreateSlackProviderData, CreateSlackProviderErrors, CreateSlackProviderResponses, CreateSnapshotData, CreateSnapshotErrors, CreateSnapshotResponses, CreateTeamData, CreateTeamErrors, CreateTeamResponses, CreateThreadArtifactData, CreateThreadArtifactErrors, CreateThreadArtifactResponses, CreateUserData, CreateUserErrors, CreateUserResponses, CreateWebhookData, CreateWebhookErrors, CreateWebhookProviderData, CreateWebhookProviderErrors, CreateWebhookProviderResponses, CreateWebhookResponses, DeactivateApiKeyData, DeactivateApiKeyErrors, DeactivateApiKeyResponses, DeactivateConnectionData, DeactivateConnectionErrors, DeactivateConnectionResponses, DeactivateProviderData, DeactivateProviderErrors, DeactivateProviderResponses, DeauthorizeDiscoveredRouteCertData, DeauthorizeDiscoveredRouteCertErrors, DeauthorizeDiscoveredRouteCertResponses, DeleteAgentData, DeleteAgentErrors, DeleteAgentResponses, DeleteAlertData, DeleteAlertErrors, DeleteAlertResponses, DeleteAlertRuleData, DeleteAlertRuleErrors, DeleteAlertRuleResponses, DeleteApiKeyData, DeleteApiKeyErrors, DeleteApiKeyResponses, DeleteBackupData, DeleteBackupErrors, DeleteBackupResponses, DeleteBackupScheduleData, DeleteBackupScheduleErrors, DeleteBackupScheduleResponses, DeleteConnectionData, DeleteConnectionErrors, DeleteConnectionResponses, DeleteCustomDomainData, DeleteCustomDomainErrors, DeleteCustomDomainResponses, DeleteDashboardData, DeleteDashboardErrors, DeleteDashboardResponses, DeleteDeploymentTokenData, DeleteDeploymentTokenErrors, DeleteDeploymentTokenResponses, DeleteDnsProviderData, DeleteDnsProviderErrors, DeleteDnsProviderResponses, DeleteDomainData, DeleteDomainErrors, DeleteDomainResponses, DeleteEmailDomainData, DeleteEmailDomainErrors, DeleteEmailDomainResponses, DeleteEmailProviderData, DeleteEmailProviderErrors, DeleteEmailProviderResponses, DeleteEnvironmentData, DeleteEnvironmentDomainData, DeleteEnvironmentDomainErrors, DeleteEnvironmentDomainResponses, DeleteEnvironmentErrors, DeleteEnvironmentResponses, DeleteEnvironmentVariableData, DeleteEnvironmentVariableErrors, DeleteEnvironmentVariableResponses, DeleteExternalImageData, DeleteExternalImageErrors, DeleteExternalImageResponses, DeleteFacetData, DeleteFacetErrors, DeleteFacetResponses, DeleteFunnelData, DeleteFunnelErrors, DeleteFunnelResponses, DeleteGitProviderData, DeleteGitProviderErrors, DeleteGitProviderResponses, DeleteGlobalMcpData, DeleteGlobalMcpErrors, DeleteGlobalMcpResponses, DeleteGlobalSkillData, DeleteGlobalSkillErrors, DeleteGlobalSkillResponses, DeleteIpAccessControlData, DeleteIpAccessControlErrors, DeleteIpAccessControlResponses, DeleteMcpData, DeleteMcpErrors, DeleteMcpResponses, DeleteMonitorData, DeleteMonitorErrors, DeleteMonitorResponses, DeleteNotificationProviderData, DeleteNotificationProviderErrors, DeleteNotificationProviderResponses, DeleteNotificationRouteData, DeleteNotificationRouteErrors, DeleteNotificationRouteResponses, DeleteOidcProviderData, DeleteOidcProviderResponses, DeleteOidcRoleMappingData, DeleteOidcRoleMappingResponses, DeletePreferencesData, DeletePreferencesErrors, DeletePreferencesResponses, DeleteProjectData, DeleteProjectErrors, DeleteProjectResponses, DeleteProjectSecretData, DeleteProjectSecretErrors, DeleteProjectSecretResponses, DeleteProviderKeyData, DeleteProviderKeyErrors, DeleteProviderKeyResponses, DeleteProviderModelData, DeleteProviderModelErrors, DeleteProviderModelResponses, DeleteProviderSafelyData, DeleteProviderSafelyErrors, DeleteProviderSafelyResponses, DeleteReleaseSourceFilesData, DeleteReleaseSourceFilesErrors, DeleteReleaseSourceFilesResponses, DeleteReleaseSourceMapsData, DeleteReleaseSourceMapsErrors, DeleteReleaseSourceMapsResponses, DeleteRouteData, DeleteRouteErrors, DeleteRouteResponses, DeleteS3SourceData, DeleteS3SourceErrors, DeleteS3SourceResponses, DeleteScanData, DeleteScanErrors, DeleteScanResponses, DeleteSecretData, DeleteSecretErrors, DeleteSecretResponses, DeleteServiceData, DeleteServiceErrors, DeleteServiceResponses, DeleteSessionReplayData, DeleteSessionReplayErrors, DeleteSessionReplayResponses, DeleteSkillData, DeleteSkillErrors, DeleteSkillResponses, DeleteSnapshotData, DeleteSnapshotErrors, DeleteSnapshotResponses, DeleteSourceMapData, DeleteSourceMapErrors, DeleteSourceMapResponses, DeleteStaticBundleData, DeleteStaticBundleErrors, DeleteStaticBundleResponses, DeleteTeamData, DeleteTeamErrors, DeleteTeamResponses, DeleteUserData, DeleteUserErrors, DeleteUserResponses, DeleteWebhookData, DeleteWebhookErrors, DeleteWebhookResponses, DeployApplicationWorkspaceProjectData, DeployApplicationWorkspaceProjectErrors, DeployApplicationWorkspaceProjectResponses, DeployFromImageData, DeployFromImageErrors, DeployFromImageResponses, DeployFromImageUploadData, DeployFromImageUploadErrors, DeployFromImageUploadResponses, DeployFromStaticData, DeployFromStaticErrors, DeployFromStaticResponses, DeployFromUploadedSourceData, DeployFromUploadedSourceErrors, DeployFromUploadedSourceResponses, DeploymentMetricsGetLatestData, DeploymentMetricsGetLatestErrors, DeploymentMetricsGetLatestResponses, DeploymentMetricsGetRangeData, DeploymentMetricsGetRangeErrors, DeploymentMetricsGetRangeResponses, DeploymentMetricsToggleData, DeploymentMetricsToggleErrors, DeploymentMetricsToggleResponses, DestroySandboxData, DestroySandboxErrors, DestroySandboxResponses, DetachScheduleServiceData, DetachScheduleServiceErrors, DetachScheduleServiceResponses, DetectPublicEnvExampleData, DetectPublicEnvExampleErrors, DetectPublicEnvExampleResponses, DetectPublicPresetsData, DetectPublicPresetsErrors, DetectPublicPresetsResponses, DisableBackupScheduleData, DisableBackupScheduleErrors, DisableBackupScheduleResponses, DisableMfaData, DisableMfaErrors, DisableMfaResponses, DisconnectCloudData, DisconnectCloudResponses, DiscoverWorkloadsData, DiscoverWorkloadsErrors, DiscoverWorkloadsResponses, DomainData, DomainErrors, DomainResponses, DownloadApplicationWorkspaceFileData, DownloadApplicationWorkspaceFileErrors, DownloadApplicationWorkspaceFileResponses, DownloadGlobalSkillArchiveData, DownloadGlobalSkillArchiveErrors, DownloadGlobalSkillArchiveResponses, DownloadGlobalWorkspaceFileData, DownloadGlobalWorkspaceFileErrors, DownloadGlobalWorkspaceFileResponses, DownloadObjectData, DownloadObjectErrors, DownloadObjectResponses, DownloadSkillArchiveData, DownloadSkillArchiveErrors, DownloadSkillArchiveResponses, EmailStatusData, EmailStatusErrors, EmailStatusResponses, EmbeddingsData, EmbeddingsErrors, EmbeddingsResponses, EnableBackupScheduleData, EnableBackupScheduleErrors, EnableBackupScheduleResponses, EnrichVisitorData, EnrichVisitorErrors, EnrichVisitorResponses, EnrollCloudData, EnrollCloudResponses, EstimateBulkActivationData, EstimateBulkActivationErrors, EstimateBulkActivationResponses, ExecData, ExecDetachedData, ExecDetachedErrors, ExecDetachedResponses, ExecErrors, ExecResponses, ExecuteDeploymentOperationData, ExecuteDeploymentOperationErrors, ExecuteDeploymentOperationResponses, ExecuteImportData, ExecuteImportErrors, ExecuteImportResponses, ExtendTimeoutData, ExtendTimeoutErrors, ExtendTimeoutResponses, ExternalServiceEnablePgStatStatementsData, ExternalServiceEnablePgStatStatementsErrors, ExternalServiceEnablePgStatStatementsResponses, ExternalServiceMetricsByDatabaseData, ExternalServiceMetricsByDatabaseErrors, ExternalServiceMetricsByDatabaseResponses, ExternalServiceMetricsCreateAlertRuleData, ExternalServiceMetricsCreateAlertRuleErrors, ExternalServiceMetricsCreateAlertRuleResponses, ExternalServiceMetricsDeleteAlertRuleData, ExternalServiceMetricsDeleteAlertRuleErrors, ExternalServiceMetricsDeleteAlertRuleResponses, ExternalServiceMetricsGetAlertRulesData, ExternalServiceMetricsGetAlertRulesErrors, ExternalServiceMetricsGetAlertRulesResponses, ExternalServiceMetricsGetLatestData, ExternalServiceMetricsGetLatestErrors, ExternalServiceMetricsGetLatestResponses, ExternalServiceMetricsGetRangeData, ExternalServiceMetricsGetRangeErrors, ExternalServiceMetricsGetRangeResponses, ExternalServiceMetricsStatusData, ExternalServiceMetricsStatusErrors, ExternalServiceMetricsStatusResponses, ExternalServiceMetricsToggleData, ExternalServiceMetricsToggleErrors, ExternalServiceMetricsToggleResponses, ExternalServiceMetricsUpdateAlertRuleData, ExternalServiceMetricsUpdateAlertRuleErrors, ExternalServiceMetricsUpdateAlertRuleResponses, ExternalServiceResetPgStatStatementsData, ExternalServiceResetPgStatStatementsErrors, ExternalServiceResetPgStatStatementsResponses, FinalizeOrderData, FinalizeOrderErrors, FinalizeOrderResponses, FinalizeProjectReleaseData, FinalizeProjectReleaseErrors, FinalizeProjectReleaseResponses, FindConversationData, FindConversationErrors, FindConversationResponses, GenerateJoinTokenData, GenerateJoinTokenErrors, GenerateJoinTokenResponses, GeneratePresetDockerfileData, GeneratePresetDockerfileErrors, GeneratePresetDockerfileResponses, GetAccessInfoData, GetAccessInfoErrors, GetAccessInfoResponses, GetActiveVisitorsData, GetActiveVisitorsErrors, GetActiveVisitorsResponses, GetActivityGraphData, GetActivityGraphErrors, GetActivityGraphResponses, GetAdminGateData, GetAdminGateErrors, GetAdminGateResponses, GetAgentData, GetAgentErrors, GetAgentResponses, GetAggregatedBucketsData, GetAggregatedBucketsErrors, GetAggregatedBucketsResponses, GetAiAgentBreakdownData, GetAiAgentBreakdownErrors, GetAiAgentBreakdownResponses, GetAiAgentPagesData, GetAiAgentPagesErrors, GetAiAgentPagesResponses, GetAiAgentTimelineData, GetAiAgentTimelineErrors, GetAiAgentTimelineResponses, GetAiDataAccessData, GetAiDataAccessErrors, GetAiDataAccessResponses, GetAiPageBreakdownData, GetAiPageBreakdownErrors, GetAiPageBreakdownResponses, GetAiProviderStatusData, GetAiProviderStatusErrors, GetAiProviderStatusResponses, GetAiStatusBreakdownData, GetAiStatusBreakdownErrors, GetAiStatusBreakdownResponses, GetAlertData, GetAlertErrors, GetAlertResponses, GetAlertRuleData, GetAlertRuleErrors, GetAlertRuleResponses, GetAllRepositoriesByNameData, GetAllRepositoriesByNameErrors, GetAllRepositoriesByNameResponses, GetAnalyticsActiveVisitorsData, GetAnalyticsActiveVisitorsErrors, GetAnalyticsActiveVisitorsResponses, GetAnalyticsEventsCountData, GetAnalyticsEventsCountErrors, GetAnalyticsEventsCountResponses, GetAnalyticsSessionEventsData, GetAnalyticsSessionEventsErrors, GetAnalyticsSessionEventsResponses, GetAnalyticsVisitorSessionsData, GetAnalyticsVisitorSessionsErrors, GetAnalyticsVisitorSessionsResponses, GetApiCallersData, GetApiCallersErrors, GetApiCallersResponses, GetApiKeyData, GetApiKeyErrors, GetApiKeyPermissionsData, GetApiKeyPermissionsErrors, GetApiKeyPermissionsResponses, GetApiKeyResponses, GetApiRoutesData, GetApiRoutesErrors, GetApiRoutesResponses, GetApiSummaryData, GetApiSummaryErrors, GetApiSummaryResponses, GetApiTimeseriesData, GetApiTimeseriesErrors, GetApiTimeseriesResponses, GetApiTrafficProxyLogAccessData, GetApiTrafficProxyLogAccessErrors, GetApiTrafficProxyLogAccessResponses, GetApplicationData, GetApplicationErrors, GetApplicationResponses, GetApplicationWorkspaceChangesData, GetApplicationWorkspaceChangesErrors, GetApplicationWorkspaceChangesResponses, GetApplicationWorkspaceData, GetApplicationWorkspaceDiffData, GetApplicationWorkspaceDiffErrors, GetApplicationWorkspaceDiffResponses, GetApplicationWorkspaceDirectoryData, GetApplicationWorkspaceDirectoryErrors, GetApplicationWorkspaceDirectoryResponses, GetApplicationWorkspaceErrors, GetApplicationWorkspaceFileData, GetApplicationWorkspaceFileErrors, GetApplicationWorkspaceFileResponses, GetApplicationWorkspaceResponses, GetAuditLogData, GetAuditLogErrors, GetAuditLogResponses, GetBackupData, GetBackupErrors, GetBackupResponses, GetBackupScheduleData, GetBackupScheduleErrors, GetBackupScheduleResponses, GetBranchesByRepositoryIdData, GetBranchesByRepositoryIdErrors, GetBranchesByRepositoryIdResponses, GetBucketedIncidentsData, GetBucketedIncidentsErrors, GetBucketedIncidentsResponses, GetBucketedStatusData, GetBucketedStatusErrors, GetBucketedStatusResponses, GetBulkActivationJobData, GetBulkActivationJobErrors, GetBulkActivationJobResponses, GetChallengeTokenData, GetChallengeTokenErrors, GetChallengeTokenResponses, GetChatReadinessData, GetChatReadinessErrors, GetChatReadinessResponses, GetCliStatusData, GetCliStatusErrors, GetCliStatusResponses, GetCloudAiCapabilityData, GetCloudAiCapabilityResponses, GetCloudBackfillStatusData, GetCloudBackfillStatusErrors, GetCloudBackfillStatusResponses, GetCloudCapabilityData, GetCloudCapabilityResponses, GetCloudStatusData, GetCloudStatusResponses, GetCloudTelemetryStatusData, GetCloudTelemetryStatusErrors, GetCloudTelemetryStatusResponses, GetClusterHealthData, GetClusterHealthErrors, GetClusterHealthResponses, GetClusterMemberData, GetClusterMemberErrors, GetClusterMemberResponses, GetCmdData, GetCmdErrors, GetCmdResponses, GetContainerDetailData, GetContainerDetailErrors, GetContainerDetailResponses, GetContainerEnvironmentVariableData, GetContainerEnvironmentVariableErrors, GetContainerEnvironmentVariableResponses, GetContainerLogsByIdData, GetContainerLogsByIdErrors, GetContainerLogsData, GetContainerLogsErrors, GetContainerMetricsData, GetContainerMetricsErrors, GetContainerMetricsResponses, GetConversationData, GetConversationDetailData, GetConversationDetailErrors, GetConversationDetailResponses, GetConversationErrors, GetConversationResponses, GetConversationsData, GetConversationsErrors, GetConversationsResponses, GetCronByIdData, GetCronByIdErrors, GetCronByIdResponses, GetCronExecutionsData, GetCronExecutionsErrors, GetCronExecutionsResponses, GetCrossProjectTraceSiblingsData, GetCrossProjectTraceSiblingsErrors, GetCrossProjectTraceSiblingsResponses, GetCurrentBulkActivationJobData, GetCurrentBulkActivationJobErrors, GetCurrentBulkActivationJobResponses, GetCurrentMonitorStatusData, GetCurrentMonitorStatusErrors, GetCurrentMonitorStatusResponses, GetCurrentUserData, GetCurrentUserErrors, GetCurrentUserResponses, GetCustomDomainData, GetCustomDomainErrors, GetCustomDomainResponses, GetDashboardData, GetDashboardErrors, GetDashboardProjectsAnalyticsData, GetDashboardProjectsAnalyticsErrors, GetDashboardProjectsAnalyticsResponses, GetDashboardResponses, GetDeliveryData, GetDeliveryErrors, GetDeliveryResponses, GetDeploymentContainerLogContentData, GetDeploymentContainerLogContentErrors, GetDeploymentContainerLogContentResponses, GetDeploymentData, GetDeploymentErrors, GetDeploymentJobLogsData, GetDeploymentJobLogsErrors, GetDeploymentJobLogsResponses, GetDeploymentJobsData, GetDeploymentJobsErrors, GetDeploymentJobsResponses, GetDeploymentOperationsData, GetDeploymentOperationsErrors, GetDeploymentOperationsResponses, GetDeploymentOperationStatusData, GetDeploymentOperationStatusErrors, GetDeploymentOperationStatusResponses, GetDeploymentResponses, GetDeploymentTokenData, GetDeploymentTokenErrors, GetDeploymentTokenResponses, GetDiskStatusData, GetDiskStatusErrors, GetDiskStatusResponses, GetDnsChangesData, GetDnsChangesErrors, GetDnsChangesResponses, GetDnsProviderData, GetDnsProviderErrors, GetDnsProviderResponses, GetDomainByHostData, GetDomainByHostErrors, GetDomainByHostResponses, GetDomainByIdData, GetDomainByIdErrors, GetDomainByIdResponses, GetDomainByNameData, GetDomainByNameErrors, GetDomainByNameResponses, GetDomainData, GetDomainDnsRecordsData, GetDomainDnsRecordsErrors, GetDomainDnsRecordsResponses, GetDomainErrors, GetDomainOrderData, GetDomainOrderErrors, GetDomainOrderResponses, GetDomainResponses, GetEmailData, GetEmailErrors, GetEmailEventsData, GetEmailEventsErrors, GetEmailEventsResponses, GetEmailLinksData, GetEmailLinksErrors, GetEmailLinksResponses, GetEmailProviderData, GetEmailProviderErrors, GetEmailProviderResponses, GetEmailResponses, GetEmailStatsData, GetEmailStatsErrors, GetEmailStatsResponses, GetEmailTrackingData, GetEmailTrackingErrors, GetEmailTrackingResponses, GetEmailTrackingStatusData, GetEmailTrackingStatusErrors, GetEmailTrackingStatusResponses, GetEntityInfoData, GetEntityInfoErrors, GetEntityInfoResponses, GetEnvironmentCronsData, GetEnvironmentCronsErrors, GetEnvironmentCronsResponses, GetEnvironmentData, GetEnvironmentDomainsData, GetEnvironmentDomainsErrors, GetEnvironmentDomainsResponses, GetEnvironmentErrors, GetEnvironmentResponses, GetEnvironmentsData, GetEnvironmentsErrors, GetEnvironmentsResponses, GetEnvironmentVariablesData, GetEnvironmentVariablesErrors, GetEnvironmentVariablesResponses, GetEnvironmentVariableValueData, GetEnvironmentVariableValueErrors, GetEnvironmentVariableValueResponses, GetErrorDashboardStatsData, GetErrorDashboardStatsErrors, GetErrorDashboardStatsResponses, GetErrorEventData, GetErrorEventErrors, GetErrorEventResponses, GetErrorGroupData, GetErrorGroupErrors, GetErrorGroupResponses, GetErrorStatsData, GetErrorStatsErrors, GetErrorStatsResponses, GetErrorTimeSeriesData, GetErrorTimeSeriesErrors, GetErrorTimeSeriesResponses, GetEventDetailData, GetEventDetailErrors, GetEventDetailResponses, GetEventEntriesData, GetEventEntriesErrors, GetEventEntriesResponses, GetEventsCountData, GetEventsCountErrors, GetEventsCountResponses, GetEventsTimelineData, GetEventsTimelineErrors, GetEventsTimelineResponses, GetEventTypeBreakdownData, GetEventTypeBreakdownErrors, GetEventTypeBreakdownResponses, GetEventVisitorsData, GetEventVisitorsErrors, GetEventVisitorsResponses, GetExternalImageData, GetExternalImageErrors, GetExternalImageResponses, GetExternalServiceBackupCapabilityData, GetExternalServiceBackupCapabilityErrors, GetExternalServiceBackupCapabilityResponses, GetFailureReportPreviewData, GetFailureReportPreviewErrors, GetFailureReportPreviewResponses, GetFeatureMaturityData, GetFeatureMaturityErrors, GetFeatureMaturityResponses, GetFileData, GetFileErrors, GetFileResponses, GetFlagData, GetFlagErrors, GetFlagResponses, GetFlagSnapshotData, GetFlagSnapshotErrors, GetFlagSnapshotResponses, GetFunnelMetricsData, GetFunnelMetricsErrors, GetFunnelMetricsResponses, GetGenaiTraceData, GetGenaiTraceErrors, GetGenaiTraceResponses, GetGeneralStatsData, GetGeneralStatsErrors, GetGeneralStatsResponses, GetGitProviderData, GetGitProviderErrors, GetGitProviderResponses, GetGlobalAiWorkspaceData, GetGlobalAiWorkspaceErrors, GetGlobalAiWorkspaceResponses, GetGlobalEventsData, GetGlobalEventsErrors, GetGlobalEventsResponses, GetGlobalEventStatsData, GetGlobalEventStatsErrors, GetGlobalEventStatsResponses, GetGlobalMcpData, GetGlobalMcpErrors, GetGlobalMcpResponses, GetGlobalSandboxStatusData, GetGlobalSandboxStatusErrors, GetGlobalSandboxStatusResponses, GetGlobalSkillData, GetGlobalSkillErrors, GetGlobalSkillResponses, GetGlobalWorkspaceChangesData, GetGlobalWorkspaceChangesErrors, GetGlobalWorkspaceChangesResponses, GetGlobalWorkspaceDiffData, GetGlobalWorkspaceDiffErrors, GetGlobalWorkspaceDiffResponses, GetGlobalWorkspaceDirectoryData, GetGlobalWorkspaceDirectoryErrors, GetGlobalWorkspaceDirectoryResponses, GetGlobalWorkspaceFileData, GetGlobalWorkspaceFileErrors, GetGlobalWorkspaceFileResponses, GetGroupedPageMetricsData, GetGroupedPageMetricsErrors, GetGroupedPageMetricsResponses, GetHealthData, GetHealthErrors, GetHealthResponses, GetHourlyVisitsData, GetHourlyVisitsErrors, GetHourlyVisitsResponses, GetHttpChallengeDebugData, GetHttpChallengeDebugErrors, GetHttpChallengeDebugResponses, GetImportStatusData, GetImportStatusErrors, GetImportStatusResponses, GetIncidentData, GetIncidentErrors, GetIncidentResponses, GetIncidentUpdatesData, GetIncidentUpdatesErrors, GetIncidentUpdatesResponses, GetIngestErrorsData, GetIngestErrorsErrors, GetIngestErrorsResponses, GetIpAccessControlData, GetIpAccessControlErrors, GetIpAccessControlResponses, GetIpGeolocationData, GetIpGeolocationErrors, GetIpGeolocationResponses, GetJoinTokenStatusData, GetJoinTokenStatusErrors, GetJoinTokenStatusResponses, GetLastDeploymentData, GetLastDeploymentErrors, GetLastDeploymentResponses, GetLatestDeploymentMediaData, GetLatestDeploymentMediaErrors, GetLatestDeploymentMediaResponses, GetLatestScanData, GetLatestScanErrors, GetLatestScanResponses, GetLatestScansPerEnvironmentData, GetLatestScansPerEnvironmentErrors, GetLatestScansPerEnvironmentResponses, GetLiveVisitorsListData, GetLiveVisitorsListErrors, GetLiveVisitorsListResponses, GetLogContextData, GetLogContextErrors, GetLogContextResponses, GetMcpData, GetMcpErrors, GetMcpResponses, GetMetricsOverTimeData, GetMetricsOverTimeErrors, GetMetricsOverTimeResponses, GetMonitorData, GetMonitorErrors, GetMonitorResponses, GetNotificationProviderData, GetNotificationProviderErrors, GetNotificationProviderResponses, GetNotificationRouteData, GetNotificationRouteErrors, GetNotificationRouteResponses, GetOnDemandCertStatusData, GetOnDemandCertStatusErrors, GetOnDemandCertStatusResponses, GetOrCreateDsnData, GetOrCreateDsnErrors, GetOrCreateDsnResponses, GetPageFlowData, GetPageFlowErrors, GetPageFlowResponses, GetPageHourlySessionsData, GetPageHourlySessionsErrors, GetPageHourlySessionsResponses, GetPagePathDetailData, GetPagePathDetailErrors, GetPagePathDetailResponses, GetPagePathsData, GetPagePathsErrors, GetPagePathsResponses, GetPagePathsSparklinesData, GetPagePathsSparklinesErrors, GetPagePathsSparklinesResponses, GetPagePathVisitorsData, GetPagePathVisitorsErrors, GetPagePathVisitorsResponses, GetPendingActionData, GetPendingActionErrors, GetPendingActionResponses, GetPerformanceMetricsData, GetPerformanceMetricsErrors, GetPerformanceMetricsResponses, GetPgUpgradeData, GetPgUpgradeErrors, GetPgUpgradeLogsData, GetPgUpgradeLogsErrors, GetPgUpgradeLogsResponses, GetPgUpgradeResponses, GetPipelineHistoryData, GetPipelineHistoryErrors, GetPipelineHistoryResponses, GetPipelineStatsData, GetPipelineStatsErrors, GetPipelineStatsResponses, GetPlatformInfoData, GetPlatformInfoErrors, GetPlatformInfoResponses, GetPostgresWalHealthData, GetPostgresWalHealthErrors, GetPostgresWalHealthResponses, GetPreferencesData, GetPreferencesErrors, GetPreferencesResponses, GetPreviewGatewayLogsData, GetPreviewGatewayLogsErrors, GetPreviewGatewayLogsResponses, GetPreviewGatewaySettingsData, GetPreviewGatewaySettingsResponses, GetPreviewGatewayStatusData, GetPreviewGatewayStatusErrors, GetPreviewGatewayStatusResponses, GetPricingData, GetPricingErrors, GetPricingResponses, GetPrivateIpData, GetPrivateIpErrors, GetPrivateIpResponses, GetProjectAlarmsSummaryData, GetProjectAlarmsSummaryErrors, GetProjectAlarmsSummaryResponses, GetProjectBySlugData, GetProjectBySlugErrors, GetProjectBySlugResponses, GetProjectCloudTelemetryData, GetProjectCloudTelemetryErrors, GetProjectCloudTelemetryResponses, GetProjectData, GetProjectDeploymentsData, GetProjectDeploymentsErrors, GetProjectDeploymentsResponses, GetProjectErrors, GetProjectResponses, GetProjectsData, GetProjectsErrors, GetProjectServiceEnvironmentVariablesData, GetProjectServiceEnvironmentVariablesErrors, GetProjectServiceEnvironmentVariablesResponses, GetProjectServiceTemplateData, GetProjectServiceTemplateErrors, GetProjectServiceTemplateResponses, GetProjectSessionReplaysData, GetProjectSessionReplaysErrors, GetProjectSessionReplaysResponses, GetProjectsHealthData, GetProjectsHealthErrors, GetProjectsHealthResponses, GetProjectsMonitorHealthData, GetProjectsMonitorHealthErrors, GetProjectsMonitorHealthResponses, GetProjectsResponses, GetProjectStatisticsData, GetProjectStatisticsErrors, GetProjectStatisticsResponses, GetProjectTemplateData, GetProjectTemplateErrors, GetProjectTemplateResponses, GetPropertyBreakdownData, GetPropertyBreakdownErrors, GetPropertyBreakdownResponses, GetPropertyTimelineData, GetPropertyTimelineErrors, GetPropertyTimelineResponses, GetProviderConnectionsData, GetProviderConnectionsErrors, GetProviderConnectionsResponses, GetProviderKeyData, GetProviderKeyErrors, GetProviderKeyResponses, GetProviderMetadataData, GetProviderMetadataErrors, GetProviderMetadataResponses, GetProvidersMetadataData, GetProvidersMetadataErrors, GetProvidersMetadataResponses, GetProxyLogByIdData, GetProxyLogByIdErrors, GetProxyLogByIdResponses, GetProxyLogByRequestIdData, GetProxyLogByRequestIdErrors, GetProxyLogByRequestIdResponses, GetProxyLogsData, GetProxyLogsErrors, GetProxyLogsResponses, GetPublicBranchesData, GetPublicBranchesErrors, GetPublicBranchesResponses, GetPublicComposePreviewData, GetPublicComposePreviewErrors, GetPublicComposePreviewResponses, GetPublicComposeServicesData, GetPublicComposeServicesErrors, GetPublicComposeServicesResponses, GetPublicIpData, GetPublicIpErrors, GetPublicIpResponses, GetPublicRepositoryData, GetPublicRepositoryErrors, GetPublicRepositoryResponses, GetQueryContainerInfoData, GetQueryContainerInfoErrors, GetQueryContainerInfoResponses, GetQuotaData, GetQuotaErrors, GetQuotaResponses, GetRecentActivityData, GetRecentActivityErrors, GetRecentActivityResponses, GetRemoteExternalImageData, GetRemoteExternalImageErrors, GetRemoteExternalImageResponses, GetRepositoryBranchesData, GetRepositoryBranchesErrors, GetRepositoryBranchesResponses, GetRepositoryByIdData, GetRepositoryByIdErrors, GetRepositoryByIdResponses, GetRepositoryByNameData, GetRepositoryByNameErrors, GetRepositoryByNameResponses, GetRepositoryComposePreviewData, GetRepositoryComposePreviewErrors, GetRepositoryComposePreviewResponses, GetRepositoryComposeServicesLiveData, GetRepositoryComposeServicesLiveErrors, GetRepositoryComposeServicesLiveResponses, GetRepositoryEnvExampleLiveData, GetRepositoryEnvExampleLiveErrors, GetRepositoryEnvExampleLiveResponses, GetRepositoryPresetByNameData, GetRepositoryPresetByNameErrors, GetRepositoryPresetByNameResponses, GetRepositoryPresetLiveData, GetRepositoryPresetLiveErrors, GetRepositoryPresetLiveResponses, GetRepositoryTagsData, GetRepositoryTagsErrors, GetRepositoryTagsResponses, GetResolvedEnvironmentVariablesData, GetResolvedEnvironmentVariablesErrors, GetResolvedEnvironmentVariablesResponses, GetResolvedEnvironmentVariableValueData, GetResolvedEnvironmentVariableValueErrors, GetResolvedEnvironmentVariableValueResponses, GetRestoreCapabilitiesData, GetRestoreCapabilitiesErrors, GetRestoreCapabilitiesResponses, GetRestoreRunData, GetRestoreRunErrors, GetRestoreRunResponses, GetRouteData, GetRouteErrors, GetRouteResponses, GetRunData, GetRunErrors, GetRunResponses, GetRunWithLogsData, GetRunWithLogsErrors, GetRunWithLogsResponses, GetS3CredentialsData, GetS3CredentialsErrors, GetS3CredentialsResponses, GetS3SourceData, GetS3SourceErrors, GetS3SourceResponses, GetSandboxData, GetSandboxErrors, GetSandboxResponses, GetSandboxStatusData, GetSandboxStatusErrors, GetSandboxStatusResponses, GetScanByDeploymentData, GetScanByDeploymentErrors, GetScanByDeploymentResponses, GetScanData, GetScanErrors, GetScanResponses, GetScanVulnerabilitiesData, GetScanVulnerabilitiesErrors, GetScanVulnerabilitiesResponses, GetServiceBySlugData, GetServiceBySlugErrors, GetServiceBySlugResponses, GetServiceData, GetServiceEnvironmentVariableData, GetServiceEnvironmentVariableErrors, GetServiceEnvironmentVariableResponses, GetServiceEnvironmentVariablesData, GetServiceEnvironmentVariablesErrors, GetServiceEnvironmentVariablesResponses, GetServiceErrors, GetServiceHealthStatusData, GetServiceHealthStatusErrors, GetServiceHealthStatusResponses, GetServicePreviewEnvironmentVariableNamesData, GetServicePreviewEnvironmentVariableNamesErrors, GetServicePreviewEnvironmentVariableNamesResponses, GetServicePreviewEnvironmentVariablesMaskedData, GetServicePreviewEnvironmentVariablesMaskedErrors, GetServicePreviewEnvironmentVariablesMaskedResponses, GetServiceResponses, GetServiceRuntimeData, GetServiceRuntimeErrors, GetServiceRuntimeResponses, GetServiceStatsData, GetServiceStatsErrors, GetServiceStatsResponses, GetServiceTypeParametersData, GetServiceTypeParametersErrors, GetServiceTypeParametersResponses, GetServiceTypesData, GetServiceTypesErrors, GetServiceTypesResponses, GetSessionDetailsData, GetSessionDetailsErrors, GetSessionDetailsResponses, GetSessionEventsData, GetSessionEventsErrors, GetSessionEventsResponses, GetSessionLogsData, GetSessionLogsErrors, GetSessionLogsResponses, GetSessionReplayData, GetSessionReplayErrors, GetSessionReplayEventsData, GetSessionReplayEventsErrors, GetSessionReplayEventsResponses, GetSessionReplayResponses, GetSettingsData, GetSettingsErrors, GetSettingsResponses, GetSkillData, GetSkillErrors, GetSkillResponses, GetSlowQueriesData, GetSlowQueriesErrors, GetSlowQueriesResponses, GetSnapshotData, GetSnapshotErrors, GetSnapshotResponses, GetStaticBundleData, GetStaticBundleErrors, GetStaticBundleResponses, GetStatusOverviewData, GetStatusOverviewErrors, GetStatusOverviewResponses, GetSystemAlarmsSummaryData, GetSystemAlarmsSummaryErrors, GetSystemAlarmsSummaryResponses, GetTagsByRepositoryIdData, GetTagsByRepositoryIdErrors, GetTagsByRepositoryIdResponses, GetTeamData, GetTeamErrors, GetTeamResponses, GetTimeBucketStatsData, GetTimeBucketStatsErrors, GetTimeBucketStatsResponses, GetTodayStatsData, GetTodayStatsErrors, GetTodayStatsResponses, GetTraceData, GetTraceErrors, GetTraceResponses, GetTraefikDiscoveryStatusData, GetTraefikDiscoveryStatusErrors, GetTraefikDiscoveryStatusResponses, GetUnifiedTraceData, GetUnifiedTraceErrors, GetUnifiedTraceResponses, GetUniqueCountsData, GetUniqueCountsErrors, GetUniqueCountsResponses, GetUniqueEventsData, GetUniqueEventsErrors, GetUniqueEventsResponses, GetUpdateCapabilityData, GetUpdateCapabilityErrors, GetUpdateCapabilityResponses, GetUpdateStatusData, GetUpdateStatusErrors, GetUpdateStatusResponses, GetUptimeHistoryData, GetUptimeHistoryErrors, GetUptimeHistoryResponses, GetUsageByProviderData, GetUsageByProviderErrors, GetUsageByProviderResponses, GetUsageRecentData, GetUsageRecentErrors, GetUsageRecentResponses, GetUsageSummaryData, GetUsageSummaryErrors, GetUsageSummaryResponses, GetUsageTimeseriesData, GetUsageTimeseriesErrors, GetUsageTimeseriesResponses, GetUsageTopModelsData, GetUsageTopModelsErrors, GetUsageTopModelsResponses, GetUserConversationAttachmentData, GetUserConversationAttachmentErrors, GetUserConversationAttachmentResponses, GetUserConversationData, GetUserConversationErrors, GetUserConversationResponses, GetUserPendingActionData, GetUserPendingActionErrors, GetUserPendingActionResponses, GetVisibleCustomDomainByHostnameData, GetVisibleCustomDomainByHostnameErrors, GetVisibleCustomDomainByHostnameResponses, GetVisitorByGuidData, GetVisitorByGuidErrors, GetVisitorByGuidResponses, GetVisitorByIdData, GetVisitorByIdErrors, GetVisitorByIdResponses, GetVisitorDetailsData, GetVisitorDetailsErrors, GetVisitorDetailsResponses, GetVisitorFacetsData, GetVisitorFacetsErrors, GetVisitorFacetsResponses, GetVisitorInfoData, GetVisitorInfoErrors, GetVisitorInfoResponses, GetVisitorJourneyData, GetVisitorJourneyErrors, GetVisitorJourneyResponses, GetVisitorsData, GetVisitorsErrors, GetVisitorSessionsData, GetVisitorSessionsErrors, GetVisitorSessionsResponses, GetVisitorsResponses, GetVisitorStatsData, GetVisitorStatsErrors, GetVisitorStatsResponses, GetWebhookData, GetWebhookErrors, GetWebhookResponses, GetWorkspaceFileLimitsData, GetWorkspaceFileLimitsErrors, GetWorkspaceFileLimitsResponses, GrantProjectAccessData, GrantProjectAccessErrors, GrantProjectAccessResponses, HandleGitProviderOauthCallbackData, HandleGitProviderOauthCallbackErrors, HasAnalyticsEventsData, HasAnalyticsEventsErrors, HasAnalyticsEventsResponses, HasErrorGroupsData, HasErrorGroupsErrors, HasErrorGroupsResponses, HasPerformanceMetricsData, HasPerformanceMetricsErrors, HasPerformanceMetricsResponses, HasTracesData, HasTracesErrors, HasTracesResponses, ImportApplicationWorkspaceGitData, ImportApplicationWorkspaceGitErrors, ImportApplicationWorkspaceGitResponses, ImportEmailDomainData, ImportEmailDomainErrors, ImportEmailDomainResponses, ImportExternalServiceData, ImportExternalServiceErrors, ImportExternalServiceResponses, ImportLocalAiProviderCredentialData, ImportLocalAiProviderCredentialErrors, ImportLocalAiProviderCredentialResponses, ImportTraefikAcmeJsonData, ImportTraefikAcmeJsonErrors, ImportTraefikAcmeJsonResponses, IngestLogsByPathData, IngestLogsByPathErrors, IngestLogsByPathResponses, IngestLogsData, IngestLogsErrors, IngestLogsResponses, IngestMetricsByPathData, IngestMetricsByPathErrors, IngestMetricsByPathResponses, IngestMetricsData, IngestMetricsErrors, IngestMetricsResponses, IngestSentryEnvelopeData, IngestSentryEnvelopeErrors, IngestSentryEnvelopeResponses, IngestSentryEventData, IngestSentryEventErrors, IngestSentryEventResponses, IngestTracesByPathData, IngestTracesByPathErrors, IngestTracesByPathResponses, IngestTracesData, IngestTracesErrors, IngestTracesResponses, IngestTunneledEnvelopeData, IngestTunneledEnvelopeErrors, IngestTunneledEnvelopeResponses, InitSessionReplayData, InitSessionReplayErrors, InitSessionReplayResponses, InspectDropArchiveData, InspectDropArchiveErrors, InspectDropArchiveResponses, IssueRuntimeCredentialsData, IssueRuntimeCredentialsErrors, IssueRuntimeCredentialsResponses, JobLogsData, JobLogsErrors, JobLogsResponses, JobStatusData, JobStatusErrors, JobStatusResponses, KillJobData, KillJobErrors, KillJobResponses, KvDelData, KvDelErrors, KvDelResponses, KvDisableData, KvDisableErrors, KvDisableResponses, KvEnableData, KvEnableErrors, KvEnableResponses, KvExpireData, KvExpireErrors, KvExpireResponses, KvGetData, KvGetErrors, KvGetResponses, KvIncrData, KvIncrErrors, KvIncrResponses, KvKeysData, KvKeysErrors, KvKeysResponses, KvSetData, KvSetErrors, KvSetResponses, KvStatusData, KvStatusErrors, KvStatusResponses, KvTtlData, KvTtlErrors, KvTtlResponses, KvUpdateData, KvUpdateErrors, KvUpdateResponses, LatestRunForSourceData, LatestRunForSourceErrors, LatestRunForSourceResponses, LinkApplicationProjectData, LinkApplicationProjectErrors, LinkApplicationProjectResponses, LinkCustomDomainToCertificateData, LinkCustomDomainToCertificateErrors, LinkCustomDomainToCertificateResponses, LinkServiceToProjectData, LinkServiceToProjectErrors, LinkServiceToProjectResponses, ListAgentRunsData, ListAgentRunsErrors, ListAgentRunsResponses, ListAgentsData, ListAgentsErrors, ListAgentsResponses, ListAiProvidersData, ListAiProvidersErrors, ListAiProvidersResponses, ListAlertRulesData, ListAlertRulesErrors, ListAlertRulesResponses, ListAlertsData, ListAlertsErrors, ListAlertsResponses, ListAllConversationsData, ListAllConversationsErrors, ListAllConversationsResponses, ListAllRunsData, ListAllRunsErrors, ListAllRunsResponses, ListAnalyticsIngestKeysData, ListAnalyticsIngestKeysErrors, ListAnalyticsIngestKeysResponses, ListApiKeysData, ListApiKeysErrors, ListApiKeysResponses, ListApplicationConversationsData, ListApplicationConversationsErrors, ListApplicationConversationsResponses, ListApplicationsData, ListApplicationsErrors, ListApplicationsResponses, ListAuditLogsData, ListAuditLogsErrors, ListAuditLogsResponses, ListAvailableContainersData, ListAvailableContainersErrors, ListAvailableContainersResponses, ListBackupAlertsData, ListBackupAlertsErrors, ListBackupAlertsResponses, ListBackupChildrenData, ListBackupChildrenErrors, ListBackupChildrenResponses, ListBackupSchedulesData, ListBackupSchedulesErrors, ListBackupSchedulesResponses, ListBackupsForScheduleData, ListBackupsForScheduleErrors, ListBackupsForScheduleResponses, ListCommitsByRepositoryIdData, ListCommitsByRepositoryIdErrors, ListCommitsByRepositoryIdResponses, ListConnectionsData, ListConnectionsErrors, ListConnectionsResponses, ListContainerHistoryData, ListContainerHistoryErrors, ListContainerHistoryResponses, ListContainersAtPathData, ListContainersAtPathErrors, ListContainersAtPathResponses, ListContainersData, ListContainersErrors, ListContainersResponses, ListConversationsData, ListConversationsErrors, ListConversationsResponses, ListCustomDomainsForProjectData, ListCustomDomainsForProjectErrors, ListCustomDomainsForProjectResponses, ListDashboardsData, ListDashboardsErrors, ListDashboardsResponses, ListDeliveriesData, ListDeliveriesErrors, ListDeliveriesResponses, ListDeploymentContainerLogsData, ListDeploymentContainerLogsErrors, ListDeploymentContainerLogsResponses, ListDeploymentTokensData, ListDeploymentTokensErrors, ListDeploymentTokensResponses, ListDiscoverableDomainsData, ListDiscoverableDomainsErrors, ListDiscoverableDomainsResponses, ListDnsProvidersData, ListDnsProvidersErrors, ListDnsProvidersResponses, ListDomainsData, ListDomainsErrors, ListDomainsResponses, ListDsnsData, ListDsnsErrors, ListDsnsResponses, ListEmailDomainProjectsData, ListEmailDomainProjectsErrors, ListEmailDomainProjectsResponses, ListEmailDomainsData, ListEmailDomainsErrors, ListEmailDomainsResponses, ListEmailProvidersData, ListEmailProvidersErrors, ListEmailProvidersResponses, ListEmailsData, ListEmailsErrors, ListEmailsResponses, ListEnrollmentTokensData, ListEnrollmentTokensErrors, ListEnrollmentTokensResponses, ListEntitiesData, ListEntitiesErrors, ListEntitiesResponses, ListErrorEventsData, ListErrorEventsErrors, ListErrorEventsResponses, ListErrorGroupsData, ListErrorGroupsErrors, ListErrorGroupsResponses, ListEventsData, ListEventsResponses, ListEventTypesData, ListEventTypesResponses, ListExternalImagesData, ListExternalImagesErrors, ListExternalImagesResponses, ListExternalPluginsData, ListExternalPluginsErrors, ListExternalPluginsResponses, ListExternalServiceBackupsData, ListExternalServiceBackupsErrors, ListExternalServiceBackupsResponses, ListFacetsData, ListFacetsErrors, ListFacetsResponses, ListFlagsData, ListFlagsErrors, ListFlagsResponses, ListFunnelsData, ListFunnelsErrors, ListFunnelsResponses, ListGitProvidersData, ListGitProvidersErrors, ListGitProvidersResponses, ListGlobalMcpsData, ListGlobalMcpsErrors, ListGlobalMcpsResponses, ListGlobalSkillsData, ListGlobalSkillsErrors, ListGlobalSkillsResponses, ListIncidentsData, ListIncidentsErrors, ListIncidentsResponses, ListInsightsData, ListInsightsErrors, ListInsightsResponses, ListIpAccessControlData, ListIpAccessControlErrors, ListIpAccessControlResponses, ListJobsData, ListJobsErrors, ListJobsResponses, ListKnownAiAgentsData, ListKnownAiAgentsErrors, ListKnownAiAgentsResponses, ListManagedDomainsData, ListManagedDomainsErrors, ListManagedDomainsResponses, ListManagedEnvironmentVariablesData, ListManagedEnvironmentVariablesErrors, ListManagedEnvironmentVariablesResponses, ListMcpsData, ListMcpsErrors, ListMcpsResponses, ListMetricLabelKeysData, ListMetricLabelKeysErrors, ListMetricLabelKeysResponses, ListMetricLabelValuesData, ListMetricLabelValuesErrors, ListMetricLabelValuesResponses, ListMetricNamesData, ListMetricNamesErrors, ListMetricNamesResponses, ListModelsData, ListModelsErrors, ListModelsResponses, ListMonitorsData, ListMonitorsErrors, ListMonitorsResponses, ListNotificationProvidersData, ListNotificationProvidersErrors, ListNotificationProvidersResponses, ListNotificationRoutesData, ListNotificationRoutesErrors, ListNotificationRoutesResponses, ListOidcProvidersData, ListOidcProvidersResponses, ListOidcProviderUsersData, ListOidcProviderUsersErrors, ListOidcProviderUsersResponses, ListOidcRoleMappingsData, ListOidcRoleMappingsResponses, ListOnDemandCertsData, ListOnDemandCertsErrors, ListOnDemandCertsResponses, ListOrdersData, ListOrdersErrors, ListOrdersResponses, ListPeersData, ListPeersErrors, ListPeersResponses, ListPendingActionsData, ListPendingActionsErrors, ListPendingActionsResponses, ListPgUpgradesData, ListPgUpgradesErrors, ListPgUpgradesResponses, ListPresetsData, ListPresetsErrors, ListPresetsResponses, ListProjectAccessData, ListProjectAccessErrors, ListProjectAccessResponses, ListProjectAlarmsData, ListProjectAlarmsErrors, ListProjectAlarmsResponses, ListProjectScansData, ListProjectScansErrors, ListProjectScansResponses, ListProjectSecretsData, ListProjectSecretsErrors, ListProjectSecretsResponses, ListProjectServicesData, ListProjectServicesErrors, ListProjectServicesResponses, ListProjectTemplatesData, ListProjectTemplatesErrors, ListProjectTemplatesResponses, ListProjectTemplateTagsData, ListProjectTemplateTagsErrors, ListProjectTemplateTagsResponses, ListProviderKeysData, ListProviderKeysErrors, ListProviderKeysResponses, ListProviderZonesData, ListProviderZonesErrors, ListProviderZonesResponses, ListPublicProvidersData, ListPublicProvidersResponses, ListReleaseFilesData, ListReleaseFilesErrors, ListReleaseFilesResponses, ListReleasesData, ListReleasesErrors, ListReleasesResponses, ListRemoteExternalImagesData, ListRemoteExternalImagesErrors, ListRemoteExternalImagesResponses, ListRenewalAttemptsData, ListRenewalAttemptsErrors, ListRenewalAttemptsResponses, ListRepositoriesByConnectionData, ListRepositoriesByConnectionErrors, ListRepositoriesByConnectionResponses, ListRepositoriesByProviderData, ListRepositoriesByProviderErrors, ListRepositoriesByProviderResponses, ListRestoreRunsForServiceData, ListRestoreRunsForServiceErrors, ListRestoreRunsForServiceResponses, ListRootContainersData, ListRootContainersErrors, ListRootContainersResponses, ListRoutesData, ListRoutesErrors, ListRoutesResponses, ListS3SourcesData, ListS3SourcesErrors, ListS3SourcesResponses, ListSandboxesData, ListSandboxesErrors, ListSandboxesResponses, ListScheduleRunJobsData, ListScheduleRunJobsErrors, ListScheduleRunJobsResponses, ListScheduleRunsData, ListScheduleRunsErrors, ListScheduleRunsResponses, ListScheduleServicesData, ListScheduleServicesErrors, ListScheduleServicesResponses, ListSecretsData, ListSecretsErrors, ListSecretsResponses, ListServiceHealthStatusesData, ListServiceHealthStatusesErrors, ListServiceHealthStatusesResponses, ListServiceProjectsData, ListServiceProjectsErrors, ListServiceProjectsResponses, ListServiceSchedulesData, ListServiceSchedulesErrors, ListServiceSchedulesResponses, ListServicesData, ListServicesErrors, ListServicesResponses, ListSkillsData, ListSkillsErrors, ListSkillsResponses, ListSnapshotsData, ListSnapshotsErrors, ListSnapshotsResponses, ListSourceBackupsData, ListSourceBackupsErrors, ListSourceBackupsResponses, ListSourceFilesData, ListSourceFilesErrors, ListSourceFilesResponses, ListSourceMapsData, ListSourceMapsErrors, ListSourceMapsResponses, ListSourcesData, ListSourcesErrors, ListSourcesResponses, ListStaticBundlesData, ListStaticBundlesErrors, ListStaticBundlesResponses, ListSyncedRepositoriesData, ListSyncedRepositoriesErrors, ListSyncedRepositoriesResponses, ListSystemAlarmsData, ListSystemAlarmsErrors, ListSystemAlarmsResponses, ListTeamMembersData, ListTeamMembersErrors, ListTeamMembersResponses, ListTeamProjectsData, ListTeamProjectsErrors, ListTeamProjectsResponses, ListTeamsData, ListTeamsErrors, ListTeamsResponses, ListThreadArtifactsData, ListThreadArtifactsErrors, ListThreadArtifactsResponses, ListTraefikDiscoveredRoutesData, ListTraefikDiscoveredRoutesErrors, ListTraefikDiscoveredRoutesResponses, ListUserPendingActionsData, ListUserPendingActionsErrors, ListUserPendingActionsResponses, ListUsersData, ListUsersErrors, ListUsersResponses, ListWebhooksData, ListWebhooksErrors, ListWebhooksResponses, LoginData, LoginErrors, LoginResponses, LogoutData, LogoutErrors, LogoutResponses, LookupDnsARecordsData, LookupDnsARecordsErrors, LookupDnsARecordsResponses, MintEnrollmentTokenData, MintEnrollmentTokenErrors, MintEnrollmentTokenResponses, MkdirData, MkdirErrors, MkdirResponses, NodeHeartbeatData, NodeHeartbeatErrors, NodeHeartbeatResponses, NodeMetricsGetAlertRulesData, NodeMetricsGetAlertRulesErrors, NodeMetricsGetAlertRulesResponses, NodeMetricsGetRangeData, NodeMetricsGetRangeErrors, NodeMetricsGetRangeResponses, NodeMetricsUpdateAlertRuleData, NodeMetricsUpdateAlertRuleErrors, NodeMetricsUpdateAlertRuleResponses, ObservabilityFullEventData, ObservabilityFullEventErrors, ObservabilityFullEventResponses, ObservabilityListEventsData, ObservabilityListEventsErrors, ObservabilityListEventsResponses, OidcCallbackData, PatchAdminGateData, PatchAdminGateErrors, PatchAdminGateResponses, PatchPreviewGatewaySettingsData, PatchPreviewGatewaySettingsErrors, PatchPreviewGatewaySettingsResponses, PauseDeploymentData, PauseDeploymentErrors, PauseDeploymentResponses, PauseSandboxData, PauseSandboxErrors, PauseSandboxResponses, PlanRestoreData, PlanRestoreErrors, PlanRestoreResponses, PostDnsAckData, PostDnsAckErrors, PostDnsAckResponses, PreviewAlertData, PreviewAlertErrors, PreviewAlertResponses, PreviewFunnelMetricsData, PreviewFunnelMetricsErrors, PreviewFunnelMetricsResponses, PreviewHostnameModeData, PreviewHostnameModeErrors, PreviewHostnameModeResponses, PromoteClusterMemberData, PromoteClusterMemberErrors, PromoteClusterMemberResponses, PromoteDeploymentData, PromoteDeploymentErrors, PromoteDeploymentResponses, ProvisionDomainData, ProvisionDomainErrors, ProvisionDomainResponses, PurgeProjectLogsData, PurgeProjectLogsErrors, PurgeProjectLogsResponses, PushExternalImageData, PushExternalImageErrors, PushExternalImageResponses, QueryDataData, QueryDataErrors, QueryDataResponses, QueryGenaiTracesData, QueryGenaiTracesErrors, QueryGenaiTracesResponses, QueryLogsData, QueryLogsErrors, QueryLogsResponses, QueryMetricsData, QueryMetricsErrors, QueryMetricsResponses, QuerySpanStatsData, QuerySpanStatsErrors, QuerySpanStatsResponses, QueryTracesData, QueryTracesErrors, QueryTracesResponses, QueryTraceSummariesData, QueryTraceSummariesErrors, QueryTraceSummariesResponses, ReadEntityRowsData, ReadEntityRowsErrors, ReadEntityRowsResponses, ReadFileData, ReadFileErrors, ReadFileResponses, ReAnalyzeData, ReAnalyzeErrors, ReAnalyzeResponses, ReassignProjectCustomDomainData, ReassignProjectCustomDomainErrors, ReassignProjectCustomDomainResponses, ReconcileCloudBackupSourceData, ReconcileCloudBackupSourceResponses, RecordConsoleEventData, RecordConsoleEventErrors, RecordConsoleEventResponses, RecordEventMetricsData, RecordEventMetricsErrors, RecordEventMetricsResponses, RecordFlagExposureData, RecordFlagExposureErrors, RecordFlagExposureResponses, RecordSpeedMetricsData, RecordSpeedMetricsErrors, RecordSpeedMetricsResponses, RefreshAiProviderModelsData, RefreshAiProviderModelsErrors, RefreshAiProviderModelsResponses, RefreshAiProviderStatusData, RefreshAiProviderStatusErrors, RefreshAiProviderStatusResponses, RefreshProviderModelsData, RefreshProviderModelsErrors, RefreshProviderModelsResponses, RefreshRouteTableData, RefreshRouteTableErrors, RefreshRouteTableResponses, RegenerateDsnData, RegenerateDsnErrors, RegenerateDsnResponses, RegisterExternalImageData, RegisterExternalImageErrors, RegisterExternalImageResponses, RegisterNodeData, RegisterNodeErrors, RegisterNodeResponses, ReinstallGitlabWebhookData, ReinstallGitlabWebhookErrors, ReinstallGitlabWebhookResponses, RejectPendingActionData, RejectPendingActionErrors, RejectPendingActionResponses, RejectUserPendingActionData, RejectUserPendingActionErrors, RejectUserPendingActionResponses, ReloadPluginsData, ReloadPluginsErrors, ReloadPluginsResponses, RemoveClusterMemberData, RemoveClusterMemberErrors, RemoveClusterMemberResponses, RemoveManagedDomainData, RemoveManagedDomainErrors, RemoveManagedDomainResponses, RemoveRoleData, RemoveRoleErrors, RemoveRoleResponses, RemoveTeamMemberData, RemoveTeamMemberErrors, RemoveTeamMemberResponses, RenameConversationData, RenameConversationErrors, RenameConversationResponses, RenameUserConversationData, RenameUserConversationErrors, RenameUserConversationResponses, RenewDomainData, RenewDomainErrors, RenewDomainResponses, RepointContinuousArchiveSourceData, RepointContinuousArchiveSourceErrors, RepointContinuousArchiveSourceResponses, RequestDiscoveredRouteCertData, RequestDiscoveredRouteCertErrors, RequestDiscoveredRouteCertResponses, RequestPasswordResetData, RequestPasswordResetErrors, RequestPasswordResetResponses, ResetPasswordData, ResetPasswordErrors, ResetPasswordResponses, ResizeSandboxData, ResizeSandboxErrors, ResizeSandboxResponses, ResolveAlarmData, ResolveAlarmErrors, ResolveAlarmResponses, ResolvePermissionData, ResolvePermissionErrors, ResolvePermissionResponses, ResolveSystemAlarmData, ResolveSystemAlarmErrors, ResolveSystemAlarmResponses, ResolveUserPermissionData, ResolveUserPermissionErrors, ResolveUserPermissionResponses, RestartContainerData, RestartContainerErrors, RestartContainerResponses, RestartPreviewGatewayData, RestartPreviewGatewayErrors, RestartPreviewGatewayResponses, RestartSandboxData, RestartSandboxErrors, RestartSandboxResponses, RestoreApplicationData, RestoreApplicationErrors, RestoreApplicationResponses, RestoreFlagData, RestoreFlagErrors, RestoreFlagResponses, RestoreUserConversationData, RestoreUserConversationErrors, RestoreUserConversationResponses, RestoreUserData, RestoreUserErrors, RestoreUserResponses, ResumeDeploymentData, ResumeDeploymentErrors, ResumeDeploymentResponses, ResumeSandboxData, ResumeSandboxErrors, ResumeSandboxResponses, RetryClusterData, RetryClusterErrors, RetryClusterResponses, RetryDeliveryData, RetryDeliveryErrors, RetryDeliveryResponses, RetryFacetBackfillData, RetryFacetBackfillErrors, RetryFacetBackfillResponses, RetryPgUpgradeData, RetryPgUpgradeErrors, RetryPgUpgradeResponses, RetryRunData, RetryRunErrors, RetryRunResponses, RevealGlobalMcpConfigData, RevealGlobalMcpConfigErrors, RevealGlobalMcpConfigResponses, RevealMcpConfigData, RevealMcpConfigErrors, RevealMcpConfigResponses, RevealNotificationProviderConfigData, RevealNotificationProviderConfigErrors, RevealNotificationProviderConfigResponses, RevealServiceEnvironmentVariablesData, RevealServiceEnvironmentVariablesErrors, RevealServiceEnvironmentVariablesResponses, RevealServiceParameterData, RevealServiceParameterErrors, RevealServiceParameterResponses, RevenueCreateIntegrationData, RevenueCreateIntegrationErrors, RevenueCreateIntegrationResponses, RevenueDeleteIntegrationData, RevenueDeleteIntegrationResponses, RevenueGlobalEventsData, RevenueGlobalEventsResponses, RevenueImportInvoicesCsvData, RevenueImportInvoicesCsvErrors, RevenueImportInvoicesCsvResponses, RevenueImportSubscriptionsCsvData, RevenueImportSubscriptionsCsvErrors, RevenueImportSubscriptionsCsvResponses, RevenueListIntegrationsData, RevenueListIntegrationsResponses, RevenueListProvidersData, RevenueListProvidersResponses, RevenueMetricsCustomersData, RevenueMetricsCustomersResponses, RevenueMetricsGlobalMrrData, RevenueMetricsGlobalMrrResponses, RevenueMetricsGlobalSummaryData, RevenueMetricsGlobalSummaryResponses, RevenueMetricsMrrData, RevenueMetricsMrrResponses, RevenueMetricsSummaryData, RevenueMetricsSummaryResponses, RevenueRecentEventsData, RevenueRecentEventsResponses, RevenueRotateTokenData, RevenueRotateTokenResponses, RevenueUpdateConfigData, RevenueUpdateConfigErrors, RevenueUpdateConfigResponses, RevenueUpdateSecretData, RevenueUpdateSecretErrors, RevenueUpdateSecretResponses, RevokeAnalyticsIngestKeyData, RevokeAnalyticsIngestKeyErrors, RevokeAnalyticsIngestKeyResponses, RevokeDsnData, RevokeDsnErrors, RevokeDsnResponses, RevokeEmailDomainProjectData, RevokeEmailDomainProjectErrors, RevokeEmailDomainProjectResponses, RevokeEnrollmentTokenData, RevokeEnrollmentTokenErrors, RevokeEnrollmentTokenResponses, RevokeJoinTokenData, RevokeJoinTokenErrors, RevokeJoinTokenResponses, RevokeProjectAccessData, RevokeProjectAccessErrors, RevokeProjectAccessResponses, RollbackPgUpgradeData, RollbackPgUpgradeErrors, RollbackPgUpgradeResponses, RollbackToDeploymentData, RollbackToDeploymentErrors, RollbackToDeploymentResponses, RootfsGcData, RootfsGcResponses, RootfsReportData, RootfsReportResponses, RotateAnalyticsIngestKeyData, RotateAnalyticsIngestKeyErrors, RotateAnalyticsIngestKeyResponses, RotateApiKeyData, RotateApiKeyErrors, RotateApiKeyResponses, RotateClusterCaData, RotateClusterCaErrors, RotateClusterCaResponses, RotateDeploymentTokenData, RotateDeploymentTokenErrors, RotateDeploymentTokenResponses, RunBackupForSourceData, RunBackupForSourceErrors, RunBackupForSourceResponses, RunConnectionHealthCheckData, RunConnectionHealthCheckErrors, RunConnectionHealthCheckResponses, RunExternalServiceBackupData, RunExternalServiceBackupErrors, RunExternalServiceBackupResponses, RunScheduleNowData, RunScheduleNowErrors, RunScheduleNowResponses, SandboxCreatePreviewLinkData, SandboxCreatePreviewLinkErrors, SandboxCreatePreviewLinkResponses, SandboxIssueRuntimeEnvironmentData, SandboxIssueRuntimeEnvironmentErrors, SandboxIssueRuntimeEnvironmentResponses, SaveAgentTokenData, SaveAgentTokenErrors, SaveAgentTokenResponses, SaveAiProviderCredentialData, SaveAiProviderCredentialErrors, SaveAiProviderCredentialResponses, SearchLogsData, SearchLogsErrors, SearchLogsResponses, SendEmailData, SendEmailErrors, SendEmailResponses, SendFailureReportData, SendFailureReportErrors, SendFailureReportResponses, SendProjectAiMessageData, SendProjectAiMessageErrors, SendProjectAiMessageResponses, SendUserMessageData, SendUserMessageErrors, SendUserMessageResponses, SetAiDataAccessData, SetAiDataAccessErrors, SetAiDataAccessResponses, SetAlternateSourcesData, SetAlternateSourcesErrors, SetAlternateSourcesResponses, SetApplicationPrimaryProjectData, SetApplicationPrimaryProjectErrors, SetApplicationPrimaryProjectResponses, SetDefaultS3SourceData, SetDefaultS3SourceErrors, SetDefaultS3SourceResponses, SetFlagEnvironmentData, SetFlagEnvironmentErrors, SetFlagEnvironmentResponses, SetPreviewPasswordData, SetPreviewPasswordErrors, SetPreviewPasswordResponses, SetTraefikDiscoveredRouteEnabledData, SetTraefikDiscoveredRouteEnabledErrors, SetTraefikDiscoveredRouteEnabledResponses, SetupDnsChallengeData, SetupDnsChallengeErrors, SetupDnsChallengeResponses, SetupDnsData, SetupDnsErrors, SetupDnsResponses, SetupEmailTrackingData, SetupEmailTrackingErrors, SetupEmailTrackingResponses, SetupMfaData, SetupMfaErrors, SetupMfaResponses, SilenceAlarmData, SilenceAlarmErrors, SilenceAlarmResponses, SilenceSystemAlarmData, SilenceSystemAlarmErrors, SilenceSystemAlarmResponses, SleepEnvironmentData, SleepEnvironmentErrors, SleepEnvironmentResponses, SmokeTestAgentData, SmokeTestAgentErrors, SmokeTestAgentResponses, SourceSandboxData, SourceSandboxErrors, SourceSandboxResponses, StartAnalysisData, StartAnalysisErrors, StartAnalysisResponses, StartContainerData, StartContainerErrors, StartContainerResponses, StartFixData, StartFixErrors, StartFixResponses, StartGitProviderOauthData, StartGitProviderOauthErrors, StartOidcLoginBySlugData, StartOidcLoginBySlugErrors, StartPgUpgradeData, StartPgUpgradeErrors, StartPgUpgradeResponses, StartRestoreData, StartRestoreErrors, StartRestoreResponses, StartServiceData, StartServiceErrors, StartServiceResponses, StartUpdateData, StartUpdateErrors, StartUpdateResponses, StatPathData, StatPathErrors, StatPathResponses, StopContainerData, StopContainerErrors, StopContainerResponses, StopSandboxData, StopSandboxErrors, StopSandboxResponses, StopServiceData, StopServiceErrors, StopServiceResponses, StopTurnData, StopTurnErrors, StopTurnResponses, StopUserTurnData, StopUserTurnErrors, StopUserTurnResponses, StorageSummaryData, StorageSummaryErrors, StorageSummaryResponses, StreamContainerMetricsData, StreamContainerMetricsErrors, StreamContainerMetricsResponses, StreamEventsData, StreamEventsErrors, StreamEventsResponses, StreamRunEventsData, StreamRunEventsErrors, StreamRunEventsResponses, SyncRepositoriesData, SyncRepositoriesErrors, SyncRepositoriesResponses, TailDeploymentJobLogsData, TailDeploymentJobLogsErrors, TailLogsData, TailLogsErrors, TailLogsResponses, TeardownDeploymentData, TeardownDeploymentErrors, TeardownDeploymentResponses, TeardownEnvironmentData, TeardownEnvironmentErrors, TeardownEnvironmentResponses, TerminalData, TerminalErrors, TestNotificationProviderData, TestNotificationProviderErrors, TestNotificationProviderResponses, TestOidcProviderData, TestOidcProviderResponses, TestProviderConnectionData, TestProviderConnectionErrors, TestProviderConnectionResponses, TestProviderData, TestProviderErrors, TestProviderKeyByIdData, TestProviderKeyByIdErrors, TestProviderKeyByIdResponses, TestProviderKeyInlineData, TestProviderKeyInlineErrors, TestProviderKeyInlineResponses, TestProviderResponses, TestS3ConnectionPreviewData, TestS3ConnectionPreviewErrors, TestS3ConnectionPreviewResponses, TestS3SourceConnectionData, TestS3SourceConnectionErrors, TestS3SourceConnectionResponses, TrackClickData, TrackClickErrors, TrackOpenData, TrackOpenErrors, TrackOpenResponses, TriggerAgentData, TriggerAgentErrors, TriggerAgentResponses, TriggerProjectPipelineData, TriggerProjectPipelineErrors, TriggerProjectPipelineResponses, TriggerScanData, TriggerScanErrors, TriggerScanResponses, TriggerServiceHealthCheckData, TriggerServiceHealthCheckErrors, TriggerServiceHealthCheckResponses, TriggerWeeklyDigestData, TriggerWeeklyDigestErrors, TriggerWeeklyDigestResponses, UnlinkApplicationProjectData, UnlinkApplicationProjectErrors, UnlinkApplicationProjectResponses, UnlinkServiceFromProjectData, UnlinkServiceFromProjectErrors, UnlinkServiceFromProjectResponses, UpdateAgentData, UpdateAgentErrors, UpdateAgentResponses, UpdateAiProviderData, UpdateAiProviderErrors, UpdateAiProviderResponses, UpdateAiSummaryPreferenceData, UpdateAiSummaryPreferenceErrors, UpdateAiSummaryPreferenceResponses, UpdateAlertData, UpdateAlertErrors, UpdateAlertResponses, UpdateAlertRuleData, UpdateAlertRuleErrors, UpdateAlertRuleResponses, UpdateAnalyticsIngestKeyData, UpdateAnalyticsIngestKeyErrors, UpdateAnalyticsIngestKeyResponses, UpdateApiKeyData, UpdateApiKeyErrors, UpdateApiKeyResponses, UpdateApplicationWorkspaceData, UpdateApplicationWorkspaceErrors, UpdateApplicationWorkspaceResponses, UpdateAutomaticDeployData, UpdateAutomaticDeployErrors, UpdateAutomaticDeployResponses, UpdateBackupScheduleData, UpdateBackupScheduleErrors, UpdateBackupScheduleResponses, UpdateCloudFeaturesData, UpdateCloudFeaturesResponses, UpdateCloudflareProviderData, UpdateCloudflareProviderErrors, UpdateCloudflareProviderResponses, UpdateConnectionTokenData, UpdateConnectionTokenErrors, UpdateConnectionTokenResponses, UpdateCustomDomainData, UpdateCustomDomainErrors, UpdateCustomDomainResponses, UpdateDashboardData, UpdateDashboardErrors, UpdateDashboardResponses, UpdateDeploymentTokenData, UpdateDeploymentTokenErrors, UpdateDeploymentTokenResponses, UpdateEmailProviderData, UpdateEmailProviderErrors, UpdateEmailProviderResponses, UpdateEnvironmentSettingsData, UpdateEnvironmentSettingsErrors, UpdateEnvironmentSettingsResponses, UpdateEnvironmentSubdomainData, UpdateEnvironmentSubdomainErrors, UpdateEnvironmentSubdomainResponses, UpdateEnvironmentVariableData, UpdateEnvironmentVariableErrors, UpdateEnvironmentVariableResponses, UpdateErrorGroupData, UpdateErrorGroupErrors, UpdateErrorGroupResponses, UpdateFlagData, UpdateFlagErrors, UpdateFlagResponses, UpdateFunnelData, UpdateFunnelErrors, UpdateFunnelResponses, UpdateGitProviderCredentialsData, UpdateGitProviderCredentialsErrors, UpdateGitProviderCredentialsResponses, UpdateGitSettingsData, UpdateGitSettingsErrors, UpdateGitSettingsResponses, UpdateGlobalMcpData, UpdateGlobalMcpErrors, UpdateGlobalMcpResponses, UpdateGlobalSkillData, UpdateGlobalSkillErrors, UpdateGlobalSkillResponses, UpdateIncidentStatusData, UpdateIncidentStatusErrors, UpdateIncidentStatusResponses, UpdateIpAccessControlData, UpdateIpAccessControlErrors, UpdateIpAccessControlResponses, UpdateManagedDomainData, UpdateManagedDomainErrors, UpdateManagedDomainResponses, UpdateMcpData, UpdateMcpErrors, UpdateMcpResponses, UpdateNotificationEmailProviderData, UpdateNotificationEmailProviderErrors, UpdateNotificationEmailProviderResponses, UpdateNotificationProviderData, UpdateNotificationProviderErrors, UpdateNotificationProviderResponses, UpdateNotificationRouteData, UpdateNotificationRouteErrors, UpdateNotificationRouteResponses, UpdateOidcProviderData, UpdateOidcProviderResponses, UpdatePermissionModeData, UpdatePermissionModeErrors, UpdatePermissionModeResponses, UpdatePreferencesData, UpdatePreferencesErrors, UpdatePreferencesResponses, UpdateProjectCloudTelemetryData, UpdateProjectCloudTelemetryErrors, UpdateProjectCloudTelemetryResponses, UpdateProjectData, UpdateProjectDeploymentConfigData, UpdateProjectDeploymentConfigErrors, UpdateProjectDeploymentConfigResponses, UpdateProjectErrors, UpdateProjectResponses, UpdateProjectSecretData, UpdateProjectSecretErrors, UpdateProjectSecretResponses, UpdateProjectSettingsData, UpdateProjectSettingsErrors, UpdateProjectSettingsResponses, UpdateProviderData, UpdateProviderErrors, UpdateProviderKeyData, UpdateProviderKeyErrors, UpdateProviderKeyResponses, UpdateProviderModelData, UpdateProviderModelErrors, UpdateProviderModelResponses, UpdateProviderResponses, UpdateRouteData, UpdateRouteErrors, UpdateRouteResponses, UpdateS3SourceData, UpdateS3SourceErrors, UpdateS3SourceResponses, UpdateSelfData, UpdateSelfErrors, UpdateSelfResponses, UpdateServiceData, UpdateServiceErrors, UpdateServiceResourcesData, UpdateServiceResourcesErrors, UpdateServiceResourcesResponses, UpdateServiceResponses, UpdateServiceTemplateRuntimeData, UpdateServiceTemplateRuntimeErrors, UpdateServiceTemplateRuntimeResponses, UpdateSessionDurationData, UpdateSessionDurationErrors, UpdateSessionDurationResponses, UpdateSettingsData, UpdateSettingsErrors, UpdateSettingsResponses, UpdateSkillData, UpdateSkillErrors, UpdateSkillResponses, UpdateSlackProviderData, UpdateSlackProviderErrors, UpdateSlackProviderResponses, UpdateSpeedMetricsData, UpdateSpeedMetricsErrors, UpdateSpeedMetricsResponses, UpdateTeamData, UpdateTeamErrors, UpdateTeamMemberRoleData, UpdateTeamMemberRoleErrors, UpdateTeamMemberRoleResponses, UpdateTeamResponses, UpdateUserData, UpdateUserErrors, UpdateUserPermissionModeData, UpdateUserPermissionModeErrors, UpdateUserPermissionModeResponses, UpdateUserResponses, UpdateWebhookData, UpdateWebhookErrors, UpdateWebhookProviderData, UpdateWebhookProviderErrors, UpdateWebhookProviderResponses, UpdateWebhookResponses, UpgradePreviewGatewayData, UpgradePreviewGatewayErrors, UpgradePreviewGatewayResponses, UpgradeProjectServiceTemplateData, UpgradeProjectServiceTemplateErrors, UpgradeProjectServiceTemplateResponses, UpgradeServiceData, UpgradeServiceErrors, UpgradeServiceResponses, UploadApplicationWorkspaceFilesData, UploadApplicationWorkspaceFilesErrors, UploadApplicationWorkspaceFilesResponses, UploadGlobalSkillData, UploadGlobalSkillErrors, UploadGlobalSkillResponses, UploadGlobalWorkspaceFilesData, UploadGlobalWorkspaceFilesErrors, UploadGlobalWorkspaceFilesResponses, UploadReleaseFileData, UploadReleaseFileErrors, UploadReleaseFileResponses, UploadSkillData, UploadSkillErrors, UploadSkillResponses, UploadSourceFileData, UploadSourceFileErrors, UploadSourceFileResponses, UploadSourceMapData, UploadSourceMapErrors, UploadSourceMapResponses, UploadStaticBundleData, UploadStaticBundleErrors, UploadStaticBundleResponses, UploadUserConversationAttachmentData, UploadUserConversationAttachmentErrors, UploadUserConversationAttachmentResponses, UpsertSecretData, UpsertSecretErrors, UpsertSecretResponses, ValidateConnectionData, ValidateConnectionErrors, ValidateConnectionResponses, ValidateEmailData, ValidateEmailErrors, ValidateEmailResponses, VerifyAndEnableMfaData, VerifyAndEnableMfaErrors, VerifyAndEnableMfaResponses, VerifyDomainData, VerifyDomainErrors, VerifyDomainResponses, VerifyEmailData, VerifyEmailErrors, VerifyEmailResponses, VerifyManagedDomainData, VerifyManagedDomainErrors, VerifyManagedDomainResponses, VerifyMfaChallengeData, VerifyMfaChallengeErrors, VerifyMfaChallengeResponses, VerifyStepUpData, VerifyStepUpErrors, VerifyStepUpResponses, WakeEnvironmentData, WakeEnvironmentErrors, WakeEnvironmentResponses, WebhookTriggerData, WebhookTriggerErrors, WebhookTriggerResponses, WorkflowDryRunData, WorkflowDryRunErrors, WorkflowDryRunResponses, WriteApplicationWorkspaceFilesData, WriteApplicationWorkspaceFilesErrors, WriteApplicationWorkspaceFilesResponses, WriteFileData, WriteFileErrors, WriteFileResponses, WriteFilesData, WriteFilesErrors, WriteFilesResponses } from './types.gen'; export type Options = Options2 & { /** @@ -705,16 +705,6 @@ export const getPricing = (options?: Optio ...options }); -export const updateAiProviderPreference = (options: Options): RequestResult => (options.client ?? client).put({ - security: [{ scheme: 'bearer', type: 'http' }], - url: '/ai/provider-preference', - ...options, - headers: { - 'Content-Type': 'application/json', - ...options.headers - } -}); - export const getAiProviderStatus = (options?: Options): RequestResult => (options?.client ?? client).get({ security: [{ scheme: 'bearer', type: 'http' }], url: '/ai/provider-status', @@ -2826,6 +2816,8 @@ export const listServices = (options?: Opt /** * Create new external service + * + * Create a managed external service. The `parameters` object is service-type-specific. Read `get_service_type_parameters` for the chosen `service_type` immediately before creating the service and provide every field that schema marks as required. Set `project_id` to create and link the service in one approval-gated operation. */ export const createService = (options: Options): RequestResult => (options.client ?? client).post({ url: '/external-services', @@ -8546,6 +8538,29 @@ export const saveAiProviderCredential = (o } }); +/** + * Import the credential already used by this provider's CLI on the Temps + * host. Discovery and encryption happen entirely server-side; the plaintext + * credential is never serialized into the response or browser state. + */ +export const importLocalAiProviderCredential = (options: Options): RequestResult => (options.client ?? client).post({ + security: [{ scheme: 'bearer', type: 'http' }], + url: '/settings/ai-providers/{provider_id}/credential/import-local', + ...options +}); + +/** + * Refresh exactly one provider's account-aware model inventory. This is an + * explicit write operation because it starts a CLI process (and, for Claude + * workspaces, a short-lived isolated sandbox). The AI service applies a + * provider-scoped single-flight and cooldown before doing that work. + */ +export const refreshAiProviderModels = (options: Options): RequestResult => (options.client ?? client).post({ + security: [{ scheme: 'bearer', type: 'http' }], + url: '/settings/ai-providers/{provider_id}/models/refresh', + ...options +}); + /** * Replace a compromised cluster CA and invalidate outstanding enrollment * tokens. Existing workers fail closed until they are re-enrolled. @@ -9563,6 +9578,16 @@ export const resumeSandbox = (options: Opt ...options }); +/** + * Issue the same scoped service variables used by a deployment runtime for + * the project attached to this sandbox. + */ +export const sandboxIssueRuntimeEnvironment = (options: Options): RequestResult => (options.client ?? client).post({ + security: [{ scheme: 'bearer', type: 'http' }], + url: '/v1/sandboxes/{id}/runtime-environment', + ...options +}); + /** * `POST /v1/sandboxes/{id}/snapshots` * diff --git a/web/src/api/client/types.gen.ts b/web/src/api/client/types.gen.ts index b11b86a46..7091d865f 100644 --- a/web/src/api/client/types.gen.ts +++ b/web/src/api/client/types.gen.ts @@ -718,24 +718,6 @@ export type AiChatLimitsSettings = { turn_timeout_secs?: number; }; -/** - * Mirrors `temps_agents::ai_cli::AiCliStatus` with utoipa `ToSchema` added. - * `AiCliStatus` itself does not derive `ToSchema`, so this local projection is - * used for OpenAPI generation only — the fields are identical. - */ -export type AiCliStatusDto = { - auth_method?: string | null; - authenticated: boolean; - installed: boolean; - provider: string; - /** - * Instructions for the operator when not installed or not authenticated. - */ - setup_hint?: string | null; - subscription_type?: string | null; - version?: string | null; -}; - /** * Global AI configuration settings. Controls the default config repo * containing `.claude/` directory (skills, MCP servers, plugins) that @@ -801,7 +783,7 @@ export type AiPageBreakdownRow = { }; /** - * Current AI provider routing preference and availability for this instance. + * Current API-gateway availability for this instance. * * The `configured` field drives the UI onboarding state: when `false` the UI * must show _exactly what is missing_ (`reason`) and _where to fix it_ @@ -809,18 +791,8 @@ export type AiPageBreakdownRow = { */ export type AiProviderStatusResponse = { /** - * Active preference: `"gateway"` (BYOK) or `"agent_cli"` (subscription). - */ - active_provider_type: string; - /** - * Catalog id of the active agent CLI provider, or `null` when - * `active_provider_type` is `"gateway"`. - */ - agent_cli_provider_id?: string | null; - agent_cli_status?: null | AiCliStatusDto; - /** - * Providers a chat user may choose for a new conversation. Authentication - * source is descriptive metadata only and never contains credentials. + * Gateway providers available to API-backed chat and summaries. Credential + * source is descriptive metadata only and never contains secret values. */ available_providers: Array; /** @@ -888,8 +860,8 @@ export type AiSummaryPreferenceDto = { */ model?: string | null; /** - * Normalized provider route (`gateway_key:{id}`, `claude_cli`, etc.). - * `null` inherits the active instance provider. + * Normalized gateway route (`gateway_key:{id}`). `null` inherits the + * active gateway key. */ provider_id?: string | null; /** @@ -2128,8 +2100,7 @@ export type AutofixerRunWithLogsResponse = { export type AvailableAiProviderDto = { /** - * `configured_key` for the gateway or `host_environment` for an ambient - * CLI login discovered in the Temps process environment. + * `configured_key` for an encrypted gateway key. */ auth_source: string; default_model_id?: string | null; @@ -4821,9 +4792,22 @@ export type CreateExternalServiceRequest = { * Target node ID for the service. Omit or null to run on the control plane. */ node_id?: number | null; + /** + * Service-type-specific configuration. Read + * `GET /external-services/types/{service_type}/parameters` before creating + * a service and provide every field its schema marks as required. Secret + * values that the schema describes as auto-generated may be omitted. + */ parameters: { [key: string]: unknown; }; + /** + * Optionally link the new service to this project as part of the same + * request. The caller must have write access to the target project. If + * linking fails, Temps removes the newly created service so callers do + * not have to recover an ambiguous half-created resource. + */ + project_id?: number | null; service_type: CreatableServiceTypeRoute; /** * Service topology: "standalone" (default) or "cluster" (HA multi-member). @@ -5521,7 +5505,8 @@ export type CreateSandboxBody = { * no explicit `source` is given, and the sandbox is attributed to the * project so it can be listed alongside it. * - * Requires access to the project — the same team/scope rules that + * Requires access to the project and `git_repositories:read` when Temps + * derives the source from the project. The same team/scope rules that * gate every other project-scoped endpoint apply. */ project_id?: number | null; @@ -9017,6 +9002,20 @@ export type ExternalServiceDetails = { export type ExternalServiceInfo = { connection_info?: string | null; + /** + * When `continuous_archive_s3_source_id` was last set. Null alongside + * a non-null source id means it was set by the original provisioning + * flow rather than an explicit repoint. + */ + continuous_archive_pinned_at?: string | null; + /** + * S3 source ID that this service's continuous archiving (Postgres/ + * Timescale WAL-G `archive_command`, or MariaDB's binlog shipper) + * currently writes to. Null for service types with no continuous + * archiving concept, or a Postgres/MariaDB service that has never had + * one provisioned. Change it with `repoint_continuous_archive_source`. + */ + continuous_archive_s3_source_id?: number | null; created_at: string; /** * Error message from failed initialization. @@ -10591,6 +10590,14 @@ export type ImportExternalServiceRequest = { version?: string | null; }; +export type ImportLocalCredentialResponse = { + auth_type: string; + provider_id: string; + saved: boolean; + source: string; + workspace_ready: boolean; +}; + export type ImportOutcomeResponse = { errors: Array; inserted: number; @@ -11684,6 +11691,19 @@ export type LiveVisitorsListResponse = { window_minutes: number; }; +/** + * Metadata about a credential that Temps can import from the server process + * user's existing CLI login. This never includes a path or credential value. + */ +export type LocalCredentialDto = { + auth_type: string; + label: string; + /** + * Stable machine-readable source: `environment` or `host_auth_store`. + */ + source: string; +}; + export type LocationCount = { count: number; location: string; @@ -12307,6 +12327,14 @@ export type ModelCapability = { tool_thinking_modes?: Array | null; }; +/** + * Provenance of a provider model inventory. Only live and unexpired cached + * inventories are authoritative enough to reject a saved model. Bootstrap + * and stale inventories remain useful for selectors, but must not block a + * turn because account entitlements may legitimately differ. + */ +export type ModelCatalogSource = 'live' | 'cache' | 'stale_cache' | 'bootstrap'; + export type ModelInfo = { id: string; object: string; @@ -14609,11 +14637,13 @@ export type PreviewGatewayLogsResponse = { /** * Workspace preview gateway settings. * - * The preview gateway is a single shared Docker container that lives on the - * `temps-sandbox-net` network and routes requests to workspace sandbox dev - * servers based on the `Host` header (`ws--.`). - * `temps serve` reconciles this container on startup; these settings let an - * operator override the image, host port, and auto-upgrade behavior. + * The preview gateway uses a private routing container plus a hardened ingress + * relay bound to host loopback. The router joins each sandbox's isolated + * network and routes requests to workspace dev servers based on the `Host` + * header (`ws--.`), while the relay never joins a + * tenant network. `temps serve` reconciles both containers on startup; these + * settings let an operator override the router image, host port, and + * auto-upgrade behavior. */ export type PreviewGatewaySettings = { /** @@ -15029,14 +15059,6 @@ export type ProjectResponse = { * Opt-in to AI summarization of API traffic analytics (NULL/false = off). */ ai_api_traffic_summary_enabled?: boolean | null; - /** - * Opt-in to AI debugging chat, e.g. on deployment failures (NULL/false = off). - */ - ai_debug_chat_enabled?: boolean | null; - /** - * Opt-in to AI propose-then-confirm write capability (false = off). - */ - ai_write_actions_enabled: boolean; /** * Whether this project also accepts deployments from a source other than * `source_type` — chiefly, whether a Git-backed project will take an @@ -15564,6 +15586,7 @@ export type ProviderCatalogDto = { host_version?: string | null; id: string; install_command: string; + local_credential?: null | LocalCredentialDto; /** * Default max turns for the autofixer analysis phase. `None` = built-in * default (10). Only enforced for CLIs with a turn flag (Claude Code). @@ -15580,9 +15603,9 @@ export type ProviderCatalogDto = { */ max_turns_fix?: number | null; /** - * `live`, `cache`, `stale_cache`, or `bootstrap`. + * Whether the catalog is live, cached, stale, or a bootstrap fallback. */ - model_source: string; + model_source: ModelCatalogSource; /** * Model ids this provider accepts, in display order. The first entry is * the recommended default. Empty when the provider doesn't expose model @@ -16319,6 +16342,14 @@ export type ReferrersAnalyticsQuery = { start_date: string; }; +export type RefreshProviderModelsResponse = { + default_runtime_model_id?: string | null; + model_source: ModelCatalogSource; + models_refreshed_at?: string | null; + provider_id: string; + runtime_models: Array; +}; + export type RegenerateDsnRequest = { base_url?: string | null; }; @@ -17474,6 +17505,16 @@ export type SandboxRoute = { url: string; }; +/** + * Live project runtime variables issued to a sandbox. Values are deliberately + * absent from Debug output and must not be cached or persisted by Temps. + */ +export type SandboxRuntimeEnvironmentResponse = { + variables: { + [key: string]: string; + }; +}; + export type SandboxStatusResponse = { docker_available: boolean; error?: string | null; @@ -19512,9 +19553,17 @@ export type SourceBackupIndexResponse = { */ export type SourceBody = { depth?: number | null; + /** + * Optional path relative to the sandbox work directory. + */ + destination?: string | null; git_connection_id?: number | null; password?: string | null; revision?: string | null; + /** + * Remove `/.git` after cloning. Requires destination. + */ + strip_git_metadata?: boolean; type: 'git'; url: string; username?: string | null; @@ -20608,7 +20657,7 @@ export type TestProviderKeyRequest = { */ base_url?: string | null; /** - * Provider ID: "openai", "anthropic", "xai", "gemini" + * Provider ID: "openai", "anthropic", "xai", "gemini", "openrouter" */ provider: string; }; @@ -22316,14 +22365,6 @@ export type UpdateProjectSettingsRequest = { * Opt in to AI summarization of API traffic analytics. */ ai_api_traffic_summary_enabled?: boolean | null; - /** - * Opt in to AI debugging chat, e.g. on deployment failures (ADR-023). - */ - ai_debug_chat_enabled?: boolean | null; - /** - * Opt in to AI propose-then-confirm write capability. - */ - ai_write_actions_enabled?: boolean | null; /** * Enable/disable attack mode (CAPTCHA protection) for all project environments */ @@ -22453,25 +22494,6 @@ export type UpdateProviderModelRequest = { is_enabled: boolean; }; -/** - * Request body for `PUT /api/ai/provider-preference`. - */ -export type UpdateProviderPreferenceRequest = { - /** - * Required when `provider_type` is `"agent_cli"`. - */ - agent_cli_provider_id?: string | null; - /** - * Deprecated compatibility field. Adapter realtime behavior is derived - * from its capability contract and cannot be toggled independently. - */ - interactive_bridge_enabled?: boolean | null; - /** - * `"gateway"` or `"agent_cli"`. - */ - provider_type: string; -}; - export type UpdateProviderRequest = { config?: unknown; enabled?: boolean | null; @@ -25528,43 +25550,6 @@ export type GetPricingResponses = { export type GetPricingResponse = GetPricingResponses[keyof GetPricingResponses]; -export type UpdateAiProviderPreferenceData = { - body: UpdateProviderPreferenceRequest; - path?: never; - query?: never; - url: '/ai/provider-preference'; -}; - -export type UpdateAiProviderPreferenceErrors = { - /** - * Validation error - */ - 400: ProblemDetails; - /** - * Unauthorized - */ - 401: ProblemDetails; - /** - * Insufficient permissions - */ - 403: ProblemDetails; - /** - * Internal server error - */ - 500: ProblemDetails; -}; - -export type UpdateAiProviderPreferenceError = UpdateAiProviderPreferenceErrors[keyof UpdateAiProviderPreferenceErrors]; - -export type UpdateAiProviderPreferenceResponses = { - /** - * Updated provider preference and availability - */ - 200: AiProviderStatusResponse; -}; - -export type UpdateAiProviderPreferenceResponse = UpdateAiProviderPreferenceResponses[keyof UpdateAiProviderPreferenceResponses]; - export type GetAiProviderStatusData = { body?: never; path?: never; @@ -25870,7 +25855,7 @@ export type RefreshProviderModelsResponses = { 200: Array; }; -export type RefreshProviderModelsResponse = RefreshProviderModelsResponses[keyof RefreshProviderModelsResponses]; +export type RefreshProviderModelsResponse2 = RefreshProviderModelsResponses[keyof RefreshProviderModelsResponses]; export type DeleteProviderModelData = { body?: never; @@ -33707,13 +33692,13 @@ export type ListServicesData = { /** * Page number (1-indexed) */ - page?: number | null; + page?: number; /** * Number of items per page (max 100) */ - page_size?: number | null; - sort_by?: string | null; - sort_order?: string | null; + page_size?: number; + sort_by?: string; + sort_order?: string; }; url: '/external-services'; }; @@ -33895,13 +33880,13 @@ export type ListProjectServicesData = { /** * Page number (1-indexed) */ - page?: number | null; + page?: number; /** * Number of items per page (max 100) */ - page_size?: number | null; - sort_by?: string | null; - sort_order?: string | null; + page_size?: number; + sort_by?: string; + sort_order?: string; }; url: '/external-services/projects/{project_id}'; }; @@ -35008,13 +34993,13 @@ export type ListServiceProjectsData = { /** * Page number (1-indexed) */ - page?: number | null; + page?: number; /** * Number of items per page (max 100) */ - page_size?: number | null; - sort_by?: string | null; - sort_order?: string | null; + page_size?: number; + sort_by?: string; + sort_order?: string; }; url: '/external-services/{id}/projects'; }; @@ -40375,13 +40360,13 @@ export type ListNotificationProvidersData = { /** * Page number (1-indexed) */ - page?: number | null; + page?: number; /** * Number of items per page (max 100) */ - page_size?: number | null; - sort_by?: string | null; - sort_order?: string | null; + page_size?: number; + sort_by?: string; + sort_order?: string; }; url: '/notification-providers'; }; @@ -40864,13 +40849,13 @@ export type ListNotificationRoutesData = { /** * Page number (1-indexed) */ - page?: number | null; + page?: number; /** * Number of items per page (max 100) */ - page_size?: number | null; - sort_by?: string | null; - sort_order?: string | null; + page_size?: number; + sort_by?: string; + sort_order?: string; }; url: '/notification-routes'; }; @@ -41033,13 +41018,13 @@ export type ListOrdersData = { /** * Page number (1-indexed) */ - page?: number | null; + page?: number; /** * Number of items per page (max 100) */ - page_size?: number | null; - sort_by?: string | null; - sort_order?: string | null; + page_size?: number; + sort_by?: string; + sort_order?: string; }; url: '/orders'; }; @@ -54092,13 +54077,13 @@ export type ListWebhooksData = { /** * Page number (1-indexed) */ - page?: number | null; + page?: number; /** * Number of items per page (max 100) */ - page_size?: number | null; - sort_by?: string | null; - sort_order?: string | null; + page_size?: number; + sort_by?: string; + sort_order?: string; }; url: '/projects/{project_id}/webhooks'; }; @@ -56457,12 +56442,6 @@ export type ListAiProvidersData = { * first paint; an authenticated refresh follows in the background. */ catalog_only?: boolean; - /** - * Run account-aware model discovery before returning. Normal catalog - * reads intentionally use cached/bootstrap models so chat first paint is - * not held hostage by provider CLIs that can take 10-15 seconds. - */ - refresh_models?: boolean; }; url: '/settings/ai-providers'; }; @@ -56567,6 +56546,80 @@ export type SaveAiProviderCredentialResponses = { export type SaveAiProviderCredentialResponse = SaveAiProviderCredentialResponses[keyof SaveAiProviderCredentialResponses]; +export type ImportLocalAiProviderCredentialData = { + body?: never; + path: { + /** + * AI provider ID + */ + provider_id: string; + }; + query?: never; + url: '/settings/ai-providers/{provider_id}/credential/import-local'; +}; + +export type ImportLocalAiProviderCredentialErrors = { + /** + * Unknown provider or invalid local credential + */ + 400: unknown; + /** + * Unauthorized + */ + 401: unknown; + /** + * System administrator permission required + */ + 403: unknown; + /** + * No importable local credential found + */ + 404: unknown; +}; + +export type ImportLocalAiProviderCredentialResponses = { + 200: ImportLocalCredentialResponse; +}; + +export type ImportLocalAiProviderCredentialResponse = ImportLocalAiProviderCredentialResponses[keyof ImportLocalAiProviderCredentialResponses]; + +export type RefreshAiProviderModelsData = { + body?: never; + path: { + /** + * AI provider ID + */ + provider_id: string; + }; + query?: never; + url: '/settings/ai-providers/{provider_id}/models/refresh'; +}; + +export type RefreshAiProviderModelsErrors = { + /** + * Unknown provider + */ + 400: unknown; + /** + * Unauthorized + */ + 401: unknown; + /** + * Settings write permission required + */ + 403: unknown; + /** + * Provider model discovery unavailable + */ + 503: unknown; +}; + +export type RefreshAiProviderModelsResponses = { + 200: RefreshProviderModelsResponse; +}; + +export type RefreshAiProviderModelsResponse = RefreshAiProviderModelsResponses[keyof RefreshAiProviderModelsResponses]; + export type RotateClusterCaData = { body: RotateClusterCaRequest; path?: never; @@ -59794,6 +59847,47 @@ export type ResumeSandboxResponses = { export type ResumeSandboxResponse = ResumeSandboxResponses[keyof ResumeSandboxResponses]; +export type SandboxIssueRuntimeEnvironmentData = { + body?: never; + path: { + id: string; + }; + query?: never; + url: '/v1/sandboxes/{id}/runtime-environment'; +}; + +export type SandboxIssueRuntimeEnvironmentErrors = { + /** + * Sandbox has no attached project + */ + 400: unknown; + /** + * Plaintext secret access is not permitted + */ + 403: unknown; + /** + * Sandbox or project environment not found + */ + 404: unknown; + /** + * Linked services expose ambiguous variables + */ + 409: unknown; + /** + * Runtime credential provider unavailable + */ + 503: unknown; +}; + +export type SandboxIssueRuntimeEnvironmentResponses = { + /** + * Runtime variables issued + */ + 200: SandboxRuntimeEnvironmentResponse; +}; + +export type SandboxIssueRuntimeEnvironmentResponse = SandboxIssueRuntimeEnvironmentResponses[keyof SandboxIssueRuntimeEnvironmentResponses]; + export type CreateSnapshotData = { body: CreateSnapshotBody; path: { diff --git a/web/src/components/agents/AgentEditPage.tsx b/web/src/components/agents/AgentEditPage.tsx index 21e655600..09ea92998 100644 --- a/web/src/components/agents/AgentEditPage.tsx +++ b/web/src/components/agents/AgentEditPage.tsx @@ -36,6 +36,7 @@ import type { AgentConfigResponse, UpsertAgentRequest, } from '@/api/client/types.gen' +import { aiProviderCatalogQueryOptions } from '@/lib/ai-provider-catalog-query' export interface TriggerConfig { error?: { new_issue?: boolean; regression?: boolean } @@ -175,19 +176,7 @@ function AgentEditForm({ ) const { data: providerCatalog } = useQuery({ - queryKey: ['ai-provider-catalog'], - queryFn: async () => { - const res = await fetch('/api/settings/ai-providers') - if (!res.ok) return null - return res.json() as Promise<{ - default_provider: string - providers: Array<{ - id: string - models: string[] - default_model: string | null - }> - }> - }, + ...aiProviderCatalogQueryOptions, staleTime: 60 * 1000, }) const availableModels = diff --git a/web/src/components/agents/AutopilotPage.tsx b/web/src/components/agents/AutopilotPage.tsx index 4da0c79b3..57bf62251 100644 --- a/web/src/components/agents/AutopilotPage.tsx +++ b/web/src/components/agents/AutopilotPage.tsx @@ -51,6 +51,7 @@ import { updateAgentMutation, } from '@/api/client/@tanstack/react-query.gen' import type { AgentRunResponse } from '@/api/client/types.gen' +import { aiProviderCatalogQueryOptions } from '@/lib/ai-provider-catalog-query' import { AutopilotStatusBadge } from './AutopilotStatusBadge' type AgentRun = AgentRunResponse @@ -386,19 +387,7 @@ export function AutopilotPage({ project }: AutopilotPageProps) { // Fetch the provider catalog to determine the platform's configured default // and whether credentials are saved (which is what actually matters for sandbox mode) const { data: providerCatalog } = useQuery({ - queryKey: ['ai-provider-catalog'], - queryFn: async () => { - const res = await fetch('/api/settings/ai-providers') - if (!res.ok) return null - return res.json() as Promise<{ - default_provider: string - providers: Array<{ - id: string - name: string - credential_saved: boolean - }> - }> - }, + ...aiProviderCatalogQueryOptions, staleTime: 60_000, }) diff --git a/web/src/components/ai-first/AiFirstWorkspace.test.tsx b/web/src/components/ai-first/AiFirstWorkspace.test.tsx index f253cfd17..8167158e5 100644 --- a/web/src/components/ai-first/AiFirstWorkspace.test.tsx +++ b/web/src/components/ai-first/AiFirstWorkspace.test.tsx @@ -4,6 +4,7 @@ import { describe, expect, test } from 'bun:test' import { renderToStaticMarkup } from 'react-dom/server' import { MemoryRouter } from 'react-router' +import type { ProviderCatalogDto } from '@/api/client' import { ApplicationStartScreen, HarnessPicker, @@ -16,6 +17,8 @@ import { import { problemDetail } from './problem-detail' import { workspaceHarnessOptions, + workspaceNeedsAutomaticWake, + workspaceShouldAttemptAutomaticWake, workspaceStatusClickTarget, workspaceStatusPresentation, } from './workspace-readiness' @@ -68,7 +71,7 @@ describe('HarnessPicker', () => { runtime_models: [], supports_max_turns: false, workspace_readiness_hint: null, - } + } satisfies Omit const harnesses = workspaceHarnessOptions([ { ...base, @@ -165,6 +168,43 @@ describe('WorkspaceStatusIndicator', () => { expect(workspaceStatusClickTarget(false, workspace)).toBe('workspace') expect(workspaceStatusClickTarget(false, null)).toBeNull() }) + + test('automatically wakes sleeping and failed desired-running workspaces only', () => { + expect( + workspaceNeedsAutomaticWake({ ...workspace, state: 'sleeping' }) + ).toBe(true) + expect(workspaceNeedsAutomaticWake({ ...workspace, state: 'failed' })).toBe( + true + ) + expect( + workspaceNeedsAutomaticWake({ ...workspace, state: 'recovering' }) + ).toBe(false) + expect(workspaceNeedsAutomaticWake(workspace)).toBe(false) + expect( + workspaceNeedsAutomaticWake({ + ...workspace, + desired_state: 'paused', + state: 'sleeping', + }) + ).toBe(false) + }) + + test('attempts an automatic wake only once per selected application', () => { + const failed = { ...workspace, state: 'failed' } + + expect( + workspaceShouldAttemptAutomaticWake(failed, 'app_one', null, null) + ).toBe(true) + expect( + workspaceShouldAttemptAutomaticWake(failed, 'app_one', 'app_one', null) + ).toBe(false) + expect( + workspaceShouldAttemptAutomaticWake(failed, 'app_one', null, 'app_one') + ).toBe(false) + expect( + workspaceShouldAttemptAutomaticWake(failed, 'app_two', 'app_one', null) + ).toBe(true) + }) }) describe('ApplicationStartScreen', () => { diff --git a/web/src/components/ai-first/AiFirstWorkspace.tsx b/web/src/components/ai-first/AiFirstWorkspace.tsx index a3639e361..4e057f12e 100644 --- a/web/src/components/ai-first/AiFirstWorkspace.tsx +++ b/web/src/components/ai-first/AiFirstWorkspace.tsx @@ -145,6 +145,7 @@ import { import { workspaceHarnessOptions, + workspaceShouldAttemptAutomaticWake, workspaceStatusClickTarget, workspaceStatusPresentation, type WorkspaceHarnessOption as HarnessOption, @@ -292,6 +293,7 @@ export function AiFirstWorkspace() { const workspaceDiffGeneration = useRef(0) const harnessRequestGeneration = useRef(0) const workspaceWakeInFlight = useRef(null) + const workspaceWakeAttempted = useRef(null) useEffect(() => { if (!leftPanelOpen) return @@ -851,12 +853,12 @@ export function AiFirstWorkspace() { // remains open. Re-read the inventory whenever an application/thread // chooser opens instead of requiring a full-page reload to see the newly // configured harness. - const loadHarnesses = useCallback(async (refreshModels = false) => { + const loadHarnesses = useCallback(async () => { const requestGeneration = ++harnessRequestGeneration.current setHarnessesLoading(true) try { const { data } = await listAiProviders({ - query: { refresh_models: refreshModels }, + query: { catalog_only: false }, throwOnError: true, }) if (requestGeneration !== harnessRequestGeneration.current) return @@ -877,10 +879,14 @@ export function AiFirstWorkspace() { const { data } = await refetchApplicationWorkspace() if (!data) return if ( - data.desired_state === 'running' && - data.state === 'sleeping' && - workspaceWakeInFlight.current !== activeApplicationId + workspaceShouldAttemptAutomaticWake( + data, + activeApplicationId, + workspaceWakeAttempted.current, + workspaceWakeInFlight.current + ) ) { + workspaceWakeAttempted.current = activeApplicationId workspaceWakeInFlight.current = activeApplicationId setActiveWorkspaceWaking(true) try { @@ -893,6 +899,11 @@ export function AiFirstWorkspace() { applicationWorkspaceOptions.queryKey, resumed ) + } catch { + // The backend persists a safe, actionable diagnostic. Re-read it + // immediately so the failed automatic wake is visible without + // waiting for the next polling interval. + await refetchApplicationWorkspace() } finally { if (workspaceWakeInFlight.current === activeApplicationId) { workspaceWakeInFlight.current = null @@ -917,14 +928,25 @@ export function AiFirstWorkspace() { const queriedWorkspace = activeApplicationId ? applicationWorkspaceQuery.data : globalWorkspaceQuery.data + useEffect(() => { + const resetTimer = window.setTimeout(() => { + workspaceWakeInFlight.current = null + workspaceWakeAttempted.current = null + setActiveWorkspaceWaking(false) + }, 0) + return () => window.clearTimeout(resetTimer) + }, [activeApplicationId]) + useEffect(() => { if (!queriedWorkspace) return const syncTimer = window.setTimeout(() => { if ( - activeApplicationId && - queriedWorkspace.desired_state === 'running' && - queriedWorkspace.state === 'sleeping' && - workspaceWakeInFlight.current !== activeApplicationId + workspaceShouldAttemptAutomaticWake( + queriedWorkspace, + activeApplicationId, + workspaceWakeAttempted.current, + workspaceWakeInFlight.current + ) ) { void loadActiveWorkspaceStatus() } @@ -932,14 +954,6 @@ export function AiFirstWorkspace() { return () => window.clearTimeout(syncTimer) }, [activeApplicationId, loadActiveWorkspaceStatus, queriedWorkspace]) - useEffect(() => { - const resetTimer = window.setTimeout(() => { - workspaceWakeInFlight.current = null - setActiveWorkspaceWaking(false) - }, 0) - return () => window.clearTimeout(resetTimer) - }, [activeApplicationId]) - useEffect(() => { const harnessLoadTimer = window.setTimeout(() => void loadHarnesses(), 0) return () => { diff --git a/web/src/components/ai-first/ApplicationWorkspaceSettingsPanel.test.tsx b/web/src/components/ai-first/ApplicationWorkspaceSettingsPanel.test.tsx index f5aa98f44..5b48e628b 100644 --- a/web/src/components/ai-first/ApplicationWorkspaceSettingsPanel.test.tsx +++ b/web/src/components/ai-first/ApplicationWorkspaceSettingsPanel.test.tsx @@ -59,4 +59,30 @@ describe('ApplicationWorkspaceSettingsPanel', () => { expect(html).not.toContain('Harness maintenance') }) + + test('shows a failed startup reason and retry before lifecycle controls', () => { + const html = renderToStaticMarkup( + + + + ) + + expect(html).toContain('role="alert"') + expect(html).toContain('Workspace could not start') + expect(html).toContain( + 'This Temps host has no private sandbox network capacity available.' + ) + expect(html).toContain('Try again') + expect(html.indexOf('Workspace could not start')).toBeLessThan( + html.indexOf('Lifecycle') + ) + }) }) diff --git a/web/src/components/ai-first/ApplicationWorkspaceSettingsPanel.tsx b/web/src/components/ai-first/ApplicationWorkspaceSettingsPanel.tsx index 1c219d886..aed2d6ee7 100644 --- a/web/src/components/ai-first/ApplicationWorkspaceSettingsPanel.tsx +++ b/web/src/components/ai-first/ApplicationWorkspaceSettingsPanel.tsx @@ -3,6 +3,7 @@ import { Activity, + AlertTriangle, Archive, ArchiveRestore, Bot, @@ -44,6 +45,7 @@ import { harnessUpgradeCommands, sandboxShellCommand, } from './harness-upgrade-commands' +import { problemDetail } from './problem-detail' type Props = { applicationPublicId: string @@ -100,7 +102,7 @@ export function ApplicationWorkspaceSettingsPanel({ }) acceptWorkspace(data) } catch (cause) { - setError(errorMessage(cause, 'Could not load workspace status.')) + setError(problemDetail(cause, 'Could not load workspace status.')) } finally { setLoading(false) } @@ -133,7 +135,7 @@ export function ApplicationWorkspaceSettingsPanel({ }) acceptWorkspace(data) } catch (cause) { - setError(errorMessage(cause, `Could not ${action} the workspace.`)) + setError(problemDetail(cause, `Could not ${action} the workspace.`)) } finally { setBusy(null) } @@ -157,7 +159,7 @@ export function ApplicationWorkspaceSettingsPanel({ }) acceptWorkspace(data) } catch (cause) { - setError(errorMessage(cause, 'Could not save workspace resources.')) + setError(problemDetail(cause, 'Could not save workspace resources.')) } finally { setBusy(null) } @@ -171,6 +173,8 @@ export function ApplicationWorkspaceSettingsPanel({ ) } + const diagnostic = error ?? workspace?.last_error + return (
@@ -200,6 +204,38 @@ export function ApplicationWorkspaceSettingsPanel({
)} + {diagnostic && ( +
+
+ +
+

Workspace could not start

+

{diagnostic}

+ {workspace?.state === 'failed' && + workspace.desired_state === 'running' && ( + + )} +
+
+
+ )} + {workspace && ( <>
@@ -530,12 +566,6 @@ export function ApplicationWorkspaceSettingsPanel({
)} - - {(error || workspace?.last_error) && ( -
- {error ?? workspace?.last_error} -
- )}
) } @@ -677,8 +707,3 @@ function formatCpu(value: number | null | undefined): string { if (value == null) return '—' return `${(value / 1_000_000).toFixed(1)} s` } - -function errorMessage(cause: unknown, fallback: string): string { - if (cause instanceof Error && cause.message.trim()) return cause.message - return fallback -} diff --git a/web/src/components/ai-first/workspace-readiness.ts b/web/src/components/ai-first/workspace-readiness.ts index 176653b50..529f0db2f 100644 --- a/web/src/components/ai-first/workspace-readiness.ts +++ b/web/src/components/ai-first/workspace-readiness.ts @@ -39,6 +39,29 @@ export function workspaceStatusClickTarget( return hasApplication || workspace ? 'workspace' : null } +export function workspaceNeedsAutomaticWake( + workspace: ApplicationWorkspaceResponse | null +): boolean { + return ( + workspace?.desired_state === 'running' && + (workspace.state === 'sleeping' || workspace.state === 'failed') + ) +} + +export function workspaceShouldAttemptAutomaticWake( + workspace: ApplicationWorkspaceResponse | null, + applicationId: string | null, + attemptedApplicationId: string | null, + inFlightApplicationId: string | null +): applicationId is string { + return ( + applicationId !== null && + workspaceNeedsAutomaticWake(workspace) && + attemptedApplicationId !== applicationId && + inFlightApplicationId !== applicationId + ) +} + export function workspaceStatusPresentation( workspace: ApplicationWorkspaceResponse | null, loading: boolean, diff --git a/web/src/components/ai/DebugChatPanel.test.ts b/web/src/components/ai/DebugChatPanel.test.ts index b898df510..4af8f2361 100644 --- a/web/src/components/ai/DebugChatPanel.test.ts +++ b/web/src/components/ai/DebugChatPanel.test.ts @@ -17,6 +17,7 @@ import { chatApiPaths, chatFailureFromProblem, chatTurnActivityLabel, + claimAutomaticModelRefresh, clearResolvedPermissionParts, conversationSnapshotPollInterval, conversationHistoryErrorMessage, @@ -28,7 +29,10 @@ import { permissionModeIsAuto, permissionModeOptionDisabled, permissionPollIsTerminal, + providerRefreshCopy, + providerRefreshMatchesSelection, serverElapsedDeciseconds, + shouldPreserveRuntimeSelectionAfterProviderLoad, shouldShowAssistantActivityAfterContent, shouldShowLiveTurn, shouldSuppressPermissionPollEvent, @@ -75,6 +79,83 @@ describe('assistantParts', () => { }) describe('conversation-local client state', () => { + test('preserves a selected provider during explicit catalog refreshes', () => { + expect(shouldPreserveRuntimeSelectionAfterProviderLoad(false, true)).toBe( + true + ) + expect(shouldPreserveRuntimeSelectionAfterProviderLoad(false, false)).toBe( + false + ) + expect(shouldPreserveRuntimeSelectionAfterProviderLoad(true, false)).toBe( + true + ) + }) + + test('claims exactly one automatic model refresh per context and provider', () => { + const attempts = new Set() + const unresolvedClaude = { + id: 'claude_cli', + name: 'Claude Code', + auth_source: 'host_environment' as const, + models: [], + model_source: 'bootstrap' as const, + model_discovery_status: 'unavailable' as const, + permission_modes: [], + } + + expect( + claimAutomaticModelRefresh(attempts, 'global', unresolvedClaude) + ).toBe(true) + expect( + claimAutomaticModelRefresh(attempts, 'global', unresolvedClaude) + ).toBe(false) + expect(attempts).toEqual(new Set(['global:claude_cli'])) + }) + + test('never attributes an in-flight model refresh to another provider', () => { + const refresh = { + providerId: 'claude_cli', + operation: 'workspace_models' as const, + } + + expect(providerRefreshMatchesSelection(refresh, 'claude_cli')).toBe(true) + expect(providerRefreshMatchesSelection(refresh, 'codex_cli')).toBe(false) + expect(providerRefreshMatchesSelection(null, 'claude_cli')).toBe(false) + }) + + test('describes workspace model discovery as a workspace start', () => { + expect( + providerRefreshCopy( + { providerId: 'claude_cli', operation: 'workspace_models' }, + 'claude_cli', + 'Claude Code' + ) + ).toEqual({ + status: 'Starting your workspace and resolving models for Claude Code…', + button: 'Starting…', + }) + }) + + test('describes provider-only refresh without claiming to start a workspace', () => { + expect( + providerRefreshCopy( + { providerId: 'claude_cli', operation: 'provider_status' }, + 'claude_cli', + 'Claude Code' + ) + ).toEqual({ + status: 'Refreshing authentication and models for Claude Code…', + button: 'Refreshing…', + }) + expect( + providerRefreshCopy( + { providerId: 'codex_cli', operation: 'provider_status' }, + 'claude_cli', + 'Claude Code' + ) + ).toBeNull() + }) + test('polls conversation snapshots only when live updates are unavailable', () => { expect(conversationSnapshotPollInterval('connected', true)).toBe(false) expect(conversationSnapshotPollInterval('connecting', true)).toBe(false) diff --git a/web/src/components/ai/DebugChatPanel.tsx b/web/src/components/ai/DebugChatPanel.tsx index dc0039c8a..79c34d58c 100644 --- a/web/src/components/ai/DebugChatPanel.tsx +++ b/web/src/components/ai/DebugChatPanel.tsx @@ -12,6 +12,7 @@ import { getUserConversation, getUserPendingAction, listAiProviders, + refreshAiProviderModels, refreshAiProviderStatus, rejectPendingAction, rejectUserPendingAction, @@ -95,12 +96,14 @@ import { useAiAssistant } from './AiAssistantContext' import { chatDraftStorageKey, chatHarnessProviderOptions, + providerCatalogNeedsRefresh, chatModelLabel, chatPermissionLabel, chatProviderLabel, chatThinkingItemContent, reconcileChatRuntimeAfterRefresh, resolveChatRuntimeSelection, + shouldAutoRefreshHarnessModels, usesHarnessCatalog, type ChatProviderOption, type ChatRuntimeSelection, @@ -144,6 +147,63 @@ interface MdNode { children?: MdNode[] } +export function shouldPreserveRuntimeSelectionAfterProviderLoad( + providerPinned: boolean, + explicitRefresh: boolean +): boolean { + return providerPinned || explicitRefresh +} + +export type ProviderRefreshState = { + providerId: string + operation: 'workspace_models' | 'provider_status' +} + +export function providerRefreshMatchesSelection( + refresh: ProviderRefreshState | null, + providerId: string | undefined +): boolean { + return refresh !== null && refresh.providerId === providerId +} + +export function providerRefreshCopy( + refresh: ProviderRefreshState | null, + providerId: string | undefined, + providerName: string +): { status: string; button: string } | null { + if (!refresh || refresh.providerId !== providerId) return null + + return refresh.operation === 'workspace_models' + ? { + status: `Starting your workspace and resolving models for ${providerName}…`, + button: 'Starting…', + } + : { + status: `Refreshing authentication and models for ${providerName}…`, + button: 'Refreshing…', + } +} + +export function claimAutomaticModelRefresh( + attempts: Set, + contextType: string, + provider: ChatProviderOption | undefined +): boolean { + if (!provider) return false + const attemptKey = `${contextType}:${provider.id}` + if ( + !shouldAutoRefreshHarnessModels( + contextType, + provider, + attempts.has(attemptKey) + ) + ) { + return false + } + attempts.add(attemptKey) + return true +} + /** * Render a single newline as a `
` (a hard break) instead of collapsing it to * a space. Standard Markdown treats a lone `\n` as a *soft* break (whitespace), @@ -2208,7 +2268,6 @@ function useConversationStream( let cancelled = false let ws: WebSocket | null = null let attempt = 0 - setTransportState('connecting') // True once this effect instance has completed at least one connection — // distinguishes the initial connect (history was already loaded by the // panel's own init fetch, no need to resync) from a later reconnect @@ -2483,13 +2542,20 @@ export function DebugChatPanel({ ) const providerPinnedRef = useRef(false) const providerStatusRequestRef = useRef(0) + const automaticModelRefreshesRef = useRef(new Set()) const [providerOptions, setProviderOptions] = useState( [] ) const [providerStatusState, setProviderStatusState] = useState< 'loading' | 'success' | 'error' >('loading') - const [providerRefreshing, setProviderRefreshing] = useState(false) + const [providerRefresh, setProviderRefresh] = + useState(null) + const providerRefreshing = providerRefresh !== null + const [providerRefreshFailure, setProviderRefreshFailure] = useState<{ + providerId: string + detail: string + } | null>(null) const [runtimeSelection, setRuntimeSelection] = useState({ providerId: 'gateway', @@ -2629,19 +2695,39 @@ export function DebugChatPanel({ ) const loadProviderStatus = useCallback( - async (forceRefresh = false, silent = false) => { + async (forceRefresh = false, providerId?: string) => { const requestGeneration = ++providerStatusRequestRef.current - if (forceRefresh) setProviderRefreshing(true) - else setProviderStatusState('loading') + if (forceRefresh) { + setProviderRefresh({ + providerId: providerId ?? '', + operation: + usesHarnessCatalog(contextType) && + providerId !== undefined && + providerId !== 'gateway' + ? 'workspace_models' + : 'provider_status', + }) + setProviderRefreshFailure(null) + } else { + setProviderStatusState('loading') + } try { + if ( + forceRefresh && + usesHarnessCatalog(contextType) && + providerId && + providerId !== 'gateway' + ) { + await refreshAiProviderModels({ + path: { provider_id: providerId }, + throwOnError: true, + }) + } const options = usesHarnessCatalog(contextType) ? chatHarnessProviderOptions( ( await listAiProviders({ - query: { - catalog_only: false, - refresh_models: forceRefresh, - }, + query: { catalog_only: false }, throwOnError: true, }) ).data.providers @@ -2659,6 +2745,7 @@ export function DebugChatPanel({ auth_source: provider.auth_source, models: extended.models ?? [], default_model_id: extended.default_model_id, + model_source: extended.model_source, model_discovery_status: extended.model_discovery_status, model_discovery_error: extended.model_discovery_error, permission_modes: extended.permission_modes ?? [], @@ -2677,35 +2764,40 @@ export function DebugChatPanel({ : options ) - if (providerPinnedRef.current) { - setRuntimeSelection((current) => - reconcileChatRuntimeAfterRefresh(options, current) - ) - } - - const active = 'gateway' if ( - !providerPinnedRef.current && - active && - options.some((option) => option.id === active) + shouldPreserveRuntimeSelectionAfterProviderLoad( + providerPinnedRef.current, + forceRefresh + ) ) { - setRuntimeSelection(resolveChatRuntimeSelection(options, active)) - } else if (!providerPinnedRef.current && options[0]) { - setRuntimeSelection( - resolveChatRuntimeSelection(options, options[0].id) + setRuntimeSelection((current) => + reconcileChatRuntimeAfterRefresh(options, current) ) + } else { + const active = 'gateway' + if (active && options.some((option) => option.id === active)) { + setRuntimeSelection(resolveChatRuntimeSelection(options, active)) + } else if (options[0]) { + setRuntimeSelection( + resolveChatRuntimeSelection(options, options[0].id) + ) + } } setProviderStatusState('success') - } catch { + } catch (refreshError) { if (requestGeneration !== providerStatusRequestRef.current) return - if (forceRefresh && !silent) { + if (forceRefresh) { + setProviderRefreshFailure({ + providerId: providerId ?? '', + detail: chatFailureFromProblem(refreshError).detail, + }) toast.error('Couldn’t refresh provider authentication and models') } else if (!forceRefresh) { setProviderStatusState('error') } } finally { if (requestGeneration === providerStatusRequestRef.current) { - setProviderRefreshing(false) + setProviderRefresh(null) } } }, @@ -2713,19 +2805,40 @@ export function DebugChatPanel({ ) useEffect(() => { - // First paint uses cached/bootstrap capabilities and never invokes a CLI. - // Account-aware names/auth are refreshed silently after the composer is - // usable; the explicit refresh button uses the same path with error UI. + // First paint stays fast by using cached/bootstrap capabilities. A second + // effect below starts the user's persistent workspace only when a saved + // harness still needs an authoritative model catalog. const timer = window.setTimeout(() => void loadProviderStatus(), 0) - const refreshTimer = usesHarnessCatalog(contextType) - ? window.setTimeout(() => void loadProviderStatus(true, true), 250) - : null return () => { window.clearTimeout(timer) - if (refreshTimer != null) window.clearTimeout(refreshTimer) } }, [contextType, loadProviderStatus]) + useEffect(() => { + const provider = selectedProviderOption + if (!provider) return + if ( + providerStatusState !== 'success' || + providerRefreshing || + turnActive || + !claimAutomaticModelRefresh( + automaticModelRefreshesRef.current, + contextType, + provider + ) + ) { + return + } + void loadProviderStatus(true, provider.id) + }, [ + contextType, + loadProviderStatus, + providerRefreshing, + providerStatusState, + selectedProviderOption, + turnActive, + ]) + useConversationStream( base, userScoped, @@ -3885,30 +3998,59 @@ export function DebugChatPanel({ variant="outline" size="sm" className="h-7" - onClick={() => void loadProviderStatus(true)} + onClick={() => void loadProviderStatus()} > Retry )} {providerStatusState === 'success' && - selectedProviderOption?.model_discovery_status === 'unavailable' && ( + selectedProviderOption && + (providerRefreshMatchesSelection( + providerRefresh, + selectedProviderOption.id + ) || + providerRefreshFailure?.providerId === selectedProviderOption.id || + providerCatalogNeedsRefresh(selectedProviderOption)) && (
- - {selectedProviderOption.model_discovery_error ?? - 'Model discovery is unavailable; the provider default remains usable.'} + + {providerRefreshMatchesSelection( + providerRefresh, + selectedProviderOption.id + ) && } + {providerRefreshCopy( + providerRefresh, + selectedProviderOption.id, + selectedProviderOption.name + )?.status ?? + (providerRefreshFailure?.providerId === + selectedProviderOption.id + ? providerRefreshFailure.detail + : (selectedProviderOption.model_discovery_error ?? + 'Model discovery is unavailable; the provider default remains usable.'))}
)} @@ -4009,6 +4151,7 @@ export function DebugChatPanel({ Boolean(publicId) || turnActive || starting || + providerRefreshing || providerOptions.length === 0 } > @@ -4196,7 +4339,9 @@ export function DebugChatPanel({ size="icon" className="h-8 w-8 shrink-0" disabled={providerRefreshing || turnActive || starting} - onClick={() => void loadProviderStatus(true)} + onClick={() => + void loadProviderStatus(true, runtimeSelection.providerId) + } aria-label="Refresh provider authentication and models" title="Refresh provider authentication and models" > diff --git a/web/src/components/ai/chat-runtime-options.test.ts b/web/src/components/ai/chat-runtime-options.test.ts index 9392efdd1..2400bda4f 100644 --- a/web/src/components/ai/chat-runtime-options.test.ts +++ b/web/src/components/ai/chat-runtime-options.test.ts @@ -6,11 +6,13 @@ import { chatHarnessProviderOptions, chatModelLabel, chatPermissionLabel, + providerCatalogNeedsRefresh, chatProviderLabel, chatThinkingItemContent, chatThinkingLabel, reconcileChatRuntimeAfterRefresh, resolveChatRuntimeSelection, + shouldAutoRefreshHarnessModels, usesHarnessCatalog, type ChatProviderOption, } from './chat-runtime-options' @@ -62,6 +64,62 @@ describe('usesHarnessCatalog', () => { }) }) +describe('shouldAutoRefreshHarnessModels', () => { + const unresolvedClaude: ChatProviderOption = { + id: 'claude_cli', + name: 'Claude Code', + auth_source: 'host_environment', + models: [], + model_discovery_status: 'unavailable', + permission_modes: [], + } + + test('requests one discovery attempt for a saved global workspace harness', () => { + expect( + shouldAutoRefreshHarnessModels('global', unresolvedClaude, false) + ).toBe(true) + expect( + shouldAutoRefreshHarnessModels('global', unresolvedClaude, true) + ).toBe(false) + }) + + test('does not start workspace discovery outside harness chat', () => { + expect( + shouldAutoRefreshHarnessModels('deployment', unresolvedClaude, false) + ).toBe(false) + }) + + test.each(['bootstrap', 'stale_cache'] as const)( + 'refreshes a non-authoritative %s catalog even when it contains fallback models', + (modelSource) => { + const [provider] = chatHarnessProviderOptions([ + { + id: 'claude_cli', + name: 'Claude Code', + workspace_ready: true, + runtime_models: [ + { + id: 'sonnet', + name: 'Sonnet', + thinking_modes: [], + }, + ], + default_runtime_model_id: 'sonnet', + model_source: modelSource, + permission_modes: [], + default_permission_mode_id: 'default', + }, + ]) + + expect(provider.model_discovery_status).toBe('unavailable') + expect(providerCatalogNeedsRefresh(provider)).toBe(true) + expect(shouldAutoRefreshHarnessModels('global', provider, false)).toBe( + true + ) + } + ) +}) + describe('resolveChatRuntimeSelection', () => { test('uses provider and model defaults for a new chat', () => { expect(resolveChatRuntimeSelection(providers, 'gateway_key:7')).toEqual({ @@ -193,6 +251,7 @@ test('harness catalog options preserve resolved runtime controls', () => { }, ], default_runtime_model_id: 'default', + model_source: 'live', permission_modes: [{ id: 'full-access', name: 'Auto' }], default_permission_mode_id: 'full-access', }, @@ -212,6 +271,7 @@ test('harness catalog options preserve resolved runtime controls', () => { }, ], default_model_id: 'default', + model_source: 'live', model_discovery_status: 'ready', model_discovery_error: null, permission_modes: [{ id: 'full-access', name: 'Auto' }], @@ -229,6 +289,7 @@ test('harness catalog excludes a host-only CLI without a workspace relay', () => workspace_ready: false, runtime_models: [], default_runtime_model_id: null, + model_source: 'bootstrap', permission_modes: [], default_permission_mode_id: 'default', }, @@ -269,3 +330,59 @@ test('a model refresh drops a stale thinking sentinel without switching harnesse permissionModeId: 'build', }) }) + +test.each(['bootstrap', 'stale_cache'])( + '%s model catalogs preserve an unresolved persisted selection', + (modelSource) => { + const incomplete: ChatProviderOption[] = [ + { + id: 'claude_cli', + name: 'Claude Code', + auth_source: 'host_environment', + models: [ + { + id: 'sonnet', + name: 'Sonnet', + thinking_options: [{ id: 'high', name: 'High' }], + }, + ], + default_model_id: 'sonnet', + model_source: modelSource, + permission_modes: [{ id: 'auto', name: 'Auto' }], + default_permission_mode_id: 'auto', + }, + ] + + expect( + reconcileChatRuntimeAfterRefresh(incomplete, { + providerId: 'claude_cli', + modelId: 'account-only-model', + thinkingOptionId: 'adaptive', + permissionModeId: 'auto', + }) + ).toEqual({ + providerId: 'claude_cli', + modelId: 'account-only-model', + thinkingOptionId: 'adaptive', + permissionModeId: 'auto', + }) + + expect( + reconcileChatRuntimeAfterRefresh(incomplete, { + providerId: 'claude_cli', + modelId: 'sonnet', + thinkingOptionId: 'medium', + permissionModeId: 'auto', + }).thinkingOptionId + ).toBe('medium') + + expect( + reconcileChatRuntimeAfterRefresh(incomplete, { + providerId: 'claude_cli', + modelId: 'sonnet', + thinkingOptionId: null, + permissionModeId: 'auto', + }).thinkingOptionId + ).toBeNull() + } +) diff --git a/web/src/components/ai/chat-runtime-options.ts b/web/src/components/ai/chat-runtime-options.ts index c8bad6020..6cdeb7fb2 100644 --- a/web/src/components/ai/chat-runtime-options.ts +++ b/web/src/components/ai/chat-runtime-options.ts @@ -19,6 +19,7 @@ export interface ChatProviderOption extends ChatSelectOption { auth_source: string models: ChatModelOption[] default_model_id?: string | null + model_source?: ProviderCatalogDto['model_source'] model_discovery_status?: string model_discovery_error?: string | null permission_modes: ChatSelectOption[] @@ -39,6 +40,7 @@ export type ChatHarnessCatalogOption = Pick< | 'workspace_ready' | 'runtime_models' | 'default_runtime_model_id' + | 'model_source' | 'permission_modes' | 'default_permission_mode_id' > @@ -48,33 +50,70 @@ export function usesHarnessCatalog(contextType: string): boolean { return contextType === 'application' || contextType === 'global' } +/** + * A saved workspace credential with no authoritative catalog needs one + * automatic discovery attempt. The backend resolves that attempt through the + * user's persistent workspace, creating or waking its sandbox as needed. + */ +export function shouldAutoRefreshHarnessModels( + contextType: string, + provider: ChatProviderOption | undefined, + alreadyAttempted: boolean +): boolean { + return ( + usesHarnessCatalog(contextType) && + !alreadyAttempted && + provider !== undefined && + provider.id !== 'gateway' && + providerCatalogNeedsRefresh(provider) + ) +} + +/** Bootstrap and stale catalogs are useful continuity data, not proof that + * the saved workspace credential can use those models. */ +export function providerCatalogNeedsRefresh( + provider: ChatProviderOption +): boolean { + return ( + provider.model_source === 'bootstrap' || + provider.model_source === 'stale_cache' || + provider.model_discovery_status === 'unavailable' + ) +} + /** Convert the Agent Sandbox catalog into the provider-neutral chat shape. */ export function chatHarnessProviderOptions( providers: ChatHarnessCatalogOption[] ): ChatProviderOption[] { return providers .filter((provider) => provider.workspace_ready) - .map((provider) => ({ - id: provider.id, - name: provider.name, - auth_source: 'host_environment', - models: (provider.runtime_models ?? []).map((model) => ({ + .map((provider) => { + const models = (provider.runtime_models ?? []).map((model) => ({ id: model.id, name: model.name, thinking_options: model.thinking_modes, tool_thinking_options: model.tool_thinking_modes, default_thinking_option_id: model.default_thinking_mode_id, - })), - default_model_id: provider.default_runtime_model_id, - model_discovery_status: - (provider.runtime_models?.length ?? 0) > 0 ? 'ready' : 'unavailable', - model_discovery_error: - (provider.runtime_models?.length ?? 0) > 0 + })) + const catalogIsAuthoritative = + provider.model_source !== 'bootstrap' && + provider.model_source !== 'stale_cache' + const modelDiscoveryReady = catalogIsAuthoritative && models.length > 0 + return { + id: provider.id, + name: provider.name, + auth_source: 'host_environment', + models, + default_model_id: provider.default_runtime_model_id, + model_source: provider.model_source, + model_discovery_status: modelDiscoveryReady ? 'ready' : 'unavailable', + model_discovery_error: modelDiscoveryReady ? null - : `Could not resolve models for ${provider.name}.`, - permission_modes: provider.permission_modes ?? [], - default_permission_mode_id: provider.default_permission_mode_id, - })) + : `Could not resolve current models for ${provider.name}.`, + permission_modes: provider.permission_modes ?? [], + default_permission_mode_id: provider.default_permission_mode_id, + } + }) } /** @@ -118,8 +157,9 @@ function firstValidId( /** * Resolve a complete, provider-valid runtime selection. Provider changes call * this without the previous model/mode values, while conversation restoration - * supplies every persisted value. In both cases the result can only contain - * options advertised by the selected provider and model. + * supplies every persisted value. Live/cached account inventories validate + * those values; bootstrap or stale inventories preserve an unresolved saved + * model until an authoritative refresh can decide whether it is valid. */ export function resolveChatRuntimeSelection( providers: ChatProviderOption[], @@ -137,21 +177,36 @@ export function resolveChatRuntimeSelection( } } - const modelId = firstValidId( - provider.models, - preferred?.modelId, - provider.default_model_id - ) + const modelCatalogIsAuthoritative = + provider.model_source !== 'bootstrap' && + provider.model_source !== 'stale_cache' + const preferredModelIsUnresolved = + !modelCatalogIsAuthoritative && + Boolean(preferred?.modelId) && + !provider.models.some((model) => model.id === preferred?.modelId) + const modelId = preferredModelIsUnresolved + ? (preferred?.modelId ?? null) + : firstValidId( + provider.models, + preferred?.modelId, + provider.default_model_id + ) const model = provider.models.find((option) => option.id === modelId) // Project chat always sends function tools. Prefer a model's narrower tool // compatibility when it differs from its general reasoning capabilities. const thinkingOptions = model?.tool_thinking_options ?? model?.thinking_options ?? [] - const thinkingOptionId = firstValidId( - thinkingOptions, - preferred?.thinkingOptionId, - model?.default_thinking_option_id - ) + const preserveUnverifiedThinking = + !modelCatalogIsAuthoritative && + preferred !== undefined && + Object.prototype.hasOwnProperty.call(preferred, 'thinkingOptionId') + const thinkingOptionId = preserveUnverifiedThinking + ? (preferred?.thinkingOptionId ?? null) + : firstValidId( + thinkingOptions, + preferred?.thinkingOptionId, + model?.default_thinking_option_id + ) const permissionModeId = firstValidId( provider.permission_modes, preferred?.permissionModeId, @@ -168,8 +223,9 @@ export function resolveChatRuntimeSelection( /** * Keep the pinned harness while reconciling model capabilities returned by a - * forced refresh. Stale model/thinking values are dropped, but a temporarily - * absent provider never makes an existing conversation switch harnesses. + * forced refresh. Authoritatively stale model/thinking values are dropped, + * but an incomplete catalog or temporarily absent provider never rewrites an + * existing conversation's runtime selection. */ export function reconcileChatRuntimeAfterRefresh( providers: ChatProviderOption[], diff --git a/web/src/components/autofixer/AutofixRunConfigForm.tsx b/web/src/components/autofixer/AutofixRunConfigForm.tsx index cef4402cc..d6b5af5ac 100644 --- a/web/src/components/autofixer/AutofixRunConfigForm.tsx +++ b/web/src/components/autofixer/AutofixRunConfigForm.tsx @@ -1,7 +1,6 @@ // SPDX-FileCopyrightText: 2024-2026 Temps Contributors // SPDX-License-Identifier: MIT OR Apache-2.0 -import { listAiProvidersOptions } from '@/api/client/@tanstack/react-query.gen' import { startAnalysis } from '@/api/client/sdk.gen' import type { AutofixRunConfig, ProjectResponse } from '@/api/client' import { Button } from '@/components/ui/button' @@ -20,6 +19,7 @@ import { useQuery } from '@tanstack/react-query' import { AlertTriangle, ArrowRight, Loader2, Wand2 } from 'lucide-react' import { useMemo, useState } from 'react' import { Link } from 'react-router' +import { aiProviderCatalogQueryOptions } from '@/lib/ai-provider-catalog-query' // Sentinel for the "use provider default" model option — Radix Select // rejects empty-string item values. @@ -61,7 +61,7 @@ export function AutofixRunConfigForm({ data: catalog, isPending, isError, - } = useQuery(listAiProvidersOptions()) + } = useQuery(aiProviderCatalogQueryOptions) const [provider, setProvider] = useState( initialConfig?.provider ?? null diff --git a/web/src/hooks/useAutofixReadiness.ts b/web/src/hooks/useAutofixReadiness.ts index 66663d43b..4e34d8435 100644 --- a/web/src/hooks/useAutofixReadiness.ts +++ b/web/src/hooks/useAutofixReadiness.ts @@ -2,10 +2,8 @@ // SPDX-License-Identifier: MIT OR Apache-2.0 import { useQuery } from '@tanstack/react-query' -import { - getSandboxStatusOptions, - listAiProvidersOptions, -} from '@/api/client/@tanstack/react-query.gen' +import { getSandboxStatusOptions } from '@/api/client/@tanstack/react-query.gen' +import { aiProviderCatalogQueryOptions } from '@/lib/ai-provider-catalog-query' /** * A single prerequisite for running AI autofix. The onboarding dialog renders @@ -79,7 +77,7 @@ export function useAutofixReadiness(opts?: { const enabled = opts?.enabled ?? true const { data: catalog, isLoading: catalogLoading } = useQuery({ - ...listAiProvidersOptions(), + ...aiProviderCatalogQueryOptions, enabled, }) diff --git a/web/src/lib/ai-provider-catalog-query.ts b/web/src/lib/ai-provider-catalog-query.ts new file mode 100644 index 000000000..9834b1320 --- /dev/null +++ b/web/src/lib/ai-provider-catalog-query.ts @@ -0,0 +1,7 @@ +// SPDX-FileCopyrightText: 2024-2026 Temps Contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 + +import { listAiProvidersOptions } from '@/api/client/@tanstack/react-query.gen' + +/** Shared query identity for every consumer of the provider catalog. */ +export const aiProviderCatalogQueryOptions = listAiProvidersOptions() diff --git a/web/src/pages/agent-sandbox/AgentSandboxDashboard.tsx b/web/src/pages/agent-sandbox/AgentSandboxDashboard.tsx index 429636d40..ab33e99e2 100644 --- a/web/src/pages/agent-sandbox/AgentSandboxDashboard.tsx +++ b/web/src/pages/agent-sandbox/AgentSandboxDashboard.tsx @@ -26,21 +26,10 @@ import { import { Button } from '@/components/ui/button' import { listSecretsOptions } from '@/api/client/@tanstack/react-query.gen' import { usePageTitle } from '@/hooks/usePageTitle' +import { aiProviderCatalogQueryOptions } from '@/lib/ai-provider-catalog-query' // ── Types from existing endpoints ─────────────────────────────────────────── -interface CatalogEntry { - id: string - name: string - credential_saved: boolean - current_auth_type: string | null -} - -interface CatalogResponse { - default_provider: string - providers: CatalogEntry[] -} - interface SandboxStatus { docker_available: boolean image_ready: boolean @@ -86,18 +75,10 @@ function ToneIcon({ tone }: { tone: Tone }) { export function AgentSandboxDashboard() { usePageTitle('AI Workflows') - const { data: catalog, isPending: catalogPending } = - useQuery({ - queryKey: ['ai-provider-catalog'], - queryFn: async () => { - // TODO(sdk-regen): migrate once /settings/ai-providers endpoint is - // added to the generated SDK. - const r = await fetch('/api/settings/ai-providers') - if (!r.ok) throw new Error('Failed to load AI provider catalog') - return r.json() - }, - staleTime: 60 * 1000, - }) + const { data: catalog, isPending: catalogPending } = useQuery({ + ...aiProviderCatalogQueryOptions, + staleTime: 60 * 1000, + }) const { data: sandboxStatus, isPending: sandboxPending } = useQuery({ @@ -132,7 +113,7 @@ export function AgentSandboxDashboard() { // Provider: ok if active provider has a saved credential; bad if no provider // has one at all; warn if active is unconfigured but a sibling is. const activeProvider = catalog?.providers.find( - (p) => p.id === catalog?.default_provider, + (p) => p.id === catalog?.default_provider ) const anyConfigured = catalog?.providers.some((p) => p.credential_saved) const providerTone: Tone = catalogPending @@ -324,7 +305,9 @@ export function AgentSandboxDashboard() { - {c.hint} + + {c.hint} +
@@ -371,7 +354,11 @@ export function AgentSandboxDashboard() {

Preview gateway

A shared proxy container that exposes dev servers running inside - sandboxes via ws-*.preview-domain. + sandboxes via{' '} + + ws-*.preview-domain + + .

@@ -380,8 +367,12 @@ export function AgentSandboxDashboard() {

Secrets

- Encrypted env vars and files injected into every sandbox. Reference - via {'${TEMPS_SECRET:NAME}'}. + Encrypted env vars and files injected into every sandbox. + Reference via{' '} + + {'${TEMPS_SECRET:NAME}'} + + .

diff --git a/web/src/pages/agent-sandbox/AgentSandboxProviderDetail.test.tsx b/web/src/pages/agent-sandbox/AgentSandboxProviderDetail.test.tsx new file mode 100644 index 000000000..f0be2d92a --- /dev/null +++ b/web/src/pages/agent-sandbox/AgentSandboxProviderDetail.test.tsx @@ -0,0 +1,83 @@ +// SPDX-FileCopyrightText: 2024-2026 Temps Contributors +// SPDX-License-Identifier: MIT OR Apache-2.0 + +import { describe, expect, test } from 'bun:test' +import { QueryClient, QueryClientProvider } from '@tanstack/react-query' +import { renderToStaticMarkup } from 'react-dom/server' +import { MemoryRouter } from 'react-router' + +import type { ProviderCatalogDto } from '@/api/client' +import { ProviderEditor } from './AgentSandboxProviderDetail' + +describe('ProviderEditor local credential onboarding', () => { + test('offers one-click import without rendering credential material', () => { + const html = renderToStaticMarkup( + + + + + + ) + + expect(html).toContain('Use local login') + expect(html).toContain('authenticated Claude Code credential') + expect(html).toContain('without exposing it to this browser') + expect(html).not.toContain('oauth-secret') + expect(html).not.toContain('.credentials.json') + }) + + test('labels import as a replacement when a credential is already saved', () => { + const html = renderToStaticMarkup( + + + + + + ) + + expect(html).toContain('Replace with local login') + }) +}) + +const provider: ProviderCatalogDto = { + id: 'claude_cli', + name: 'Claude Code', + install_command: 'install claude', + auth_command: 'claude setup-token', + auth_flavors: [ + { + id: 'subscription', + label: 'Subscription (OAuth)', + description: 'Claude subscription credential', + format: 'oauth_token', + }, + ], + models: ['sonnet'], + runtime_models: [], + default_runtime_model_id: 'sonnet', + permission_modes: [], + default_permission_mode_id: 'default', + credential_saved: false, + current_auth_type: null, + default_model: null, + max_turns_analysis: null, + max_turns_fix: null, + max_turns_feedback: null, + supports_max_turns: true, + host_authenticated: true, + host_auth_method: 'host_auth_store', + host_version: '2.1.0', + model_source: 'bootstrap', + models_refreshed_at: null, + host_auth_hint: null, + workspace_ready: false, + workspace_readiness_hint: 'Save a Claude Code credential.', + local_credential: { + auth_type: 'subscription', + source: 'host_auth_store', + label: 'Authenticated host CLI', + }, +} diff --git a/web/src/pages/agent-sandbox/AgentSandboxProviderDetail.tsx b/web/src/pages/agent-sandbox/AgentSandboxProviderDetail.tsx index 45058e86c..b50381ccb 100644 --- a/web/src/pages/agent-sandbox/AgentSandboxProviderDetail.tsx +++ b/web/src/pages/agent-sandbox/AgentSandboxProviderDetail.tsx @@ -2,14 +2,17 @@ // SPDX-License-Identifier: MIT OR Apache-2.0 import { Link, useParams } from 'react-router' -import { useQuery, useQueryClient } from '@tanstack/react-query' +import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query' import { useEffect, useRef, useState } from 'react' import { toast } from 'sonner' import { + AlertTriangle, ArrowLeft, CheckCircle2, + Download, Loader2, Play, + RefreshCw, Save, XCircle, } from 'lucide-react' @@ -33,52 +36,23 @@ import { SelectValue, } from '@/components/ui/select' import { Textarea } from '@/components/ui/textarea' - -type CredentialFormat = 'api_key' | 'oauth_token' | 'config_file' - -interface AuthFlavorDto { - id: string - label: string - description: string - format: CredentialFormat - env_var: string | null -} - -interface ProviderCatalogDto { - id: string - name: string - install_command: string - auth_command: string - auth_flavors: AuthFlavorDto[] - credential_saved: boolean - current_auth_type: string | null - models: string[] - default_model: string | null - max_turns_analysis: number | null - max_turns_fix: number | null - max_turns_feedback: number | null - supports_max_turns: boolean - workspace_ready: boolean - workspace_readiness_hint: string | null -} - -interface ProviderCatalogResponse { - default_provider: string - providers: ProviderCatalogDto[] -} - -async function fetchCatalog(): Promise { - const r = await fetch('/api/settings/ai-providers') - if (!r.ok) throw new Error(`Failed to load AI provider catalog (${r.status})`) - return r.json() -} +import type { ProviderCatalogDto, ProviderCatalogResponse } from '@/api/client' +import { + importLocalAiProviderCredentialMutation, + refreshAiProviderModelsMutation, +} from '@/api/client/@tanstack/react-query.gen' +import { problemDetail } from '@/lib/api-problem' +import { aiProviderCatalogQueryOptions } from '@/lib/ai-provider-catalog-query' +import { + isSavedProviderModelUnavailable, + mergeProviderModelRefresh, +} from './provider-model-catalog' export function AgentSandboxProviderDetail() { const { id } = useParams<{ id: string }>() usePageTitle(id ? `Provider · ${id}` : 'AI Provider') const { data, isPending, isError } = useQuery({ - queryKey: ['ai-provider-catalog'], - queryFn: fetchCatalog, + ...aiProviderCatalogQueryOptions, staleTime: 60 * 1000, }) @@ -147,7 +121,7 @@ interface ProviderEditorProps { isActive: boolean } -function ProviderEditor({ provider, isActive }: ProviderEditorProps) { +export function ProviderEditor({ provider, isActive }: ProviderEditorProps) { const queryClient = useQueryClient() const defaultFlavor = provider.auth_flavors.find((f) => f.id === provider.current_auth_type) ?? @@ -174,6 +148,10 @@ function ProviderEditor({ provider, isActive }: ProviderEditorProps) { (initialModel !== '' && !provider.models.includes(initialModel)) ) const [savingModel, setSavingModel] = useState(false) + const refreshModelsMutation = useMutation(refreshAiProviderModelsMutation()) + const importLocalCredentialMutation = useMutation( + importLocalAiProviderCredentialMutation() + ) useEffect(() => { const fresh = provider.default_model ?? '' @@ -195,6 +173,61 @@ function ProviderEditor({ provider, isActive }: ProviderEditorProps) { provider.auth_flavors.find((f) => f.id === selectedFlavorId) ?? defaultFlavor + const savedModelUnavailable = isSavedProviderModelUnavailable({ + savedModel: serverModel, + availableModels: provider.models, + source: provider.model_source, + }) + + const handleRefreshModels = async () => { + try { + const refreshed = await refreshModelsMutation.mutateAsync({ + path: { provider_id: provider.id }, + }) + queryClient.setQueryData( + aiProviderCatalogQueryOptions.queryKey, + (catalog) => + catalog ? mergeProviderModelRefresh(catalog, refreshed) : catalog + ) + const freshModel = provider.default_model ?? '' + const refreshedModelIds = refreshed.runtime_models.map( + (model) => model.id + ) + setCustomMode( + refreshedModelIds.length === 0 || + (freshModel !== '' && !refreshedModelIds.includes(freshModel)) + ) + void queryClient.invalidateQueries({ + queryKey: aiProviderCatalogQueryOptions.queryKey, + }) + + if ( + refreshed.model_source === 'live' || + refreshed.model_source === 'cache' + ) { + toast.success(`${provider.name} models refreshed`, { + description: `${refreshed.runtime_models.length} models reported by ${ + provider.workspace_ready + ? 'the saved workspace credential' + : 'the authenticated host CLI' + }.`, + }) + } else { + toast.warning(`Could not refresh ${provider.name} models`, { + description: + 'Temps kept the last known model list because live discovery did not complete.', + }) + } + } catch (cause) { + toast.error(`Could not refresh ${provider.name} models`, { + description: problemDetail( + cause, + 'The provider did not return a model catalog. Check its credential and try again.' + ), + }) + } + } + const persistModel = async (next: string) => { if (next === serverModel) return setSavingModel(true) @@ -222,7 +255,9 @@ function ProviderEditor({ provider, isActive }: ProviderEditorProps) { ? `${provider.name} will use its default model` : `${provider.name} model set to ${next}` ) - await queryClient.invalidateQueries({ queryKey: ['ai-provider-catalog'] }) + await queryClient.invalidateQueries({ + queryKey: aiProviderCatalogQueryOptions.queryKey, + }) } catch (e) { toast.error(`Failed to save ${provider.name} model`, { description: e instanceof Error ? e.message : 'Network error', @@ -264,7 +299,9 @@ function ProviderEditor({ provider, isActive }: ProviderEditorProps) { } toast.success(`${provider.name} is now the active provider`) await Promise.all([ - queryClient.invalidateQueries({ queryKey: ['ai-provider-catalog'] }), + queryClient.invalidateQueries({ + queryKey: aiProviderCatalogQueryOptions.queryKey, + }), queryClient.invalidateQueries({ queryKey: ['platform-settings'] }), ]) } catch (e) { @@ -337,7 +374,9 @@ function ProviderEditor({ provider, isActive }: ProviderEditorProps) { } toast.success(`${provider.name} credential encrypted and saved`) setCredential('') - await queryClient.invalidateQueries({ queryKey: ['ai-provider-catalog'] }) + await queryClient.invalidateQueries({ + queryKey: aiProviderCatalogQueryOptions.queryKey, + }) } catch (e) { toast.error(`Failed to save ${provider.name} credential`, { description: e instanceof Error ? e.message : 'Network error', @@ -347,6 +386,31 @@ function ProviderEditor({ provider, isActive }: ProviderEditorProps) { } } + const handleImportLocalCredential = async () => { + try { + const imported = await importLocalCredentialMutation.mutateAsync({ + path: { provider_id: provider.id }, + }) + setSelectedFlavorId(imported.auth_type) + setCredential('') + await queryClient.invalidateQueries({ + queryKey: aiProviderCatalogQueryOptions.queryKey, + }) + toast.success(`${provider.name} local login imported`, { + description: imported.workspace_ready + ? 'The credential is encrypted and this harness is ready for persistent workspaces.' + : 'The credential is encrypted and ready for supported host workflows.', + }) + } catch (cause) { + toast.error(`Could not import ${provider.name} local login`, { + description: problemDetail( + cause, + 'Authenticate the CLI as the operating-system user running Temps, then try again.' + ), + }) + } + } + return (
@@ -435,14 +499,49 @@ function ProviderEditor({ provider, isActive }: ProviderEditorProps) { - Credential - - Encrypted with AES-256-GCM at rest. Workspace-capable providers use - it only through a short-lived server relay; the reusable credential - is never injected into the sandbox. - +
+
+ Credential + + Encrypted with AES-256-GCM at rest. Workspace-capable providers + use it only through a short-lived server relay; the reusable + credential is never injected into the sandbox. + +
+ {provider.local_credential && ( + + )} +
+ {provider.local_credential && ( +
+ + + Temps found an authenticated {provider.name} credential in{' '} + {provider.local_credential.label.toLowerCase()}. Importing it + copies the credential directly into encrypted settings without + exposing it to this browser. + +
+ )} {provider.auth_flavors.length > 1 && (
{provider.auth_flavors.map((flavor) => ( @@ -564,24 +663,62 @@ function ProviderEditor({ provider, isActive }: ProviderEditorProps) { -
+
Default model - {provider.id === 'opencode' - ? 'OpenCode resolves models via ~/.config/opencode/config.json or per-session flags. Setting a value here exports it to OPENCODE_MODEL.' - : 'Leave blank to let the CLI pick. Custom values are accepted — the catalog is just a convenience list.'} + {provider.workspace_ready + ? 'Leave blank to let the CLI pick. Refresh checks which models the saved workspace credential can run inside a short-lived isolated sandbox.' + : provider.id === 'opencode' + ? 'OpenCode resolves models from its configured providers. Refresh asks the authenticated CLI on the Temps host for the current list.' + : 'Leave blank to let the CLI pick. Refresh asks the authenticated CLI installed on the Temps host which models this account can run.'} +

+ {provider.models_refreshed_at + ? `Last refreshed ${new Date(provider.models_refreshed_at).toLocaleString()} · ${provider.model_source.replace('_', ' ')}` + : provider.workspace_ready + ? 'Bootstrap catalog — not yet verified with the saved workspace credential.' + : 'Bootstrap catalog — not yet verified against the authenticated host CLI.'} +

+
+
+ {savingModel && ( + + + Saving… + + )} +
- {savingModel && ( - - - Saving… - - )}
- + + {savedModelUnavailable && ( +
+ + + The saved model {serverModel} was not reported by + the refreshed CLI. Choose an available model or use the provider + default before starting another turn. + +
+ )} {provider.models.length > 0 && !customMode ? (