diff --git a/Cargo.lock b/Cargo.lock index e6b96e9df..a0e99aba5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -242,6 +242,7 @@ dependencies = [ "container-registry 0.3.1 (git+https://github.com/alienplatform/container_registry-rs.git?rev=f0d0fe6)", "dotenvy", "futures", + "hex", "k8s-openapi", "object_store", "oci-client", diff --git a/client-sdks/manager/openapi.json b/client-sdks/manager/openapi.json index d8b6bbaac..7d735f28b 100644 --- a/client-sdks/manager/openapi.json +++ b/client-sdks/manager/openapi.json @@ -13910,6 +13910,24 @@ ], "description": "The only AWS credential form remote binding resolution can return." }, + "RemoteAwsKmsKeyBinding": { + "type": "object", + "required": [ + "keyArn" + ], + "properties": { + "keyArn": { + "type": "string" + }, + "region": { + "type": [ + "string", + "null" + ] + } + }, + "additionalProperties": false + }, "RemoteAzureClientConfig": { "type": "object", "description": "Response-safe Azure client configuration containing one storage-audience\naccess token for the stack's Remote Bindings identity.", @@ -13965,6 +13983,18 @@ ], "description": "The only Azure credential form remote binding resolution can return." }, + "RemoteAzureKeyVaultKeyBinding": { + "type": "object", + "required": [ + "keyId" + ], + "properties": { + "keyId": { + "type": "string" + } + }, + "additionalProperties": false + }, "RemoteBlobStorageBinding": { "type": "object", "description": "Concrete Azure Blob Storage topology returned to remote clients.", @@ -14015,6 +14045,18 @@ }, "additionalProperties": false }, + "RemoteGcpCloudKmsKeyBinding": { + "type": "object", + "required": [ + "cryptoKeyName" + ], + "properties": { + "cryptoKeyName": { + "type": "string" + } + }, + "additionalProperties": false + }, "RemoteGcpCredentials": { "oneOf": [ { @@ -14200,7 +14242,7 @@ }, "resourceId": { "type": "string", - "description": "Logical Storage resource id in the deployment's stack state." + "description": "Logical remote-enabled resource id in the deployment's stack state." } }, "additionalProperties": false @@ -14287,6 +14329,87 @@ ] } } + }, + { + "type": "object", + "description": "AWS KMS key and an AWS session.", + "required": [ + "binding", + "clientConfig", + "expiresAt", + "service" + ], + "properties": { + "binding": { + "$ref": "#/components/schemas/RemoteAwsKmsKeyBinding" + }, + "clientConfig": { + "$ref": "#/components/schemas/RemoteAwsClientConfig" + }, + "expiresAt": { + "type": "string" + }, + "service": { + "type": "string", + "enum": [ + "kms" + ] + } + } + }, + { + "type": "object", + "description": "GCP Cloud KMS key and an access token.", + "required": [ + "binding", + "clientConfig", + "expiresAt", + "service" + ], + "properties": { + "binding": { + "$ref": "#/components/schemas/RemoteGcpCloudKmsKeyBinding" + }, + "clientConfig": { + "$ref": "#/components/schemas/RemoteGcpClientConfig" + }, + "expiresAt": { + "type": "string" + }, + "service": { + "type": "string", + "enum": [ + "cloud-kms" + ] + } + } + }, + { + "type": "object", + "description": "Azure Key Vault key and a vault-audience access token.", + "required": [ + "binding", + "clientConfig", + "expiresAt", + "service" + ], + "properties": { + "binding": { + "$ref": "#/components/schemas/RemoteAzureKeyVaultKeyBinding" + }, + "clientConfig": { + "$ref": "#/components/schemas/RemoteAzureClientConfig" + }, + "expiresAt": { + "type": "string" + }, + "service": { + "type": "string", + "enum": [ + "key-vault-key" + ] + } + } } ], "description": "One approved remote Storage binding paired with credentials for the same\nprovider. The discriminant makes cross-provider combinations impossible." diff --git a/client-sdks/manager/rust/openapi-3.0.json b/client-sdks/manager/rust/openapi-3.0.json index e2c37e416..0ce30b5c8 100644 --- a/client-sdks/manager/rust/openapi-3.0.json +++ b/client-sdks/manager/rust/openapi-3.0.json @@ -11997,6 +11997,22 @@ ], "description": "The only AWS credential form remote binding resolution can return." }, + "RemoteAwsKmsKeyBinding": { + "type": "object", + "required": [ + "keyArn" + ], + "properties": { + "keyArn": { + "type": "string" + }, + "region": { + "type": "string", + "nullable": true + } + }, + "additionalProperties": false + }, "RemoteAzureClientConfig": { "type": "object", "description": "Response-safe Azure client configuration containing one storage-audience\naccess token for the stack's Remote Bindings identity.", @@ -12050,6 +12066,18 @@ ], "description": "The only Azure credential form remote binding resolution can return." }, + "RemoteAzureKeyVaultKeyBinding": { + "type": "object", + "required": [ + "keyId" + ], + "properties": { + "keyId": { + "type": "string" + } + }, + "additionalProperties": false + }, "RemoteBlobStorageBinding": { "type": "object", "description": "Concrete Azure Blob Storage topology returned to remote clients.", @@ -12098,6 +12126,18 @@ }, "additionalProperties": false }, + "RemoteGcpCloudKmsKeyBinding": { + "type": "object", + "required": [ + "cryptoKeyName" + ], + "properties": { + "cryptoKeyName": { + "type": "string" + } + }, + "additionalProperties": false + }, "RemoteGcpCredentials": { "oneOf": [ { @@ -12281,7 +12321,7 @@ }, "resourceId": { "type": "string", - "description": "Logical Storage resource id in the deployment's stack state." + "description": "Logical remote-enabled resource id in the deployment's stack state." } }, "additionalProperties": false @@ -12368,6 +12408,87 @@ ] } } + }, + { + "type": "object", + "description": "AWS KMS key and an AWS session.", + "required": [ + "binding", + "clientConfig", + "expiresAt", + "service" + ], + "properties": { + "binding": { + "$ref": "#/components/schemas/RemoteAwsKmsKeyBinding" + }, + "clientConfig": { + "$ref": "#/components/schemas/RemoteAwsClientConfig" + }, + "expiresAt": { + "type": "string" + }, + "service": { + "type": "string", + "enum": [ + "kms" + ] + } + } + }, + { + "type": "object", + "description": "GCP Cloud KMS key and an access token.", + "required": [ + "binding", + "clientConfig", + "expiresAt", + "service" + ], + "properties": { + "binding": { + "$ref": "#/components/schemas/RemoteGcpCloudKmsKeyBinding" + }, + "clientConfig": { + "$ref": "#/components/schemas/RemoteGcpClientConfig" + }, + "expiresAt": { + "type": "string" + }, + "service": { + "type": "string", + "enum": [ + "cloud-kms" + ] + } + } + }, + { + "type": "object", + "description": "Azure Key Vault key and a vault-audience access token.", + "required": [ + "binding", + "clientConfig", + "expiresAt", + "service" + ], + "properties": { + "binding": { + "$ref": "#/components/schemas/RemoteAzureKeyVaultKeyBinding" + }, + "clientConfig": { + "$ref": "#/components/schemas/RemoteAzureClientConfig" + }, + "expiresAt": { + "type": "string" + }, + "service": { + "type": "string", + "enum": [ + "key-vault-key" + ] + } + } } ], "description": "One approved remote Storage binding paired with credentials for the same\nprovider. The discriminant makes cross-provider combinations impossible." diff --git a/client-sdks/platform/typescript/docs/models/projectrole.md b/client-sdks/platform/typescript/docs/models/projectrole.md index 6e63beead..bb047810c 100644 --- a/client-sdks/platform/typescript/docs/models/projectrole.md +++ b/client-sdks/platform/typescript/docs/models/projectrole.md @@ -7,11 +7,11 @@ Role for project-scoped service accounts ```typescript import { ProjectRole } from "@alienplatform/platform-api/models"; -let value: ProjectRole = "project.developer"; +let value: ProjectRole = "project.encryption"; ``` ## Values ```typescript -"project.viewer" | "project.developer" +"project.viewer" | "project.developer" | "project.encryption" ``` \ No newline at end of file diff --git a/client-sdks/platform/typescript/src/models/projectrole.ts b/client-sdks/platform/typescript/src/models/projectrole.ts index 1f43dde16..bd223d18f 100644 --- a/client-sdks/platform/typescript/src/models/projectrole.ts +++ b/client-sdks/platform/typescript/src/models/projectrole.ts @@ -11,6 +11,7 @@ import { ClosedEnum } from "../types/enums.js"; export const ProjectRole = { ProjectViewer: "project.viewer", ProjectDeveloper: "project.developer", + ProjectEncryption: "project.encryption", } as const; /** * Role for project-scoped service accounts diff --git a/crates/alien-aws-clients/src/aws/kms.rs b/crates/alien-aws-clients/src/aws/kms.rs new file mode 100644 index 000000000..b5fb40834 --- /dev/null +++ b/crates/alien-aws-clients/src/aws/kms.rs @@ -0,0 +1,167 @@ +use crate::aws::aws_request_utils::{AwsRequestBuilderExt, AwsSignConfig}; +use crate::aws::credential_provider::AwsCredentialProvider; +use alien_client_core::Result; +use alien_error::{Context, IntoAlienError}; +use async_trait::async_trait; +use bon::Builder; +use reqwest::{Client, Method}; +use serde::{de::DeserializeOwned, Deserialize, Serialize}; +use std::collections::BTreeMap; + +#[cfg(feature = "test-utils")] +use mockall::automock; + +#[cfg_attr(feature = "test-utils", automock)] +#[cfg_attr(target_arch = "wasm32", async_trait(?Send))] +#[cfg_attr(not(target_arch = "wasm32"), async_trait)] +pub trait KmsApi: Send + Sync + std::fmt::Debug { + async fn encrypt(&self, request: EncryptRequest) -> Result; + async fn decrypt(&self, request: DecryptRequest) -> Result; + async fn describe_key(&self, key_id: &str) -> Result; +} + +#[derive(Debug, Clone)] +pub struct KmsClient { + client: Client, + credentials: AwsCredentialProvider, +} + +impl KmsClient { + pub fn new(client: Client, credentials: AwsCredentialProvider) -> Self { + Self { + client, + credentials, + } + } + + async fn send( + &self, + target: &str, + body: String, + key_id: &str, + ) -> Result { + self.credentials.ensure_fresh().await?; + let region = self.credentials.region(); + let endpoint = self + .credentials + .get_service_endpoint_option("kms") + .map(str::to_string) + .unwrap_or_else(|| format!("https://kms.{region}.amazonaws.com")); + let host = format!("kms.{region}.amazonaws.com"); + let request = self + .client + .request(Method::POST, endpoint) + .host(&host) + .header("X-Amz-Target", format!("TrentService.{target}")) + .header("Content-Type", "application/x-amz-json-1.1") + .content_sha256(&body) + .body(body); + crate::aws::aws_request_utils::sign_send_json( + request, + &AwsSignConfig { + service_name: "kms".to_string(), + region: region.to_string(), + credentials: self.credentials.get_credentials(), + signing_region: None, + }, + ) + .await + .context(alien_client_core::ErrorData::GenericError { + message: format!("AWS KMS {target} failed for key '{key_id}'"), + }) + } +} + +#[cfg_attr(target_arch = "wasm32", async_trait(?Send))] +#[cfg_attr(not(target_arch = "wasm32"), async_trait)] +impl KmsApi for KmsClient { + async fn encrypt(&self, request: EncryptRequest) -> Result { + let key_id = request.key_id.clone(); + let body = serde_json::to_string(&request).into_alien_error().context( + alien_client_core::ErrorData::SerializationError { + message: "Failed to serialize AWS KMS Encrypt request".to_string(), + }, + )?; + self.send("Encrypt", body, &key_id).await + } + + async fn decrypt(&self, request: DecryptRequest) -> Result { + let key_id = request.key_id.clone(); + let body = serde_json::to_string(&request).into_alien_error().context( + alien_client_core::ErrorData::SerializationError { + message: "Failed to serialize AWS KMS Decrypt request".to_string(), + }, + )?; + self.send("Decrypt", body, &key_id).await + } + + async fn describe_key(&self, key_id: &str) -> Result { + let body = serde_json::to_string(&DescribeKeyRequest { key_id }) + .into_alien_error() + .context(alien_client_core::ErrorData::SerializationError { + message: "Failed to serialize AWS KMS DescribeKey request".to_string(), + })?; + self.send("DescribeKey", body, key_id).await + } +} + +#[derive(Serialize)] +#[serde(rename_all = "PascalCase")] +struct DescribeKeyRequest<'a> { + key_id: &'a str, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "PascalCase")] +pub struct DescribeKeyResponse { + pub key_metadata: KeyMetadata, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "PascalCase")] +pub struct KeyMetadata { + pub arn: String, + pub key_id: String, + pub enabled: bool, + pub key_state: String, + pub key_usage: String, + pub key_spec: String, + #[serde(default)] + pub deletion_date: Option, +} + +#[derive(Debug, Clone, Serialize, Builder)] +#[serde(rename_all = "PascalCase")] +pub struct EncryptRequest { + #[builder(start_fn)] + pub key_id: String, + #[builder(start_fn)] + pub plaintext: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub encryption_context: Option>, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "PascalCase")] +pub struct EncryptResponse { + pub ciphertext_blob: String, + pub key_id: String, +} + +#[derive(Debug, Clone, Serialize, Builder)] +#[serde(rename_all = "PascalCase")] +pub struct DecryptRequest { + #[builder(start_fn)] + pub key_id: String, + #[builder(start_fn)] + pub ciphertext_blob: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub encryption_context: Option>, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "PascalCase")] +pub struct DecryptResponse { + pub plaintext: String, + pub key_id: String, +} diff --git a/crates/alien-aws-clients/src/aws/mod.rs b/crates/alien-aws-clients/src/aws/mod.rs index dfd56176b..981c7c1fe 100644 --- a/crates/alien-aws-clients/src/aws/mod.rs +++ b/crates/alien-aws-clients/src/aws/mod.rs @@ -61,6 +61,7 @@ pub mod elbv2; pub mod eventbridge; pub mod iam; pub mod lambda; +pub mod kms; pub mod rds; pub mod resourcegroupstagging; pub mod s3; diff --git a/crates/alien-aws-clients/src/lib.rs b/crates/alien-aws-clients/src/lib.rs index 530a8b28e..c845f43db 100644 --- a/crates/alien-aws-clients/src/lib.rs +++ b/crates/alien-aws-clients/src/lib.rs @@ -19,6 +19,7 @@ pub use aws::eks::{EksApi, EksClient}; pub use aws::eventbridge::{EventBridgeApi, EventBridgeClient}; pub use aws::iam::{IamApi, IamClient}; pub use aws::lambda::{LambdaApi, LambdaClient}; +pub use aws::kms::{KmsApi, KmsClient}; pub use aws::rds::{RdsApi, RdsClient}; pub use aws::resourcegroupstagging::{ResourceGroupsTaggingApi, ResourceGroupsTaggingClient}; pub use aws::s3::{S3Api, S3Client}; diff --git a/crates/alien-azure-clients/src/azure/keyvault.rs b/crates/alien-azure-clients/src/azure/keyvault.rs index 78f094b26..b9a116ff1 100644 --- a/crates/alien-azure-clients/src/azure/keyvault.rs +++ b/crates/alien-azure-clients/src/azure/keyvault.rs @@ -7,6 +7,7 @@ use alien_client_core::{ErrorData, Result}; use alien_error::{AlienError, Context, ContextError, IntoAlienError}; use reqwest::{Client, Method, RequestBuilder, Response, StatusCode}; +use serde::{Deserialize, Serialize}; #[cfg(feature = "test-utils")] use mockall::automock; @@ -209,6 +210,56 @@ pub trait KeyVaultSecretsApi: Send + Sync + std::fmt::Debug { ) -> Result; } +#[cfg_attr(feature = "test-utils", automock)] +#[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))] +#[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)] +pub trait KeyVaultKeysApi: Send + Sync + std::fmt::Debug { + async fn get_key(&self, key_id: &str) -> Result; + async fn encrypt( + &self, + key_id: &str, + request: KeyOperationRequest, + ) -> Result; + async fn decrypt( + &self, + key_id: &str, + request: KeyOperationRequest, + ) -> Result; +} + +#[derive(Debug, Clone, Serialize)] +pub struct KeyOperationRequest { + pub alg: String, + pub value: String, +} + +#[derive(Debug, Clone, Deserialize)] +pub struct KeyOperationResponse { + pub kid: String, + pub value: String, +} + +#[derive(Debug, Clone, Deserialize)] +pub struct KeyBundle { + pub key: JsonWebKey, + pub attributes: KeyAttributes, +} + +#[derive(Debug, Clone, Deserialize)] +pub struct JsonWebKey { + pub kid: String, + pub kty: String, + #[serde(default)] + pub key_ops: Vec, +} + +#[derive(Debug, Clone, Deserialize)] +pub struct KeyAttributes { + pub enabled: Option, + #[serde(rename = "recoveryLevel")] + pub recovery_level: Option, +} + #[cfg_attr(feature = "test-utils", automock)] #[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))] #[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)] @@ -743,6 +794,112 @@ impl KeyVaultSecretsApi for AzureKeyVaultSecretsClient { } } +// ----------------------------------------------------------------------------- +// Key Vault Keys client +// ----------------------------------------------------------------------------- + +#[derive(Debug)] +pub struct AzureKeyVaultKeysClient { + client: Client, + token_cache: AzureTokenCache, +} + +impl AzureKeyVaultKeysClient { + pub fn new(client: Client, token_cache: AzureTokenCache) -> Self { + Self { + client, + token_cache, + } + } + + async fn operation( + &self, + key_id: &str, + operation: &str, + request: KeyOperationRequest, + ) -> Result { + let mut url = url::Url::parse(&format!( + "{}/{}", + key_id.trim_end_matches('/'), + operation.to_ascii_lowercase() + )) + .into_alien_error() + .context(ErrorData::InvalidInput { + message: "Azure Key Vault key ID is not a valid URL".to_string(), + field_name: Some("keyId".to_string()), + })?; + url.query_pairs_mut().append_pair("api-version", "7.4"); + let response = send_key_vault_request( + &self.token_cache, + self.client.post(url.clone()).json(&request), + operation, + ) + .await?; + if !response.status().is_success() { + return Err(key_vault_response_error( + response.status(), + operation, + "Azure Key Vault Key", + key_id, + &url, + )); + } + response + .json::() + .await + .into_alien_error() + .context(key_vault_parse_error(operation, &url)) + } +} + +#[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))] +#[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)] +impl KeyVaultKeysApi for AzureKeyVaultKeysClient { + async fn get_key(&self, key_id: &str) -> Result { + let mut url = + url::Url::parse(key_id) + .into_alien_error() + .context(ErrorData::InvalidInput { + message: "Azure Key Vault key ID is not a valid URL".to_string(), + field_name: Some("keyId".to_string()), + })?; + url.query_pairs_mut().append_pair("api-version", "7.4"); + let response = + send_key_vault_request(&self.token_cache, self.client.get(url.clone()), "GetKey") + .await?; + if !response.status().is_success() { + return Err(key_vault_response_error( + response.status(), + "GetKey", + "Azure Key Vault Key", + key_id, + &url, + )); + } + response + .json::() + .await + .into_alien_error() + .context(key_vault_parse_error("GetKey", &url)) + } + + async fn encrypt( + &self, + key_id: &str, + request: KeyOperationRequest, + ) -> Result { + self.operation(key_id, "Encrypt", request).await + } + + async fn decrypt( + &self, + key_id: &str, + request: KeyOperationRequest, + ) -> Result { + self.operation(key_id, "Decrypt", request).await + } +} + // ----------------------------------------------------------------------------- // Key Vault Certificates client // ----------------------------------------------------------------------------- diff --git a/crates/alien-azure-clients/src/lib.rs b/crates/alien-azure-clients/src/lib.rs index 8b6fc5373..70477dae6 100644 --- a/crates/alien-azure-clients/src/lib.rs +++ b/crates/alien-azure-clients/src/lib.rs @@ -21,8 +21,8 @@ pub use azure::disks::{AzureManagedDisksClient, ManagedDisksApi}; pub use azure::event_grid::{AzureEventGridClient, EventGridApi}; pub use azure::flexible_server::{AzureFlexibleServerClient, FlexibleServerApi}; pub use azure::keyvault::{ - AzureKeyVaultManagementClient, AzureKeyVaultSecretsClient, KeyVaultManagementApi, - KeyVaultSecretsApi, + AzureKeyVaultKeysClient, AzureKeyVaultManagementClient, AzureKeyVaultSecretsClient, + KeyVaultKeysApi, KeyVaultManagementApi, KeyVaultSecretsApi, }; pub use azure::load_balancers::{AzureLoadBalancerClient, LoadBalancerApi}; pub use azure::long_running_operation::{LongRunningOperationApi, LongRunningOperationClient}; diff --git a/crates/alien-bindings-node/src/key.rs b/crates/alien-bindings-node/src/key.rs new file mode 100644 index 000000000..cce31a877 --- /dev/null +++ b/crates/alien-bindings-node/src/key.rs @@ -0,0 +1,52 @@ +use crate::error::map_alien_error; +use alien_bindings::Key; +use napi::bindgen_prelude::Buffer; +use napi_derive::napi; +use std::collections::{BTreeMap, HashMap}; +use std::sync::Arc; + +#[napi] +pub struct KeyHandle { + inner: Arc, +} + +impl KeyHandle { + pub(crate) fn new(inner: Arc) -> Self { + Self { inner } + } +} + +fn ordered_context(context: Option>) -> Option> { + context.map(|values| values.into_iter().collect()) +} + +#[napi] +impl KeyHandle { + #[napi] + pub async fn encrypt( + &self, + plaintext: Buffer, + context: Option>, + ) -> napi::Result { + let context = ordered_context(context); + self.inner + .encrypt(&plaintext, context.as_ref()) + .await + .map(Buffer::from) + .map_err(map_alien_error) + } + + #[napi] + pub async fn decrypt( + &self, + ciphertext: Buffer, + context: Option>, + ) -> napi::Result { + let context = ordered_context(context); + self.inner + .decrypt(&ciphertext, context.as_ref()) + .await + .map(Buffer::from) + .map_err(map_alien_error) + } +} diff --git a/crates/alien-bindings-node/src/lib.rs b/crates/alien-bindings-node/src/lib.rs index 4e2809d48..a3463780b 100644 --- a/crates/alien-bindings-node/src/lib.rs +++ b/crates/alien-bindings-node/src/lib.rs @@ -10,6 +10,7 @@ mod container; mod error; +mod key; mod kv; mod postgres; mod queue; @@ -26,6 +27,7 @@ use napi_derive::napi; use std::sync::Arc; pub use container::ContainerHandle; +pub use key::KeyHandle; pub use kv::KvHandle; pub use postgres::{PostgresConnectionJs, PostgresHandle}; pub use queue::QueueHandle; @@ -68,6 +70,14 @@ impl BindingsHandle { Ok(StorageHandle::new(storage, name)) } + /// Resolve the provider-backed key binding named `name`. + #[napi] + pub async fn key(&self, name: String) -> napi::Result { + let inner = self.inner.clone(); + let key = inner.key(&name).await.map_err(map_alien_error)?; + Ok(KeyHandle::new(key)) + } + /// Resolve the key-value binding named `name`. #[napi] pub async fn kv(&self, name: String) -> napi::Result { @@ -112,7 +122,7 @@ impl BindingsHandle { } } -/// The JS-facing remote entry point. Its narrow surface makes unsupported +/// The JS-facing remote entry point. Its typed surface makes unsupported /// binding kinds impossible to request through the native addon. #[cfg(feature = "platform-sdk")] #[napi] @@ -145,4 +155,11 @@ impl RemoteBindingsHandle { let storage = self.inner.storage(&name).await.map_err(map_alien_error)?; Ok(RemoteStorageHandle::new(storage, name)) } + + /// Resolve the key binding named `name`. + #[napi] + pub async fn key(&self, name: String) -> napi::Result { + let key = self.inner.key(&name).await.map_err(map_alien_error)?; + Ok(KeyHandle::new(key)) + } } diff --git a/crates/alien-bindings/Cargo.toml b/crates/alien-bindings/Cargo.toml index 8c2fde321..2d65fb38f 100644 --- a/crates/alien-bindings/Cargo.toml +++ b/crates/alien-bindings/Cargo.toml @@ -15,7 +15,7 @@ aws = ["object_store/aws", "dep:base64", "dep:alien-aws-clients", "alien-client- gcp = ["object_store/gcp", "dep:base64", "dep:alien-gcp-clients", "alien-client-config/gcp"] azure = ["object_store/azure", "dep:base64", "dep:alien-azure-clients", "alien-client-config/azure"] kubernetes = ["dep:alien-k8s-clients", "dep:k8s-openapi", "alien-client-config/kubernetes"] -local = ["object_store/fs", "dep:base64", "dep:oci-client", "dep:turso", "dep:sha2", "tokio/fs", "tokio/process", "alien-core/local"] +local = ["object_store/fs", "dep:base64", "dep:oci-client", "dep:turso", "tokio/fs", "tokio/process", "alien-core/local"] test = [] # Test platform support - fast mock implementations without real cloud APIs openapi = ["dep:utoipa"] platform-sdk = ["dep:alien-platform-api", "dep:alien-manager-api"] # Platform/manager API access for RemoteBindings @@ -52,7 +52,7 @@ oci-client = { workspace = true, default-features = false, features = ["rustls-t # for `Builder::experimental_multiprocess_wal`) and its rationale live in the # workspace Cargo.toml so every crate links the same turso_core. turso = { workspace = true, optional = true } -sha2 = { workspace = true, optional = true } +sha2 = { workspace = true } # AWS base64 = { workspace = true, optional = true } @@ -79,6 +79,7 @@ async-trait = { workspace = true } uuid = { workspace = true, features = ["v4", "serde"] } base64 = { workspace = true } tracing-subscriber = { workspace = true } +hex = { workspace = true } [target.'cfg(unix)'.dev-dependencies] container-registry = { workspace = true, features = ["test-support"] } diff --git a/crates/alien-bindings/src/bindings.rs b/crates/alien-bindings/src/bindings.rs index 029089eb0..40fc0f631 100644 --- a/crates/alien-bindings/src/bindings.rs +++ b/crates/alien-bindings/src/bindings.rs @@ -7,9 +7,11 @@ use crate::error::Result; use crate::provider::{BindingsProvider, LazyEnvBindingsProvider}; -use crate::refreshing::{RefreshingKv, RefreshingQueue, RefreshingStorage, RefreshingVault}; +use crate::refreshing::{ + RefreshingKey, RefreshingKv, RefreshingQueue, RefreshingStorage, RefreshingVault, +}; use crate::traits::{ - BindingsProviderApi, Container, Kv, MessagePayload, Postgres, Queue, QueueMessage, Storage, + BindingsProviderApi, Container, Key, Kv, MessagePayload, Postgres, Queue, QueueMessage, Storage, Vault, }; use std::collections::HashMap; @@ -133,6 +135,15 @@ impl Bindings { ))) } + /// Loads a provider-backed key binding that refreshes minted credentials before use. + pub async fn key(&self, binding_name: &str) -> Result> { + self.provider.load_key(binding_name).await?; + Ok(Arc::new(RefreshingKey::new( + self.provider.clone(), + binding_name.to_string(), + ))) + } + /// Loads an environment-backed key-value binding that refreshes minted /// credentials before use. pub async fn kv(&self, binding_name: &str) -> Result> { diff --git a/crates/alien-bindings/src/error.rs b/crates/alien-bindings/src/error.rs index 202186e70..3178d4085 100644 --- a/crates/alien-bindings/src/error.rs +++ b/crates/alien-bindings/src/error.rs @@ -13,6 +13,26 @@ pub fn binding_env_var(binding_name: &str) -> String { #[derive(Debug, Clone, AlienErrorData, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub enum ErrorData { + /// Plaintext or context is outside the portable Key binding limits. + #[error( + code = "KEY_INPUT_INVALID", + message = "Key input is invalid: {reason}", + retryable = "false", + internal = "false", + http_status_code = 400 + )] + KeyInputInvalid { reason: String }, + + /// Decrypted provider data is not a valid Alien Key frame. + #[error( + code = "KEY_CIPHERTEXT_INVALID", + message = "Key ciphertext is invalid: {reason}", + retryable = "false", + internal = "false", + http_status_code = 400 + )] + KeyCiphertextInvalid { reason: String }, + /// No binding configuration was found for the requested binding name (the /// `ALIEN__BINDING` environment variable was not set). #[error( diff --git a/crates/alien-bindings/src/lib.rs b/crates/alien-bindings/src/lib.rs index be712696a..b603238e2 100644 --- a/crates/alien-bindings/src/lib.rs +++ b/crates/alien-bindings/src/lib.rs @@ -10,7 +10,7 @@ pub use remote::{RemoteBindings, RemoteStorage}; pub use traits::{ ArtifactRegistry, ArtifactRegistryCredentials, ArtifactRegistryPermissions, AwsServiceAccountInfo, AzureServiceAccountInfo, Binding, BindingsProviderApi, Build, Container, - GcpServiceAccountInfo, ImpersonationRequest, InvalidPostgresCaCertificates, Kv, KvEntry, + GcpServiceAccountInfo, ImpersonationRequest, InvalidPostgresCaCertificates, Key, Kv, KvEntry, Postgres, PostgresConnectionParams, PostgresTlsPolicy, PutCondition, Queue, RegistryAuthMethod, RepositoryResponse, ServiceAccount, ServiceAccountInfo, SslMode, Storage, Vault, Worker, }; diff --git a/crates/alien-bindings/src/provider.rs b/crates/alien-bindings/src/provider.rs index 8036f6a30..681176776 100644 --- a/crates/alien-bindings/src/provider.rs +++ b/crates/alien-bindings/src/provider.rs @@ -4,7 +4,7 @@ use crate::{ error::{binding_env_var, ErrorData, Result}, providers::postgres::runtime::PostgresRuntime, traits::{ - ArtifactRegistry, BindingsProviderApi, Build, Container, Kv, Postgres, Queue, + ArtifactRegistry, BindingsProviderApi, Build, Container, Key, Kv, Postgres, Queue, ServiceAccount, Storage, Vault, Worker, }, }; @@ -441,6 +441,11 @@ impl BindingsProviderApi for LazyEnvBindingsProvider { self.provider().await?.load_storage(binding_name).await } + async fn load_key(&self, binding_name: &str) -> Result> { + self.ensure_binding_present(binding_name)?; + self.provider().await?.load_key(binding_name).await + } + async fn load_build(&self, binding_name: &str) -> Result> { self.ensure_binding_present(binding_name)?; self.provider().await?.load_build(binding_name).await @@ -644,6 +649,129 @@ impl BindingsProviderApi for BindingsProvider { Ok(result) } + async fn load_key(&self, binding_name: &str) -> Result> { + if let Some(cached) = self.get_cached::>("key", binding_name).await { + return Ok(cached); + } + + use alien_core::bindings::KeyBinding; + let binding: KeyBinding = self.parse_binding(binding_name, "key")?; + let key: Arc = match binding { + #[cfg(feature = "aws")] + KeyBinding::AwsKms(config) => { + use crate::providers::key::aws::AwsKmsKey; + use alien_aws_clients::kms::KmsClient; + let mut aws_config = self.client_config.aws_config().cloned().ok_or_else(|| { + AlienError::new(ErrorData::ClientConfigInvalid { + platform: Platform::Aws, + message: "AWS config not available".to_string(), + }) + })?; + if let Some(region) = config.region { + aws_config.region = region + .into_value(binding_name, "region") + .context(ErrorData::config_invalid( + binding_name, + "Failed to extract region from KMS binding", + ))?; + } + let credentials = + alien_aws_clients::AwsCredentialProvider::from_config(aws_config) + .await + .context(ErrorData::BindingSetupFailed { + binding_type: "AWS KMS key".to_string(), + reason: "Failed to create credential provider".to_string(), + })?; + let key_arn = config + .key_arn + .into_value(binding_name, "key_arn") + .context(ErrorData::config_invalid( + binding_name, + "Failed to extract key_arn from KMS binding", + ))?; + Arc::new(AwsKmsKey::new( + Arc::new(KmsClient::new( + crate::http_client::create_http_client(), + credentials, + )), + key_arn, + )) + } + #[cfg(not(feature = "aws"))] + KeyBinding::AwsKms(_) => { + return Err(AlienError::new(ErrorData::FeatureNotEnabled { + feature: "aws".to_string(), + })) + } + #[cfg(feature = "gcp")] + KeyBinding::GcpCloudKms(config) => { + use crate::providers::key::gcp::GcpCloudKmsKey; + use alien_gcp_clients::cloud_kms::CloudKmsClient; + let gcp_config = self.client_config.gcp_config().ok_or_else(|| { + AlienError::new(ErrorData::ClientConfigInvalid { + platform: Platform::Gcp, + message: "GCP config not available".to_string(), + }) + })?; + let crypto_key_name = config + .crypto_key_name + .into_value(binding_name, "crypto_key_name") + .context(ErrorData::config_invalid( + binding_name, + "Failed to extract crypto_key_name from Cloud KMS binding", + ))?; + Arc::new(GcpCloudKmsKey::new( + Arc::new(CloudKmsClient::new( + crate::http_client::create_http_client(), + gcp_config.clone(), + )), + crypto_key_name, + )) + } + #[cfg(not(feature = "gcp"))] + KeyBinding::GcpCloudKms(_) => { + return Err(AlienError::new(ErrorData::FeatureNotEnabled { + feature: "gcp".to_string(), + })) + } + #[cfg(feature = "azure")] + KeyBinding::AzureKeyVault(config) => { + use crate::providers::key::azure::AzureKeyVaultKey; + use alien_azure_clients::keyvault::AzureKeyVaultKeysClient; + use alien_azure_clients::AzureTokenCache; + let azure_config = self.client_config.azure_config().ok_or_else(|| { + AlienError::new(ErrorData::ClientConfigInvalid { + platform: Platform::Azure, + message: "Azure config not available".to_string(), + }) + })?; + let key_id = config + .key_id + .into_value(binding_name, "key_id") + .context(ErrorData::config_invalid( + binding_name, + "Failed to extract key_id from Key Vault binding", + ))?; + Arc::new(AzureKeyVaultKey::new( + Arc::new(AzureKeyVaultKeysClient::new( + crate::http_client::create_http_client(), + AzureTokenCache::new(azure_config.clone()), + )), + key_id, + )) + } + #[cfg(not(feature = "azure"))] + KeyBinding::AzureKeyVault(_) => { + return Err(AlienError::new(ErrorData::FeatureNotEnabled { + feature: "azure".to_string(), + })) + } + }; + + self.put_cache("key", binding_name, key.clone()).await; + Ok(key) + } + async fn load_build(&self, binding_name: &str) -> Result> { use alien_core::bindings::BuildBinding; diff --git a/crates/alien-bindings/src/providers/key/aws.rs b/crates/alien-bindings/src/providers/key/aws.rs new file mode 100644 index 000000000..59217e24d --- /dev/null +++ b/crates/alien-bindings/src/providers/key/aws.rs @@ -0,0 +1,131 @@ +use super::{encode_context, frame, unframe}; +use crate::error::{ErrorData, Result}; +use crate::traits::{Binding, Key}; +use alien_aws_clients::kms::{DecryptRequest, EncryptRequest, KmsApi}; +use alien_error::{Context, IntoAlienError}; +use async_trait::async_trait; +use base64::{engine::general_purpose::STANDARD, Engine as _}; +use std::collections::BTreeMap; +use std::sync::Arc; + +#[derive(Debug)] +pub struct AwsKmsKey { + client: Arc, + key_arn: String, +} + +impl AwsKmsKey { + pub fn new(client: Arc, key_arn: String) -> Self { + Self { client, key_arn } + } +} + +impl Binding for AwsKmsKey {} + +#[async_trait] +impl Key for AwsKmsKey { + async fn encrypt( + &self, + plaintext: &[u8], + context: Option<&BTreeMap>, + ) -> Result> { + let canonical = encode_context(context)?; + let response = self + .client + .encrypt( + EncryptRequest::builder( + self.key_arn.clone(), + STANDARD.encode(frame(plaintext, &canonical)?), + ) + .maybe_encryption_context(context.cloned()) + .build(), + ) + .await + .context(ErrorData::CloudPlatformError { + message: "AWS KMS encrypt failed".to_string(), + resource_id: None, + })?; + STANDARD + .decode(response.ciphertext_blob) + .into_alien_error() + .context(ErrorData::CloudPlatformError { + message: "AWS KMS returned invalid ciphertext encoding".to_string(), + resource_id: None, + }) + } + + async fn decrypt( + &self, + ciphertext: &[u8], + context: Option<&BTreeMap>, + ) -> Result> { + let canonical = encode_context(context)?; + let response = self + .client + .decrypt( + DecryptRequest::builder(self.key_arn.clone(), STANDARD.encode(ciphertext)) + .maybe_encryption_context(context.cloned()) + .build(), + ) + .await + .context(ErrorData::CloudPlatformError { + message: "AWS KMS decrypt failed".to_string(), + resource_id: None, + })?; + let framed = STANDARD + .decode(response.plaintext) + .into_alien_error() + .context(ErrorData::KeyCiphertextInvalid { + reason: "provider plaintext encoding is invalid".to_string(), + })?; + unframe(&framed, &canonical) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use alien_aws_clients::kms::{DecryptResponse, EncryptResponse, MockKmsApi}; + + #[tokio::test] + async fn passes_context_to_kms_and_validates_it_after_decrypt() { + let context = BTreeMap::from([("tenant".to_string(), "acme".to_string())]); + let canonical = encode_context(Some(&context)).unwrap(); + let framed = frame(b"root", &canonical).unwrap(); + let expected_context = context.clone(); + let mut client = MockKmsApi::new(); + client + .expect_encrypt() + .withf(move |request| { + request.key_id == "key-arn" + && request.encryption_context.as_ref() == Some(&expected_context) + }) + .returning(|_| { + Ok(EncryptResponse { + ciphertext_blob: STANDARD.encode(b"ciphertext"), + key_id: "key-arn".to_string(), + }) + }); + let decrypt_context = context.clone(); + client + .expect_decrypt() + .withf(move |request| { + request.key_id == "key-arn" + && request.ciphertext_blob == STANDARD.encode(b"ciphertext") + && request.encryption_context.as_ref() == Some(&decrypt_context) + }) + .returning(move |_| { + Ok(DecryptResponse { + plaintext: STANDARD.encode(&framed), + key_id: "key-arn".to_string(), + }) + }); + + let key = AwsKmsKey::new(Arc::new(client), "key-arn".to_string()); + let ciphertext = key.encrypt(b"root", Some(&context)).await.unwrap(); + assert_eq!( + key.decrypt(&ciphertext, Some(&context)).await.unwrap(), + b"root" + ); + } +} diff --git a/crates/alien-bindings/src/providers/key/azure.rs b/crates/alien-bindings/src/providers/key/azure.rs new file mode 100644 index 000000000..9c0a8ac0b --- /dev/null +++ b/crates/alien-bindings/src/providers/key/azure.rs @@ -0,0 +1,125 @@ +use super::{encode_context, frame, unframe}; +use crate::error::{ErrorData, Result}; +use crate::traits::{Binding, Key}; +use alien_azure_clients::keyvault::{KeyOperationRequest, KeyVaultKeysApi}; +use alien_error::{Context, IntoAlienError}; +use async_trait::async_trait; +use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _}; +use std::collections::BTreeMap; +use std::sync::Arc; + +#[derive(Debug)] +pub struct AzureKeyVaultKey { + client: Arc, + key_id: String, +} + +impl AzureKeyVaultKey { + pub fn new(client: Arc, key_id: String) -> Self { + Self { client, key_id } + } +} + +impl Binding for AzureKeyVaultKey {} + +#[async_trait] +impl Key for AzureKeyVaultKey { + async fn encrypt( + &self, + plaintext: &[u8], + context: Option<&BTreeMap>, + ) -> Result> { + let canonical = encode_context(context)?; + let response = self + .client + .encrypt( + &self.key_id, + KeyOperationRequest { + alg: "RSA-OAEP-256".to_string(), + value: URL_SAFE_NO_PAD.encode(frame(plaintext, &canonical)?), + }, + ) + .await + .context(ErrorData::CloudPlatformError { + message: "Azure Key Vault encrypt failed".to_string(), + resource_id: None, + })?; + URL_SAFE_NO_PAD + .decode(response.value) + .into_alien_error() + .context(ErrorData::CloudPlatformError { + message: "Azure Key Vault returned invalid ciphertext encoding".to_string(), + resource_id: None, + }) + } + + async fn decrypt( + &self, + ciphertext: &[u8], + context: Option<&BTreeMap>, + ) -> Result> { + let canonical = encode_context(context)?; + let response = self + .client + .decrypt( + &self.key_id, + KeyOperationRequest { + alg: "RSA-OAEP-256".to_string(), + value: URL_SAFE_NO_PAD.encode(ciphertext), + }, + ) + .await + .context(ErrorData::CloudPlatformError { + message: "Azure Key Vault decrypt failed".to_string(), + resource_id: None, + })?; + let framed = URL_SAFE_NO_PAD + .decode(response.value) + .into_alien_error() + .context(ErrorData::KeyCiphertextInvalid { + reason: "provider plaintext encoding is invalid".to_string(), + })?; + unframe(&framed, &canonical) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use alien_azure_clients::keyvault::{KeyOperationResponse, MockKeyVaultKeysApi}; + + #[tokio::test] + async fn binds_context_inside_the_portable_frame() { + let context = BTreeMap::from([("tenant".to_string(), "acme".to_string())]); + let canonical = encode_context(Some(&context)).unwrap(); + let framed = frame(b"root", &canonical).unwrap(); + let mut client = MockKeyVaultKeysApi::new(); + client.expect_encrypt().returning(|key_id, request| { + assert_eq!(key_id, "versioned-key-id"); + assert_eq!(request.alg, "RSA-OAEP-256"); + Ok(KeyOperationResponse { + kid: key_id.to_string(), + value: URL_SAFE_NO_PAD.encode(b"ciphertext"), + }) + }); + client + .expect_decrypt() + .times(2) + .returning(move |key_id, request| { + assert_eq!(key_id, "versioned-key-id"); + assert_eq!(request.alg, "RSA-OAEP-256"); + Ok(KeyOperationResponse { + kid: key_id.to_string(), + value: URL_SAFE_NO_PAD.encode(&framed), + }) + }); + + let key = AzureKeyVaultKey::new(Arc::new(client), "versioned-key-id".to_string()); + let ciphertext = key.encrypt(b"root", Some(&context)).await.unwrap(); + assert_eq!( + key.decrypt(&ciphertext, Some(&context)).await.unwrap(), + b"root" + ); + assert!(key.decrypt(&ciphertext, None).await.is_err()); + } +} diff --git a/crates/alien-bindings/src/providers/key/gcp.rs b/crates/alien-bindings/src/providers/key/gcp.rs new file mode 100644 index 000000000..8bf775a08 --- /dev/null +++ b/crates/alien-bindings/src/providers/key/gcp.rs @@ -0,0 +1,134 @@ +use super::{encode_context, frame, unframe}; +use crate::error::{ErrorData, Result}; +use crate::traits::{Binding, Key}; +use alien_error::{Context, IntoAlienError}; +use alien_gcp_clients::cloud_kms::{CloudKmsApi, DecryptRequest, EncryptRequest}; +use async_trait::async_trait; +use base64::{engine::general_purpose::STANDARD, Engine as _}; +use std::collections::BTreeMap; +use std::sync::Arc; + +#[derive(Debug)] +pub struct GcpCloudKmsKey { + client: Arc, + crypto_key_name: String, +} + +impl GcpCloudKmsKey { + pub fn new(client: Arc, crypto_key_name: String) -> Self { + Self { + client, + crypto_key_name, + } + } +} + +impl Binding for GcpCloudKmsKey {} + +#[async_trait] +impl Key for GcpCloudKmsKey { + async fn encrypt( + &self, + plaintext: &[u8], + context: Option<&BTreeMap>, + ) -> Result> { + let canonical = encode_context(context)?; + let response = self + .client + .encrypt( + &self.crypto_key_name, + EncryptRequest { + plaintext: STANDARD.encode(frame(plaintext, &canonical)?), + additional_authenticated_data: Some(STANDARD.encode(&canonical)), + }, + ) + .await + .context(ErrorData::CloudPlatformError { + message: "GCP Cloud KMS encrypt failed".to_string(), + resource_id: None, + })?; + STANDARD + .decode(response.ciphertext) + .into_alien_error() + .context(ErrorData::CloudPlatformError { + message: "GCP Cloud KMS returned invalid ciphertext encoding".to_string(), + resource_id: None, + }) + } + + async fn decrypt( + &self, + ciphertext: &[u8], + context: Option<&BTreeMap>, + ) -> Result> { + let canonical = encode_context(context)?; + let response = self + .client + .decrypt( + &self.crypto_key_name, + DecryptRequest { + ciphertext: STANDARD.encode(ciphertext), + additional_authenticated_data: Some(STANDARD.encode(&canonical)), + }, + ) + .await + .context(ErrorData::CloudPlatformError { + message: "GCP Cloud KMS decrypt failed".to_string(), + resource_id: None, + })?; + let framed = STANDARD + .decode(response.plaintext) + .into_alien_error() + .context(ErrorData::KeyCiphertextInvalid { + reason: "provider plaintext encoding is invalid".to_string(), + })?; + unframe(&framed, &canonical) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use alien_gcp_clients::cloud_kms::{DecryptResponse, EncryptResponse, MockCloudKmsApi}; + + #[tokio::test] + async fn passes_canonical_context_as_aad() { + let context = BTreeMap::from([("tenant".to_string(), "acme".to_string())]); + let canonical = encode_context(Some(&context)).unwrap(); + let expected_aad = STANDARD.encode(&canonical); + let framed = frame(b"root", &canonical).unwrap(); + let encrypt_aad = expected_aad.clone(); + let mut client = MockCloudKmsApi::new(); + client + .expect_encrypt() + .withf(move |name, request| { + name == "key-name" + && request.additional_authenticated_data.as_ref() == Some(&encrypt_aad) + }) + .returning(|_, _| { + Ok(EncryptResponse { + name: "version-name".to_string(), + ciphertext: STANDARD.encode(b"ciphertext"), + }) + }); + client + .expect_decrypt() + .withf(move |name, request| { + name == "key-name" + && request.ciphertext == STANDARD.encode(b"ciphertext") + && request.additional_authenticated_data.as_ref() == Some(&expected_aad) + }) + .returning(move |_, _| { + Ok(DecryptResponse { + plaintext: STANDARD.encode(&framed), + }) + }); + + let key = GcpCloudKmsKey::new(Arc::new(client), "key-name".to_string()); + let ciphertext = key.encrypt(b"root", Some(&context)).await.unwrap(); + assert_eq!( + key.decrypt(&ciphertext, Some(&context)).await.unwrap(), + b"root" + ); + } +} diff --git a/crates/alien-bindings/src/providers/key/mod.rs b/crates/alien-bindings/src/providers/key/mod.rs new file mode 100644 index 000000000..fb77ea0e7 --- /dev/null +++ b/crates/alien-bindings/src/providers/key/mod.rs @@ -0,0 +1,109 @@ +use crate::error::{ErrorData, Result}; +use alien_error::AlienError; +use sha2::{Digest, Sha256}; +use std::collections::BTreeMap; + +#[cfg(feature = "aws")] +pub mod aws; +#[cfg(feature = "azure")] +pub mod azure; +#[cfg(feature = "gcp")] +pub mod gcp; + +const MAGIC: &[u8; 4] = b"AKBF"; +const VERSION: u8 = 1; +const HEADER_LENGTH: usize = 39; +const MAX_PLAINTEXT_LENGTH: usize = 128; +const MAX_CONTEXT_LENGTH: usize = 16 * 1024; + +pub(crate) fn encode_context(context: Option<&BTreeMap>) -> Result> { + let empty_context = BTreeMap::new(); + let context = context.unwrap_or(&empty_context); + let mut encoded = Vec::new(); + encoded.extend_from_slice(&(context.len() as u32).to_be_bytes()); + for (key, value) in context { + let key = key.as_bytes(); + let value = value.as_bytes(); + encoded.extend_from_slice(&(key.len() as u32).to_be_bytes()); + encoded.extend_from_slice(key); + encoded.extend_from_slice(&(value.len() as u32).to_be_bytes()); + encoded.extend_from_slice(value); + if encoded.len() > MAX_CONTEXT_LENGTH { + return Err(AlienError::new(ErrorData::KeyInputInvalid { + reason: "canonical context exceeds 16 KiB".to_string(), + })); + } + } + Ok(encoded) +} + +pub(crate) fn frame(plaintext: &[u8], canonical_context: &[u8]) -> Result> { + if plaintext.len() > MAX_PLAINTEXT_LENGTH { + return Err(AlienError::new(ErrorData::KeyInputInvalid { + reason: "plaintext exceeds the portable 128-byte limit".to_string(), + })); + } + let mut frame = Vec::with_capacity(HEADER_LENGTH + plaintext.len()); + frame.extend_from_slice(MAGIC); + frame.push(VERSION); + frame.extend_from_slice(&(plaintext.len() as u16).to_be_bytes()); + frame.extend_from_slice(&Sha256::digest(canonical_context)); + frame.extend_from_slice(plaintext); + Ok(frame) +} + +pub(crate) fn unframe(frame: &[u8], canonical_context: &[u8]) -> Result> { + if frame.len() < HEADER_LENGTH || &frame[..4] != MAGIC || frame[4] != VERSION { + return Err(AlienError::new(ErrorData::KeyCiphertextInvalid { + reason: "decrypted data is not an Alien Key frame".to_string(), + })); + } + let plaintext_length = u16::from_be_bytes([frame[5], frame[6]]) as usize; + if plaintext_length > MAX_PLAINTEXT_LENGTH || frame.len() != HEADER_LENGTH + plaintext_length { + return Err(AlienError::new(ErrorData::KeyCiphertextInvalid { + reason: "decrypted frame has an invalid plaintext length".to_string(), + })); + } + let expected_context_hash = Sha256::digest(canonical_context); + if frame[7..39] != expected_context_hash[..] { + return Err(AlienError::new(ErrorData::KeyCiphertextInvalid { + reason: "context does not match the encrypted value".to_string(), + })); + } + Ok(frame[HEADER_LENGTH..].to_vec()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn frame_enforces_limits_and_context() { + let context = BTreeMap::from([ + ("project".to_string(), "example".to_string()), + ("purpose".to_string(), "root".to_string()), + ]); + let canonical = encode_context(Some(&context)).unwrap(); + let framed = frame(&[7; 128], &canonical).unwrap(); + assert_eq!(unframe(&framed, &canonical).unwrap(), vec![7; 128]); + assert!(frame(&[0; 129], &canonical).is_err()); + assert!(unframe(&framed, &encode_context(None).unwrap()).is_err()); + } + + #[test] + fn canonical_context_and_frame_match_the_published_vector() { + let context = BTreeMap::from([ + ("purpose".to_string(), "root".to_string()), + ("project".to_string(), "example".to_string()), + ]); + let canonical = encode_context(Some(&context)).unwrap(); + assert_eq!( + hex::encode(&canonical), + "000000020000000770726f6a656374000000076578616d706c6500000007707572706f736500000004726f6f74" + ); + assert_eq!( + hex::encode(frame(b"hello", &canonical).unwrap()), + "414b4246010005faf89ea5b4228220f52708c3fc60f67ede69c57333979676767bf5715253e4a768656c6c6f" + ); + } +} diff --git a/crates/alien-bindings/src/providers/mod.rs b/crates/alien-bindings/src/providers/mod.rs index 5cda99c5d..f23d54a13 100644 --- a/crates/alien-bindings/src/providers/mod.rs +++ b/crates/alien-bindings/src/providers/mod.rs @@ -3,6 +3,7 @@ pub mod artifact_registry; pub mod build; pub mod container; pub mod kv; +pub mod key; #[cfg(feature = "local")] pub(crate) mod local_store; pub mod postgres; diff --git a/crates/alien-bindings/src/refreshing.rs b/crates/alien-bindings/src/refreshing.rs index 87bc8fbf9..e24956940 100644 --- a/crates/alien-bindings/src/refreshing.rs +++ b/crates/alien-bindings/src/refreshing.rs @@ -33,8 +33,8 @@ use crate::presigned::PresignedRequest; #[cfg(feature = "platform-sdk")] use crate::remote::RemoteStorage; use crate::traits::{ - Binding, BindingsProviderApi, Kv, KvEntry, MessagePayload, PutOptions as KvPutOptions, Queue, - QueueMessage, ScanResult, Storage, Vault, + Binding, BindingsProviderApi, Key, Kv, KvEntry, MessagePayload, PutOptions as KvPutOptions, + Queue, QueueMessage, ScanResult, Storage, Vault, }; const OBJECT_STORE_NAME: &str = "Alien binding"; @@ -49,6 +49,22 @@ pub(super) trait StorageProviderApi: Send + Sync + fmt::Debug { async fn load_storage(&self, binding_name: &str) -> Result>; } +/// The smallest provider surface needed by a refreshable Key handle. +#[async_trait] +pub(super) trait KeyProviderApi: Send + Sync + fmt::Debug { + async fn load_key(&self, binding_name: &str) -> Result>; +} + +#[async_trait] +impl KeyProviderApi for T +where + T: BindingsProviderApi + Send + Sync + fmt::Debug, +{ + async fn load_key(&self, binding_name: &str) -> Result> { + BindingsProviderApi::load_key(self, binding_name).await + } +} + #[async_trait] impl StorageProviderApi for T where @@ -440,6 +456,51 @@ impl Queue for RefreshingQueue { } } +/// Key handle that resolves a fresh-enough provider for every operation. +#[derive(Debug)] +pub(super) struct RefreshingKey { + provider: Arc, + binding_name: String, +} + +impl RefreshingKey { + pub(super) fn new(provider: Arc, binding_name: String) -> Self { + Self { + provider, + binding_name, + } + } +} + +impl Binding for RefreshingKey {} + +#[async_trait] +impl Key for RefreshingKey { + async fn encrypt( + &self, + plaintext: &[u8], + context: Option<&std::collections::BTreeMap>, + ) -> Result> { + self.provider + .load_key(&self.binding_name) + .await? + .encrypt(plaintext, context) + .await + } + + async fn decrypt( + &self, + ciphertext: &[u8], + context: Option<&std::collections::BTreeMap>, + ) -> Result> { + self.provider + .load_key(&self.binding_name) + .await? + .decrypt(ciphertext, context) + .await + } +} + /// Vault handle that resolves a fresh-enough provider for every operation. #[derive(Debug)] pub(super) struct RefreshingVault { diff --git a/crates/alien-bindings/src/remote.rs b/crates/alien-bindings/src/remote.rs index d6841a5aa..f6e788cfe 100644 --- a/crates/alien-bindings/src/remote.rs +++ b/crates/alien-bindings/src/remote.rs @@ -11,14 +11,14 @@ use std::sync::Arc; use alien_error::{AlienError, Context, IntoAlienError}; use async_trait::async_trait; use chrono::{DateTime, Duration as ChronoDuration, Utc}; -use serde::Deserialize; +use serde::{Deserialize, Serialize}; use tokio::sync::{Mutex, RwLock}; use tracing::debug; use crate::error::{ErrorData, Result}; use crate::provider::BindingsProvider; -use crate::refreshing::{RefreshingStorage, StorageProviderApi}; -use crate::traits::{BindingsProviderApi, Storage}; +use crate::refreshing::{KeyProviderApi, RefreshingKey, RefreshingStorage, StorageProviderApi}; +use crate::traits::{BindingsProviderApi, Key, Storage}; mod access; mod manager_conversion; @@ -48,7 +48,7 @@ impl Clock for SystemClock { } } -/// App-facing provider for resource-scoped remote Storage bindings. +/// App-facing provider for resource-scoped remote bindings. /// /// The bearer token and all returned client configurations are deliberately /// omitted from `Debug` output. @@ -78,6 +78,26 @@ impl RemoteBindingsProvider { Self::discover(deployment_id, token, api_base_url, Arc::new(SystemClock)).await } + fn from_manager_access( + deployment_id: &str, + manager_url: &str, + manager_token: &str, + expires_at: DateTime, + ) -> Result { + let clock: Arc = Arc::new(SystemClock); + Ok(Self { + source: Arc::new(RemoteBindingSource::from_manager_access( + deployment_id, + manager_url, + manager_token, + expires_at, + clock.clone(), + )?), + resolvers: RwLock::new(HashMap::new()), + clock, + }) + } + async fn discover( deployment_id: &str, token: &str, @@ -162,10 +182,14 @@ impl StorageProviderApi for RemoteBindingsProvider { } } -/// Resource-scoped remote Storage bindings for an existing deployment. -/// -/// This type intentionally exposes Storage only. Other binding kinds are not -/// part of the remote v0 contract and therefore cannot be requested. +#[async_trait] +impl KeyProviderApi for RemoteBindingsProvider { + async fn load_key(&self, binding_name: &str) -> Result> { + self.resolver(binding_name).await.key().await + } +} + +/// Resource-scoped remote bindings for an existing deployment. #[derive(Debug)] pub struct RemoteBindings { provider: Arc, @@ -225,6 +249,28 @@ impl RemoteBindings { }) } + /// Uses an already-issued, deployment-scoped Manager capability. + /// + /// This path does not contact Platform and cannot refresh the capability. + /// Construct a new instance after `expires_at`; callers should load the + /// required binding immediately and discard it with the returned cloud + /// credentials. + pub fn from_manager_access( + deployment_id: &str, + manager_url: &str, + manager_token: &str, + expires_at: DateTime, + ) -> Result { + Ok(Self { + provider: Arc::new(RemoteBindingsProvider::from_manager_access( + deployment_id, + manager_url, + manager_token, + expires_at, + )?), + }) + } + #[cfg(test)] fn from_provider(provider: Arc) -> Self { Self { provider } @@ -239,6 +285,15 @@ impl RemoteBindings { initial, ))) } + + /// Loads a Key binding and keeps its short-lived credential lease fresh. + pub async fn key(&self, resource_id: &str) -> Result> { + self.provider.load_key(resource_id).await?; + Ok(Arc::new(RefreshingKey::new( + self.provider.clone(), + resource_id.to_string(), + ))) + } } #[derive(Deserialize)] @@ -265,6 +320,29 @@ enum ResolvedRemoteBinding { #[serde(rename = "expiresAt")] expires_at: DateTime, }, + Kms { + binding: alien_core::AwsKmsKeyBinding, + #[serde(rename = "clientConfig")] + client_config: Box, + #[serde(rename = "expiresAt")] + expires_at: DateTime, + }, + #[serde(rename = "cloud-kms")] + CloudKms { + binding: alien_core::GcpCloudKmsKeyBinding, + #[serde(rename = "clientConfig")] + client_config: Box, + #[serde(rename = "expiresAt")] + expires_at: DateTime, + }, + #[serde(rename = "key-vault-key")] + KeyVaultKey { + binding: alien_core::AzureKeyVaultKeyBinding, + #[serde(rename = "clientConfig")] + client_config: Box, + #[serde(rename = "expiresAt")] + expires_at: DateTime, + }, #[cfg(test)] #[serde(rename = "local-storage")] Local { @@ -295,7 +373,7 @@ impl ResolvedRemoteBinding { validate_aws_remote_client_config(&client_config, expires_at)?; ( alien_core::ClientConfig::Aws(client_config), - alien_core::StorageBinding::S3(binding), + serialize_remote_binding(alien_core::StorageBinding::S3(binding))?, expires_at, ) } @@ -307,7 +385,7 @@ impl ResolvedRemoteBinding { validate_azure_remote_client_config(&client_config)?; ( alien_core::ClientConfig::Azure(client_config), - alien_core::StorageBinding::Blob(binding), + serialize_remote_binding(alien_core::StorageBinding::Blob(binding))?, expires_at, ) } @@ -319,7 +397,43 @@ impl ResolvedRemoteBinding { validate_gcp_remote_client_config(&client_config)?; ( alien_core::ClientConfig::Gcp(client_config), - alien_core::StorageBinding::Gcs(binding), + serialize_remote_binding(alien_core::StorageBinding::Gcs(binding))?, + expires_at, + ) + } + Self::Kms { + binding, + client_config, + expires_at, + } => { + validate_aws_remote_client_config(&client_config, expires_at)?; + ( + alien_core::ClientConfig::Aws(client_config), + serialize_remote_binding(alien_core::KeyBinding::AwsKms(binding))?, + expires_at, + ) + } + Self::CloudKms { + binding, + client_config, + expires_at, + } => { + validate_gcp_remote_client_config(&client_config)?; + ( + alien_core::ClientConfig::Gcp(client_config), + serialize_remote_binding(alien_core::KeyBinding::GcpCloudKms(binding))?, + expires_at, + ) + } + Self::KeyVaultKey { + binding, + client_config, + expires_at, + } => { + validate_azure_remote_client_config(&client_config)?; + ( + alien_core::ClientConfig::Azure(client_config), + serialize_remote_binding(alien_core::KeyBinding::AzureKeyVault(binding))?, expires_at, ) } @@ -332,19 +446,22 @@ impl ResolvedRemoteBinding { alien_core::ClientConfig::Local { state_directory: client_config.state_directory, }, - alien_core::StorageBinding::Local(binding), + serialize_remote_binding(alien_core::StorageBinding::Local(binding))?, expires_at, ), }; - let binding = serde_json::to_value(binding).into_alien_error().context( - ErrorData::RemoteAccessFailed { - operation: "convert typed remote Storage lease".to_string(), - }, - )?; Ok((client_config, binding, expires_at)) } } +fn serialize_remote_binding(binding: impl Serialize) -> Result { + serde_json::to_value(binding) + .into_alien_error() + .context(ErrorData::RemoteAccessFailed { + operation: "convert typed remote binding lease".to_string(), + }) +} + fn invalid_remote_lease(provider: &str, reason: &str) -> AlienError { AlienError::new(ErrorData::RemoteAccessFailed { operation: format!("validate {provider} remote Storage credential lease: {reason}"), @@ -506,6 +623,12 @@ struct RemoteStorageResolver { clock: Arc, } +#[derive(Clone, Copy)] +enum RequestedBindingKind { + Storage, + Key, +} + impl fmt::Debug for RemoteStorageResolver { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("RemoteStorageResolver") @@ -518,10 +641,25 @@ impl fmt::Debug for RemoteStorageResolver { impl RemoteStorageResolver { async fn storage(&self) -> Result> { - BindingsProviderApi::load_storage(&*self.provider().await?, &self.resource_id).await + BindingsProviderApi::load_storage( + &*self.provider(RequestedBindingKind::Storage).await?, + &self.resource_id, + ) + .await } - async fn provider(&self) -> Result> { + async fn key(&self) -> Result> { + BindingsProviderApi::load_key( + &*self.provider(RequestedBindingKind::Key).await?, + &self.resource_id, + ) + .await + } + + async fn provider( + &self, + requested_kind: RequestedBindingKind, + ) -> Result> { let now = self.clock.now(); let observed_generation = { let state = self.state.read().await; @@ -562,7 +700,7 @@ impl RemoteStorageResolver { let result = self.source.resolve(&self.resource_id).await; let now = self.clock.now(); let result = match result { - Ok(resolved) => self.build_cache_entry(resolved, now).await, + Ok(resolved) => self.build_cache_entry(resolved, now, requested_kind).await, Err(error) => Err(error), }; let mut state = self.state.write().await; @@ -597,6 +735,7 @@ impl RemoteStorageResolver { &self, resolved: ResolvedRemoteBinding, now: DateTime, + requested_kind: RequestedBindingKind, ) -> Result { let (client_config, binding, expires_at) = resolved.into_provider_parts()?; if expires_at <= now { @@ -614,7 +753,14 @@ impl RemoteStorageResolver { )?); // Validate the typed binding and provider feature before committing the // lease. An invalid response must not poison the cache until expiry. - BindingsProviderApi::load_storage(&*provider, &self.resource_id).await?; + match requested_kind { + RequestedBindingKind::Storage => { + BindingsProviderApi::load_storage(&*provider, &self.resource_id).await?; + } + RequestedBindingKind::Key => { + BindingsProviderApi::load_key(&*provider, &self.resource_id).await?; + } + } let lifetime = expires_at - now; let refresh_skew = std::cmp::min( ChronoDuration::seconds(MAX_REFRESH_SKEW_SECONDS), diff --git a/crates/alien-bindings/src/remote/access.rs b/crates/alien-bindings/src/remote/access.rs index 9b2e3ecf5..44cec667f 100644 --- a/crates/alien-bindings/src/remote/access.rs +++ b/crates/alien-bindings/src/remote/access.rs @@ -20,7 +20,7 @@ const REMOTE_REQUEST_TIMEOUT: Duration = Duration::from_secs(30); pub(super) struct RemoteBindingSource { pub(super) deployment_id: String, - platform: alien_platform_api::Client, + platform: Option, manager: RwLock, manager_refresh_lock: Mutex<()>, allow_insecure_manager_url: bool, @@ -106,7 +106,7 @@ impl RemoteBindingSource { Ok(Self { deployment_id: deployment_id.to_string(), - platform, + platform: Some(platform), manager: RwLock::new(manager), manager_refresh_lock: Mutex::new(()), allow_insecure_manager_url, @@ -115,6 +115,40 @@ impl RemoteBindingSource { }) } + pub(super) fn from_manager_access( + deployment_id: &str, + manager_url: &str, + manager_token: &str, + expires_at: DateTime, + clock: Arc, + ) -> Result { + let parsed = reqwest::Url::parse(manager_url) + .into_alien_error() + .context(ErrorData::RemoteAccessFailed { + operation: "parse assigned Manager URL".to_string(), + })?; + let allow_insecure = parsed + .host_str() + .and_then(|host| host.parse::().ok()) + .is_some_and(|address| address.is_loopback()); + let url = validate_manager_url(manager_url, allow_insecure)?; + let http = authenticated_http_client(manager_token, "assigned Manager")?; + Ok(Self { + deployment_id: deployment_id.to_string(), + platform: None, + manager: RwLock::new(DiscoveredManager { + url, + http, + refresh_at: expires_at, + generation: 0, + }), + manager_refresh_lock: Mutex::new(()), + allow_insecure_manager_url: allow_insecure, + manager_resolver: Arc::new(GeneratedManagerBindingResolver), + clock, + }) + } + async fn manager_access(&self) -> Result { let now = self.clock.now(); { @@ -137,9 +171,14 @@ impl RemoteBindingSource { } async fn refresh_manager_access_locked(&self) -> Result { + let platform = self.platform.as_ref().ok_or_else(|| { + alien_error::AlienError::new(ErrorData::RemoteAccessFailed { + operation: "refresh expired assigned Manager access".to_string(), + }) + })?; let next_generation = self.manager.read().await.generation.wrapping_add(1); let manager = discover_manager_access( - &self.platform, + platform, &self.deployment_id, self.allow_insecure_manager_url, self.clock.as_ref(), @@ -169,7 +208,7 @@ impl RemoteBindingSource { .await { Ok(binding) => Ok(binding), - Err(error) if is_auth_or_assignment_rejection(&error) => { + Err(error) if self.platform.is_some() && is_auth_or_assignment_rejection(&error) => { let manager = self.refresh_after_rejection(manager.generation).await?; self.manager_resolver .resolve(&manager, &self.deployment_id, resource_id) diff --git a/crates/alien-bindings/src/remote/manager_conversion.rs b/crates/alien-bindings/src/remote/manager_conversion.rs index 1e0eeb935..6885f4566 100644 --- a/crates/alien-bindings/src/remote/manager_conversion.rs +++ b/crates/alien-bindings/src/remote/manager_conversion.rs @@ -90,6 +90,78 @@ impl ResolvedRemoteBinding { expires_at: parse_manager_expiry(expires_at, resource_id)?, } } + manager_types::ResolveBindingResponse::Kms { + binding, + client_config, + expires_at, + } => { + let manager_types::RemoteAwsCredentials::SessionCredentials { + access_key_id, + secret_access_key, + session_token, + expires_at: credential_expires_at, + } = client_config.credentials; + Self::Kms { + binding: alien_core::AwsKmsKeyBinding { + key_arn: binding.key_arn.into(), + region: binding.region.map(Into::into), + }, + client_config: Box::new(alien_core::AwsClientConfig { + account_id: client_config.account_id, + region: client_config.region, + credentials: alien_core::AwsCredentials::SessionCredentials { + access_key_id, + secret_access_key, + session_token, + expires_at: credential_expires_at, + }, + service_overrides: None, + }), + expires_at: parse_manager_expiry(expires_at, resource_id)?, + } + } + manager_types::ResolveBindingResponse::CloudKms { + binding, + client_config, + expires_at, + } => { + let manager_types::RemoteGcpCredentials::AccessToken(token) = + client_config.credentials; + Self::CloudKms { + binding: alien_core::GcpCloudKmsKeyBinding { + crypto_key_name: binding.crypto_key_name.into(), + }, + client_config: Box::new(alien_core::GcpClientConfig { + project_id: client_config.project_id, + region: client_config.region, + credentials: alien_core::GcpCredentials::AccessToken { token }, + service_overrides: None, + project_number: client_config.project_number, + }), + expires_at: parse_manager_expiry(expires_at, resource_id)?, + } + } + manager_types::ResolveBindingResponse::KeyVaultKey { + binding, + client_config, + expires_at, + } => { + let manager_types::RemoteAzureCredentials::AccessToken(token) = + client_config.credentials; + Self::KeyVaultKey { + binding: alien_core::AzureKeyVaultKeyBinding { + key_id: binding.key_id.into(), + }, + client_config: Box::new(alien_core::AzureClientConfig { + subscription_id: client_config.subscription_id, + tenant_id: client_config.tenant_id, + region: client_config.region, + credentials: alien_core::AzureCredentials::AccessToken { token }, + service_overrides: None, + }), + expires_at: parse_manager_expiry(expires_at, resource_id)?, + } + } }; Ok(lease) } @@ -107,7 +179,7 @@ fn parse_manager_timestamp( DateTime::parse_from_rfc3339(timestamp) .into_alien_error() .context(ErrorData::RemoteAccessFailed { - operation: format!("parse {field} for remote Storage binding '{resource_id}'"), + operation: format!("parse {field} for remote binding '{resource_id}'"), }) .map(|expires_at| expires_at.with_timezone(&Utc)) } diff --git a/crates/alien-bindings/src/remote/tests/manager_contract.rs b/crates/alien-bindings/src/remote/tests/manager_contract.rs index 30cf8b54e..da067766a 100644 --- a/crates/alien-bindings/src/remote/tests/manager_contract.rs +++ b/crates/alien-bindings/src/remote/tests/manager_contract.rs @@ -1,5 +1,63 @@ use super::*; +#[tokio::test] +async fn preissued_manager_access_loads_a_binding_without_platform_discovery() { + let expires_at = Utc::now() + ChronoDuration::minutes(5); + let response = Arc::new(StdRwLock::new(( + StatusCode::OK, + json!({ + "service": "s3", + "binding": { "bucketName": "customer-bucket" }, + "clientConfig": { + "accountId": "123456789012", + "region": "us-east-1", + "credentials": { + "type": "sessionCredentials", + "accessKeyId": "AKIAEXAMPLE", + "secretAccessKey": "secret", + "sessionToken": "session", + "expiresAt": expires_at.to_rfc3339(), + }, + }, + "expiresAt": expires_at.to_rfc3339(), + }), + ))); + let requests = Arc::new(StdMutex::new(Vec::new())); + let manager_url = spawn_generated_contract_server(GeneratedContractState { + response, + requests: requests.clone(), + }) + .await; + + let bindings = RemoteBindings::from_manager_access( + DEPLOYMENT_ID, + &manager_url, + GENERATED_MANAGER_TOKEN, + expires_at, + ) + .expect("construct bindings from assigned Manager access"); + bindings + .storage("files") + .await + .expect("resolve the binding directly through Manager"); + + assert_eq!( + requests + .lock() + .expect("generated contract requests lock") + .as_slice(), + &[RecordedRequest { + method: "POST".to_string(), + path: "/v1/bindings/resolve".to_string(), + authorization: Some(format!("Bearer {GENERATED_MANAGER_TOKEN}")), + body: Some(json!({ + "deploymentId": DEPLOYMENT_ID, + "resourceId": "files", + })), + }] + ); +} + #[tokio::test] async fn generated_manager_adapter_decodes_cloud_lease_and_structured_error() { let response = Arc::new(StdRwLock::new(( diff --git a/crates/alien-bindings/src/traits.rs b/crates/alien-bindings/src/traits.rs index 8e405cdb1..136a01f1f 100644 --- a/crates/alien-bindings/src/traits.rs +++ b/crates/alien-bindings/src/traits.rs @@ -38,6 +38,22 @@ pub trait Storage: Binding + ObjectStore { -> Result; } +/// A provider-backed key for small wrap and unwrap operations. +#[async_trait] +pub trait Key: Binding { + async fn encrypt( + &self, + plaintext: &[u8], + context: Option<&BTreeMap>, + ) -> Result>; + + async fn decrypt( + &self, + ciphertext: &[u8], + context: Option<&BTreeMap>, + ) -> Result>; +} + /// A build binding that provides build execution capabilities. #[async_trait] pub trait Build: Binding { @@ -955,6 +971,16 @@ pub trait BindingsProviderApi: Send + Sync + std::fmt::Debug { /// Given a binding identifier, builds a Storage implementation. async fn load_storage(&self, binding_name: &str) -> Result>; + /// Given a binding identifier, builds a Key implementation. + async fn load_key(&self, binding_name: &str) -> Result> { + Err(alien_error::AlienError::new( + crate::error::ErrorData::OperationNotSupported { + operation: "load_key".to_string(), + reason: format!("Key resource '{binding_name}' is not supported by this provider"), + }, + )) + } + /// Given a binding identifier, builds a Build implementation. async fn load_build(&self, binding_name: &str) -> Result>; diff --git a/crates/alien-cloudformation/src/built_ins.rs b/crates/alien-cloudformation/src/built_ins.rs index 3d9b1f8ef..0ae8e82c3 100644 --- a/crates/alien-cloudformation/src/built_ins.rs +++ b/crates/alien-cloudformation/src/built_ins.rs @@ -5,7 +5,7 @@ use crate::{ emitters::aws::{ - AwsAiEmitter, AwsArtifactRegistryEmitter, AwsBuildEmitter, AwsEmailEmitter, + AwsAiEmitter, AwsArtifactRegistryEmitter, AwsBuildEmitter, AwsEmailEmitter, AwsKeyEmitter, AwsKubernetesClusterEmitter, AwsKvEmitter, AwsNetworkEmitter, AwsOpenSearchEmitter, AwsQueueEmitter, AwsRemoteBindingsEmitter, AwsRemoteStackManagementEmitter, AwsServiceAccountEmitter, AwsStorageEmitter, AwsVaultEmitter, AwsWorkerEmitter, @@ -13,9 +13,9 @@ use crate::{ registry::CfRegistry, }; use alien_core::{ - Ai, ArtifactRegistry, AwsOpenSearch, Build, Email, KubernetesCluster, Kv, Network, Platform, - Queue, RemoteBindings, RemoteStackManagement, ResourceType, ServiceAccount, Storage, Vault, - Worker, + Ai, ArtifactRegistry, AwsOpenSearch, Build, Email, Key, KubernetesCluster, Kv, Network, + Platform, Queue, RemoteBindings, RemoteStackManagement, ResourceType, ServiceAccount, Storage, + Vault, Worker, }; pub(crate) fn register_aws(registry: &mut CfRegistry) { @@ -28,6 +28,7 @@ pub(crate) fn register_aws(registry: &mut CfRegistry) { aws(registry, Ai::RESOURCE_TYPE, AwsAiEmitter); aws(registry, Storage::RESOURCE_TYPE, AwsStorageEmitter); + aws(registry, Key::RESOURCE_TYPE, AwsKeyEmitter); // Experimental resources are provider-specific: AwsOpenSearch only // registers an AWS emitter, so other platforms fail with a typed // ImportRegistrationMissing error at generation time. diff --git a/crates/alien-cloudformation/src/emitters/aws/key.rs b/crates/alien-cloudformation/src/emitters/aws/key.rs new file mode 100644 index 000000000..69b7d46f8 --- /dev/null +++ b/crates/alien-cloudformation/src/emitters/aws/key.rs @@ -0,0 +1,139 @@ +use crate::{ + emitter::CfEmitter, + emitters::aws::helpers::{required_logical_id, resource_config, tags}, + template::{CfExpression, CfResource}, +}; +use alien_core::{import::EmitContext, ErrorData, Key, RemoteBindings, Result}; +use alien_error::AlienError; + +#[derive(Debug, Clone, Copy, Default)] +pub struct AwsKeyEmitter; + +impl CfEmitter for AwsKeyEmitter { + fn emit_resources(&self, ctx: &EmitContext<'_>) -> Result> { + let _ = resource_config::(ctx, Key::RESOURCE_TYPE)?; + let logical_id = required_logical_id(ctx)?; + let mut key = CfResource::new(logical_id.to_string(), "AWS::KMS::Key".to_string()); + key.properties.insert( + "Description".to_string(), + CfExpression::from(format!("Alien encryption key '{}'", ctx.resource_id)), + ); + key.properties + .insert("EnableKeyRotation".to_string(), CfExpression::from(true)); + key.properties + .insert("PendingWindowInDays".to_string(), CfExpression::from(30u32)); + key.properties + .insert("KeyPolicy".to_string(), root_key_policy()); + key.properties.insert("Tags".to_string(), tags(ctx)); + key.deletion_policy = Some("Retain".to_string()); + key.update_replace_policy = Some("Retain".to_string()); + + let mut resources = vec![key]; + if alien_core::remote_bindings::remote_binding_for_entry(ctx.resource).is_some() { + resources.push(remote_access_policy(ctx, logical_id)?); + } + Ok(resources) + } + + fn emit_import_ref(&self, ctx: &EmitContext<'_>) -> Result { + let logical_id = required_logical_id(ctx)?; + Ok(CfExpression::object([( + "keyArn", + CfExpression::get_att(logical_id, "Arn"), + )])) + } + + fn emit_binding_ref(&self, ctx: &EmitContext<'_>) -> Result> { + let logical_id = required_logical_id(ctx)?; + Ok(Some(CfExpression::object([ + ("service", CfExpression::from("kms")), + ("keyArn", CfExpression::get_att(logical_id, "Arn")), + ("region", CfExpression::ref_("AWS::Region")), + ]))) + } +} + +fn root_key_policy() -> CfExpression { + CfExpression::object([ + ("Version", CfExpression::from("2012-10-17")), + ( + "Statement", + CfExpression::list([CfExpression::object([ + ("Sid", CfExpression::from("EnableAccountAdministration")), + ("Effect", CfExpression::from("Allow")), + ( + "Principal", + CfExpression::object([( + "AWS", + CfExpression::sub("arn:${AWS::Partition}:iam::${AWS::AccountId}:root"), + )]), + ), + ("Action", CfExpression::from("kms:*")), + ("Resource", CfExpression::from("*")), + ])]), + ), + ]) +} + +fn remote_access_policy(ctx: &EmitContext<'_>, key_id: &str) -> Result { + let access_role_id = ctx + .stack + .resources() + .find_map(|(id, entry)| { + (entry.config.resource_type() == RemoteBindings::RESOURCE_TYPE) + .then(|| ctx.name_for(id)) + .flatten() + }) + .map(|id| format!("{id}Role")) + .ok_or_else(|| { + AlienError::new(ErrorData::GenericError { + message: "remote Key has no Remote Bindings identity".to_string(), + }) + })?; + let actions = alien_permissions::get_permission_set("key/remote-cryptography") + .and_then(|set| set.platforms.aws.as_ref()) + .into_iter() + .flatten() + .flat_map(|entry| entry.grant.actions.iter().flatten()) + .cloned() + .collect::>(); + if actions.is_empty() { + return Err(AlienError::new(ErrorData::GenericError { + message: "key/remote-cryptography has no AWS actions".to_string(), + })); + } + + let mut policy = CfResource::new( + format!("{key_id}RemoteCryptographyPolicy"), + "AWS::IAM::Policy".to_string(), + ); + policy.properties.insert( + "PolicyName".to_string(), + CfExpression::sub(format!( + "${{AWS::StackName}}-{}-key-access", + ctx.resource_id + )), + ); + policy.properties.insert( + "Roles".to_string(), + CfExpression::list([CfExpression::ref_(access_role_id)]), + ); + policy.properties.insert( + "PolicyDocument".to_string(), + CfExpression::object([ + ("Version", CfExpression::from("2012-10-17")), + ( + "Statement", + CfExpression::list([CfExpression::object([ + ("Effect", CfExpression::from("Allow")), + ( + "Action", + CfExpression::list(actions.into_iter().map(CfExpression::from)), + ), + ("Resource", CfExpression::get_att(key_id, "Arn")), + ])]), + ), + ]), + ); + Ok(policy) +} diff --git a/crates/alien-cloudformation/src/emitters/aws/mod.rs b/crates/alien-cloudformation/src/emitters/aws/mod.rs index 637f18fb6..a229dee46 100644 --- a/crates/alien-cloudformation/src/emitters/aws/mod.rs +++ b/crates/alien-cloudformation/src/emitters/aws/mod.rs @@ -10,6 +10,7 @@ pub mod artifact_registry; pub mod build; pub mod email; pub mod helpers; +pub mod key; pub mod kubernetes_cluster; pub mod kv; pub mod network; @@ -26,6 +27,7 @@ pub use ai::AwsAiEmitter; pub use artifact_registry::AwsArtifactRegistryEmitter; pub use build::AwsBuildEmitter; pub use email::AwsEmailEmitter; +pub use key::AwsKeyEmitter; pub use kubernetes_cluster::AwsKubernetesClusterEmitter; pub use kv::AwsKvEmitter; pub use network::AwsNetworkEmitter; diff --git a/crates/alien-cloudformation/src/emitters/aws/storage.rs b/crates/alien-cloudformation/src/emitters/aws/storage.rs index fd651b2c5..e8e8ffe87 100644 --- a/crates/alien-cloudformation/src/emitters/aws/storage.rs +++ b/crates/alien-cloudformation/src/emitters/aws/storage.rs @@ -37,13 +37,25 @@ impl CfEmitter for AwsStorageEmitter { bucket .properties .insert("BucketName".to_string(), bucket_name(storage.id())); + let encryption = if let Some(key_id) = storage + .encryption_key + .as_ref() + .and_then(|key| ctx.name_for(&key.id)) + { + CfExpression::object([ + ("SSEAlgorithm", CfExpression::from("aws:kms")), + ("KMSMasterKeyID", CfExpression::get_att(key_id, "Arn")), + ]) + } else { + CfExpression::object([("SSEAlgorithm", CfExpression::from("AES256"))]) + }; bucket.properties.insert( "BucketEncryption".to_string(), CfExpression::object([( "ServerSideEncryptionConfiguration", CfExpression::list([CfExpression::object([( "ServerSideEncryptionByDefault", - CfExpression::object([("SSEAlgorithm", CfExpression::from("AES256"))]), + encryption, )])]), )]), ); @@ -396,6 +408,49 @@ fn storage_iam_policies( policy_resource.depends_on.push(role_id.clone()); resources.push(policy_resource); } + + if let Some(key_id) = storage + .encryption_key + .as_ref() + .and_then(|key| ctx.name_for(&key.id)) + { + let policy_id = format!("{bucket_id}{role_id}NativeEncryption{owner_index}"); + let mut policy_resource = CfResource::new(policy_id, "AWS::IAM::Policy".to_string()); + policy_resource.properties.insert( + "PolicyName".to_string(), + CfExpression::sub(format!( + "${{AWS::StackName}}-{}-native-encryption", + storage.id() + )), + ); + policy_resource.properties.insert( + "PolicyDocument".to_string(), + CfExpression::object([ + ("Version", CfExpression::from("2012-10-17")), + ( + "Statement", + CfExpression::list([CfExpression::object([ + ("Effect", CfExpression::from("Allow")), + ( + "Action", + CfExpression::list([ + CfExpression::from("kms:GenerateDataKey"), + CfExpression::from("kms:Decrypt"), + ]), + ), + ("Resource", CfExpression::get_att(key_id, "Arn")), + ])]), + ), + ]), + ); + policy_resource.properties.insert( + "Roles".to_string(), + CfExpression::list([CfExpression::ref_(&role_id)]), + ); + policy_resource.depends_on.push(key_id.to_string()); + policy_resource.depends_on.push(role_id.clone()); + resources.push(policy_resource); + } } Ok(resources) diff --git a/crates/alien-cloudformation/tests/generator/aws_data_layer_tests.rs b/crates/alien-cloudformation/tests/generator/aws_data_layer_tests.rs index e30ad1ddd..fccbab71d 100644 --- a/crates/alien-cloudformation/tests/generator/aws_data_layer_tests.rs +++ b/crates/alien-cloudformation/tests/generator/aws_data_layer_tests.rs @@ -3,11 +3,85 @@ use super::helpers::{custom_resource_registration, render_built_ins, render_built_ins_template}; use alien_cloudformation::RegistrationMode; use alien_core::{ - Kv, LifecycleRule, PermissionProfile, Queue, RemoteBindings, RemoteStackManagement, + Key, Kv, LifecycleRule, PermissionProfile, Queue, RemoteBindings, RemoteStackManagement, ResourceLifecycle, ResourceRef, ServiceAccount, Stack, StackSettings, Storage, Vault, Worker, WorkerCode, WorkerTrigger, }; +#[test] +fn aws_key_template_is_valid_and_retained() { + let mut stack = Stack::new("enterprise-key".to_string()) + .add_with_remote_access( + Key::new("customer-key".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .add( + RemoteBindings::new("access".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .build(); + stack + .resources + .get_mut("customer-key") + .unwrap() + .dependencies = vec![ResourceRef::new(RemoteBindings::RESOURCE_TYPE, "access")]; + + let (template, yaml) = render_built_ins_template( + &stack, + StackSettings::default(), + RegistrationMode::OutputsFallback, + alien_cloudformation::CloudFormationTarget::Aws, + "aws", + "aws key", + ); + let key = template + .resources + .values() + .find(|resource| resource.resource_type == "AWS::KMS::Key") + .expect("KMS key should render"); + + assert_eq!(key.deletion_policy.as_deref(), Some("Retain")); + assert_eq!(key.update_replace_policy.as_deref(), Some("Retain")); + assert!(yaml.contains("kms:Encrypt")); + assert!(yaml.contains("kms:Decrypt")); +} + +#[test] +fn aws_storage_uses_customer_managed_key() { + let stack = Stack::new("encrypted-storage".to_string()) + .permissions(alien_core::PermissionsConfig::new().with_profile( + "app", + PermissionProfile::new().resource("data", ["storage/data-write"]), + )) + .add( + Key::new("customer-key".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .add( + Storage::new("data".to_string()) + .encryption_key(ResourceRef::new(Key::RESOURCE_TYPE, "customer-key")) + .build(), + ResourceLifecycle::Frozen, + ) + .add( + ServiceAccount::new("app-sa".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .build(); + + let yaml = render_built_ins( + &stack, + StackSettings::default(), + RegistrationMode::OutputsFallback, + "aws encrypted storage", + ); + assert!(yaml.contains("SSEAlgorithm: aws:kms")); + assert!(yaml.contains("KMSMasterKeyID:")); + assert!(yaml.contains("Fn::GetAtt:")); + assert!(yaml.contains("kms:GenerateDataKey")); + assert!(yaml.contains("kms:Decrypt")); +} + #[test] fn aws_data_layer_renders_idiomatic_template() { let stack = Stack::new("data-layer".to_string()) diff --git a/crates/alien-cloudformation/tests/generator/gating_matrix_tests.rs b/crates/alien-cloudformation/tests/generator/gating_matrix_tests.rs index 0727a527d..ee9b10d8d 100644 --- a/crates/alien-cloudformation/tests/generator/gating_matrix_tests.rs +++ b/crates/alien-cloudformation/tests/generator/gating_matrix_tests.rs @@ -11,7 +11,7 @@ use super::helpers::{ }; use alien_cloudformation::{CfRegistry, CloudFormationTarget}; use alien_core::{ - ownership_policy_for_resource_type, Ai, AwsOpenSearch, Email, EmailInbound, Kv, + ownership_policy_for_resource_type, Ai, AwsOpenSearch, Email, EmailInbound, Key, Kv, PermissionProfile, Platform, Queue, ResourceLifecycle, ResourceRef, ServiceAccount, Stack, StackSettings, Storage, Vault, Worker, WorkerCode, }; @@ -36,6 +36,11 @@ fn gated_fixture(resource_type: &str) -> Option { ResourceLifecycle::Frozen, "fixtureEnabled", ), + "key" => base().add_enabled_when( + Key::new("fixture".to_string()).build(), + ResourceLifecycle::Frozen, + "fixtureEnabled", + ), "queue" => base().add_enabled_when( Queue::new("fixture".to_string()).build(), ResourceLifecycle::Frozen, diff --git a/crates/alien-core/src/bin/schema_exporter.rs b/crates/alien-core/src/bin/schema_exporter.rs index 99f1267f8..99766d51c 100644 --- a/crates/alien-core/src/bin/schema_exporter.rs +++ b/crates/alien-core/src/bin/schema_exporter.rs @@ -72,6 +72,9 @@ use utoipa::OpenApi; AzureManagementConfig, Storage, StorageOutputs, + Key, + KeyFingerprint, + KeyOutputs, Build, BuildOutputs, BuildStatus, @@ -175,6 +178,7 @@ use utoipa::OpenApi; AwsOpenSearchImportData, AwsQueueImportData, AwsKvImportData, + AwsKeyImportData, AwsVaultImportData, AwsNetworkImportData, AwsServiceAccountImportData, @@ -188,6 +192,7 @@ use utoipa::OpenApi; GcpWorkerImportData, GcpQueueImportData, GcpKvImportData, + GcpKeyImportData, GcpVaultImportData, GcpNetworkImportData, GcpServiceAccountImportData, @@ -202,6 +207,7 @@ use utoipa::OpenApi; AzureWorkerImportData, AzureQueueImportData, AzureKvImportData, + AzureKeyImportData, AzureVaultImportData, AzureNetworkImportData, AzureServiceAccountImportData, diff --git a/crates/alien-core/src/bindings/key.rs b/crates/alien-core/src/bindings/key.rs new file mode 100644 index 000000000..ff55d3fa8 --- /dev/null +++ b/crates/alien-core/src/bindings/key.rs @@ -0,0 +1,86 @@ +use super::BindingValue; +use serde::{Deserialize, Serialize}; + +/// Provider key reference used for native encrypt and decrypt operations. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))] +#[serde(tag = "service")] +pub enum KeyBinding { + /// AWS Key Management Service. + #[serde(rename = "kms")] + AwsKms(AwsKmsKeyBinding), + /// GCP Cloud Key Management Service. + #[serde(rename = "cloud-kms")] + GcpCloudKms(GcpCloudKmsKeyBinding), + /// Azure Key Vault Keys. + #[serde(rename = "key-vault-key")] + AzureKeyVault(AzureKeyVaultKeyBinding), +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))] +#[serde(rename_all = "camelCase")] +pub struct AwsKmsKeyBinding { + pub key_arn: BindingValue, + pub region: Option>, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))] +#[serde(rename_all = "camelCase")] +pub struct GcpCloudKmsKeyBinding { + pub crypto_key_name: BindingValue, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))] +#[serde(rename_all = "camelCase")] +pub struct AzureKeyVaultKeyBinding { + pub key_id: BindingValue, +} + +impl KeyBinding { + pub fn aws_kms(key_arn: impl Into, region: Option>) -> Self { + Self::AwsKms(AwsKmsKeyBinding { + key_arn: key_arn.into().into(), + region: region.map(|value| value.into().into()), + }) + } + + pub fn gcp_cloud_kms(crypto_key_name: impl Into) -> Self { + Self::GcpCloudKms(GcpCloudKmsKeyBinding { + crypto_key_name: crypto_key_name.into().into(), + }) + } + + pub fn azure_key_vault(key_id: impl Into) -> Self { + Self::AzureKeyVault(AzureKeyVaultKeyBinding { + key_id: key_id.into().into(), + }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn provider_tags_round_trip_without_ambiguity() { + let bindings = [ + KeyBinding::aws_kms("arn:aws:kms:us-east-1:123:key/abc", Some("us-east-1")), + KeyBinding::gcp_cloud_kms( + "projects/example/locations/us/keyRings/data/cryptoKeys/customer", + ), + KeyBinding::azure_key_vault("https://example.vault.azure.net/keys/customer/version"), + ]; + + for binding in bindings { + let json = serde_json::to_value(&binding).unwrap(); + assert_eq!(serde_json::from_value::(json).unwrap(), binding); + } + } +} diff --git a/crates/alien-core/src/bindings/mod.rs b/crates/alien-core/src/bindings/mod.rs index 088dbe8ec..f6c2cc9fb 100644 --- a/crates/alien-core/src/bindings/mod.rs +++ b/crates/alien-core/src/bindings/mod.rs @@ -19,6 +19,7 @@ mod artifact_registry; mod build; mod container; mod container_apps_environment; +mod key; mod kv; mod postgres; mod queue; @@ -27,9 +28,7 @@ mod storage; mod vault; mod worker; -pub use ai::{ - AiBinding, BedrockAiBinding, ExternalAiBinding, FoundryAiBinding, VertexAiBinding, -}; +pub use ai::{AiBinding, BedrockAiBinding, ExternalAiBinding, FoundryAiBinding, VertexAiBinding}; pub use artifact_registry::{ AcrArtifactRegistryBinding, ArtifactRegistryBinding, EcrArtifactRegistryBinding, GarArtifactRegistryBinding, LocalArtifactRegistryBinding, @@ -41,6 +40,7 @@ pub use container::{ ContainerBinding, HorizonContainerBinding, KubernetesContainerBinding, LocalContainerBinding, }; pub use container_apps_environment::ContainerAppsEnvironmentBinding; +pub use key::{AwsKmsKeyBinding, AzureKeyVaultKeyBinding, GcpCloudKmsKeyBinding, KeyBinding}; pub use kv::{ DynamodbKvBinding, FirestoreKvBinding, KvBinding, LocalKvBinding, RedisKvBinding, TableStorageKvBinding, diff --git a/crates/alien-core/src/heartbeat.rs b/crates/alien-core/src/heartbeat.rs index 5aad9249c..eaf2cd8a5 100644 --- a/crates/alien-core/src/heartbeat.rs +++ b/crates/alien-core/src/heartbeat.rs @@ -158,6 +158,8 @@ pub enum ResourceHeartbeatData { AzureServiceBusNamespace(AzureServiceBusNamespaceHeartbeatData), #[serde(rename = "ai")] Ai(AiHeartbeatData), + #[serde(rename = "key")] + Key(KeyHeartbeatData), } #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] @@ -186,6 +188,60 @@ pub enum ProviderLifecycleState { Failed, } +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[serde(rename_all = "camelCase")] +pub struct KeyHeartbeatStatus { + pub health: ObservedHealth, + pub lifecycle: ProviderLifecycleState, + pub message: Option, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[serde(tag = "provider", content = "data", rename_all = "kebab-case")] +pub enum KeyHeartbeatData { + AwsKms(AwsKmsKeyHeartbeatData), + GcpCloudKms(GcpCloudKmsKeyHeartbeatData), + AzureKeyVault(AzureKeyVaultKeyHeartbeatData), +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[serde(rename_all = "camelCase")] +pub struct AwsKmsKeyHeartbeatData { + pub status: KeyHeartbeatStatus, + pub key_arn: String, + pub key_state: String, + pub enabled: bool, + pub key_spec: String, + pub key_usage: String, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[serde(rename_all = "camelCase")] +pub struct GcpCloudKmsKeyHeartbeatData { + pub status: KeyHeartbeatStatus, + pub crypto_key_name: String, + pub purpose: String, + pub primary_version: Option, + pub primary_state: Option, + pub algorithm: Option, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[serde(rename_all = "camelCase")] +pub struct AzureKeyVaultKeyHeartbeatData { + pub status: KeyHeartbeatStatus, + pub key_id: String, + pub enabled: Option, + pub key_type: String, + pub key_operations: Vec, + pub recovery_level: Option, +} + #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] #[serde(rename_all = "camelCase")] diff --git a/crates/alien-core/src/import/data/aws/key.rs b/crates/alien-core/src/import/data/aws/key.rs new file mode 100644 index 000000000..7e63b4422 --- /dev/null +++ b/crates/alien-core/src/import/data/aws/key.rs @@ -0,0 +1,11 @@ +use serde::{Deserialize, Serialize}; + +/// AWS KMS key created by the customer-installed setup stack. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))] +#[serde(rename_all = "camelCase")] +pub struct AwsKeyImportData { + /// Immutable KMS key ARN. Alias ARNs are not accepted. + pub key_arn: String, +} diff --git a/crates/alien-core/src/import/data/aws/mod.rs b/crates/alien-core/src/import/data/aws/mod.rs index 44a604394..a6afca8a8 100644 --- a/crates/alien-core/src/import/data/aws/mod.rs +++ b/crates/alien-core/src/import/data/aws/mod.rs @@ -3,6 +3,7 @@ pub mod artifact_registry; pub mod build; pub mod compute_cluster; pub mod email; +pub mod key; pub mod kv; pub mod network; pub mod open_search; @@ -20,6 +21,7 @@ pub use artifact_registry::*; pub use build::*; pub use compute_cluster::*; pub use email::*; +pub use key::*; pub use kv::*; pub use network::*; pub use open_search::*; diff --git a/crates/alien-core/src/import/data/azure/key.rs b/crates/alien-core/src/import/data/azure/key.rs new file mode 100644 index 000000000..0a0c1c7b8 --- /dev/null +++ b/crates/alien-core/src/import/data/azure/key.rs @@ -0,0 +1,17 @@ +use serde::{Deserialize, Serialize}; + +/// Azure Key Vault key created by the customer-installed setup stack. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))] +#[serde(rename_all = "camelCase")] +pub struct AzureKeyImportData { + /// ARM resource ID of the dedicated Key Vault. + pub vault_resource_id: String, + /// Key name within the vault. + pub key_name: String, + /// Version ID that identifies the original key lineage. + pub lineage_version_id: String, + /// Full versioned Key Vault key ID used for new wrapping operations. + pub key_id: String, +} diff --git a/crates/alien-core/src/import/data/azure/mod.rs b/crates/alien-core/src/import/data/azure/mod.rs index 4d8b7cbb2..8430dfb39 100644 --- a/crates/alien-core/src/import/data/azure/mod.rs +++ b/crates/alien-core/src/import/data/azure/mod.rs @@ -3,6 +3,7 @@ pub mod artifact_registry; pub mod build; pub mod compute_cluster; pub mod container_apps_environment; +pub mod key; pub mod kv; pub mod network; pub mod postgres; @@ -23,6 +24,7 @@ pub use artifact_registry::*; pub use build::*; pub use compute_cluster::*; pub use container_apps_environment::*; +pub use key::*; pub use kv::*; pub use network::*; pub use postgres::*; diff --git a/crates/alien-core/src/import/data/gcp/key.rs b/crates/alien-core/src/import/data/gcp/key.rs new file mode 100644 index 000000000..dd7a91b69 --- /dev/null +++ b/crates/alien-core/src/import/data/gcp/key.rs @@ -0,0 +1,13 @@ +use serde::{Deserialize, Serialize}; + +/// GCP Cloud KMS key created by the customer-installed setup stack. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))] +#[serde(rename_all = "camelCase")] +pub struct GcpKeyImportData { + /// Full CryptoKey resource name, without a CryptoKeyVersion. + pub crypto_key_name: String, + /// Full primary CryptoKeyVersion resource name used for new wrapping operations. + pub primary_version: String, +} diff --git a/crates/alien-core/src/import/data/gcp/mod.rs b/crates/alien-core/src/import/data/gcp/mod.rs index e14609ce8..01ba92083 100644 --- a/crates/alien-core/src/import/data/gcp/mod.rs +++ b/crates/alien-core/src/import/data/gcp/mod.rs @@ -2,6 +2,7 @@ pub mod ai; pub mod artifact_registry; pub mod build; pub mod compute_cluster; +pub mod key; pub mod kv; pub mod network; pub mod postgres; @@ -18,6 +19,7 @@ pub use ai::*; pub use artifact_registry::*; pub use build::*; pub use compute_cluster::*; +pub use key::*; pub use kv::*; pub use network::*; pub use postgres::*; diff --git a/crates/alien-core/src/import/data/mod.rs b/crates/alien-core/src/import/data/mod.rs index 01b902caf..d6dcdfac9 100644 --- a/crates/alien-core/src/import/data/mod.rs +++ b/crates/alien-core/src/import/data/mod.rs @@ -10,26 +10,27 @@ pub mod kubernetes_cluster; pub use aws::{ AwsAiImportData, AwsArtifactRegistryImportData, AwsBuildImportData, AwsComputeClusterImportData, AwsEmailDkimTokenImportData, AwsEmailDomainImportData, - AwsEmailImportData, AwsKvImportData, AwsNetworkImportData, AwsOpenSearchImportData, - AwsPostgresImportData, AwsQueueImportData, AwsRemoteBindingsImportData, - AwsRemoteStackManagementImportData, AwsServiceAccountImportData, AwsStorageImportData, - AwsVaultImportData, AwsWorkerImportData, + AwsEmailImportData, AwsKeyImportData, AwsKvImportData, AwsNetworkImportData, + AwsOpenSearchImportData, AwsPostgresImportData, AwsQueueImportData, + AwsRemoteBindingsImportData, AwsRemoteStackManagementImportData, AwsServiceAccountImportData, + AwsStorageImportData, AwsVaultImportData, AwsWorkerImportData, }; pub use azure::{ AzureAiImportData, AzureArtifactRegistryImportData, AzureBuildImportData, AzureComputeClusterImportData, AzureContainerAppsEnvironmentImportData, - AzureFlexibleServerPostgresImportData, AzureKvImportData, AzureNetworkImportData, - AzureQueueImportData, AzureRemoteBindingsImportData, AzureRemoteStackManagementImportData, - AzureResourceGroupImportData, AzureServiceAccountImportData, AzureServiceActivationImportData, + AzureFlexibleServerPostgresImportData, AzureKeyImportData, AzureKvImportData, + AzureNetworkImportData, AzureQueueImportData, AzureRemoteBindingsImportData, + AzureRemoteStackManagementImportData, AzureResourceGroupImportData, + AzureServiceAccountImportData, AzureServiceActivationImportData, AzureServiceBusNamespaceImportData, AzureStorageAccountImportData, AzureStorageImportData, AzureVaultImportData, AzureWorkerImportData, }; pub use gcp::{ GcpAiImportData, GcpArtifactRegistryImportData, GcpBuildImportData, - GcpComputeClusterImportData, GcpKvImportData, GcpNetworkImportData, GcpPostgresImportData, - GcpQueueImportData, GcpRemoteBindingsImportData, GcpRemoteStackManagementImportData, - GcpServiceAccountImportData, GcpServiceActivationImportData, GcpStorageImportData, - GcpVaultImportData, GcpWorkerImportData, + GcpComputeClusterImportData, GcpKeyImportData, GcpKvImportData, GcpNetworkImportData, + GcpPostgresImportData, GcpQueueImportData, GcpRemoteBindingsImportData, + GcpRemoteStackManagementImportData, GcpServiceAccountImportData, + GcpServiceActivationImportData, GcpStorageImportData, GcpVaultImportData, GcpWorkerImportData, }; pub use kubernetes_cluster::{ AzureApplicationGatewayForContainersBootstrap, KubernetesClusterImportData, @@ -77,6 +78,7 @@ mod schema_snapshots { ("aws_email", schema::()), ("aws_function", schema::()), ("aws_kv", schema::()), + ("aws_key", schema::()), ("aws_network", schema::()), ("aws_open_search", schema::()), ("aws_postgres", schema::()), @@ -107,6 +109,7 @@ mod schema_snapshots { ), ("azure_function", schema::()), ("azure_kv", schema::()), + ("azure_key", schema::()), ("azure_network", schema::()), ( "azure_postgres", @@ -151,6 +154,7 @@ mod schema_snapshots { ), ("gcp_function", schema::()), ("gcp_kv", schema::()), + ("gcp_key", schema::()), ("gcp_network", schema::()), ("gcp_postgres", schema::()), ("gcp_queue", schema::()), diff --git a/crates/alien-core/src/import/data/snapshots/alien_core__import__data__schema_snapshots__import_data_schemas.snap b/crates/alien-core/src/import/data/snapshots/alien_core__import__data__schema_snapshots__import_data_schemas.snap index a27492af7..55d1a65e6 100644 --- a/crates/alien-core/src/import/data/snapshots/alien_core__import__data__schema_snapshots__import_data_schemas.snap +++ b/crates/alien-core/src/import/data/snapshots/alien_core__import__data__schema_snapshots__import_data_schemas.snap @@ -303,6 +303,21 @@ expression: schemas "title": "AwsKvImportData", "type": "object" }, + "aws_key": { + "$schema": "http://json-schema.org/draft-07/schema#", + "description": "AWS KMS key created by the customer-installed setup stack.", + "properties": { + "keyArn": { + "description": "Immutable KMS key ARN. Alias ARNs are not accepted.", + "type": "string" + } + }, + "required": [ + "keyArn" + ], + "title": "AwsKeyImportData", + "type": "object" + }, "aws_network": { "$schema": "http://json-schema.org/draft-07/schema#", "definitions": { @@ -547,6 +562,13 @@ expression: schemas "description": "Whether the management inline policy was attached by the generated stack.", "type": "boolean" }, + "remoteBindingsRoleArn": { + "description": "Setup-owned role used only for opted-in remote binding data access.", + "type": [ + "string", + "null" + ] + }, "roleArn": { "description": "Cross-account management role ARN.", "type": "string" @@ -881,6 +903,36 @@ expression: schemas "title": "AzureKvImportData", "type": "object" }, + "azure_key": { + "$schema": "http://json-schema.org/draft-07/schema#", + "description": "Azure Key Vault key created by the customer-installed setup stack.", + "properties": { + "keyId": { + "description": "Full versioned Key Vault key ID used for new wrapping operations.", + "type": "string" + }, + "keyName": { + "description": "Key name within the vault.", + "type": "string" + }, + "lineageVersionId": { + "description": "Version ID that identifies the original key lineage.", + "type": "string" + }, + "vaultResourceId": { + "description": "ARM resource ID of the dedicated Key Vault.", + "type": "string" + } + }, + "required": [ + "keyId", + "keyName", + "lineageVersionId", + "vaultResourceId" + ], + "title": "AzureKeyImportData", + "type": "object" + }, "azure_network": { "$schema": "http://json-schema.org/draft-07/schema#", "description": "Azure Network ImportData — VNet + subnets + NAT topology.", @@ -1078,6 +1130,20 @@ expression: schemas "description": "Management UAMI principal id.", "type": "string" }, + "remoteBindingsClientId": { + "description": "Remote Bindings UAMI client id used for workload identity exchange.", + "type": [ + "string", + "null" + ] + }, + "remoteBindingsIdentityId": { + "description": "Setup-owned UAMI resource id used only for opted-in remote bindings.", + "type": [ + "string", + "null" + ] + }, "resourceGroup": { "description": "Resource group containing the management identity.", "type": "string" @@ -1561,6 +1627,26 @@ expression: schemas "title": "GcpKvImportData", "type": "object" }, + "gcp_key": { + "$schema": "http://json-schema.org/draft-07/schema#", + "description": "GCP Cloud KMS key created by the customer-installed setup stack.", + "properties": { + "cryptoKeyName": { + "description": "Full CryptoKey resource name, without a CryptoKeyVersion.", + "type": "string" + }, + "primaryVersion": { + "description": "Full primary CryptoKeyVersion resource name used for new wrapping operations.", + "type": "string" + } + }, + "required": [ + "cryptoKeyName", + "primaryVersion" + ], + "title": "GcpKeyImportData", + "type": "object" + }, "gcp_network": { "$schema": "http://json-schema.org/draft-07/schema#", "description": "GCP Network ImportData — VPC + subnetwork + Cloud NAT topology.", @@ -1733,6 +1819,13 @@ expression: schemas "null" ] }, + "remoteBindingsServiceAccountEmail": { + "description": "Setup-owned service account used only for opted-in remote bindings.", + "type": [ + "string", + "null" + ] + }, "serviceAccountEmail": { "description": "Service account email the manager impersonates.", "type": "string" diff --git a/crates/alien-core/src/ownership.rs b/crates/alien-core/src/ownership.rs index 92e3541e0..87649d89d 100644 --- a/crates/alien-core/src/ownership.rs +++ b/crates/alien-core/src/ownership.rs @@ -75,7 +75,7 @@ pub fn ownership_policy_for_resource_type(resource_type: &str) -> ResourceOwners "function" | "container-cluster" => removed_resource_type(), "worker" | "daemon" | "container" => live_only(), "compute-cluster" => frozen_with_runtime_cleanup(), - "artifact-registry" => frozen_with_management(), + "artifact-registry" | "key" => frozen_with_management(), "build" | "network" | "remote-stack-management" diff --git a/crates/alien-core/src/remote_bindings.rs b/crates/alien-core/src/remote_bindings.rs index e8e51ae45..12a807821 100644 --- a/crates/alien-core/src/remote_bindings.rs +++ b/crates/alien-core/src/remote_bindings.rs @@ -3,6 +3,7 @@ use crate::{ResourceEntry, ResourceLifecycle, ResourceType}; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum RemoteBindingKind { Storage, + Key, } /// One resource type's provider-neutral Remote Bindings contract. @@ -20,18 +21,28 @@ pub struct RemoteBindingDefinition { pub revision: u32, } -const DEFINITIONS: &[RemoteBindingDefinition] = &[RemoteBindingDefinition { - resource_type: "storage", - permission_set: "storage/remote-data-write", - kind: RemoteBindingKind::Storage, - description: "Read and write objects in this storage resource", - setup_support_resource_types: &[ - "azure_resource_group", - "azure_storage_account", - "service_activation", - ], - revision: 1, -}]; +const DEFINITIONS: &[RemoteBindingDefinition] = &[ + RemoteBindingDefinition { + resource_type: "storage", + permission_set: "storage/remote-data-write", + kind: RemoteBindingKind::Storage, + description: "Read and write objects in this storage resource", + setup_support_resource_types: &[ + "azure_resource_group", + "azure_storage_account", + "service_activation", + ], + revision: 1, + }, + RemoteBindingDefinition { + resource_type: "key", + permission_set: "key/remote-cryptography", + kind: RemoteBindingKind::Key, + description: "Encrypt and decrypt small values with this key", + setup_support_resource_types: &["azure_resource_group", "service_activation"], + revision: 1, + }, +]; pub fn remote_binding_definition( resource_type: &ResourceType, diff --git a/crates/alien-core/src/resource.rs b/crates/alien-core/src/resource.rs index b0a520fa9..c90e10a14 100644 --- a/crates/alien-core/src/resource.rs +++ b/crates/alien-core/src/resource.rs @@ -198,6 +198,10 @@ impl<'de> Deserialize<'de> for Resource { serde_json::from_value::(value) .map_err(serde::de::Error::custom)?, ), + "key" => Box::new( + serde_json::from_value::(value) + .map_err(serde::de::Error::custom)?, + ), "queue" => Box::new( serde_json::from_value::(value) .map_err(serde::de::Error::custom)?, @@ -277,6 +281,7 @@ impl<'de> Deserialize<'de> for Resource { "compute-cluster", "kubernetes-cluster", "storage", + "key", "queue", "email", "kv", @@ -554,6 +559,10 @@ impl<'de> Deserialize<'de> for ResourceOutputs { serde_json::from_value::(value) .map_err(serde::de::Error::custom)?, ), + "key" => Box::new( + serde_json::from_value::(value) + .map_err(serde::de::Error::custom)?, + ), "queue" => Box::new( serde_json::from_value::(value) .map_err(serde::de::Error::custom)?, @@ -638,6 +647,7 @@ impl<'de> Deserialize<'de> for ResourceOutputs { "container", "compute-cluster", "storage", + "key", "queue", "email", "kv", diff --git a/crates/alien-core/src/resource_links.rs b/crates/alien-core/src/resource_links.rs index fb5b2579d..a235e5b72 100644 --- a/crates/alien-core/src/resource_links.rs +++ b/crates/alien-core/src/resource_links.rs @@ -236,6 +236,7 @@ mod tests { ("network", false), ("service-account", false), ("artifact-registry", false), + ("key", false), ("service_activation", false), ("remote-stack-management", false), ("resource-access", false), diff --git a/crates/alien-core/src/resources/key.rs b/crates/alien-core/src/resources/key.rs new file mode 100644 index 000000000..356902a9d --- /dev/null +++ b/crates/alien-core/src/resources/key.rs @@ -0,0 +1,157 @@ +use crate::{ + error::{ErrorData, Result}, + resource::{ResourceDefinition, ResourceOutputsDefinition, ResourceRef, ResourceType}, +}; +use alien_error::AlienError; +use bon::Builder; +use serde::{Deserialize, Serialize}; +use std::any::Any; + +/// A customer-managed encryption key. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Builder)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +#[builder(start_fn = new)] +pub struct Key { + /// Identifier for the key resource. + #[builder(start_fn)] + pub id: String, +} + +impl Key { + pub const RESOURCE_TYPE: ResourceType = ResourceType::from_static("key"); + + pub fn id(&self) -> &str { + &self.id + } +} + +/// Stable identity of a provider key family. +/// +/// Provider-native version rotation does not change this value. Replacing the +/// provider key does. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[serde(tag = "provider", rename_all = "lowercase", deny_unknown_fields)] +pub enum KeyFingerprint { + /// An immutable AWS KMS key ARN. Alias ARNs are not accepted. + Aws { key_arn: String }, + /// A full GCP CryptoKey resource name, without a CryptoKeyVersion. + Gcp { crypto_key_name: String }, + /// An Azure Key Vault key family pinned to its original lineage. + Azure { + vault_resource_id: String, + key_name: String, + lineage_version_id: String, + }, +} + +/// Outputs generated by a successfully provisioned Key. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +pub struct KeyOutputs { + /// Stable provider key-family identity. + pub fingerprint: KeyFingerprint, + /// Exact provider key version used for new wrapping operations. + pub wrapping_key_id: String, +} + +impl ResourceDefinition for Key { + fn get_resource_type(&self) -> ResourceType { + Self::RESOURCE_TYPE + } + + fn id(&self) -> &str { + &self.id + } + + fn get_dependencies(&self) -> Vec { + Vec::new() + } + + fn validate_update(&self, new_config: &dyn ResourceDefinition) -> Result<()> { + let Some(new_key) = new_config.as_any().downcast_ref::() else { + return Err(AlienError::new(ErrorData::UnexpectedResourceType { + resource_id: self.id.clone(), + expected: Self::RESOURCE_TYPE, + actual: new_config.get_resource_type(), + })); + }; + + if self.id != new_key.id { + return Err(AlienError::new(ErrorData::InvalidResourceUpdate { + resource_id: self.id.clone(), + reason: "the 'id' field is immutable".to_string(), + })); + } + + Ok(()) + } + + fn as_any(&self) -> &dyn Any { + self + } + + fn as_any_mut(&mut self) -> &mut dyn Any { + self + } + + fn box_clone(&self) -> Box { + Box::new(self.clone()) + } + + fn resource_eq(&self, other: &dyn ResourceDefinition) -> bool { + other.as_any().downcast_ref::() == Some(self) + } + + fn to_json_value(&self) -> serde_json::Result { + serde_json::to_value(self) + } +} + +impl ResourceOutputsDefinition for KeyOutputs { + fn get_resource_type(&self) -> ResourceType { + Key::RESOURCE_TYPE + } + + fn as_any(&self) -> &dyn Any { + self + } + + fn box_clone(&self) -> Box { + Box::new(self.clone()) + } + + fn outputs_eq(&self, other: &dyn ResourceOutputsDefinition) -> bool { + other.as_any().downcast_ref::() == Some(self) + } + + fn to_json_value(&self) -> serde_json::Result { + serde_json::to_value(self) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn provider_rotation_preserves_the_key_family_fingerprint() { + let fingerprint = KeyFingerprint::Gcp { + crypto_key_name: "projects/example/locations/us/keyRings/data/cryptoKeys/customer" + .to_string(), + }; + let before = KeyOutputs { + fingerprint: fingerprint.clone(), + wrapping_key_id: "projects/example/locations/us/keyRings/data/cryptoKeys/customer/cryptoKeyVersions/1".to_string(), + }; + let after = KeyOutputs { + fingerprint, + wrapping_key_id: "projects/example/locations/us/keyRings/data/cryptoKeys/customer/cryptoKeyVersions/2".to_string(), + }; + + assert_eq!(before.fingerprint, after.fingerprint); + assert_ne!(before.wrapping_key_id, after.wrapping_key_id); + } +} diff --git a/crates/alien-core/src/resources/mod.rs b/crates/alien-core/src/resources/mod.rs index 9ac6a356d..e73f7b039 100644 --- a/crates/alien-core/src/resources/mod.rs +++ b/crates/alien-core/src/resources/mod.rs @@ -21,6 +21,9 @@ pub use email::*; mod storage; pub use storage::*; +mod key; +pub use key::*; + mod queue; pub use queue::*; diff --git a/crates/alien-core/src/resources/storage.rs b/crates/alien-core/src/resources/storage.rs index e06e0357d..346710994 100644 --- a/crates/alien-core/src/resources/storage.rs +++ b/crates/alien-core/src/resources/storage.rs @@ -57,6 +57,10 @@ pub struct Storage { #[serde(default)] #[builder(default)] pub cors_allowed_origins: Vec, + + /// Customer-managed Key used by the provider's native storage encryption. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub encryption_key: Option, } impl Storage { @@ -112,7 +116,7 @@ impl ResourceDefinition for Storage { } fn get_dependencies(&self) -> Vec { - Vec::new() + self.encryption_key.iter().cloned().collect() } fn validate_update(&self, new_config: &dyn ResourceDefinition) -> Result<()> { @@ -158,3 +162,18 @@ impl ResourceDefinition for Storage { serde_json::to_value(self) } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn encryption_key_is_an_implicit_dependency() { + let key = ResourceRef::new(crate::Key::RESOURCE_TYPE, "customer-key"); + let storage = Storage::new("customer-data".to_string()) + .encryption_key(key.clone()) + .build(); + + assert_eq!(storage.get_dependencies(), vec![key]); + } +} diff --git a/crates/alien-gcp-clients/src/gcp/cloud_kms.rs b/crates/alien-gcp-clients/src/gcp/cloud_kms.rs new file mode 100644 index 000000000..4fd7375a1 --- /dev/null +++ b/crates/alien-gcp-clients/src/gcp/cloud_kms.rs @@ -0,0 +1,153 @@ +use crate::gcp::api_client::{GcpClientBase, GcpServiceConfig}; +use crate::gcp::GcpClientConfig; +use alien_client_core::Result; +use async_trait::async_trait; +use reqwest::{Client, Method}; +use serde::{Deserialize, Serialize}; + +#[cfg(feature = "test-utils")] +use mockall::automock; + +#[derive(Debug)] +pub struct CloudKmsServiceConfig; + +impl GcpServiceConfig for CloudKmsServiceConfig { + fn base_url(&self) -> &'static str { + "https://cloudkms.googleapis.com/v1" + } + + fn default_audience(&self) -> &'static str { + "https://cloudkms.googleapis.com/" + } + + fn service_name(&self) -> &'static str { + "Cloud KMS" + } + + fn service_key(&self) -> &'static str { + "cloudkms" + } +} + +#[cfg_attr(feature = "test-utils", automock)] +#[cfg_attr(target_arch = "wasm32", async_trait(?Send))] +#[cfg_attr(not(target_arch = "wasm32"), async_trait)] +pub trait CloudKmsApi: Send + Sync + std::fmt::Debug { + async fn get_crypto_key(&self, crypto_key_name: &str) -> Result; + async fn encrypt( + &self, + crypto_key_name: &str, + request: EncryptRequest, + ) -> Result; + async fn decrypt( + &self, + crypto_key_name: &str, + request: DecryptRequest, + ) -> Result; +} + +#[derive(Debug)] +pub struct CloudKmsClient { + base: GcpClientBase, +} + +impl CloudKmsClient { + pub fn new(client: Client, config: GcpClientConfig) -> Self { + Self { + base: GcpClientBase::new(client, config, Box::new(CloudKmsServiceConfig)), + } + } +} + +#[cfg_attr(target_arch = "wasm32", async_trait(?Send))] +#[cfg_attr(not(target_arch = "wasm32"), async_trait)] +impl CloudKmsApi for CloudKmsClient { + async fn get_crypto_key(&self, crypto_key_name: &str) -> Result { + self.base + .execute_request::( + Method::GET, + crypto_key_name, + None, + None, + crypto_key_name, + ) + .await + } + + async fn encrypt( + &self, + crypto_key_name: &str, + request: EncryptRequest, + ) -> Result { + self.base + .execute_request( + Method::POST, + &format!("{crypto_key_name}:encrypt"), + None, + Some(request), + crypto_key_name, + ) + .await + } + + async fn decrypt( + &self, + crypto_key_name: &str, + request: DecryptRequest, + ) -> Result { + self.base + .execute_request( + Method::POST, + &format!("{crypto_key_name}:decrypt"), + None, + Some(request), + crypto_key_name, + ) + .await + } +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct CryptoKey { + pub name: String, + pub purpose: String, + pub primary: Option, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct CryptoKeyVersion { + pub name: String, + pub state: String, + pub algorithm: String, +} + +#[derive(Debug, Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct EncryptRequest { + pub plaintext: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub additional_authenticated_data: Option, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct EncryptResponse { + pub name: String, + pub ciphertext: String, +} + +#[derive(Debug, Clone, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct DecryptRequest { + pub ciphertext: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub additional_authenticated_data: Option, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct DecryptResponse { + pub plaintext: String, +} diff --git a/crates/alien-gcp-clients/src/gcp/mod.rs b/crates/alien-gcp-clients/src/gcp/mod.rs index 096e65978..7222e0fd9 100644 --- a/crates/alien-gcp-clients/src/gcp/mod.rs +++ b/crates/alien-gcp-clients/src/gcp/mod.rs @@ -3,6 +3,7 @@ pub mod artifactregistry; pub mod cloud_sql; pub mod cloudasset; pub mod cloudbuild; +pub mod cloud_kms; pub mod cloudrun; pub mod cloudscheduler; pub mod compute; diff --git a/crates/alien-gcp-clients/src/lib.rs b/crates/alien-gcp-clients/src/lib.rs index 51e1eccbe..f04503d76 100644 --- a/crates/alien-gcp-clients/src/lib.rs +++ b/crates/alien-gcp-clients/src/lib.rs @@ -16,6 +16,7 @@ pub use gcp::artifactregistry::{ArtifactRegistryApi, ArtifactRegistryClient}; pub use gcp::cloud_sql::{CloudSqlApi, CloudSqlClient}; pub use gcp::cloudasset::{CloudAssetApi, CloudAssetClient}; pub use gcp::cloudbuild::{CloudBuildApi, CloudBuildClient}; +pub use gcp::cloud_kms::{CloudKmsApi, CloudKmsClient}; pub use gcp::cloudrun::{CloudRunApi, CloudRunClient}; pub use gcp::cloudscheduler::{CloudSchedulerApi, CloudSchedulerClient}; pub use gcp::compute::{ComputeApi, ComputeClient}; diff --git a/crates/alien-infra/src/aws_importers.rs b/crates/alien-infra/src/aws_importers.rs index db79565fc..e1bca0f8c 100644 --- a/crates/alien-infra/src/aws_importers.rs +++ b/crates/alien-infra/src/aws_importers.rs @@ -11,7 +11,7 @@ #[cfg(feature = "kubernetes")] use alien_core::KubernetesCluster; use alien_core::{ - Ai, ArtifactRegistry, AwsOpenSearch, Build, Email, Kv, Network, Platform, Queue, Storage, + Ai, ArtifactRegistry, AwsOpenSearch, Build, Email, Key, Kv, Network, Platform, Queue, Storage, Vault, Worker, }; use alien_core::{RemoteBindings, RemoteStackManagement, ServiceAccount}; @@ -20,6 +20,7 @@ use crate::ai::AwsAiImporter; use crate::artifact_registry::AwsArtifactRegistryImporter; use crate::build::AwsBuildImporter; use crate::email::AwsEmailImporter; +use crate::key::AwsKeyImporter; #[cfg(feature = "kubernetes")] use crate::kubernetes_cluster::KubernetesClusterImporter; use crate::kv::AwsKvImporter; @@ -40,6 +41,7 @@ pub fn register(registry: &mut ImporterRegistry) { .register(Ai::RESOURCE_TYPE, Platform::Aws, AwsAiImporter) .register(Storage::RESOURCE_TYPE, Platform::Aws, AwsStorageImporter) .register(Kv::RESOURCE_TYPE, Platform::Aws, AwsKvImporter) + .register(Key::RESOURCE_TYPE, Platform::Aws, AwsKeyImporter) .register(Vault::RESOURCE_TYPE, Platform::Aws, AwsVaultImporter) .register(Queue::RESOURCE_TYPE, Platform::Aws, AwsQueueImporter) .register(Network::RESOURCE_TYPE, Platform::Aws, AwsNetworkImporter) diff --git a/crates/alien-infra/src/azure_importers.rs b/crates/alien-infra/src/azure_importers.rs index f30245fbc..c4ddf6e94 100644 --- a/crates/alien-infra/src/azure_importers.rs +++ b/crates/alien-infra/src/azure_importers.rs @@ -13,7 +13,7 @@ use alien_core::KubernetesCluster; use alien_core::{ Ai, ArtifactRegistry, AzureContainerAppsEnvironment, AzureResourceGroup, - AzureServiceBusNamespace, AzureStorageAccount, Build, Kv, Network, Platform, Queue, + AzureServiceBusNamespace, AzureStorageAccount, Build, Key, Kv, Network, Platform, Queue, RemoteBindings, RemoteStackManagement, ServiceAccount, ServiceActivation, Storage, Vault, Worker, }; @@ -21,6 +21,7 @@ use alien_core::{ use crate::ai::AzureAiImporter; use crate::artifact_registry::AzureArtifactRegistryImporter; use crate::build::AzureBuildImporter; +use crate::key::AzureKeyImporter; #[cfg(feature = "kubernetes")] use crate::kubernetes_cluster::KubernetesClusterImporter; use crate::kv::AzureKvImporter; @@ -49,6 +50,7 @@ pub fn register(registry: &mut ImporterRegistry) { AzureStorageImporter, ) .register(Kv::RESOURCE_TYPE, Platform::Azure, AzureKvImporter) + .register(Key::RESOURCE_TYPE, Platform::Azure, AzureKeyImporter) .register(Vault::RESOURCE_TYPE, Platform::Azure, AzureVaultImporter) .register(Queue::RESOURCE_TYPE, Platform::Azure, AzureQueueImporter) .register( diff --git a/crates/alien-infra/src/core/controller.rs b/crates/alien-infra/src/core/controller.rs index 73cd36a51..c695e517e 100644 --- a/crates/alien-infra/src/core/controller.rs +++ b/crates/alien-infra/src/core/controller.rs @@ -1141,6 +1141,14 @@ fn deserialize_controller_by_tag( #[cfg(feature = "local")] "LocalAiController" => deser!(crate::ai::LocalAiController), + // Setup-owned encryption Key controllers + #[cfg(feature = "aws")] + "AwsKeyController" => deser!(crate::key::AwsKeyController), + #[cfg(feature = "gcp")] + "GcpKeyController" => deser!(crate::key::GcpKeyController), + #[cfg(feature = "azure")] + "AzureKeyController" => deser!(crate::key::AzureKeyController), + // Service activation controllers #[cfg(feature = "gcp")] "GcpServiceActivationController" => { @@ -1449,6 +1457,24 @@ mod tests { ); } + #[cfg(feature = "aws")] + #[test] + fn aws_key_controller_state_round_trips() { + assert_controller_state_round_trips(crate::key::AwsKeyController::default()); + } + + #[cfg(feature = "gcp")] + #[test] + fn gcp_key_controller_state_round_trips() { + assert_controller_state_round_trips(crate::key::GcpKeyController::default()); + } + + #[cfg(feature = "azure")] + #[test] + fn azure_key_controller_state_round_trips() { + assert_controller_state_round_trips(crate::key::AzureKeyController::default()); + } + #[test] fn controller_state_validation_rejects_missing_version() { let value = serde_json::json!({ diff --git a/crates/alien-infra/src/core/registry.rs b/crates/alien-infra/src/core/registry.rs index c73abf299..b573d0bab 100644 --- a/crates/alien-infra/src/core/registry.rs +++ b/crates/alien-infra/src/core/registry.rs @@ -16,7 +16,7 @@ use alien_core::Daemon; use alien_core::Postgres; use alien_core::{ Ai, ArtifactRegistry, AwsOpenSearch, AzureContainerAppsEnvironment, AzureResourceGroup, - AzureServiceBusNamespace, AzureStorageAccount, Build, Email, Kv, Network, RemoteBindings, + AzureServiceBusNamespace, AzureStorageAccount, Build, Email, Key, Kv, Network, RemoteBindings, RemoteStackManagement, ServiceAccount, ServiceActivation, Storage, Vault, Worker, }; use alien_core::{Platform, ResourceDefinition, ResourceType}; @@ -247,6 +247,28 @@ impl ResourceRegistry { Box::new(DefaultControllerFactory::::new()), ); + // Key resources are setup-owned and enter deployments through stack import. + #[cfg(feature = "aws")] + registry.register_controller_factory( + Key::RESOURCE_TYPE, + Platform::Aws, + Box::new(DefaultControllerFactory::::new()), + ); + + #[cfg(feature = "gcp")] + registry.register_controller_factory( + Key::RESOURCE_TYPE, + Platform::Gcp, + Box::new(DefaultControllerFactory::::new()), + ); + + #[cfg(feature = "azure")] + registry.register_controller_factory( + Key::RESOURCE_TYPE, + Platform::Azure, + Box::new(DefaultControllerFactory::::new()), + ); + // Register built-in AWS OpenSearch controller (AWS only; the // experimental resource is Frozen-only and enters deployments // through stack import). diff --git a/crates/alien-infra/src/core/service_provider.rs b/crates/alien-infra/src/core/service_provider.rs index b5aa428ba..2454020e7 100644 --- a/crates/alien-infra/src/core/service_provider.rs +++ b/crates/alien-infra/src/core/service_provider.rs @@ -13,6 +13,7 @@ use alien_aws_clients::{ elbv2::{Elbv2Api, Elbv2Client}, eventbridge::{EventBridgeApi, EventBridgeClient}, iam::{IamApi, IamClient}, + kms::{KmsApi, KmsClient}, lambda::{LambdaApi, LambdaClient}, rds::{RdsApi, RdsClient}, s3::{S3Api, S3Client}, @@ -34,8 +35,9 @@ use alien_azure_clients::{ event_grid::{AzureEventGridClient, EventGridApi}, flexible_server::{AzureFlexibleServerClient, FlexibleServerApi}, keyvault::{ - AzureKeyVaultCertificatesClient, AzureKeyVaultManagementClient, AzureKeyVaultSecretsClient, - KeyVaultCertificatesApi, KeyVaultManagementApi, KeyVaultSecretsApi, + AzureKeyVaultCertificatesClient, AzureKeyVaultKeysClient, AzureKeyVaultManagementClient, + AzureKeyVaultSecretsClient, KeyVaultCertificatesApi, KeyVaultKeysApi, + KeyVaultManagementApi, KeyVaultSecretsApi, }, load_balancers::{AzureLoadBalancerClient, LoadBalancerApi}, long_running_operation::{LongRunningOperationApi, LongRunningOperationClient}, @@ -56,6 +58,7 @@ use alien_azure_clients::{ use alien_error::Context; use alien_gcp_clients::{ artifactregistry::{ArtifactRegistryApi, ArtifactRegistryClient}, + cloud_kms::{CloudKmsApi, CloudKmsClient}, cloud_sql::{CloudSqlApi, CloudSqlClient}, cloudbuild::{CloudBuildApi, CloudBuildClient}, cloudrun::{CloudRunApi, CloudRunClient}, @@ -136,6 +139,7 @@ pub trait PlatformServiceProvider: Send + Sync { &self, config: &AwsClientConfig, ) -> Result>; + async fn get_aws_kms_client(&self, config: &AwsClientConfig) -> Result>; // GCP clients fn get_gcp_iam_client(&self, config: &GcpClientConfig) -> Result>; @@ -171,6 +175,7 @@ pub trait PlatformServiceProvider: Send + Sync { &self, config: &GcpClientConfig, ) -> Result>; + fn get_gcp_cloud_kms_client(&self, config: &GcpClientConfig) -> Result>; // Azure clients fn get_azure_application_gateway_client( @@ -245,6 +250,10 @@ pub trait PlatformServiceProvider: Send + Sync { &self, config: &AzureClientConfig, ) -> Result>; + fn get_azure_key_vault_keys_client( + &self, + config: &AzureClientConfig, + ) -> Result>; fn get_azure_key_vault_certificates_client( &self, config: &AzureClientConfig, @@ -473,6 +482,19 @@ impl PlatformServiceProvider for DefaultPlatformServiceProvider { Ok(Arc::new(S3Client::new(reqwest::Client::new(), credentials))) } + async fn get_aws_kms_client(&self, config: &AwsClientConfig) -> Result> { + let credentials = AwsCredentialProvider::from_config(config.clone()) + .await + .context(crate::error::ErrorData::CloudPlatformError { + message: "Failed to create AWS credential provider".to_string(), + resource_id: None, + })?; + Ok(Arc::new(KmsClient::new( + reqwest::Client::new(), + credentials, + ))) + } + async fn get_aws_ses_client(&self, config: &AwsClientConfig) -> Result> { let credentials = AwsCredentialProvider::from_config(config.clone()) .await @@ -790,6 +812,13 @@ impl PlatformServiceProvider for DefaultPlatformServiceProvider { ))) } + fn get_gcp_cloud_kms_client(&self, config: &GcpClientConfig) -> Result> { + Ok(Arc::new(CloudKmsClient::new( + reqwest::Client::new(), + config.clone(), + ))) + } + fn get_gcp_firestore_client(&self, config: &GcpClientConfig) -> Result> { Ok(Arc::new(FirestoreClient::new( reqwest::Client::new(), @@ -1019,6 +1048,16 @@ impl PlatformServiceProvider for DefaultPlatformServiceProvider { ))) } + fn get_azure_key_vault_keys_client( + &self, + config: &AzureClientConfig, + ) -> Result> { + Ok(Arc::new(AzureKeyVaultKeysClient::new( + reqwest::Client::new(), + AzureTokenCache::new(config.clone()), + ))) + } + fn get_azure_key_vault_certificates_client( &self, config: &AzureClientConfig, diff --git a/crates/alien-infra/src/gcp_importers.rs b/crates/alien-infra/src/gcp_importers.rs index cce67098e..d61bed0ae 100644 --- a/crates/alien-infra/src/gcp_importers.rs +++ b/crates/alien-infra/src/gcp_importers.rs @@ -6,13 +6,14 @@ #[cfg(feature = "kubernetes")] use alien_core::KubernetesCluster; use alien_core::{ - Ai, ArtifactRegistry, Build, Kv, Network, Platform, Queue, Storage, Vault, Worker, + Ai, ArtifactRegistry, Build, Key, Kv, Network, Platform, Queue, Storage, Vault, Worker, }; use alien_core::{RemoteBindings, RemoteStackManagement, ServiceAccount, ServiceActivation}; use crate::ai::GcpAiImporter; use crate::artifact_registry::GcpArtifactRegistryImporter; use crate::build::GcpBuildImporter; +use crate::key::GcpKeyImporter; #[cfg(feature = "kubernetes")] use crate::kubernetes_cluster::KubernetesClusterImporter; use crate::kv::GcpKvImporter; @@ -33,6 +34,7 @@ pub fn register(registry: &mut ImporterRegistry) { .register(Ai::RESOURCE_TYPE, Platform::Gcp, GcpAiImporter) .register(Storage::RESOURCE_TYPE, Platform::Gcp, GcpStorageImporter) .register(Kv::RESOURCE_TYPE, Platform::Gcp, GcpKvImporter) + .register(Key::RESOURCE_TYPE, Platform::Gcp, GcpKeyImporter) .register(Vault::RESOURCE_TYPE, Platform::Gcp, GcpVaultImporter) .register(Queue::RESOURCE_TYPE, Platform::Gcp, GcpQueueImporter) .register(Network::RESOURCE_TYPE, Platform::Gcp, GcpNetworkImporter) diff --git a/crates/alien-infra/src/key/aws.rs b/crates/alien-infra/src/key/aws.rs new file mode 100644 index 000000000..e70867507 --- /dev/null +++ b/crates/alien-infra/src/key/aws.rs @@ -0,0 +1,159 @@ +use std::time::Duration; + +use alien_core::{ + bindings::KeyBinding, + import::{data::AwsKeyImportData, ImportContext}, + AwsKmsKeyHeartbeatData, HeartbeatBackend, Key, KeyFingerprint, KeyHeartbeatData, + KeyHeartbeatStatus, KeyOutputs, ObservedHealth, Platform, ProviderLifecycleState, + ResourceHeartbeat, ResourceHeartbeatData, ResourceOutputs, ResourceStatus, StackResourceState, +}; +use alien_error::{AlienError, Context, IntoAlienError}; +use alien_macros::controller; +use chrono::Utc; + +use crate::{ + core::ResourceControllerContext, + error::{ErrorData, Result}, + import::ResourceImporter, + import_helpers::make_imported_state, +}; + +#[controller] +pub struct AwsKeyController { + pub(crate) key_arn: Option, + pub(crate) region: Option, +} + +#[controller] +impl AwsKeyController { + #[flow_entry(Create)] + #[handler(state = CreateStart, on_failure = CreateFailed, status = ResourceStatus::Provisioning)] + async fn create_start(&mut self, ctx: &ResourceControllerContext<'_>) -> Result { + let key = ctx.desired_resource_config::()?; + Err(AlienError::new(ErrorData::ResourceConfigInvalid { + resource_id: Some(key.id.clone()), + message: "key resources are setup-owned and enter a deployment through stack import" + .to_string(), + })) + } + + #[handler(state = Ready, on_failure = RefreshFailed, status = ResourceStatus::Running)] + async fn ready(&mut self, ctx: &ResourceControllerContext<'_>) -> Result { + let config = ctx.desired_resource_config::()?; + let key_arn = self.key_arn.as_deref().ok_or_else(|| { + AlienError::new(ErrorData::ResourceStateSerializationFailed { + resource_id: config.id.clone(), + message: "Imported AWS key is missing its ARN".to_string(), + }) + })?; + let metadata = ctx + .service_provider + .get_aws_kms_client(ctx.get_aws_config()?) + .await? + .describe_key(key_arn) + .await + .context(ErrorData::CloudPlatformError { + message: "Failed to read AWS KMS key metadata".to_string(), + resource_id: Some(config.id.clone()), + })? + .key_metadata; + if metadata.arn != key_arn { + return Err(AlienError::new(ErrorData::ResourceDrift { + resource_id: config.id.clone(), + message: "AWS KMS returned metadata for a different key".to_string(), + })); + } + let (health, lifecycle) = match metadata.key_state.as_str() { + "Enabled" if metadata.enabled => { + (ObservedHealth::Healthy, ProviderLifecycleState::Running) + } + "Disabled" => (ObservedHealth::Unhealthy, ProviderLifecycleState::Stopped), + "PendingDeletion" | "PendingReplicaDeletion" => { + (ObservedHealth::Unhealthy, ProviderLifecycleState::Deleting) + } + _ => (ObservedHealth::Degraded, ProviderLifecycleState::Unknown), + }; + ctx.emit_heartbeat(ResourceHeartbeat { + deployment_id: None, + resource_id: config.id.clone(), + resource_type: Key::RESOURCE_TYPE, + controller_platform: Platform::Aws, + backend: HeartbeatBackend::Aws, + observed_at: Utc::now(), + data: ResourceHeartbeatData::Key(KeyHeartbeatData::AwsKms(AwsKmsKeyHeartbeatData { + status: KeyHeartbeatStatus { + health, + lifecycle, + message: None, + }, + key_arn: metadata.arn, + key_state: metadata.key_state, + enabled: metadata.enabled, + key_spec: metadata.key_spec, + key_usage: metadata.key_usage, + })), + raw: vec![], + }); + Ok(HandlerAction::Continue { + state: Ready, + suggested_delay: Some(Duration::from_secs(300)), + }) + } + + terminal_state!( + state = CreateFailed, + status = ResourceStatus::ProvisionFailed + ); + terminal_state!( + state = RefreshFailed, + status = ResourceStatus::RefreshFailed + ); + terminal_state!(state = Deleted, status = ResourceStatus::Deleted); + + fn build_outputs(&self) -> Option { + let key_arn = self.key_arn.clone()?; + Some(ResourceOutputs::new(KeyOutputs { + fingerprint: KeyFingerprint::Aws { + key_arn: key_arn.clone(), + }, + wrapping_key_id: key_arn, + })) + } + + fn get_binding_params(&self) -> Result> { + let Some(key_arn) = &self.key_arn else { + return Ok(None); + }; + Ok(Some( + serde_json::to_value(KeyBinding::aws_kms(key_arn, self.region.as_deref())) + .into_alien_error() + .context(ErrorData::ResourceStateSerializationFailed { + resource_id: "binding".to_string(), + message: "Failed to serialize Key binding parameters".to_string(), + })?, + )) + } +} + +#[derive(Debug, Default)] +pub struct AwsKeyImporter; + +impl ResourceImporter for AwsKeyImporter { + type ImportData = AwsKeyImportData; + + fn import( + &self, + data: Self::ImportData, + ctx: &ImportContext<'_>, + ) -> alien_core::Result { + make_imported_state( + AwsKeyController { + state: AwsKeyState::Ready, + key_arn: Some(data.key_arn), + region: Some(ctx.region.to_string()), + _internal_stay_count: None, + }, + ctx, + ) + } +} diff --git a/crates/alien-infra/src/key/azure.rs b/crates/alien-infra/src/key/azure.rs new file mode 100644 index 000000000..5e82b14e2 --- /dev/null +++ b/crates/alien-infra/src/key/azure.rs @@ -0,0 +1,169 @@ +use std::time::Duration; + +use alien_core::{ + bindings::KeyBinding, + import::{data::AzureKeyImportData, ImportContext}, + AzureKeyVaultKeyHeartbeatData, HeartbeatBackend, Key, KeyFingerprint, KeyHeartbeatData, + KeyHeartbeatStatus, KeyOutputs, ObservedHealth, Platform, ProviderLifecycleState, + ResourceHeartbeat, ResourceHeartbeatData, ResourceOutputs, ResourceStatus, StackResourceState, +}; +use alien_error::{AlienError, Context, IntoAlienError}; +use alien_macros::controller; +use chrono::Utc; + +use crate::{ + core::ResourceControllerContext, + error::{ErrorData, Result}, + import::ResourceImporter, + import_helpers::make_imported_state, +}; + +#[controller] +pub struct AzureKeyController { + pub(crate) vault_resource_id: Option, + pub(crate) key_name: Option, + pub(crate) lineage_version_id: Option, + pub(crate) key_id: Option, +} + +#[controller] +impl AzureKeyController { + #[flow_entry(Create)] + #[handler(state = CreateStart, on_failure = CreateFailed, status = ResourceStatus::Provisioning)] + async fn create_start(&mut self, ctx: &ResourceControllerContext<'_>) -> Result { + let key = ctx.desired_resource_config::()?; + Err(AlienError::new(ErrorData::ResourceConfigInvalid { + resource_id: Some(key.id.clone()), + message: "key resources are setup-owned and enter a deployment through stack import" + .to_string(), + })) + } + + #[handler(state = Ready, on_failure = RefreshFailed, status = ResourceStatus::Running)] + async fn ready(&mut self, ctx: &ResourceControllerContext<'_>) -> Result { + let config = ctx.desired_resource_config::()?; + let versioned_key_id = self.key_id.clone().ok_or_else(|| { + AlienError::new(ErrorData::ResourceStateSerializationFailed { + resource_id: config.id.clone(), + message: "Imported Azure key is missing its data-plane key ID".to_string(), + }) + })?; + let current_key_id = versioned_key_id + .rsplit_once('/') + .map(|(id, _)| id) + .ok_or_else(|| { + AlienError::new(ErrorData::ResourceStateSerializationFailed { + resource_id: config.id.clone(), + message: "Imported Azure key ID does not contain a version".to_string(), + }) + })?; + let key = ctx + .service_provider + .get_azure_key_vault_keys_client(ctx.get_azure_config()?)? + .get_key(current_key_id) + .await + .context(ErrorData::CloudPlatformError { + message: "Failed to read Azure Key Vault key metadata".to_string(), + resource_id: Some(config.id.clone()), + })?; + if !key.key.kid.starts_with(&format!("{current_key_id}/")) { + return Err(AlienError::new(ErrorData::ResourceDrift { + resource_id: config.id.clone(), + message: "Azure Key Vault returned metadata for a different key".to_string(), + })); + } + self.key_id = Some(key.key.kid.clone()); + let (health, lifecycle) = match key.attributes.enabled { + Some(true) => (ObservedHealth::Healthy, ProviderLifecycleState::Running), + Some(false) => (ObservedHealth::Unhealthy, ProviderLifecycleState::Stopped), + None => (ObservedHealth::Degraded, ProviderLifecycleState::Unknown), + }; + ctx.emit_heartbeat(ResourceHeartbeat { + deployment_id: None, + resource_id: config.id.clone(), + resource_type: Key::RESOURCE_TYPE, + controller_platform: Platform::Azure, + backend: HeartbeatBackend::Azure, + observed_at: Utc::now(), + data: ResourceHeartbeatData::Key(KeyHeartbeatData::AzureKeyVault( + AzureKeyVaultKeyHeartbeatData { + status: KeyHeartbeatStatus { + health, + lifecycle, + message: None, + }, + key_id: key.key.kid, + enabled: key.attributes.enabled, + key_type: key.key.kty, + key_operations: key.key.key_ops, + recovery_level: key.attributes.recovery_level, + }, + )), + raw: vec![], + }); + Ok(HandlerAction::Continue { + state: Ready, + suggested_delay: Some(Duration::from_secs(300)), + }) + } + + terminal_state!( + state = CreateFailed, + status = ResourceStatus::ProvisionFailed + ); + terminal_state!( + state = RefreshFailed, + status = ResourceStatus::RefreshFailed + ); + terminal_state!(state = Deleted, status = ResourceStatus::Deleted); + + fn build_outputs(&self) -> Option { + Some(ResourceOutputs::new(KeyOutputs { + fingerprint: KeyFingerprint::Azure { + vault_resource_id: self.vault_resource_id.clone()?, + key_name: self.key_name.clone()?, + lineage_version_id: self.lineage_version_id.clone()?, + }, + wrapping_key_id: self.key_id.clone()?, + })) + } + + fn get_binding_params(&self) -> Result> { + let Some(key_id) = &self.key_id else { + return Ok(None); + }; + Ok(Some( + serde_json::to_value(KeyBinding::azure_key_vault(key_id)) + .into_alien_error() + .context(ErrorData::ResourceStateSerializationFailed { + resource_id: "binding".to_string(), + message: "Failed to serialize Key binding parameters".to_string(), + })?, + )) + } +} + +#[derive(Debug, Default)] +pub struct AzureKeyImporter; + +impl ResourceImporter for AzureKeyImporter { + type ImportData = AzureKeyImportData; + + fn import( + &self, + data: Self::ImportData, + ctx: &ImportContext<'_>, + ) -> alien_core::Result { + make_imported_state( + AzureKeyController { + state: AzureKeyState::Ready, + vault_resource_id: Some(data.vault_resource_id), + key_name: Some(data.key_name), + lineage_version_id: Some(data.lineage_version_id), + key_id: Some(data.key_id), + _internal_stay_count: None, + }, + ctx, + ) + } +} diff --git a/crates/alien-infra/src/key/gcp.rs b/crates/alien-infra/src/key/gcp.rs new file mode 100644 index 000000000..ff9ae5e5b --- /dev/null +++ b/crates/alien-infra/src/key/gcp.rs @@ -0,0 +1,158 @@ +use std::time::Duration; + +use alien_core::{ + bindings::KeyBinding, + import::{data::GcpKeyImportData, ImportContext}, + GcpCloudKmsKeyHeartbeatData, HeartbeatBackend, Key, KeyFingerprint, KeyHeartbeatData, + KeyHeartbeatStatus, KeyOutputs, ObservedHealth, Platform, ProviderLifecycleState, + ResourceHeartbeat, ResourceHeartbeatData, ResourceOutputs, ResourceStatus, StackResourceState, +}; +use alien_error::{AlienError, Context, IntoAlienError}; +use alien_macros::controller; +use chrono::Utc; + +use crate::{ + core::ResourceControllerContext, + error::{ErrorData, Result}, + import::ResourceImporter, + import_helpers::make_imported_state, +}; + +#[controller] +pub struct GcpKeyController { + pub(crate) crypto_key_name: Option, + pub(crate) primary_version: Option, +} + +#[controller] +impl GcpKeyController { + #[flow_entry(Create)] + #[handler(state = CreateStart, on_failure = CreateFailed, status = ResourceStatus::Provisioning)] + async fn create_start(&mut self, ctx: &ResourceControllerContext<'_>) -> Result { + let key = ctx.desired_resource_config::()?; + Err(AlienError::new(ErrorData::ResourceConfigInvalid { + resource_id: Some(key.id.clone()), + message: "key resources are setup-owned and enter a deployment through stack import" + .to_string(), + })) + } + + #[handler(state = Ready, on_failure = RefreshFailed, status = ResourceStatus::Running)] + async fn ready(&mut self, ctx: &ResourceControllerContext<'_>) -> Result { + let config = ctx.desired_resource_config::()?; + let crypto_key_name = self.crypto_key_name.as_deref().ok_or_else(|| { + AlienError::new(ErrorData::ResourceStateSerializationFailed { + resource_id: config.id.clone(), + message: "Imported GCP key is missing its CryptoKey name".to_string(), + }) + })?; + let key = ctx + .service_provider + .get_gcp_cloud_kms_client(ctx.get_gcp_config()?)? + .get_crypto_key(crypto_key_name) + .await + .context(ErrorData::CloudPlatformError { + message: "Failed to read GCP Cloud KMS key metadata".to_string(), + resource_id: Some(config.id.clone()), + })?; + if key.name != crypto_key_name { + return Err(AlienError::new(ErrorData::ResourceDrift { + resource_id: config.id.clone(), + message: "GCP Cloud KMS returned metadata for a different key".to_string(), + })); + } + let primary_state = key.primary.as_ref().map(|version| version.state.as_str()); + let (health, lifecycle) = match primary_state { + Some("ENABLED") => (ObservedHealth::Healthy, ProviderLifecycleState::Running), + Some("DISABLED") => (ObservedHealth::Unhealthy, ProviderLifecycleState::Stopped), + Some("DESTROY_SCHEDULED") | Some("DESTROYED") => { + (ObservedHealth::Unhealthy, ProviderLifecycleState::Deleting) + } + _ => (ObservedHealth::Degraded, ProviderLifecycleState::Unknown), + }; + self.primary_version = key.primary.as_ref().map(|version| version.name.clone()); + ctx.emit_heartbeat(ResourceHeartbeat { + deployment_id: None, + resource_id: config.id.clone(), + resource_type: Key::RESOURCE_TYPE, + controller_platform: Platform::Gcp, + backend: HeartbeatBackend::Gcp, + observed_at: Utc::now(), + data: ResourceHeartbeatData::Key(KeyHeartbeatData::GcpCloudKms( + GcpCloudKmsKeyHeartbeatData { + status: KeyHeartbeatStatus { + health, + lifecycle, + message: None, + }, + crypto_key_name: key.name, + purpose: key.purpose, + primary_version: key.primary.as_ref().map(|version| version.name.clone()), + primary_state: key.primary.as_ref().map(|version| version.state.clone()), + algorithm: key.primary.map(|version| version.algorithm), + }, + )), + raw: vec![], + }); + Ok(HandlerAction::Continue { + state: Ready, + suggested_delay: Some(Duration::from_secs(300)), + }) + } + + terminal_state!( + state = CreateFailed, + status = ResourceStatus::ProvisionFailed + ); + terminal_state!( + state = RefreshFailed, + status = ResourceStatus::RefreshFailed + ); + terminal_state!(state = Deleted, status = ResourceStatus::Deleted); + + fn build_outputs(&self) -> Option { + Some(ResourceOutputs::new(KeyOutputs { + fingerprint: KeyFingerprint::Gcp { + crypto_key_name: self.crypto_key_name.clone()?, + }, + wrapping_key_id: self.primary_version.clone()?, + })) + } + + fn get_binding_params(&self) -> Result> { + let Some(crypto_key_name) = &self.crypto_key_name else { + return Ok(None); + }; + Ok(Some( + serde_json::to_value(KeyBinding::gcp_cloud_kms(crypto_key_name)) + .into_alien_error() + .context(ErrorData::ResourceStateSerializationFailed { + resource_id: "binding".to_string(), + message: "Failed to serialize Key binding parameters".to_string(), + })?, + )) + } +} + +#[derive(Debug, Default)] +pub struct GcpKeyImporter; + +impl ResourceImporter for GcpKeyImporter { + type ImportData = GcpKeyImportData; + + fn import( + &self, + data: Self::ImportData, + ctx: &ImportContext<'_>, + ) -> alien_core::Result { + make_imported_state( + GcpKeyController { + state: GcpKeyState::Ready, + crypto_key_name: Some(data.crypto_key_name), + primary_version: Some(data.primary_version), + _internal_stay_count: None, + }, + ctx, + ) + } +} diff --git a/crates/alien-infra/src/key/mod.rs b/crates/alien-infra/src/key/mod.rs new file mode 100644 index 000000000..26f457be0 --- /dev/null +++ b/crates/alien-infra/src/key/mod.rs @@ -0,0 +1,7 @@ +mod aws; +mod azure; +mod gcp; + +pub use aws::{AwsKeyController, AwsKeyImporter}; +pub use azure::{AzureKeyController, AzureKeyImporter}; +pub use gcp::{GcpKeyController, GcpKeyImporter}; diff --git a/crates/alien-infra/src/lib.rs b/crates/alien-infra/src/lib.rs index 31f208bd3..e2703515f 100644 --- a/crates/alien-infra/src/lib.rs +++ b/crates/alien-infra/src/lib.rs @@ -79,6 +79,9 @@ pub use kv::AwsKvImporter; pub use kv::LocalKvController; pub use kv::{AwsKvController, AzureKvController, AzureKvImporter, GcpKvController, GcpKvImporter}; +mod key; +pub use key::*; + mod postgres; #[cfg(feature = "local")] pub use postgres::LocalPostgresController; diff --git a/crates/alien-infra/tests/importers.rs b/crates/alien-infra/tests/importers.rs index f1970bbbd..67820e8ed 100644 --- a/crates/alien-infra/tests/importers.rs +++ b/crates/alien-infra/tests/importers.rs @@ -24,14 +24,15 @@ use alien_core::import::{ data::{ - AwsAiImportData, AwsKvImportData, AwsRemoteBindingsImportData, + AwsAiImportData, AwsKeyImportData, AwsKvImportData, AwsRemoteBindingsImportData, AwsRemoteStackManagementImportData, AwsServiceAccountImportData, AwsStorageImportData, - AzureAiImportData, AzureContainerAppsEnvironmentImportData, AzureRemoteBindingsImportData, - AzureRemoteStackManagementImportData, AzureResourceGroupImportData, - AzureServiceAccountImportData, AzureStorageAccountImportData, AzureStorageImportData, - GcpAiImportData, GcpBuildImportData, GcpKvImportData, GcpNetworkImportData, - GcpRemoteBindingsImportData, GcpRemoteStackManagementImportData, - GcpServiceActivationImportData, GcpStorageImportData, KubernetesClusterImportData, + AzureAiImportData, AzureContainerAppsEnvironmentImportData, AzureKeyImportData, + AzureRemoteBindingsImportData, AzureRemoteStackManagementImportData, + AzureResourceGroupImportData, AzureServiceAccountImportData, AzureStorageAccountImportData, + AzureStorageImportData, GcpAiImportData, GcpBuildImportData, GcpKeyImportData, + GcpKvImportData, GcpNetworkImportData, GcpRemoteBindingsImportData, + GcpRemoteStackManagementImportData, GcpServiceActivationImportData, GcpStorageImportData, + KubernetesClusterImportData, }, ImportContext, }; @@ -39,13 +40,13 @@ use alien_core::{ Ai, ArtifactRegistry, AwsManagementConfig, AwsOpenSearch, AwsOpenSearchOutputs, AzureContainerAppsEnvironment, AzureContainerAppsEnvironmentOutputs, AzureManagementConfig, AzureResourceGroup, AzureResourceGroupOutputs, AzureServiceBusNamespace, AzureStorageAccount, - AzureStorageAccountOutputs, Build, Email, EmailInbound, EmailOutputs, GcpManagementConfig, - KubernetesCluster, KubernetesClusterOutputs, KubernetesClusterOwnership, - KubernetesClusterProvider, KubernetesHeartbeatMode, Kv, ManagementConfig, Network, - NetworkSettings, Platform, Queue, RemoteBindings, RemoteBindingsOutputs, RemoteStackManagement, - RemoteStackManagementOutputs, Resource, ResourceDefinition, ResourceEntry, ResourceLifecycle, - ResourceRef, ResourceStatus, ResourceType, ServiceAccount, ServiceActivation, StackSettings, - Storage, Vault, Worker, + AzureStorageAccountOutputs, Build, Email, EmailInbound, EmailOutputs, GcpManagementConfig, Key, + KeyFingerprint, KeyOutputs, KubernetesCluster, KubernetesClusterOutputs, + KubernetesClusterOwnership, KubernetesClusterProvider, KubernetesHeartbeatMode, Kv, + ManagementConfig, Network, NetworkSettings, Platform, Queue, RemoteBindings, + RemoteBindingsOutputs, RemoteStackManagement, RemoteStackManagementOutputs, Resource, + ResourceDefinition, ResourceEntry, ResourceLifecycle, ResourceRef, ResourceStatus, + ResourceType, ServiceAccount, ServiceActivation, StackSettings, Storage, Vault, Worker, }; use alien_infra::{ImporterRegistry, StackResourceStateExt}; use serde_json::json; @@ -987,6 +988,92 @@ fn azure_ai_round_trip() { assert_eq!(outputs.account.as_deref(), Some("myprefix-llm")); } +#[test] +fn key_handoff_preserves_provider_identity_and_remote_binding() { + let cases = [ + ( + Platform::Aws, + serde_json::to_value(AwsKeyImportData { + key_arn: "arn:aws:kms:us-east-1:123456789012:key/11111111-2222-3333-4444-555555555555".to_string(), + }) + .unwrap(), + KeyFingerprint::Aws { + key_arn: "arn:aws:kms:us-east-1:123456789012:key/11111111-2222-3333-4444-555555555555".to_string(), + }, + "arn:aws:kms:us-east-1:123456789012:key/11111111-2222-3333-4444-555555555555", + "kms", + ), + ( + Platform::Gcp, + serde_json::to_value(GcpKeyImportData { + crypto_key_name: "projects/example/locations/us/keyRings/data/cryptoKeys/customer".to_string(), + primary_version: "projects/example/locations/us/keyRings/data/cryptoKeys/customer/cryptoKeyVersions/1".to_string(), + }) + .unwrap(), + KeyFingerprint::Gcp { + crypto_key_name: "projects/example/locations/us/keyRings/data/cryptoKeys/customer".to_string(), + }, + "projects/example/locations/us/keyRings/data/cryptoKeys/customer/cryptoKeyVersions/1", + "cloud-kms", + ), + ( + Platform::Azure, + serde_json::to_value(AzureKeyImportData { + vault_resource_id: "/subscriptions/sub/resourceGroups/rg/providers/Microsoft.KeyVault/vaults/example".to_string(), + key_name: "customer".to_string(), + lineage_version_id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".to_string(), + key_id: "https://example.vault.azure.net/keys/customer/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".to_string(), + }) + .unwrap(), + KeyFingerprint::Azure { + vault_resource_id: "/subscriptions/sub/resourceGroups/rg/providers/Microsoft.KeyVault/vaults/example".to_string(), + key_name: "customer".to_string(), + lineage_version_id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".to_string(), + }, + "https://example.vault.azure.net/keys/customer/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "key-vault-key", + ), + ]; + + for (platform, payload, expected_fingerprint, expected_wrapping_key, expected_service) in cases + { + let entry = remote_entry(Key::new("enterprise-key".to_string()).build()); + let management = match platform { + Platform::Aws => aws_management_config(), + Platform::Gcp => gcp_management_config(), + Platform::Azure => azure_management_config(), + _ => unreachable!(), + }; + let state = run_through_registry( + &Key::RESOURCE_TYPE, + platform, + payload, + &entry, + "test-region", + &management, + ); + + assert_running_with_internal_state(&state); + let outputs = state + .outputs + .as_ref() + .and_then(|outputs| outputs.downcast_ref::()) + .expect("key import must expose typed outputs"); + assert_eq!(outputs.fingerprint, expected_fingerprint); + assert_eq!(outputs.wrapping_key_id, expected_wrapping_key); + assert_eq!( + state.remote_binding_params.as_ref().unwrap()["service"], + expected_service + ); + if platform == Platform::Aws { + assert_eq!( + state.remote_binding_params.as_ref().unwrap()["region"], + "test-region" + ); + } + } +} + #[test] fn registry_built_in_covers_all_oss_pairs() { let registry = ImporterRegistry::built_in(); @@ -995,6 +1082,7 @@ fn registry_built_in_covers_all_oss_pairs() { Ai::RESOURCE_TYPE, Storage::RESOURCE_TYPE, Kv::RESOURCE_TYPE, + Key::RESOURCE_TYPE, Vault::RESOURCE_TYPE, Queue::RESOURCE_TYPE, Network::RESOURCE_TYPE, @@ -1018,6 +1106,7 @@ fn registry_built_in_covers_all_oss_pairs() { Ai::RESOURCE_TYPE, Storage::RESOURCE_TYPE, Kv::RESOURCE_TYPE, + Key::RESOURCE_TYPE, Vault::RESOURCE_TYPE, Queue::RESOURCE_TYPE, Network::RESOURCE_TYPE, @@ -1040,6 +1129,7 @@ fn registry_built_in_covers_all_oss_pairs() { Ai::RESOURCE_TYPE, Storage::RESOURCE_TYPE, Kv::RESOURCE_TYPE, + Key::RESOURCE_TYPE, Vault::RESOURCE_TYPE, Queue::RESOURCE_TYPE, Network::RESOURCE_TYPE, diff --git a/crates/alien-manager/openapi.json b/crates/alien-manager/openapi.json index d8b6bbaac..7d735f28b 100644 --- a/crates/alien-manager/openapi.json +++ b/crates/alien-manager/openapi.json @@ -13910,6 +13910,24 @@ ], "description": "The only AWS credential form remote binding resolution can return." }, + "RemoteAwsKmsKeyBinding": { + "type": "object", + "required": [ + "keyArn" + ], + "properties": { + "keyArn": { + "type": "string" + }, + "region": { + "type": [ + "string", + "null" + ] + } + }, + "additionalProperties": false + }, "RemoteAzureClientConfig": { "type": "object", "description": "Response-safe Azure client configuration containing one storage-audience\naccess token for the stack's Remote Bindings identity.", @@ -13965,6 +13983,18 @@ ], "description": "The only Azure credential form remote binding resolution can return." }, + "RemoteAzureKeyVaultKeyBinding": { + "type": "object", + "required": [ + "keyId" + ], + "properties": { + "keyId": { + "type": "string" + } + }, + "additionalProperties": false + }, "RemoteBlobStorageBinding": { "type": "object", "description": "Concrete Azure Blob Storage topology returned to remote clients.", @@ -14015,6 +14045,18 @@ }, "additionalProperties": false }, + "RemoteGcpCloudKmsKeyBinding": { + "type": "object", + "required": [ + "cryptoKeyName" + ], + "properties": { + "cryptoKeyName": { + "type": "string" + } + }, + "additionalProperties": false + }, "RemoteGcpCredentials": { "oneOf": [ { @@ -14200,7 +14242,7 @@ }, "resourceId": { "type": "string", - "description": "Logical Storage resource id in the deployment's stack state." + "description": "Logical remote-enabled resource id in the deployment's stack state." } }, "additionalProperties": false @@ -14287,6 +14329,87 @@ ] } } + }, + { + "type": "object", + "description": "AWS KMS key and an AWS session.", + "required": [ + "binding", + "clientConfig", + "expiresAt", + "service" + ], + "properties": { + "binding": { + "$ref": "#/components/schemas/RemoteAwsKmsKeyBinding" + }, + "clientConfig": { + "$ref": "#/components/schemas/RemoteAwsClientConfig" + }, + "expiresAt": { + "type": "string" + }, + "service": { + "type": "string", + "enum": [ + "kms" + ] + } + } + }, + { + "type": "object", + "description": "GCP Cloud KMS key and an access token.", + "required": [ + "binding", + "clientConfig", + "expiresAt", + "service" + ], + "properties": { + "binding": { + "$ref": "#/components/schemas/RemoteGcpCloudKmsKeyBinding" + }, + "clientConfig": { + "$ref": "#/components/schemas/RemoteGcpClientConfig" + }, + "expiresAt": { + "type": "string" + }, + "service": { + "type": "string", + "enum": [ + "cloud-kms" + ] + } + } + }, + { + "type": "object", + "description": "Azure Key Vault key and a vault-audience access token.", + "required": [ + "binding", + "clientConfig", + "expiresAt", + "service" + ], + "properties": { + "binding": { + "$ref": "#/components/schemas/RemoteAzureKeyVaultKeyBinding" + }, + "clientConfig": { + "$ref": "#/components/schemas/RemoteAzureClientConfig" + }, + "expiresAt": { + "type": "string" + }, + "service": { + "type": "string", + "enum": [ + "key-vault-key" + ] + } + } } ], "description": "One approved remote Storage binding paired with credentials for the same\nprovider. The discriminant makes cross-provider combinations impossible." diff --git a/crates/alien-manager/src/credential_materialization.rs b/crates/alien-manager/src/credential_materialization.rs index 3796411e1..3243c72f9 100644 --- a/crates/alien-manager/src/credential_materialization.rs +++ b/crates/alien-manager/src/credential_materialization.rs @@ -18,6 +18,7 @@ use crate::traits::RemoteStorageCredentialSource; const GCP_CLOUD_PLATFORM_SCOPE: &str = "https://www.googleapis.com/auth/cloud-platform"; pub(crate) const AZURE_STORAGE_SCOPE: &str = "https://storage.azure.com/.default"; +pub(crate) const AZURE_KEY_VAULT_SCOPE: &str = "https://vault.azure.net/.default"; const REMOTE_STORAGE_DURATION_SECONDS: i32 = 3600; const AZURE_MINT_SCOPES: [&str; 4] = [ "https://management.azure.com/.default", @@ -32,10 +33,13 @@ pub(crate) struct MaterializedCredentialLease { } /// Exact cloud resource requested by remote binding resolution. -pub(crate) enum RemoteStorageCredentialScope { +pub(crate) enum RemoteBindingCredentialScope { AwsS3, + AwsKms, GcpGcs, + GcpCloudKms, AzureBlob, + AzureKeyVault, } impl std::fmt::Debug for MaterializedCredentialLease { @@ -118,12 +122,12 @@ pub(crate) async fn materialize_minted_client_config( /// Materialize the one short-lived credential needed by remote Storage and /// preserve the cloud provider's authoritative expiry. -pub(crate) async fn materialize_remote_storage_lease( +pub(crate) async fn materialize_remote_binding_lease( source: RemoteStorageCredentialSource, - scope: RemoteStorageCredentialScope, + scope: RemoteBindingCredentialScope, ) -> Result> { let RemoteStorageCredentialSource::Direct(config) = source; - if config.platform() != remote_scope_platform(&scope) { + if config.platform() != remote_binding_scope_platform(&scope) { return Err(ErrorData::internal( "Remote Bindings credential provider does not match the resolved resource", )); @@ -151,8 +155,17 @@ pub(crate) async fn materialize_remote_storage_lease( }) } ClientConfig::Azure(config) => { + let azure_scope = match scope { + RemoteBindingCredentialScope::AzureBlob => AZURE_STORAGE_SCOPE, + RemoteBindingCredentialScope::AzureKeyVault => AZURE_KEY_VAULT_SCOPE, + _ => { + return Err(ErrorData::internal( + "Remote Bindings credential scope does not match Azure", + )) + } + }; let token = config - .get_bearer_token_with_scope(AZURE_STORAGE_SCOPE) + .get_bearer_token_with_scope(azure_scope) .await .context(ErrorData::CredentialMaterializationFailed { platform: Platform::Azure, @@ -182,7 +195,7 @@ fn aws_remote_storage_lease( ) -> Result> { let AwsCredentials::SessionCredentials { expires_at, .. } = &config.credentials else { return Err(ErrorData::internal( - "Remote AWS Storage credentials are not a short-lived session", + "Remote Bindings AWS credentials are not a short-lived session", )); }; let expires_at = DateTime::parse_from_rfc3339(expires_at) @@ -202,11 +215,14 @@ fn aws_remote_storage_lease( }) } -fn remote_scope_platform(scope: &RemoteStorageCredentialScope) -> Platform { +fn remote_binding_scope_platform(scope: &RemoteBindingCredentialScope) -> Platform { match scope { - RemoteStorageCredentialScope::AwsS3 => Platform::Aws, - RemoteStorageCredentialScope::GcpGcs => Platform::Gcp, - RemoteStorageCredentialScope::AzureBlob => Platform::Azure, + RemoteBindingCredentialScope::AwsS3 => Platform::Aws, + RemoteBindingCredentialScope::AwsKms => Platform::Aws, + RemoteBindingCredentialScope::GcpGcs => Platform::Gcp, + RemoteBindingCredentialScope::GcpCloudKms => Platform::Gcp, + RemoteBindingCredentialScope::AzureBlob => Platform::Azure, + RemoteBindingCredentialScope::AzureKeyVault => Platform::Azure, } } @@ -226,12 +242,47 @@ mod tests { project_number: None, })); - let error = materialize_remote_storage_lease( + let error = materialize_remote_binding_lease( RemoteStorageCredentialSource::Direct(config), - RemoteStorageCredentialScope::AwsS3, + RemoteBindingCredentialScope::AwsS3, ) .await .expect_err("provider mismatch must fail closed"); assert!(!error.retryable); } + + #[tokio::test] + async fn azure_key_resolution_selects_only_the_key_vault_audience() { + let config = ClientConfig::Azure(Box::new(AzureClientConfig { + subscription_id: "subscription".to_string(), + tenant_id: "tenant".to_string(), + region: Some("eastus".to_string()), + credentials: AzureCredentials::ScopedAccessTokens { + tokens: HashMap::from([ + (AZURE_STORAGE_SCOPE.to_string(), "storage-token".to_string()), + ( + AZURE_KEY_VAULT_SCOPE.to_string(), + "key-vault-token".to_string(), + ), + ]), + }, + service_overrides: None, + })); + + let lease = materialize_remote_binding_lease( + RemoteStorageCredentialSource::Direct(config), + RemoteBindingCredentialScope::AzureKeyVault, + ) + .await + .unwrap(); + let ClientConfig::Azure(config) = lease.client_config else { + panic!("expected Azure client config"); + }; + assert_eq!( + config.credentials, + AzureCredentials::AccessToken { + token: "key-vault-token".to_string(), + } + ); + } } diff --git a/crates/alien-manager/src/providers/impersonation_credentials.rs b/crates/alien-manager/src/providers/impersonation_credentials.rs index fd2d59357..14f070cc8 100644 --- a/crates/alien-manager/src/providers/impersonation_credentials.rs +++ b/crates/alien-manager/src/providers/impersonation_credentials.rs @@ -209,16 +209,14 @@ impl CredentialResolver for ImpersonationCredentialResolver { .and_then(|state| state.outputs.as_ref()) .and_then(|outputs| outputs.downcast_ref::()) .and_then(|outputs| outputs.legacy_remote_bindings_access.as_ref()); - let outputs = first_class_outputs - .or(legacy_outputs) - .ok_or_else(|| { - AlienError::new(GenericError { - message: format!( - "Remote Bindings identity state is required for deployment {}; rerun setup", - deployment.id - ), - }) - })?; + let outputs = first_class_outputs.or(legacy_outputs).ok_or_else(|| { + AlienError::new(GenericError { + message: format!( + "Remote Bindings identity state is required for deployment {}; rerun setup", + deployment.id + ), + }) + })?; let provider = self.provider_for_target(deployment.platform); let base = impersonate_management_sa(&**provider, deployment.platform).await?; diff --git a/crates/alien-manager/src/routes/bindings.rs b/crates/alien-manager/src/routes/bindings.rs index adb3bf2b1..089eba7ee 100644 --- a/crates/alien-manager/src/routes/bindings.rs +++ b/crates/alien-manager/src/routes/bindings.rs @@ -6,8 +6,8 @@ use alien_core::{ AwsClientConfig, AwsCredentials, AzureClientConfig, AzureCredentials, BindingValue, - ClientConfig, DeploymentStatus, GcpClientConfig, GcpCredentials, Platform, ResourceLifecycle, - ResourceStatus, Storage, StorageBinding, + ClientConfig, DeploymentStatus, GcpClientConfig, GcpCredentials, Key, KeyBinding, Platform, + ResourceLifecycle, ResourceStatus, Storage, StorageBinding, }; use alien_error::{Context, ContextError, IntoAlienError}; use axum::{ @@ -22,7 +22,7 @@ use serde::{Deserialize, Serialize}; use super::{auth, current_release_resource, load_current_release, AppState}; use crate::credential_materialization::{ - materialize_remote_storage_lease, MaterializedCredentialLease, RemoteStorageCredentialScope, + materialize_remote_binding_lease, MaterializedCredentialLease, RemoteBindingCredentialScope, }; use crate::error::ErrorData; use crate::traits::{deployment_status_from_record, DeploymentRecord, ReleaseStore}; @@ -38,7 +38,7 @@ const REMOTE_BINDING_REFRESH_HINT_SECONDS: i64 = 3600; pub struct ResolveBindingRequest { /// Deployment containing the remote-enabled resource. pub deployment_id: String, - /// Logical Storage resource id in the deployment's stack state. + /// Logical remote-enabled resource id in the deployment's stack state. pub resource_id: String, } @@ -72,6 +72,55 @@ pub enum ResolveBindingResponse { #[serde(rename = "expiresAt")] expires_at: String, }, + /// AWS KMS key and an AWS session. + #[serde(rename = "kms")] + Kms { + binding: RemoteAwsKmsKeyBinding, + #[serde(rename = "clientConfig")] + client_config: RemoteAwsClientConfig, + #[serde(rename = "expiresAt")] + expires_at: String, + }, + /// GCP Cloud KMS key and an access token. + #[serde(rename = "cloud-kms")] + CloudKms { + binding: RemoteGcpCloudKmsKeyBinding, + #[serde(rename = "clientConfig")] + client_config: RemoteGcpClientConfig, + #[serde(rename = "expiresAt")] + expires_at: String, + }, + /// Azure Key Vault key and a vault-audience access token. + #[serde(rename = "key-vault-key")] + KeyVaultKey { + binding: RemoteAzureKeyVaultKeyBinding, + #[serde(rename = "clientConfig")] + client_config: RemoteAzureClientConfig, + #[serde(rename = "expiresAt")] + expires_at: String, + }, +} + +#[derive(Serialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +pub struct RemoteAwsKmsKeyBinding { + pub key_arn: String, + pub region: Option, +} + +#[derive(Serialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +pub struct RemoteGcpCloudKmsKeyBinding { + pub crypto_key_name: String, +} + +#[derive(Serialize)] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +pub struct RemoteAzureKeyVaultKeyBinding { + pub key_id: String, } /// Concrete S3 topology returned to remote clients. @@ -214,12 +263,42 @@ pub enum RemoteStorageBinding { Gcs(RemoteGcsStorageBinding), } +enum RemoteKeyBinding { + Aws(RemoteAwsKmsKeyBinding), + Gcp(RemoteGcpCloudKmsKeyBinding), + Azure(RemoteAzureKeyVaultKeyBinding), +} + +enum ResolvedRemoteBinding { + Storage(RemoteStorageBinding), + Key(RemoteKeyBinding), +} + +impl ResolvedRemoteBinding { + fn credential_scope(&self) -> RemoteBindingCredentialScope { + match self { + Self::Storage(binding) => binding.credential_scope(), + Self::Key(binding) => binding.credential_scope(), + } + } +} + +impl RemoteKeyBinding { + fn credential_scope(&self) -> RemoteBindingCredentialScope { + match self { + Self::Aws(_) => RemoteBindingCredentialScope::AwsKms, + Self::Gcp(_) => RemoteBindingCredentialScope::GcpCloudKms, + Self::Azure(_) => RemoteBindingCredentialScope::AzureKeyVault, + } + } +} + impl RemoteStorageBinding { - fn credential_scope(&self) -> RemoteStorageCredentialScope { + fn credential_scope(&self) -> RemoteBindingCredentialScope { match self { - Self::S3(_) => RemoteStorageCredentialScope::AwsS3, - Self::Gcs(_) => RemoteStorageCredentialScope::GcpGcs, - Self::Blob(_) => RemoteStorageCredentialScope::AzureBlob, + Self::S3(_) => RemoteBindingCredentialScope::AwsS3, + Self::Gcs(_) => RemoteBindingCredentialScope::GcpGcs, + Self::Blob(_) => RemoteBindingCredentialScope::AzureBlob, } } } @@ -240,7 +319,7 @@ impl TryFrom for RemoteAwsClientConfig { fn try_from(config: AwsClientConfig) -> Result { if config.service_overrides.is_some() { return Err(ErrorData::internal( - "Remote AWS Storage response contains service endpoint overrides", + "Remote Bindings AWS response contains service endpoint overrides", )); } let AwsCredentials::SessionCredentials { @@ -251,7 +330,7 @@ impl TryFrom for RemoteAwsClientConfig { } = config.credentials else { return Err(ErrorData::internal( - "Remote AWS Storage response credentials are not a short-lived session", + "Remote Bindings AWS response credentials are not a short-lived session", )); }; @@ -274,12 +353,12 @@ impl TryFrom for RemoteGcpClientConfig { fn try_from(config: GcpClientConfig) -> Result { if config.service_overrides.is_some() { return Err(ErrorData::internal( - "Remote GCP Storage response contains service endpoint overrides", + "Remote Bindings GCP response contains service endpoint overrides", )); } let GcpCredentials::AccessToken { token } = config.credentials else { return Err(ErrorData::internal( - "Remote GCP Storage response credentials are not a short-lived access token", + "Remote Bindings GCP response credentials are not a short-lived access token", )); }; @@ -298,12 +377,12 @@ impl TryFrom for RemoteAzureClientConfig { fn try_from(config: AzureClientConfig) -> Result { if config.service_overrides.is_some() { return Err(ErrorData::internal( - "Remote Azure Storage response contains service endpoint overrides", + "Remote Bindings Azure response contains service endpoint overrides", )); } let AzureCredentials::AccessToken { token } = config.credentials else { return Err(ErrorData::internal( - "Remote Azure Storage response credentials are not a short-lived access token", + "Remote Bindings Azure response credentials are not a short-lived access token", )); }; @@ -323,7 +402,7 @@ fn concrete_binding_value( match value { BindingValue::Value(value) if !value.is_empty() => Ok(value.clone()), _ => Err(ErrorData::internal(format!( - "Remote Storage binding field '{field}' is not a concrete value" + "Remote binding field '{field}' is not a concrete value" ))), } } @@ -359,6 +438,37 @@ impl ResolveBindingResponse { )), } } + + fn from_key_parts( + binding: RemoteKeyBinding, + lease: MaterializedCredentialLease, + expires_at: String, + ) -> Result> { + match (binding, lease.client_config) { + (RemoteKeyBinding::Aws(binding), ClientConfig::Aws(client_config)) => Ok(Self::Kms { + binding, + client_config: (*client_config).try_into()?, + expires_at, + }), + (RemoteKeyBinding::Gcp(binding), ClientConfig::Gcp(client_config)) => { + Ok(Self::CloudKms { + binding, + client_config: (*client_config).try_into()?, + expires_at, + }) + } + (RemoteKeyBinding::Azure(binding), ClientConfig::Azure(client_config)) => { + Ok(Self::KeyVaultKey { + binding, + client_config: (*client_config).try_into()?, + expires_at, + }) + } + _ => Err(ErrorData::internal( + "Remote Key binding and materialized credential platforms do not match", + )), + } + } } pub fn router() -> Router { @@ -420,21 +530,31 @@ async fn resolve_binding( .into_response(); } - if let Err(error) = require_current_release_remote_access( + let binding_kind = match require_current_release_remote_access( state.release_store.as_ref(), &deployment, &request.resource_id, ) .await { - return error.into_response(); - } + Ok(kind) => kind, + Err(error) => return error.into_response(), + }; - if let Err(error) = require_setup_owned_remote_storage(&deployment, &request.resource_id) { + if let Err(error) = require_setup_owned_remote_binding(&deployment, &request.resource_id) { return error.into_response(); } - let binding = match remote_storage_binding(&deployment, &request.resource_id) { + let binding = match binding_kind { + alien_core::remote_bindings::RemoteBindingKind::Storage => { + remote_storage_binding(&deployment, &request.resource_id) + .map(ResolvedRemoteBinding::Storage) + } + alien_core::remote_bindings::RemoteBindingKind::Key => { + remote_key_binding(&deployment, &request.resource_id).map(ResolvedRemoteBinding::Key) + } + }; + let binding = match binding { Ok(binding) => binding, Err(error) => return error.into_response(), }; @@ -455,7 +575,7 @@ async fn resolve_binding( .into_response() } }; - let lease = match materialize_remote_storage_lease(resolved, scope).await { + let lease = match materialize_remote_binding_lease(resolved, scope).await { Ok(materialized) => materialized, Err(error) => return error.into_response(), }; @@ -466,7 +586,15 @@ async fn resolve_binding( Err(error) => return error.into_response(), }; - let response = match ResolveBindingResponse::from_parts(binding, lease, expires_at.clone()) { + let response = match binding { + ResolvedRemoteBinding::Storage(binding) => { + ResolveBindingResponse::from_parts(binding, lease, expires_at.clone()) + } + ResolvedRemoteBinding::Key(binding) => { + ResolveBindingResponse::from_key_parts(binding, lease, expires_at.clone()) + } + }; + let response = match response { Ok(response) => response, Err(error) => return error.into_response(), }; @@ -477,7 +605,7 @@ async fn resolve_binding( resource_id = %request.resource_id, platform = %deployment.platform, expires_at = %expires_at, - "Issued remote Storage credentials" + "Issued remote binding credentials" ); ( @@ -491,7 +619,7 @@ async fn resolve_binding( /// prove that generated setup created the resource. Remote Bindings v0 must /// therefore reject them even if stale synchronized state contains binding /// parameters from an older manager. -fn require_setup_owned_remote_storage( +fn require_setup_owned_remote_binding( deployment: &DeploymentRecord, resource_id: &str, ) -> Result<(), alien_error::AlienError> { @@ -506,7 +634,7 @@ fn require_setup_owned_remote_storage( .is_some_and(|bindings| bindings.has(resource_id)); if in_deployment_config || in_stack_settings { return Err(ErrorData::bad_request(format!( - "Remote Storage resource '{resource_id}' cannot use an external binding; remote access is limited to resources created by setup" + "Remote resource '{resource_id}' cannot use an external binding; remote access is limited to resources created by setup" ))); } Ok(()) @@ -550,7 +678,7 @@ fn remote_binding_expiry( if expires_at <= now { return Err(ErrorData::internal( - "Remote Storage credential lease is already expired", + "Remote binding credential lease is already expired", )); } @@ -568,7 +696,7 @@ async fn require_current_release_remote_access( release_store: &dyn ReleaseStore, deployment: &DeploymentRecord, resource_id: &str, -) -> Result<(), alien_error::AlienError> { +) -> Result> { let release_id = deployment.current_release_id.as_deref().ok_or_else(|| { ErrorData::bad_request( "Deployment has no current release; remote bindings cannot be resolved", @@ -582,7 +710,8 @@ async fn require_current_release_remote_access( "remote binding resolution", ) .await?; - let (_, resource) = current_release_resource(&release, deployment, release_id, resource_id)?; + let (stack, resource) = + current_release_resource(&release, deployment, release_id, resource_id)?; let definition = alien_core::remote_bindings::remote_binding_definition(&resource.config.resource_type()) @@ -591,23 +720,30 @@ async fn require_current_release_remote_access( "Resource '{resource_id}' does not support Remote Bindings" )) })?; - if definition.kind != alien_core::remote_bindings::RemoteBindingKind::Storage { - return Err(ErrorData::bad_request(format!( - "Resource '{resource_id}' has a Remote Binding kind this endpoint does not support" - ))); - } if resource.lifecycle != ResourceLifecycle::Frozen { return Err(ErrorData::bad_request(format!( - "Storage resource '{resource_id}' is not Frozen in the deployment's current release" + "Remote resource '{resource_id}' is not Frozen in the deployment's current release" ))); } if !resource.remote_access { return Err(ErrorData::bad_request(format!( - "Storage resource '{resource_id}' is not enabled for remote access in the deployment's current release" + "Resource '{resource_id}' is not enabled for remote access in the deployment's current release" ))); } + if definition.kind == alien_core::remote_bindings::RemoteBindingKind::Key + && stack + .resources + .values() + .filter(|entry| entry.remote_access) + .count() + != 1 + { + return Err(ErrorData::bad_request( + "A remotely published Key must be the deployment's only remoteAccess resource", + )); + } - Ok(()) + Ok(definition.kind) } fn remote_storage_binding( @@ -687,6 +823,84 @@ fn remote_storage_binding( } } +fn remote_key_binding( + deployment: &DeploymentRecord, + resource_id: &str, +) -> Result> { + if !matches!( + deployment.platform, + Platform::Aws | Platform::Gcp | Platform::Azure + ) { + return Err(ErrorData::bad_request(format!( + "Remote Key is not supported for deployment platform '{}'", + deployment.platform + ))); + } + let stack_state = deployment.stack_state.as_ref().ok_or_else(|| { + ErrorData::bad_request("Deployment has no stack state (not yet provisioned)") + })?; + let resource = stack_state.resource(resource_id).ok_or_else(|| { + ErrorData::bad_request(format!( + "Resource '{resource_id}' does not exist in stack state" + )) + })?; + if resource.resource_type != Key::RESOURCE_TYPE.as_ref() { + return Err(ErrorData::bad_request(format!( + "Resource '{resource_id}' is not a key" + ))); + } + if resource.lifecycle != Some(ResourceLifecycle::Frozen) { + return Err(ErrorData::bad_request(format!( + "Key resource '{resource_id}' is not Frozen" + ))); + } + if resource.status != ResourceStatus::Running { + return Err(ErrorData::bad_request(format!( + "Key resource '{resource_id}' is not running" + ))); + } + let binding = resource.remote_binding_params.clone().ok_or_else(|| { + ErrorData::bad_request(format!( + "Key resource '{resource_id}' is not enabled for remote access" + )) + })?; + let binding: KeyBinding = + serde_json::from_value(binding) + .into_alien_error() + .context(ErrorData::BadRequest { + reason: format!("Key resource '{resource_id}' has an invalid remote binding"), + })?; + match (deployment.platform, binding) { + (Platform::Aws, KeyBinding::AwsKms(binding)) => { + Ok(RemoteKeyBinding::Aws(RemoteAwsKmsKeyBinding { + key_arn: concrete_binding_value(&binding.key_arn, "AWS KMS keyArn")?, + region: binding + .region + .as_ref() + .map(|region| concrete_binding_value(region, "AWS KMS region")) + .transpose()?, + })) + } + (Platform::Gcp, KeyBinding::GcpCloudKms(binding)) => { + Ok(RemoteKeyBinding::Gcp(RemoteGcpCloudKmsKeyBinding { + crypto_key_name: concrete_binding_value( + &binding.crypto_key_name, + "GCP Cloud KMS cryptoKeyName", + )?, + })) + } + (Platform::Azure, KeyBinding::AzureKeyVault(binding)) => { + Ok(RemoteKeyBinding::Azure(RemoteAzureKeyVaultKeyBinding { + key_id: concrete_binding_value(&binding.key_id, "Azure Key Vault keyId")?, + })) + } + _ => Err(ErrorData::bad_request(format!( + "Key resource '{resource_id}' binding does not match deployment platform '{}'", + deployment.platform + ))), + } +} + #[cfg(test)] #[path = "bindings/tests.rs"] mod tests; diff --git a/crates/alien-manager/src/routes/bindings/tests.rs b/crates/alien-manager/src/routes/bindings/tests.rs index 942fcd218..7748ed811 100644 --- a/crates/alien-manager/src/routes/bindings/tests.rs +++ b/crates/alien-manager/src/routes/bindings/tests.rs @@ -73,6 +73,7 @@ fn stack_state_with_resource( versioning: false, lifecycle_rules: Vec::new(), cors_allowed_origins: Vec::new(), + encryption_key: None, })) .maybe_lifecycle(lifecycle) .maybe_remote_binding_params(remote_binding_params) @@ -130,6 +131,7 @@ fn storage() -> Storage { versioning: false, lifecycle_rules: Vec::new(), cors_allowed_origins: Vec::new(), + encryption_key: None, } } @@ -196,13 +198,44 @@ fn external_storage_binding_is_rejected_even_with_synchronized_params() { ..StackSettings::default() }); - let error = require_setup_owned_remote_storage(&deployment, "files") + let error = require_setup_owned_remote_binding(&deployment, "files") .expect_err("existing buckets are outside the Remote Bindings v0 contract"); assert_eq!(error.code, "BAD_REQUEST"); assert!(error.message.contains("cannot use an external binding")); assert!(error.message.contains("created by setup")); } +#[test] +fn remote_key_validation_returns_only_concrete_provider_topology() { + let cases = [ + ( + Platform::Aws, + KeyBinding::aws_kms("arn:aws:kms:us-east-1:123:key/abc", Some("us-east-1")), + ), + ( + Platform::Gcp, + KeyBinding::gcp_cloud_kms( + "projects/example/locations/us/keyRings/data/cryptoKeys/customer", + ), + ), + ( + Platform::Azure, + KeyBinding::azure_key_vault("https://example.vault.azure.net/keys/customer/version"), + ), + ]; + + for (platform, binding) in cases { + let mut state = stack_state_with_resource( + Key::RESOURCE_TYPE.as_ref(), + Some(ResourceLifecycle::Frozen), + ResourceStatus::Running, + Some(serde_json::to_value(binding).unwrap()), + ); + state.platform = platform; + assert!(remote_key_binding(&deployment_on_platform(state, platform), "files").is_ok()); + } +} + #[tokio::test] async fn remote_access_uses_the_current_release_not_the_desired_release() { let mut deployment = deployment(stack_state_with_resource( @@ -231,6 +264,32 @@ async fn remote_access_uses_the_current_release_not_the_desired_release() { .expect("the current release explicitly enables remote access"); } +#[tokio::test] +async fn key_resolution_rechecks_that_no_sibling_is_remotely_published() { + let stack = Stack::new("stack".to_string()) + .add_with_remote_access( + Key { + id: "customer-key".to_string(), + }, + ResourceLifecycle::Frozen, + ) + .add_with_remote_access(storage(), ResourceLifecycle::Frozen) + .build(); + let mut deployment = deployment(StackState::new(Platform::Aws)); + deployment.current_release_id = Some("current".to_string()); + let store = StubReleaseStore { + releases: HashMap::from([( + "current".to_string(), + release("current", Platform::Aws, stack), + )]), + }; + + let error = require_current_release_remote_access(&store, &deployment, "customer-key") + .await + .expect_err("resolver must repeat the one-remote-resource rule"); + assert!(error.message.contains("only remoteAccess resource")); +} + #[tokio::test] async fn legacy_binding_params_cannot_bypass_a_disabled_current_release() { let mut deployment = deployment(stack_state_with_resource( diff --git a/crates/alien-manager/tests/credentials_mint.rs b/crates/alien-manager/tests/credentials_mint.rs index b8f4c543b..7fe6362d8 100644 --- a/crates/alien-manager/tests/credentials_mint.rs +++ b/crates/alien-manager/tests/credentials_mint.rs @@ -529,6 +529,7 @@ fn mint_test_stack(platform: Platform) -> Stack { versioning: false, lifecycle_rules: Vec::new(), cors_allowed_origins: Vec::new(), + encryption_key: None, }, ResourceLifecycle::Frozen, ) diff --git a/crates/alien-manager/tests/credentials_mint/bindings_resolve.rs b/crates/alien-manager/tests/credentials_mint/bindings_resolve.rs index 8ec246b5d..502b2e3b4 100644 --- a/crates/alien-manager/tests/credentials_mint/bindings_resolve.rs +++ b/crates/alien-manager/tests/credentials_mint/bindings_resolve.rs @@ -36,6 +36,7 @@ async fn persist_remote_storage_state(fixture: &Fixture) { versioning: false, lifecycle_rules: Vec::new(), cors_allowed_origins: Vec::new(), + encryption_key: None, })) .maybe_lifecycle(Some(ResourceLifecycle::Frozen)) .maybe_remote_binding_params(Some(serde_json::json!({ diff --git a/crates/alien-permissions/permission-sets/key/management.jsonc b/crates/alien-permissions/permission-sets/key/management.jsonc new file mode 100644 index 000000000..45f122eb3 --- /dev/null +++ b/crates/alien-permissions/permission-sets/key/management.jsonc @@ -0,0 +1,48 @@ +{ + "id": "key/management", + "description": "Allows the Manager to read key metadata for heartbeat and drift detection", + "platforms": { + "aws": [ + { + "label": "read-key-metadata", + "description": "Read the selected KMS key's state and immutable metadata.", + "grant": { + "actions": ["kms:DescribeKey"] + }, + "binding": { + "resource": { + "resources": ["${resourceName}"] + } + } + } + ], + "gcp": [ + { + "label": "read-key-metadata", + "description": "Read the selected Cloud KMS key and version metadata.", + "grant": { + "predefinedRoles": ["roles/cloudkms.viewer"] + }, + "binding": { + "resource": { + "scope": "${resourceName}" + } + } + } + ], + "azure": [ + { + "label": "read-key-metadata", + "description": "Read the selected Key Vault key's properties and public metadata.", + "grant": { + "predefinedRoles": ["Key Vault Reader"] + }, + "binding": { + "resource": { + "scope": "${resourceName}" + } + } + } + ] + } +} diff --git a/crates/alien-permissions/permission-sets/key/native-storage.jsonc b/crates/alien-permissions/permission-sets/key/native-storage.jsonc new file mode 100644 index 000000000..00a5184d7 --- /dev/null +++ b/crates/alien-permissions/permission-sets/key/native-storage.jsonc @@ -0,0 +1,20 @@ +{ + "id": "key/native-storage", + "description": "Allows an application using native storage encryption to use the selected key", + "platforms": { + "aws": [ + { + "label": "use-for-storage", + "description": "Generate storage data keys and decrypt encrypted storage objects.", + "grant": { + "actions": ["kms:GenerateDataKey", "kms:Decrypt"] + }, + "binding": { + "resource": { + "resources": ["${resourceName}"] + } + } + } + ] + } +} diff --git a/crates/alien-permissions/permission-sets/key/remote-cryptography.jsonc b/crates/alien-permissions/permission-sets/key/remote-cryptography.jsonc new file mode 100644 index 000000000..0835f8ad6 --- /dev/null +++ b/crates/alien-permissions/permission-sets/key/remote-cryptography.jsonc @@ -0,0 +1,51 @@ +{ + "id": "key/remote-cryptography", + "description": "Allows encryption and decryption with one customer-managed key", + "platforms": { + "aws": [ + { + "label": "encrypt-and-decrypt", + "description": "Encrypt and decrypt with the selected AWS KMS key.", + "grant": { + "actions": ["kms:Encrypt", "kms:Decrypt"] + }, + "binding": { + "resource": { + "resources": ["${resourceName}"] + } + } + } + ], + "gcp": [ + { + "label": "encrypt-and-decrypt", + "description": "Encrypt and decrypt with the selected Cloud KMS key.", + "grant": { + "predefinedRoles": ["roles/cloudkms.cryptoKeyEncrypterDecrypter"] + }, + "binding": { + "resource": { + "scope": "${resourceName}" + } + } + } + ], + "azure": [ + { + "label": "encrypt-and-decrypt", + "description": "Encrypt and decrypt with the selected Azure Key Vault key.", + "grant": { + "dataActions": [ + "Microsoft.KeyVault/vaults/keys/encrypt/action", + "Microsoft.KeyVault/vaults/keys/decrypt/action" + ] + }, + "binding": { + "resource": { + "scope": "${resourceName}" + } + } + } + ] + } +} diff --git a/crates/alien-permissions/src/generators/azure_runtime.rs b/crates/alien-permissions/src/generators/azure_runtime.rs index a15dab1f9..e09a7f223 100644 --- a/crates/alien-permissions/src/generators/azure_runtime.rs +++ b/crates/alien-permissions/src/generators/azure_runtime.rs @@ -584,6 +584,7 @@ pub fn azure_predefined_role_id(role_name: &str) -> Option<&'static str> { "Azure Service Bus Data Sender" => Some("69a216fc-b8fb-44d8-bc22-1f3c2cd27a39"), "Cognitive Services OpenAI User" => Some("5e0bd9bd-7b93-4f28-af87-19fc36ad61bd"), "Key Vault Contributor" => Some("f25e0fa2-a7c8-4377-a976-54943a77a395"), + "Key Vault Reader" => Some("21090545-7ca7-4776-b22c-e363652d74d2"), "Key Vault Secrets User" => Some("4633458b-17de-408a-b874-0445c86b69e6"), "Managed Identity Contributor" => Some("e40ec5ca-96e0-45a2-b4ff-59039f2c2b59"), "Network Contributor" => Some("4d97b98b-1d4f-4787-a291-c67834d212e7"), diff --git a/crates/alien-permissions/tests/registry_tests.rs b/crates/alien-permissions/tests/registry_tests.rs index 9870c83a4..6f1b5a0ac 100644 --- a/crates/alien-permissions/tests/registry_tests.rs +++ b/crates/alien-permissions/tests/registry_tests.rs @@ -186,6 +186,16 @@ fn test_openai_user_role_id_resolves() { ); } +#[test] +fn test_key_vault_reader_role_id_resolves() { + use alien_permissions::generators::azure_runtime::azure_predefined_role_id; + assert_eq!( + azure_predefined_role_id("Key Vault Reader"), + Some("21090545-7ca7-4776-b22c-e363652d74d2"), + "the metadata-only Key Vault Reader role GUID must be registered" + ); +} + #[test] fn test_ai_permission_sets_have_all_platforms() { for id in ["ai/provision", "ai/management", "ai/heartbeat", "ai/invoke"] { diff --git a/crates/alien-preflights/src/compile_time/allowed_user_resources.rs b/crates/alien-preflights/src/compile_time/allowed_user_resources.rs index 8e6dbef10..291f21954 100644 --- a/crates/alien-preflights/src/compile_time/allowed_user_resources.rs +++ b/crates/alien-preflights/src/compile_time/allowed_user_resources.rs @@ -32,6 +32,7 @@ impl CompileTimeCheck for AllowedUserResourcesCheck { "queue", "kv", "vault", + "key", "container", "service-account", // Customer-declarable to express pool/capacity-group config @@ -82,6 +83,7 @@ mod tests { let email = alien_core::Email::new("test-email".to_string()).build(); let search = alien_core::AwsOpenSearch::new("test-search".to_string()).build(); let storage = Storage::new("test-storage".to_string()).build(); + let key = alien_core::Key::new("test-key".to_string()).build(); let worker = Worker::new("test-worker".to_string()) .code(WorkerCode::Image { image: "test:latest".to_string(), @@ -90,6 +92,16 @@ mod tests { .build(); let mut resources = IndexMap::new(); + resources.insert( + "test-key".to_string(), + ResourceEntry { + config: alien_core::Resource::new(key), + lifecycle: ResourceLifecycle::Frozen, + dependencies: Vec::new(), + remote_access: true, + enabled_when: None, + }, + ); resources.insert( "test-storage".to_string(), ResourceEntry { diff --git a/crates/alien-preflights/src/compile_time/frozen_resource_lifecycle.rs b/crates/alien-preflights/src/compile_time/frozen_resource_lifecycle.rs index f33c5ef27..07b0bfb07 100644 --- a/crates/alien-preflights/src/compile_time/frozen_resource_lifecycle.rs +++ b/crates/alien-preflights/src/compile_time/frozen_resource_lifecycle.rs @@ -1,6 +1,6 @@ use crate::error::Result; use crate::{CheckResult, CompileTimeCheck}; -use alien_core::{ownership_policy_for_resource_type, Platform, Stack}; +use alien_core::{ownership_policy_for_resource_type, Platform, ResourceLifecycle, Stack, Storage}; /// Ensures each resource uses a lifecycle allowed by the ownership policy. /// @@ -18,8 +18,28 @@ impl CompileTimeCheck for FrozenResourceLifecycleCheck { stack.resources().next().is_some() } - async fn check(&self, stack: &Stack, _platform: Platform) -> Result { + async fn check(&self, stack: &Stack, platform: Platform) -> Result { let mut errors = Vec::new(); + let encrypted_azure_storage_count = stack + .resources() + .filter_map(|(_, entry)| entry.config.downcast_ref::()) + .filter(|storage| storage.encryption_key.is_some()) + .count(); + let azure_storage_count = stack + .resources() + .filter(|(_, entry)| entry.config.downcast_ref::().is_some()) + .count(); + + if platform == Platform::Azure + && encrypted_azure_storage_count > 0 + && (encrypted_azure_storage_count != 1 || azure_storage_count != 1) + { + errors.push( + "Azure Storage customer-managed encryption is account-wide; a stack using \ + Storage.encryptionKey() must contain exactly one Storage resource" + .to_string(), + ); + } for (resource_id, resource_entry) in stack.resources() { let resource_type_value = resource_entry.config.resource_type(); @@ -35,6 +55,34 @@ impl CompileTimeCheck for FrozenResourceLifecycleCheck { policy.allowed_lifecycles() )); } + + let Some(storage) = resource_entry.config.downcast_ref::() else { + continue; + }; + let Some(key_ref) = &storage.encryption_key else { + continue; + }; + if !matches!(platform, Platform::Aws | Platform::Gcp | Platform::Azure) { + errors.push(format!( + "Storage '{}' uses encryptionKey, which is not supported on platform '{}'", + resource_id, + platform.as_str() + )); + } + if resource_entry.lifecycle != ResourceLifecycle::Frozen { + errors.push(format!( + "Storage '{}' uses encryptionKey and must use the Frozen lifecycle", + resource_id + )); + } + if let Some(key_entry) = stack.resources.get(&key_ref.id) { + if key_entry.lifecycle != ResourceLifecycle::Frozen { + errors.push(format!( + "Storage '{}' encryption Key '{}' must use the Frozen lifecycle", + resource_id, key_ref.id + )); + } + } } if errors.is_empty() { @@ -49,8 +97,8 @@ impl CompileTimeCheck for FrozenResourceLifecycleCheck { mod tests { use super::*; use alien_core::{ - ArtifactRegistry, Build, CapacityGroup, ComputeCluster, Container, ContainerCode, - ResourceEntry, ResourceLifecycle, ResourceSpec, Storage, Worker, WorkerCode, + ArtifactRegistry, Build, CapacityGroup, ComputeCluster, Container, ContainerCode, Key, + ResourceEntry, ResourceLifecycle, ResourceRef, ResourceSpec, Storage, Worker, WorkerCode, }; use indexmap::IndexMap; @@ -276,4 +324,99 @@ mod tests { assert!(result.success); } } + + fn stack_with_encrypted_storage(storage_lifecycle: ResourceLifecycle) -> Stack { + let key = Key::new("customer-key".to_string()).build(); + let storage = Storage::new("customer-data".to_string()) + .encryption_key(ResourceRef::new(Key::RESOURCE_TYPE, "customer-key")) + .build(); + let mut resources = IndexMap::new(); + resources.insert( + "customer-key".to_string(), + ResourceEntry { + config: alien_core::Resource::new(key), + lifecycle: ResourceLifecycle::Frozen, + dependencies: Vec::new(), + remote_access: false, + enabled_when: None, + }, + ); + resources.insert( + "customer-data".to_string(), + ResourceEntry { + config: alien_core::Resource::new(storage), + lifecycle: storage_lifecycle, + dependencies: Vec::new(), + remote_access: false, + enabled_when: None, + }, + ); + Stack { + id: "test-stack".to_string(), + resources, + permissions: alien_core::permissions::PermissionsConfig::default(), + supported_platforms: None, + inputs: vec![], + } + } + + #[tokio::test] + async fn encrypted_storage_must_be_frozen() { + let result = FrozenResourceLifecycleCheck + .check( + &stack_with_encrypted_storage(ResourceLifecycle::Live), + Platform::Aws, + ) + .await + .unwrap(); + + assert!(!result.success); + assert!(result + .errors + .iter() + .any(|error| error.contains("uses encryptionKey and must use the Frozen lifecycle"))); + } + + #[tokio::test] + async fn encrypted_storage_rejects_unsupported_platforms() { + let result = FrozenResourceLifecycleCheck + .check( + &stack_with_encrypted_storage(ResourceLifecycle::Frozen), + Platform::Kubernetes, + ) + .await + .unwrap(); + + assert!(!result.success); + assert!(result + .errors + .iter() + .any(|error| error.contains("not supported on platform 'kubernetes'"))); + } + + #[tokio::test] + async fn azure_encrypted_storage_rejects_a_shared_storage_account() { + let mut stack = stack_with_encrypted_storage(ResourceLifecycle::Frozen); + stack.resources.insert( + "other-data".to_string(), + ResourceEntry { + config: alien_core::Resource::new(Storage::new("other-data".to_string()).build()), + lifecycle: ResourceLifecycle::Frozen, + dependencies: Vec::new(), + remote_access: false, + enabled_when: None, + }, + ); + + let result = FrozenResourceLifecycleCheck + .check(&stack, Platform::Azure) + .await + .unwrap(); + + assert!(!result.success); + assert!(result + .errors + .iter() + .any(|error| error.contains("must contain exactly one Storage resource"))); + } } diff --git a/crates/alien-preflights/src/mutations/management_permission_profile.rs b/crates/alien-preflights/src/mutations/management_permission_profile.rs index fd8b58a73..08864863b 100644 --- a/crates/alien-preflights/src/mutations/management_permission_profile.rs +++ b/crates/alien-preflights/src/mutations/management_permission_profile.rs @@ -147,7 +147,18 @@ fn generate_auto_management_profile( permission_set_ids.insert(format!("{}/provision", permission_resource_type)); } ResourceLifecycle::Frozen if policy.requires_management_permissions() => { - permission_set_ids.insert(format!("{}/management", permission_resource_type)); + let permission = format!("{}/management", permission_resource_type); + if resource_type == "key" { + // Key metadata access must name the exact customer key. + // The Key emitter binds this permission after setup knows + // the provider resource identifier. + resource_permission_set_ids + .entry(resource_id.clone()) + .or_default() + .insert(permission); + } else { + permission_set_ids.insert(permission); + } } ResourceLifecycle::Frozen => { // Frozen resources are setup-owned by default. Heartbeat, diff --git a/crates/alien-preflights/src/mutations/remote_bindings.rs b/crates/alien-preflights/src/mutations/remote_bindings.rs index 80cc7c215..a9a1e5401 100644 --- a/crates/alien-preflights/src/mutations/remote_bindings.rs +++ b/crates/alien-preflights/src/mutations/remote_bindings.rs @@ -2,7 +2,7 @@ use crate::{error::ErrorData, error::Result, StackMutation}; use alien_core::{ - DeploymentConfig, Platform, RemoteBindingGrant, RemoteBindings, ResourceEntry, + DeploymentConfig, Key, Platform, RemoteBindingGrant, RemoteBindings, ResourceEntry, ResourceLifecycle, Stack, StackState, }; use alien_error::AlienError; @@ -44,6 +44,8 @@ impl StackMutation for RemoteBindingsMutation { _stack_state: &StackState, _config: &DeploymentConfig, ) -> Result { + validate_remote_key_is_the_only_published_resource(&stack, self.description())?; + if let Some(existing) = stack.resources.get(REMOTE_BINDINGS_ID) { return Err(AlienError::new(ErrorData::StackMutationFailed { mutation_name: self.description().to_string(), @@ -87,11 +89,41 @@ impl StackMutation for RemoteBindingsMutation { } } +fn validate_remote_key_is_the_only_published_resource( + stack: &Stack, + mutation_name: &str, +) -> Result<()> { + let remote_resources = stack + .resources + .iter() + .filter(|(_, entry)| entry.has_remote_bindings()) + .collect::>(); + let remote_keys = remote_resources + .iter() + .filter(|(_, entry)| entry.config.resource_type() == Key::RESOURCE_TYPE) + .count(); + + if remote_keys == 0 || (remote_keys == 1 && remote_resources.len() == 1) { + return Ok(()); + } + + Err(AlienError::new(ErrorData::StackMutationFailed { + mutation_name: mutation_name.to_string(), + message: "a remotely published Key must be the deployment's only remoteAccess resource" + .to_string(), + resource_id: remote_resources + .iter() + .find(|(_, entry)| entry.config.resource_type() == Key::RESOURCE_TYPE) + .map(|(id, _)| (*id).clone()), + })) +} + #[cfg(test)] mod tests { use super::*; use alien_core::{ - EnvironmentVariablesSnapshot, ExternalBindings, ManagementConfig, StackSettings, Storage, + EnvironmentVariablesSnapshot, ExternalBindings, Key, ManagementConfig, StackSettings, + Storage, }; fn config() -> DeploymentConfig { @@ -195,4 +227,56 @@ mod tests { &config() )); } + + #[tokio::test] + async fn remote_key_must_be_the_only_published_resource() { + let stack = Stack::new("application".to_string()) + .add_with_remote_access( + Key::new("customer-key".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .add_with_remote_access( + Storage::new("exports".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .build(); + let state = StackState::new(Platform::Test); + + let error = RemoteBindingsMutation + .mutate(stack, &state, &config()) + .await + .expect_err("a remote Key must reject another remotely published resource"); + + assert_eq!(error.code, "STACK_MUTATION_FAILED"); + assert!(error.to_string().contains("only remoteAccess resource")); + } + + #[tokio::test] + async fn remote_key_allows_non_remote_application_resources() { + let stack = Stack::new("application".to_string()) + .add_with_remote_access( + Key::new("customer-key".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .add( + Storage::new("internal".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .build(); + let state = StackState::new(Platform::Test); + + let mutated = RemoteBindingsMutation + .mutate(stack, &state, &config()) + .await + .expect("non-remote application resources are allowed beside a remote Key"); + let bindings = mutated + .resources + .get(REMOTE_BINDINGS_ID) + .and_then(|entry| entry.config.downcast_ref::()) + .expect("Remote Bindings config"); + + assert_eq!(bindings.grants.len(), 1); + assert_eq!(bindings.grants[0].resource_id, "customer-key"); + assert_eq!(bindings.grants[0].permission_set, "key/remote-cryptography"); + } } diff --git a/crates/alien-terraform/src/built_ins.rs b/crates/alien-terraform/src/built_ins.rs index 50e4e3a66..d4e8577c2 100644 --- a/crates/alien-terraform/src/built_ins.rs +++ b/crates/alien-terraform/src/built_ins.rs @@ -6,9 +6,9 @@ use crate::registry::TfRegistry; use alien_core::{ Ai, ArtifactRegistry, AzureContainerAppsEnvironment, AzureResourceGroup, - AzureServiceBusNamespace, AzureStorageAccount, Build, KubernetesCluster, Kv, Network, Platform, - Queue, RemoteBindings, RemoteStackManagement, ServiceAccount, ServiceActivation, Storage, - Vault, Worker, + AzureServiceBusNamespace, AzureStorageAccount, Build, Key, KubernetesCluster, Kv, Network, + Platform, Queue, RemoteBindings, RemoteStackManagement, ServiceAccount, ServiceActivation, + Storage, Vault, Worker, }; pub(crate) fn register_all(registry: &mut TfRegistry) { @@ -22,6 +22,7 @@ fn register_aws(registry: &mut TfRegistry) { let p = Platform::Aws; registry.register(Ai::RESOURCE_TYPE, p, aws::AwsAiEmitter); registry.register(Storage::RESOURCE_TYPE, p, aws::AwsStorageEmitter); + registry.register(Key::RESOURCE_TYPE, p, aws::AwsKeyEmitter); registry.register(Kv::RESOURCE_TYPE, p, aws::AwsKvEmitter); registry.register(Queue::RESOURCE_TYPE, p, aws::AwsQueueEmitter); registry.register(Vault::RESOURCE_TYPE, p, aws::AwsVaultEmitter); @@ -60,6 +61,7 @@ fn register_gcp(registry: &mut TfRegistry) { let p = Platform::Gcp; registry.register(Ai::RESOURCE_TYPE, p, gcp::GcpAiEmitter); registry.register(Storage::RESOURCE_TYPE, p, gcp::GcpStorageEmitter); + registry.register(Key::RESOURCE_TYPE, p, gcp::GcpKeyEmitter); registry.register(Kv::RESOURCE_TYPE, p, gcp::GcpKvEmitter); registry.register(Queue::RESOURCE_TYPE, p, gcp::GcpQueueEmitter); registry.register(Vault::RESOURCE_TYPE, p, gcp::GcpVaultEmitter); @@ -105,6 +107,7 @@ fn register_azure(registry: &mut TfRegistry) { // Main resources — one emitter per Alien resource type. registry.register(Ai::RESOURCE_TYPE, p, azure::AzureAiEmitter); registry.register(Storage::RESOURCE_TYPE, p, azure::AzureStorageEmitter); + registry.register(Key::RESOURCE_TYPE, p, azure::AzureKeyEmitter); registry.register(Kv::RESOURCE_TYPE, p, azure::AzureKvEmitter); registry.register(Queue::RESOURCE_TYPE, p, azure::AzureQueueEmitter); registry.register(Vault::RESOURCE_TYPE, p, azure::AzureVaultEmitter); diff --git a/crates/alien-terraform/src/emitters/aws/key.rs b/crates/alien-terraform/src/emitters/aws/key.rs new file mode 100644 index 000000000..eb6435da4 --- /dev/null +++ b/crates/alien-terraform/src/emitters/aws/key.rs @@ -0,0 +1,135 @@ +use crate::{ + block::{attr, nested, resource_block}, + emitter::{TfEmitter, TfFragment}, + emitters::aws::helpers::{ + aws_terraform_permission_context, downcast, emit_iam_role_policy_for_target_with_label, + iam_policy_name_sanitize, required_label, tags, + }, + expr, +}; +use alien_core::{ + import::EmitContext, Key, PermissionSetReference, RemoteBindings, RemoteStackManagement, Result, +}; +use alien_permissions::BindingTarget; +use hcl::expr::Expression; + +#[derive(Debug, Clone, Copy, Default)] +pub struct AwsKeyEmitter; + +impl TfEmitter for AwsKeyEmitter { + fn emit(&self, ctx: &EmitContext<'_>) -> Result { + let _ = downcast::(ctx, Key::RESOURCE_TYPE)?; + let label = required_label(ctx)?; + let mut fragment = TfFragment::default().with_resource(resource_block( + "aws_kms_key", + label, + [ + attr( + "description", + Expression::String(format!("Alien encryption key '{}'", ctx.resource_id)), + ), + attr("enable_key_rotation", Expression::Bool(true)), + attr( + "deletion_window_in_days", + Expression::Number(hcl::Number::from(30i64)), + ), + attr("tags", tags(ctx, "key")), + nested(crate::block::block( + "lifecycle", + [attr("prevent_destroy", Expression::Bool(true))], + )), + ], + )); + + if let Some(management_label) = management_label(ctx) { + let permission = PermissionSetReference::from_name("key/management"); + if let Some(permission_set) = + permission.resolve(|name| alien_permissions::get_permission_set(name).cloned()) + { + let context = aws_terraform_permission_context() + .with_resource_name(format!("${{aws_kms_key.{label}.arn}}")); + emit_iam_role_policy_for_target_with_label( + &mut fragment, + management_label, + &permission_set, + &format!("{management_label}_{label}_management"), + &format!("management-{}-key-metadata", ctx.resource_id), + &context, + BindingTarget::Resource, + )?; + } + } + + if let (Some(definition), Some(access_label)) = ( + alien_core::remote_bindings::remote_binding_for_entry(ctx.resource), + remote_bindings_label(ctx), + ) { + let permission = PermissionSetReference::from_name(definition.permission_set); + if let Some(permission_set) = + permission.resolve(|name| alien_permissions::get_permission_set(name).cloned()) + { + let context = aws_terraform_permission_context() + .with_resource_name(format!("${{aws_kms_key.{label}.arn}}")); + emit_iam_role_policy_for_target_with_label( + &mut fragment, + access_label, + &permission_set, + &format!("{access_label}_{label}_remote_cryptography"), + &format!( + "access-{}-{}", + ctx.resource_id, + iam_policy_name_sanitize(&permission_set.id) + ), + &context, + BindingTarget::Resource, + )?; + } + } + + Ok(fragment) + } + + fn emit_import_ref(&self, ctx: &EmitContext<'_>) -> Result { + let label = required_label(ctx)?; + Ok(expr::object([( + "keyArn", + expr::traversal(["aws_kms_key", label, "arn"]), + )])) + } + + fn emit_binding_ref(&self, ctx: &EmitContext<'_>) -> Result> { + let label = required_label(ctx)?; + Ok(Some(expr::object([ + ("service", Expression::String("kms".to_string())), + ("keyArn", expr::traversal(["aws_kms_key", label, "arn"])), + ("region", expr::raw("data.aws_region.current.region")), + ]))) + } +} + +fn remote_bindings_label<'a>(ctx: &'a EmitContext<'_>) -> Option<&'a str> { + ctx.stack.resources().find_map(|(id, entry)| { + (entry.config.resource_type() == RemoteBindings::RESOURCE_TYPE) + .then(|| ctx.name_for(id)) + .flatten() + }) +} + +fn management_label<'a>(ctx: &'a EmitContext<'_>) -> Option<&'a str> { + let has_permission = ctx + .stack + .management() + .profile() + .and_then(|profile| profile.0.get(ctx.resource_id)) + .is_some_and(|refs| { + refs.iter() + .any(|reference| reference.id() == "key/management") + }); + has_permission.then(|| { + ctx.stack.resources().find_map(|(id, entry)| { + (entry.config.resource_type() == RemoteStackManagement::RESOURCE_TYPE) + .then(|| ctx.name_for(id)) + .flatten() + }) + })? +} diff --git a/crates/alien-terraform/src/emitters/aws/mod.rs b/crates/alien-terraform/src/emitters/aws/mod.rs index 5d08d4a7f..4518e91a6 100644 --- a/crates/alien-terraform/src/emitters/aws/mod.rs +++ b/crates/alien-terraform/src/emitters/aws/mod.rs @@ -8,6 +8,7 @@ pub mod ai; pub mod artifact_registry; pub mod build; pub mod helpers; +pub mod key; pub mod kv; pub mod network; pub mod queue; @@ -21,6 +22,7 @@ pub mod worker; pub use ai::AwsAiEmitter; pub use artifact_registry::AwsArtifactRegistryEmitter; pub use build::AwsBuildEmitter; +pub use key::AwsKeyEmitter; pub use kv::AwsKvEmitter; pub use network::AwsNetworkEmitter; pub use queue::AwsQueueEmitter; diff --git a/crates/alien-terraform/src/emitters/aws/storage.rs b/crates/alien-terraform/src/emitters/aws/storage.rs index a40a5095f..96130fc76 100644 --- a/crates/alien-terraform/src/emitters/aws/storage.rs +++ b/crates/alien-terraform/src/emitters/aws/storage.rs @@ -33,7 +33,13 @@ impl TfEmitter for AwsStorageEmitter { let mut fragment = TfFragment::default(); fragment.resource_blocks.push(bucket(label, ctx, storage)); - fragment.resource_blocks.push(encryption(label)); + fragment.resource_blocks.push(encryption( + label, + storage + .encryption_key + .as_ref() + .and_then(|key| ctx.name_for(&key.id)), + )); fragment.resource_blocks.push(ownership_controls(label)); fragment .resource_blocks @@ -49,6 +55,7 @@ impl TfEmitter for AwsStorageEmitter { .push(lifecycle(label, &storage.lifecycle_rules)); } emit_storage_iam(ctx, &mut fragment, label)?; + emit_storage_key_iam(ctx, &mut fragment, storage, label)?; Ok(fragment) } @@ -79,6 +86,39 @@ impl TfEmitter for AwsStorageEmitter { } } +fn emit_storage_key_iam( + ctx: &EmitContext<'_>, + fragment: &mut TfFragment, + storage: &Storage, + storage_label: &str, +) -> Result<()> { + let Some(key_label) = storage + .encryption_key + .as_ref() + .and_then(|key| ctx.name_for(&key.id)) + else { + return Ok(()); + }; + let Some(permission_set) = alien_permissions::get_permission_set("key/native-storage") else { + return Ok(()); + }; + let context = aws_terraform_permission_context() + .with_resource_name(format!("${{aws_kms_key.{key_label}.arn}}")); + + for (owner_label, _) in storage_permission_owners(ctx) { + emit_iam_role_policy_for_target_with_label( + fragment, + &owner_label, + permission_set, + &format!("{storage_label}_{owner_label}_native_encryption"), + &format!("{}-native-encryption", ctx.resource_id), + &context, + BindingTarget::Resource, + )?; + } + Ok(()) +} + fn bucket(label: &str, ctx: &EmitContext<'_>, storage: &Storage) -> Block { resource_block( "aws_s3_bucket", @@ -94,14 +134,25 @@ fn bucket(label: &str, ctx: &EmitContext<'_>, storage: &Storage) -> Block { ) } -fn encryption(label: &str) -> Block { - let inner = block( - "apply_server_side_encryption_by_default", - [attr( - "sse_algorithm", - Expression::String("AES256".to_string()), - )], - ); +fn encryption(label: &str, key_label: Option<&str>) -> Block { + let mut encryption = vec![attr( + "sse_algorithm", + Expression::String( + if key_label.is_some() { + "aws:kms" + } else { + "AES256" + } + .to_string(), + ), + )]; + if let Some(key_label) = key_label { + encryption.push(attr( + "kms_master_key_id", + expr::traversal(["aws_kms_key", key_label, "arn"]), + )); + } + let inner = block("apply_server_side_encryption_by_default", encryption); let rule = block("rule", [nested(inner)]); resource_block( "aws_s3_bucket_server_side_encryption_configuration", diff --git a/crates/alien-terraform/src/emitters/azure/key.rs b/crates/alien-terraform/src/emitters/azure/key.rs new file mode 100644 index 000000000..496f102be --- /dev/null +++ b/crates/alien-terraform/src/emitters/azure/key.rs @@ -0,0 +1,360 @@ +use crate::{ + block::{attr, data_block, nested, resource_block}, + emitter::{TfEmitter, TfFragment}, + emitters::azure::helpers::{ + downcast, emit_remote_bindings_role_definitions, permission_context, + remote_bindings_role_label, required_label, tags, + }, + expr, +}; +use alien_core::{ + import::EmitContext, ErrorData, Key, RemoteBindings, RemoteStackManagement, Result, +}; +use alien_error::{AlienError, Context}; +use alien_permissions::{ + generators::{AzureRoleDefinitionRef, AzureRuntimePermissionsGenerator}, + BindingTarget, +}; +use hcl::expr::Expression; + +#[derive(Debug, Clone, Copy, Default)] +pub struct AzureKeyEmitter; + +impl TfEmitter for AzureKeyEmitter { + fn emit(&self, ctx: &EmitContext<'_>) -> Result { + let _ = downcast::(ctx, Key::RESOURCE_TYPE)?; + let label = required_label(ctx)?; + let client_label = format!("{label}_current"); + let suffix_label = format!("{label}_vault_suffix"); + let mut fragment = TfFragment::default(); + + fragment + .data_blocks + .push(data_block("azurerm_client_config", &client_label, [])); + fragment.resource_blocks.push(resource_block( + "random_id", + &suffix_label, + [attr( + "byte_length", + Expression::Number(hcl::Number::from(3i64)), + )], + )); + fragment.resource_blocks.push(resource_block( + "azurerm_key_vault", + label, + [ + attr( + "name", + expr::raw(format!( + "format(\"%s-%s\", trim(substr(lower(replace(\"${{local.resource_prefix}}-{}\", \"_\", \"-\")), 0, 17), \"-\"), random_id.{suffix_label}.hex)", + ctx.resource_id + )), + ), + attr( + "resource_group_name", + expr::raw("var.azure_resource_group_name"), + ), + attr("location", expr::raw("var.azure_location")), + attr( + "tenant_id", + expr::traversal([ + "data", + "azurerm_client_config", + client_label.as_str(), + "tenant_id", + ]), + ), + attr("sku_name", Expression::String("standard".to_string())), + attr("rbac_authorization_enabled", Expression::Bool(true)), + attr("purge_protection_enabled", Expression::Bool(true)), + attr( + "soft_delete_retention_days", + Expression::Number(hcl::Number::from(90i64)), + ), + attr("public_network_access_enabled", Expression::Bool(true)), + attr("tags", tags(ctx, "key")), + nested(crate::block::block( + "lifecycle", + [attr("prevent_destroy", Expression::Bool(true))], + )), + ], + )); + fragment.resource_blocks.push(resource_block( + "azurerm_key_vault_key", + label, + [ + attr("name", Expression::String("key".to_string())), + attr( + "key_vault_id", + expr::traversal(["azurerm_key_vault", label, "id"]), + ), + attr("key_type", Expression::String("RSA".to_string())), + attr("key_size", Expression::Number(hcl::Number::from(2048i64))), + attr( + "key_opts", + Expression::Array(vec![ + Expression::String("decrypt".to_string()), + Expression::String("encrypt".to_string()), + Expression::String("unwrapKey".to_string()), + Expression::String("wrapKey".to_string()), + ]), + ), + attr( + "depends_on", + Expression::Array(vec![expr::traversal([ + "time_sleep", + &format!("{label}_installer_rbac"), + ])]), + ), + nested(crate::block::block( + "lifecycle", + [attr("prevent_destroy", Expression::Bool(true))], + )), + ], + )); + + let installer_assignment_label = format!("{label}_installer_key_admin"); + fragment.resource_blocks.push(resource_block( + "azurerm_role_assignment", + &installer_assignment_label, + [ + attr( + "name", + expr::raw(format!( + "uuidv5(\"oid\", \"deployment:azure:key-installer:${{local.resource_prefix}}:{label}\")" + )), + ), + attr( + "scope", + expr::traversal(["azurerm_key_vault", label, "id"]), + ), + attr( + "role_definition_id", + expr::template("/subscriptions/${var.azure_subscription_id}/providers/Microsoft.Authorization/roleDefinitions/14b46e9e-c2b7-41b4-b07b-48a6ebf60603".to_string()), + ), + attr( + "principal_id", + expr::traversal([ + "data", + "azurerm_client_config", + client_label.as_str(), + "object_id", + ]), + ), + ], + )); + fragment.resource_blocks.push(resource_block( + "time_sleep", + &format!("{label}_installer_rbac"), + [ + attr("create_duration", Expression::String("60s".to_string())), + attr( + "depends_on", + Expression::Array(vec![expr::traversal([ + "azurerm_role_assignment", + installer_assignment_label.as_str(), + ])]), + ), + ], + )); + + emit_remote_access(ctx, label, &mut fragment)?; + emit_management_access(ctx, label, &mut fragment)?; + Ok(fragment) + } + + fn emit_import_ref(&self, ctx: &EmitContext<'_>) -> Result { + let label = required_label(ctx)?; + Ok(expr::object([ + ( + "vaultResourceId", + expr::traversal(["azurerm_key_vault", label, "id"]), + ), + ( + "keyName", + expr::traversal(["azurerm_key_vault_key", label, "name"]), + ), + ( + "lineageVersionId", + expr::traversal(["azurerm_key_vault_key", label, "version"]), + ), + ( + "keyId", + expr::traversal(["azurerm_key_vault_key", label, "id"]), + ), + ])) + } + + fn emit_binding_ref(&self, ctx: &EmitContext<'_>) -> Result> { + let label = required_label(ctx)?; + Ok(Some(expr::object([ + ("service", Expression::String("key-vault-key".to_string())), + ( + "keyId", + expr::traversal(["azurerm_key_vault_key", label, "id"]), + ), + ]))) + } +} + +fn emit_management_access( + ctx: &EmitContext<'_>, + label: &str, + fragment: &mut TfFragment, +) -> Result<()> { + let Some(management_label) = management_label(ctx) else { + return Ok(()); + }; + let permission_set = + alien_permissions::get_permission_set("key/management").ok_or_else(|| { + AlienError::new(ErrorData::GenericError { + message: "key/management permission set is not registered".to_string(), + }) + })?; + let context = permission_context(label).with_resource_name(format!( + "${{azurerm_key_vault_key.{label}.resource_versionless_id}}" + )); + let plan = AzureRuntimePermissionsGenerator::new() + .generate_grant_plan(permission_set, BindingTarget::Resource, &context) + .context(ErrorData::GenericError { + message: "failed to generate Azure Key management permissions".to_string(), + })?; + + for (index, binding) in plan.bindings.iter().enumerate() { + let AzureRoleDefinitionRef::Predefined { role_definition_id } = &binding.role_definition + else { + return Err(AlienError::new(ErrorData::GenericError { + message: "key/management must use an Azure predefined role".to_string(), + })); + }; + fragment.resource_blocks.push(resource_block( + "azurerm_role_assignment", + &format!("{label}_management_{index}"), + [ + attr( + "name", + expr::raw(format!( + "uuidv5(\"oid\", \"deployment:azure:key-management:${{local.resource_prefix}}:{label}:{index}\")" + )), + ), + attr("scope", expr::template(binding.scope.clone())), + attr( + "role_definition_id", + expr::template(role_definition_id.clone()), + ), + attr( + "principal_id", + expr::traversal([ + "azurerm_user_assigned_identity", + management_label, + "principal_id", + ]), + ), + ], + )); + } + + Ok(()) +} + +fn emit_remote_access(ctx: &EmitContext<'_>, label: &str, fragment: &mut TfFragment) -> Result<()> { + if alien_core::remote_bindings::remote_binding_for_entry(ctx.resource).is_none() { + return Ok(()); + } + let access_label = remote_bindings_label(ctx).ok_or_else(|| { + AlienError::new(ErrorData::GenericError { + message: "remote Key has no Remote Bindings identity".to_string(), + }) + })?; + let permission_set = alien_permissions::get_permission_set("key/remote-cryptography") + .ok_or_else(|| { + AlienError::new(ErrorData::GenericError { + message: "key/remote-cryptography permission set is not registered".to_string(), + }) + })?; + let context = permission_context(label).with_resource_name(format!( + "${{azurerm_key_vault_key.{label}.resource_versionless_id}}" + )); + let plan = AzureRuntimePermissionsGenerator::new() + .generate_grant_plan(permission_set, BindingTarget::Resource, &context) + .context(ErrorData::GenericError { + message: "failed to generate Azure remote Key permissions".to_string(), + })?; + + emit_remote_bindings_role_definitions(fragment, permission_set)?; + for (index, binding) in plan.bindings.iter().enumerate() { + let role_definition_id = match &binding.role_definition { + AzureRoleDefinitionRef::Predefined { role_definition_id } => { + expr::template(role_definition_id.clone()) + } + AzureRoleDefinitionRef::Custom { key } => { + let custom_index = plan + .custom_roles + .iter() + .position(|role| &role.key == key) + .ok_or_else(|| { + AlienError::new(ErrorData::GenericError { + message: format!("missing generated Azure role '{key}'"), + }) + })?; + let role_label = remote_bindings_role_label(&binding.role_name, custom_index); + expr::traversal([ + "azurerm_role_definition", + role_label.as_str(), + "role_definition_resource_id", + ]) + } + }; + fragment.resource_blocks.push(resource_block( + "azurerm_role_assignment", + &format!("{label}_access_{index}"), + [ + attr( + "name", + expr::raw(format!( + "uuidv5(\"oid\", \"deployment:azure:key-access:${{local.resource_prefix}}:{label}:{index}\")" + )), + ), + attr("scope", expr::template(binding.scope.clone())), + attr("role_definition_id", role_definition_id), + attr( + "principal_id", + expr::traversal([ + "azurerm_user_assigned_identity", + access_label, + "principal_id", + ]), + ), + ], + )); + } + + Ok(()) +} + +fn remote_bindings_label<'a>(ctx: &'a EmitContext<'_>) -> Option<&'a str> { + ctx.stack.resources().find_map(|(id, entry)| { + (entry.config.resource_type() == RemoteBindings::RESOURCE_TYPE) + .then(|| ctx.name_for(id)) + .flatten() + }) +} + +fn management_label<'a>(ctx: &'a EmitContext<'_>) -> Option<&'a str> { + let has_permission = ctx + .stack + .management() + .profile() + .and_then(|profile| profile.0.get(ctx.resource_id)) + .is_some_and(|refs| { + refs.iter() + .any(|reference| reference.id() == "key/management") + }); + has_permission.then(|| { + ctx.stack.resources().find_map(|(id, entry)| { + (entry.config.resource_type() == RemoteStackManagement::RESOURCE_TYPE) + .then(|| ctx.name_for(id)) + .flatten() + }) + })? +} diff --git a/crates/alien-terraform/src/emitters/azure/mod.rs b/crates/alien-terraform/src/emitters/azure/mod.rs index e332d42c4..6d71836ce 100644 --- a/crates/alien-terraform/src/emitters/azure/mod.rs +++ b/crates/alien-terraform/src/emitters/azure/mod.rs @@ -16,6 +16,7 @@ pub mod artifact_registry; pub mod build; pub mod container_apps_environment; pub mod helpers; +pub mod key; pub mod kv; pub mod network; pub mod queue; @@ -34,6 +35,7 @@ pub use ai::AzureAiEmitter; pub use artifact_registry::AzureArtifactRegistryEmitter; pub use build::AzureBuildEmitter; pub use container_apps_environment::AzureContainerAppsEnvironmentEmitter; +pub use key::AzureKeyEmitter; pub use kv::AzureKvEmitter; pub use network::AzureNetworkEmitter; pub use queue::AzureQueueEmitter; diff --git a/crates/alien-terraform/src/emitters/azure/storage_account.rs b/crates/alien-terraform/src/emitters/azure/storage_account.rs index 84d9051a3..9bdcc8ff8 100644 --- a/crates/alien-terraform/src/emitters/azure/storage_account.rs +++ b/crates/alien-terraform/src/emitters/azure/storage_account.rs @@ -36,6 +36,7 @@ impl TfEmitter for AzureStorageAccountEmitter { let label = required_label(ctx)?; let versioning_enabled = stack_has_versioned_storage(ctx); + let encryption_key_label = stack_encryption_key_label(ctx); let mut body: Vec = vec![ attr("name", storage_account_name_local()), @@ -64,11 +65,95 @@ impl TfEmitter for AzureStorageAccountEmitter { ], ))); - Ok(TfFragment::default().with_resource(resource_block( - "azurerm_storage_account", - label, - body, - ))) + let mut fragment = TfFragment::default(); + if let Some(key_label) = encryption_key_label { + let identity_label = format!("{label}_encryption"); + let role_label = format!("{label}_encryption_key"); + fragment.resource_blocks.push(resource_block( + "azurerm_user_assigned_identity", + &identity_label, + [ + attr( + "name", + expr::raw("\"${local.resource_prefix}-storage-encryption\""), + ), + attr( + "resource_group_name", + expr::raw("var.azure_resource_group_name"), + ), + attr("location", expr::raw("var.azure_location")), + ], + )); + fragment.resource_blocks.push(resource_block( + "azurerm_role_assignment", + &role_label, + [ + attr( + "scope", + expr::traversal([ + "azurerm_key_vault_key", + key_label, + "resource_versionless_id", + ]), + ), + attr( + "role_definition_name", + Expression::String("Key Vault Crypto Service Encryption User".to_string()), + ), + attr( + "principal_id", + expr::traversal([ + "azurerm_user_assigned_identity", + identity_label.as_str(), + "principal_id", + ]), + ), + ], + )); + body.push(nested(block( + "identity", + [ + attr("type", Expression::String("UserAssigned".to_string())), + attr( + "identity_ids", + Expression::Array(vec![expr::traversal([ + "azurerm_user_assigned_identity", + identity_label.as_str(), + "id", + ])]), + ), + ], + ))); + body.push(nested(block( + "customer_managed_key", + [ + attr( + "key_vault_key_id", + expr::traversal(["azurerm_key_vault_key", key_label, "versionless_id"]), + ), + attr( + "user_assigned_identity_id", + expr::traversal([ + "azurerm_user_assigned_identity", + identity_label.as_str(), + "id", + ]), + ), + ], + ))); + body.push(attr( + "depends_on", + Expression::Array(vec![expr::traversal([ + "azurerm_role_assignment", + role_label.as_str(), + ])]), + )); + } + + fragment + .resource_blocks + .push(resource_block("azurerm_storage_account", label, body)); + Ok(fragment) } fn emit_import_ref(&self, ctx: &EmitContext<'_>) -> Result { @@ -116,3 +201,13 @@ fn stack_has_versioned_storage(ctx: &EmitContext<'_>) -> bool { .unwrap_or(false) }) } + +fn stack_encryption_key_label<'a>(ctx: &'a EmitContext<'_>) -> Option<&'a str> { + ctx.stack.resources().find_map(|(_, entry)| { + entry + .config + .downcast_ref::() + .and_then(|storage| storage.encryption_key.as_ref()) + .and_then(|key| ctx.name_for(&key.id)) + }) +} diff --git a/crates/alien-terraform/src/emitters/gcp/key.rs b/crates/alien-terraform/src/emitters/gcp/key.rs new file mode 100644 index 000000000..84d6518d6 --- /dev/null +++ b/crates/alien-terraform/src/emitters/gcp/key.rs @@ -0,0 +1,189 @@ +use crate::{ + block::{attr, nested, resource_block}, + emitter::{TfEmitter, TfFragment}, + emitters::gcp::helpers::{downcast, labels, required_label, service_account_member_for_label}, + expr, +}; +use alien_core::{ + import::EmitContext, ErrorData, Key, RemoteBindings, RemoteStackManagement, Result, +}; +use alien_error::AlienError; +use hcl::expr::Expression; + +#[derive(Debug, Clone, Copy, Default)] +pub struct GcpKeyEmitter; + +impl TfEmitter for GcpKeyEmitter { + fn emit(&self, ctx: &EmitContext<'_>) -> Result { + let key = downcast::(ctx, Key::RESOURCE_TYPE)?; + let label = required_label(ctx)?; + let ring_label = format!("{label}_ring"); + let ring_suffix_label = format!("{label}_ring_suffix"); + let mut fragment = TfFragment::default() + .with_resource(resource_block( + "random_id", + &ring_suffix_label, + [attr( + "byte_length", + Expression::Number(hcl::Number::from(3i64)), + )], + )) + .with_resource(resource_block( + "google_kms_key_ring", + &ring_label, + [ + attr("project", expr::raw("var.gcp_project")), + attr( + "name", + expr::raw(format!( + "format(\"%s-%s\", trim(substr(replace(lower(format(\"%s-{}\", local.resource_prefix)), \"_\", \"-\"), 0, 56), \"-\"), random_id.{ring_suffix_label}.hex)", + key.id() + )), + ), + attr("location", expr::raw("var.gcp_region")), + ], + )) + .with_resource(resource_block( + "google_kms_crypto_key", + label, + [ + attr("name", Expression::String("key".to_string())), + attr( + "key_ring", + expr::traversal(["google_kms_key_ring", ring_label.as_str(), "id"]), + ), + attr("purpose", Expression::String("ENCRYPT_DECRYPT".to_string())), + attr( + "rotation_period", + Expression::String("7776000s".to_string()), + ), + attr("labels", labels(ctx, "key")), + nested(crate::block::block( + "lifecycle", + [attr("prevent_destroy", Expression::Bool(true))], + )), + ], + )); + + if let Some(access_label) = remote_bindings_label(ctx) { + let role = gcp_remote_role()?; + fragment.resource_blocks.push(resource_block( + "google_kms_crypto_key_iam_member", + &format!("{label}_remote_cryptography"), + [ + attr( + "crypto_key_id", + expr::traversal(["google_kms_crypto_key", label, "id"]), + ), + attr("role", Expression::String(role)), + attr( + "member", + expr::template(format!( + "serviceAccount:${{google_service_account.{access_label}.email}}" + )), + ), + ], + )); + } + + if let Some(management_label) = management_label(ctx) { + fragment.resource_blocks.push(resource_block( + "google_kms_crypto_key_iam_member", + &format!("{label}_management"), + [ + attr( + "crypto_key_id", + expr::traversal(["google_kms_crypto_key", label, "id"]), + ), + attr( + "role", + Expression::String("roles/cloudkms.viewer".to_string()), + ), + attr("member", service_account_member_for_label(management_label)), + ], + )); + } + + Ok(fragment) + } + + fn emit_import_ref(&self, ctx: &EmitContext<'_>) -> Result { + let label = required_label(ctx)?; + Ok(expr::object([ + ( + "cryptoKeyName", + expr::traversal(["google_kms_crypto_key", label, "id"]), + ), + ( + "primaryVersion", + expr::raw(format!("google_kms_crypto_key.{label}.primary[0].name")), + ), + ])) + } + + fn emit_binding_ref(&self, ctx: &EmitContext<'_>) -> Result> { + let label = required_label(ctx)?; + Ok(Some(expr::object([ + ("service", Expression::String("cloud-kms".to_string())), + ( + "cryptoKeyName", + expr::traversal(["google_kms_crypto_key", label, "id"]), + ), + ]))) + } +} + +fn gcp_remote_role() -> Result { + let permission_set = alien_permissions::get_permission_set("key/remote-cryptography") + .ok_or_else(|| { + AlienError::new(ErrorData::GenericError { + message: "key/remote-cryptography permission set is not registered".to_string(), + }) + })?; + let roles = permission_set + .platforms + .gcp + .as_ref() + .and_then(|entries| entries.first()) + .and_then(|entry| entry.grant.predefined_roles.as_ref()) + .ok_or_else(|| { + AlienError::new(ErrorData::GenericError { + message: "key/remote-cryptography has no GCP predefined role".to_string(), + }) + })?; + roles.first().cloned().ok_or_else(|| { + AlienError::new(ErrorData::GenericError { + message: "key/remote-cryptography has an empty GCP role list".to_string(), + }) + }) +} + +fn remote_bindings_label<'a>(ctx: &'a EmitContext<'_>) -> Option<&'a str> { + if alien_core::remote_bindings::remote_binding_for_entry(ctx.resource).is_none() { + return None; + } + ctx.stack.resources().find_map(|(id, entry)| { + (entry.config.resource_type() == RemoteBindings::RESOURCE_TYPE) + .then(|| ctx.name_for(id)) + .flatten() + }) +} + +fn management_label<'a>(ctx: &'a EmitContext<'_>) -> Option<&'a str> { + let has_permission = ctx + .stack + .management() + .profile() + .and_then(|profile| profile.0.get(ctx.resource_id)) + .is_some_and(|refs| { + refs.iter() + .any(|reference| reference.id() == "key/management") + }); + has_permission.then(|| { + ctx.stack.resources().find_map(|(id, entry)| { + (entry.config.resource_type() == RemoteStackManagement::RESOURCE_TYPE) + .then(|| ctx.name_for(id)) + .flatten() + }) + })? +} diff --git a/crates/alien-terraform/src/emitters/gcp/mod.rs b/crates/alien-terraform/src/emitters/gcp/mod.rs index 5668534d7..c5f51d08a 100644 --- a/crates/alien-terraform/src/emitters/gcp/mod.rs +++ b/crates/alien-terraform/src/emitters/gcp/mod.rs @@ -9,6 +9,7 @@ pub mod ai; pub mod artifact_registry; pub mod build; pub mod helpers; +pub mod key; pub mod kv; pub mod network; pub mod queue; @@ -23,6 +24,7 @@ pub mod worker; pub use ai::GcpAiEmitter; pub use artifact_registry::GcpArtifactRegistryEmitter; pub use build::GcpBuildEmitter; +pub use key::GcpKeyEmitter; pub use kv::GcpKvEmitter; pub use network::GcpNetworkEmitter; pub use queue::GcpQueueEmitter; diff --git a/crates/alien-terraform/src/emitters/gcp/storage.rs b/crates/alien-terraform/src/emitters/gcp/storage.rs index e56e69234..b40eaa8ac 100644 --- a/crates/alien-terraform/src/emitters/gcp/storage.rs +++ b/crates/alien-terraform/src/emitters/gcp/storage.rs @@ -6,7 +6,7 @@ //! blocks. use crate::{ - block::{attr, block, nested, resource_block}, + block::{attr, block, data_block, nested, resource_block}, emitter::{TfEmitter, TfFragment}, emitters::gcp::helpers::{ binding_label_for_role, downcast, emit_custom_roles_for_bindings, labels, @@ -37,6 +37,14 @@ impl TfEmitter for GcpStorageEmitter { fragment.resource_blocks.push(bucket(label, ctx, storage)); + if let Some(key_label) = storage + .encryption_key + .as_ref() + .and_then(|key| ctx.name_for(&key.id)) + { + emit_storage_key_access(&mut fragment, label, key_label); + } + if storage.public_read { fragment.resource_blocks.push(public_iam_binding(label)); } @@ -77,6 +85,35 @@ impl TfEmitter for GcpStorageEmitter { } } +fn emit_storage_key_access(fragment: &mut TfFragment, label: &str, key_label: &str) { + let service_agent_label = format!("{label}_service_agent"); + fragment.data_blocks.push(data_block( + "google_storage_project_service_account", + &service_agent_label, + [attr("project", expr::raw("var.gcp_project"))], + )); + fragment.resource_blocks.push(resource_block( + "google_kms_crypto_key_iam_member", + &format!("{label}_storage_encryption"), + [ + attr( + "crypto_key_id", + expr::traversal(["google_kms_crypto_key", key_label, "id"]), + ), + attr( + "role", + Expression::String("roles/cloudkms.cryptoKeyEncrypterDecrypter".to_string()), + ), + attr( + "member", + expr::template(format!( + "serviceAccount:${{data.google_storage_project_service_account.{service_agent_label}.email_address}}" + )), + ), + ], + )); +} + fn bucket(label: &str, ctx: &EmitContext<'_>, storage: &Storage) -> hcl::structure::Block { let mut body: Vec = vec![ attr("name", resource_prefix_template(storage.id())), @@ -106,6 +143,27 @@ fn bucket(label: &str, ctx: &EmitContext<'_>, storage: &Storage) -> hcl::structu ))); } + if let Some(key_label) = storage + .encryption_key + .as_ref() + .and_then(|key| ctx.name_for(&key.id)) + { + body.push(nested(block( + "encryption", + [attr( + "default_kms_key_name", + expr::traversal(["google_kms_crypto_key", key_label, "id"]), + )], + ))); + body.push(attr( + "depends_on", + Expression::Array(vec![expr::traversal([ + "google_kms_crypto_key_iam_member", + &format!("{label}_storage_encryption"), + ])]), + )); + } + for rule in &storage.lifecycle_rules { body.push(nested(lifecycle_rule_block(rule))); } diff --git a/crates/alien-terraform/src/generator.rs b/crates/alien-terraform/src/generator.rs index 14d0bfb65..a795efbec 100644 --- a/crates/alien-terraform/src/generator.rs +++ b/crates/alien-terraform/src/generator.rs @@ -24,7 +24,7 @@ use crate::{ }; use alien_core::{ import::{EmitContext, CURRENT_SETUP_IMPORT_FORMAT_VERSION}, - ownership_policy_for_resource_type, DeploymentModel, ErrorData, HeartbeatsMode, + ownership_policy_for_resource_type, DeploymentModel, ErrorData, HeartbeatsMode, Key, KubernetesCertificateMode, KubernetesExposureSettings, KubernetesSettings, Network, NetworkSettings, RemoteBindings, RemoteStackManagement, ResourceLifecycle, Result, Stack, StackInputDefaultValue, StackInputDefinition, StackInputKind, StackInputProvider, @@ -456,6 +456,10 @@ pub fn generate_terraform_module( if let Some(contents) = remote_bindings_permissions_md(stack, target) { files.insert("PERMISSIONS.md".to_string(), contents); } + let retained_key_detach = retained_key_detach_script(stack, target, &labels); + if let Some(contents) = &retained_key_detach { + files.insert("detach-retained-keys.sh".to_string(), contents.clone()); + } files.insert( "README.md".to_string(), readme_md( @@ -466,6 +470,7 @@ pub fn generate_terraform_module( &stack_settings, options.helm_install.as_ref(), &stack_inputs, + retained_key_detach.is_some(), ), ); @@ -484,6 +489,60 @@ pub fn generate_terraform_module( Ok(module) } +fn retained_key_detach_script( + stack: &Stack, + target: TerraformTarget, + labels: &IndexMap, +) -> Option { + let mut addresses = Vec::new(); + for (resource_id, entry) in stack.resources() { + if entry.config.resource_type() != Key::RESOURCE_TYPE { + continue; + } + let label = labels.get(resource_id)?; + match target.cloud_platform() { + alien_core::Platform::Aws => { + addresses.push(format!("aws_kms_key.{label}")); + } + alien_core::Platform::Gcp => { + addresses.push(format!("google_kms_crypto_key.{label}")); + addresses.push(format!("google_kms_key_ring.{label}_ring")); + } + alien_core::Platform::Azure => { + addresses.push(format!("azurerm_key_vault_key.{label}")); + addresses.push(format!("azurerm_key_vault.{label}")); + } + _ => {} + } + } + if addresses.is_empty() { + return None; + } + + let mut script = String::from( + "#!/bin/sh\nset -eu\n\n\ +if [ \"${ALIEN_CONFIRM_DETACH_RETAINED_KEYS:-}\" != \"yes\" ]; then\n\ + echo \"Set ALIEN_CONFIRM_DETACH_RETAINED_KEYS=yes after removing all key consumers and remote access.\" >&2\n\ + exit 1\n\ +fi\n\n\ +TF_CLI=${TF_CLI:-terraform}\n\ +case \"$TF_CLI\" in\n\ + terraform|tofu) ;;\n\ + *) echo \"TF_CLI must be terraform or tofu\" >&2; exit 1 ;;\n\ +esac\n\n\ +detach_if_present() {\n\ + address=$1\n\ + if \"$TF_CLI\" state list | grep -F -x -q \"$address\"; then\n\ + \"$TF_CLI\" state rm \"$address\"\n\ + fi\n\ +}\n\n", + ); + for address in addresses { + script.push_str(&format!("detach_if_present '{address}'\n")); + } + Some(script) +} + fn remote_bindings_permissions_md(stack: &Stack, target: TerraformTarget) -> Option { let resources = stack .resources() @@ -3031,6 +3090,7 @@ fn readme_md( stack_settings: &StackSettings, helm_install: Option<&TerraformHelmInstall>, stack_inputs: &[StackInputDefinition], + has_retained_keys: bool, ) -> String { let required_env = if registration.is_some() { "export TF_VAR_token=\"...\"".to_string() @@ -3087,6 +3147,11 @@ fn readme_md( .is_kubernetes() .then(|| readme_kubernetes_operations(target)) .unwrap_or_default(); + let retained_key_operations = if has_retained_keys { + "\n\n## Retained encryption keys\n\nEncryption keys are protected from Terraform deletion. Before destroying this setup, remove remote access and every key consumer, wait for active operations to finish, and run:\n\n```bash\nALIEN_CONFIRM_DETACH_RETAINED_KEYS=yes sh ./detach-retained-keys.sh\nterraform destroy\n```\n\nThe script only removes the listed keys and their provider containers from Terraform state; it does not delete them. It is idempotent and also supports OpenTofu with `TF_CLI=tofu`." + } else { + "" + }; let inputs = input_sections.join("\n\n"); format!( "# Deployment setup - {display_name}\n\n\ @@ -3105,13 +3170,14 @@ Use your organization's normal backend and approval workflow. A typical local re - `deployment_resources`: setup-owned resource metadata handed to the deployment runtime.\n\ - `deployment_input_values`: deployer input values JSON, emitted only when the stack declares deployer inputs.\n\ - `deployment_id` and `deployment_token`: emitted only when Terraform performs registration.\ -{kubernetes_operations}", +{kubernetes_operations}{retained_key_operations}", display_name = display_name, target = target.name(), inputs = inputs, required_env = required_env, registration_note = registration_note, - kubernetes_operations = kubernetes_operations + kubernetes_operations = kubernetes_operations, + retained_key_operations = retained_key_operations ) } diff --git a/crates/alien-terraform/tests/generator/aws_data_layer_tests.rs b/crates/alien-terraform/tests/generator/aws_data_layer_tests.rs index 1b9e7d7f6..eb2ed83e0 100644 --- a/crates/alien-terraform/tests/generator/aws_data_layer_tests.rs +++ b/crates/alien-terraform/tests/generator/aws_data_layer_tests.rs @@ -7,11 +7,109 @@ use super::helpers::{assert_terraform_valid, render, snapshot_module}; use alien_core::{ - Ai, Kv, LifecycleRule, PermissionProfile, Queue, RemoteBindings, ResourceLifecycle, + Ai, Key, Kv, LifecycleRule, PermissionProfile, Queue, RemoteBindings, ResourceLifecycle, ResourceRef, ServiceAccount, Stack, StackSettings, Storage, Vault, }; use alien_terraform::TerraformTarget; +#[test] +fn aws_key_package_is_valid_and_retained() { + let mut stack = Stack::new("enterprise-key".to_string()) + .add_with_remote_access( + Key::new("customer-key".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .add( + RemoteBindings::new("access".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .build(); + stack + .resources + .get_mut("customer-key") + .unwrap() + .dependencies = vec![ResourceRef::new(RemoteBindings::RESOURCE_TYPE, "access")]; + + let module = render(&stack, TerraformTarget::Aws, StackSettings::default()); + let rendered = module + .files + .values() + .cloned() + .collect::>() + .join("\n"); + + assert!(rendered.contains("prevent_destroy = true")); + assert!(rendered.contains("\"kms:Encrypt\"")); + assert!(rendered.contains("\"kms:Decrypt\"")); + assert!(rendered.contains("aws_kms_key.customer_key.arn")); + let detach = module + .get("detach-retained-keys.sh") + .expect("retained Key detach operation"); + assert!(detach.contains("detach_if_present 'aws_kms_key.customer_key'")); + assert!(module + .get("README.md") + .unwrap() + .contains("terraform destroy")); + assert_terraform_valid(&module, "aws_key_package"); +} + +#[cfg(unix)] +#[test] +fn retained_key_detach_operation_is_idempotent_and_narrow() { + use std::fs; + use std::os::unix::fs::PermissionsExt; + use std::process::Command; + + let stack = Stack::new("enterprise-key".to_string()) + .add( + Key::new("customer-key".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .build(); + let module = render(&stack, TerraformTarget::Aws, StackSettings::default()); + let temp = tempfile::tempdir().unwrap(); + let detach_path = temp.path().join("detach-retained-keys.sh"); + fs::write(&detach_path, module.get("detach-retained-keys.sh").unwrap()).unwrap(); + fs::write( + temp.path().join("state"), + "aws_kms_key.customer_key\naws_iam_role.unrelated\n", + ) + .unwrap(); + let terraform_path = temp.path().join("terraform"); + fs::write( + &terraform_path, + "#!/bin/sh\nset -eu\nif [ \"$1 $2\" = \"state list\" ]; then cat \"$TEST_STATE\"; exit 0; fi\nif [ \"$1 $2\" = \"state rm\" ]; then\n grep -F -x -v \"$3\" \"$TEST_STATE\" > \"$TEST_STATE.next\"\n mv \"$TEST_STATE.next\" \"$TEST_STATE\"\n echo \"$3\" >> \"$TEST_LOG\"\n exit 0\nfi\nexit 2\n", + ) + .unwrap(); + fs::set_permissions(&terraform_path, fs::Permissions::from_mode(0o755)).unwrap(); + + for _ in 0..2 { + let path = format!( + "{}:{}", + temp.path().display(), + std::env::var("PATH").unwrap_or_default() + ); + let status = Command::new("sh") + .arg(&detach_path) + .env("ALIEN_CONFIRM_DETACH_RETAINED_KEYS", "yes") + .env("PATH", path) + .env("TEST_STATE", temp.path().join("state")) + .env("TEST_LOG", temp.path().join("log")) + .status() + .unwrap(); + assert!(status.success()); + } + + assert_eq!( + fs::read_to_string(temp.path().join("state")).unwrap(), + "aws_iam_role.unrelated\n" + ); + assert_eq!( + fs::read_to_string(temp.path().join("log")).unwrap(), + "aws_kms_key.customer_key\n" + ); +} + #[test] fn aws_storage_minimal_renders_idiomatic_module() { let stack = Stack::new("acme-prod".to_string()) @@ -25,6 +123,43 @@ fn aws_storage_minimal_renders_idiomatic_module() { assert_terraform_valid(&module, "aws_storage_minimal"); } +#[test] +fn aws_storage_uses_customer_managed_key() { + let stack = Stack::new("encrypted-storage".to_string()) + .permissions(alien_core::PermissionsConfig::new().with_profile( + "app", + PermissionProfile::new().resource("data", ["storage/data-write"]), + )) + .add( + Key::new("customer-key".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .add( + Storage::new("data".to_string()) + .encryption_key(ResourceRef::new(Key::RESOURCE_TYPE, "customer-key")) + .build(), + ResourceLifecycle::Frozen, + ) + .add( + ServiceAccount::new("app-sa".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .build(); + let module = render(&stack, TerraformTarget::Aws, StackSettings::default()); + let rendered = module + .files + .values() + .cloned() + .collect::>() + .join("\n"); + + assert!(rendered.contains("sse_algorithm = \"aws:kms\"")); + assert!(rendered.contains("kms_master_key_id = aws_kms_key.customer_key.arn")); + assert!(rendered.contains("kms:GenerateDataKey")); + assert!(rendered.contains("kms:Decrypt")); + assert_terraform_valid(&module, "aws_encrypted_storage"); +} + #[test] fn aws_storage_with_versioning_and_lifecycle() { let stack = Stack::new("acme-audit".to_string()) diff --git a/crates/alien-terraform/tests/generator/azure_data_layer_tests.rs b/crates/alien-terraform/tests/generator/azure_data_layer_tests.rs index b2bcd27e4..c9d70853c 100644 --- a/crates/alien-terraform/tests/generator/azure_data_layer_tests.rs +++ b/crates/alien-terraform/tests/generator/azure_data_layer_tests.rs @@ -13,7 +13,7 @@ use super::helpers::{assert_terraform_valid, render, snapshot_module}; use alien_core::{ - Ai, AzureResourceGroup, AzureServiceBusNamespace, AzureStorageAccount, Kv, LifecycleRule, + Ai, AzureResourceGroup, AzureServiceBusNamespace, AzureStorageAccount, Key, Kv, LifecycleRule, PermissionProfile, Queue, RemoteBindings, ResourceLifecycle, ResourceRef, ServiceAccount, Stack, StackSettings, Storage, Vault, }; @@ -31,6 +31,52 @@ fn service_bus_namespace() -> AzureServiceBusNamespace { AzureServiceBusNamespace::new("default-service-bus-namespace".to_string()).build() } +#[test] +fn azure_key_package_is_valid_and_retained() { + let mut stack = Stack::new("enterprise-key".to_string()) + .add(resource_group(), ResourceLifecycle::Frozen) + .add_with_remote_access( + Key::new("customer-key".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .add( + RemoteBindings::new("access".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .build(); + stack + .resources + .get_mut("customer-key") + .unwrap() + .dependencies = vec![ + ResourceRef::new(AzureResourceGroup::RESOURCE_TYPE, "default-resource-group"), + ResourceRef::new(RemoteBindings::RESOURCE_TYPE, "access"), + ]; + + let module = render(&stack, TerraformTarget::Azure, StackSettings::default()); + let rendered = module + .files + .values() + .cloned() + .collect::>() + .join("\n"); + + assert!(rendered.contains("azurerm_key_vault_key")); + assert!(rendered.matches("prevent_destroy = true").count() >= 2); + assert!(rendered.contains("azurerm_role_assignment\" \"customer_key_installer_key_admin")); + assert!(rendered.contains("14b46e9e-c2b7-41b4-b07b-48a6ebf60603")); + assert!(rendered.contains("time_sleep\" \"customer_key_installer_rbac")); + assert!(rendered.contains("create_duration = \"60s\"")); + assert!(rendered.contains("Microsoft.KeyVault/vaults/keys/encrypt/action")); + assert!(rendered.contains("Microsoft.KeyVault/vaults/keys/decrypt/action")); + let detach = module + .get("detach-retained-keys.sh") + .expect("retained Key detach operation"); + assert!(detach.contains("azurerm_key_vault_key.customer_key")); + assert!(detach.contains("azurerm_key_vault.customer_key")); + assert_terraform_valid(&module, "azure_key_package"); +} + #[test] fn azure_resource_dependencies_emit_depends_on() { let stack = Stack::new("acme-deps".to_string()) @@ -69,6 +115,41 @@ fn azure_storage_minimal_renders_idiomatic_module() { assert_terraform_valid(&module, "azure_storage_minimal"); } +#[test] +fn azure_storage_account_uses_customer_managed_key() { + let stack = Stack::new("encrypted-storage".to_string()) + .add(resource_group(), ResourceLifecycle::Frozen) + .add( + Key::new("customer-key".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .add(storage_account(), ResourceLifecycle::Frozen) + .add( + Storage::new("data".to_string()) + .encryption_key(ResourceRef::new(Key::RESOURCE_TYPE, "customer-key")) + .build(), + ResourceLifecycle::Frozen, + ) + .build(); + let module = render(&stack, TerraformTarget::Azure, StackSettings::default()); + let rendered = module + .files + .values() + .cloned() + .collect::>() + .join("\n"); + + assert!(rendered.contains("customer_managed_key")); + assert!(rendered.contains("key_vault_key_id")); + assert!(rendered.contains(".versionless_id")); + assert!(rendered.contains("scope")); + assert!(rendered.contains(".resource_versionless_id")); + assert!(rendered.contains("Key Vault Crypto Service Encryption User")); + assert!(rendered.contains("\"unwrapKey\"")); + assert!(rendered.contains("\"wrapKey\"")); + assert_terraform_valid(&module, "azure_encrypted_storage"); +} + #[test] fn azure_storage_profile_permissions_emit_container_role_assignment() { let stack = Stack::new("acme-storage-permissions".to_string()) diff --git a/crates/alien-terraform/tests/generator/gating_matrix_tests.rs b/crates/alien-terraform/tests/generator/gating_matrix_tests.rs index ba9c626cc..183ec5316 100644 --- a/crates/alien-terraform/tests/generator/gating_matrix_tests.rs +++ b/crates/alien-terraform/tests/generator/gating_matrix_tests.rs @@ -9,8 +9,8 @@ use super::helpers::{assert_terraform_valid, gate_input, render, snapshot_module}; use alien_core::{ ownership_policy_for_resource_type, Ai, AzureResourceGroup, AzureServiceBusNamespace, - AzureStorageAccount, Kv, PermissionProfile, Platform, Queue, ResourceLifecycle, ServiceAccount, - Stack, StackBuilder, StackSettings, Storage, Vault, Worker, WorkerCode, + AzureStorageAccount, Key, Kv, PermissionProfile, Platform, Queue, ResourceLifecycle, + ServiceAccount, Stack, StackBuilder, StackSettings, Storage, Vault, Worker, WorkerCode, }; use alien_terraform::{TerraformTarget, TfRegistry}; @@ -75,6 +75,11 @@ fn gated_fixture(resource_type: &str, platform: Platform) -> Option { ResourceLifecycle::Frozen, "fixtureEnabled", ), + "key" => base().add_enabled_when( + Key::new("fixture".to_string()).build(), + ResourceLifecycle::Frozen, + "fixtureEnabled", + ), _ => return None, }; Some(stack.build()) diff --git a/crates/alien-terraform/tests/generator/gcp_data_layer_tests.rs b/crates/alien-terraform/tests/generator/gcp_data_layer_tests.rs index 05bfacb81..449f0dab7 100644 --- a/crates/alien-terraform/tests/generator/gcp_data_layer_tests.rs +++ b/crates/alien-terraform/tests/generator/gcp_data_layer_tests.rs @@ -7,12 +7,80 @@ use super::helpers::{assert_terraform_valid, render, snapshot_module}; use alien_core::{ - Ai, Kv, LifecycleRule, ManagementPermissions, PermissionProfile, PermissionsConfig, Queue, + Ai, Key, Kv, LifecycleRule, ManagementPermissions, PermissionProfile, PermissionsConfig, Queue, RemoteBindings, RemoteStackManagement, ResourceLifecycle, ResourceRef, ServiceAccount, Stack, StackSettings, Storage, Vault, }; use alien_terraform::TerraformTarget; +#[test] +fn gcp_key_package_is_valid_and_retained() { + let mut stack = Stack::new("enterprise-key".to_string()) + .add_with_remote_access( + Key::new("customer-key".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .add( + RemoteBindings::new("access".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .build(); + stack + .resources + .get_mut("customer-key") + .unwrap() + .dependencies = vec![ResourceRef::new(RemoteBindings::RESOURCE_TYPE, "access")]; + + let module = render(&stack, TerraformTarget::Gcp, StackSettings::default()); + let rendered = module + .files + .values() + .cloned() + .collect::>() + .join("\n"); + + assert!(rendered.contains("google_kms_key_ring")); + assert!(rendered.contains("random_id.customer_key_ring_suffix.hex")); + assert!(rendered.contains("prevent_destroy = true")); + assert!(rendered.contains("roles/cloudkms.cryptoKeyEncrypterDecrypter")); + let detach = module + .get("detach-retained-keys.sh") + .expect("retained Key detach operation"); + assert!(detach.contains("google_kms_crypto_key.customer_key")); + assert!(detach.contains("google_kms_key_ring.customer_key_ring")); + assert_terraform_valid(&module, "gcp_key_package"); +} + +#[test] +fn gcp_storage_uses_customer_managed_key() { + let stack = Stack::new("encrypted-storage".to_string()) + .add( + Key::new("customer-key".to_string()).build(), + ResourceLifecycle::Frozen, + ) + .add( + Storage::new("data".to_string()) + .encryption_key(ResourceRef::new(Key::RESOURCE_TYPE, "customer-key")) + .build(), + ResourceLifecycle::Frozen, + ) + .build(); + let module = render(&stack, TerraformTarget::Gcp, StackSettings::default()); + let rendered = module + .files + .values() + .cloned() + .collect::>() + .join("\n"); + + assert!(rendered.contains("default_kms_key_name = google_kms_crypto_key.customer_key.id")); + assert!(rendered.contains("google_storage_project_service_account")); + assert!(rendered.contains("roles/cloudkms.cryptoKeyEncrypterDecrypter")); + assert!(rendered.contains("depends_on")); + assert!(rendered.contains("google_kms_crypto_key_iam_member.data_storage_encryption")); + assert_terraform_valid(&module, "gcp_encrypted_storage"); +} + #[test] fn gcp_storage_minimal_renders_idiomatic_module() { let stack = Stack::new("acme-prod".to_string()) diff --git a/crates/alien-test/src/distribution.rs b/crates/alien-test/src/distribution.rs index acde13572..ac84526c8 100644 --- a/crates/alien-test/src/distribution.rs +++ b/crates/alien-test/src/distribution.rs @@ -15,8 +15,8 @@ use alien_core::{ import::{ data::{AwsArtifactRegistryImportData, AwsKvImportData, AwsStorageImportData}, AzureRemoteStackManagementImportData, AzureServiceBusNamespaceImportData, - GcpRemoteStackManagementImportData, ImportSourceKind, ImportedResource, StackImportRequest, - StackImportResponse, + GcpKeyImportData, GcpRemoteStackManagementImportData, ImportSourceKind, ImportedResource, + StackImportRequest, StackImportResponse, }, AwsManagementConfig, AzureClientConfig, AzureCredentials, AzureManagementConfig, DeploymentConfig, DeploymentModel as StackDeploymentModel, EnvironmentVariablesSnapshot, @@ -28,7 +28,7 @@ use alien_core::{ }; #[cfg(test)] use alien_core::{Container, ContainerCode, Kv, Queue, ResourceSpec, Storage, Vault}; -use alien_gcp_clients::{GcpClientConfigExt, ResourceManagerApi}; +use alien_gcp_clients::{CloudKmsApi, GcpClientConfigExt, ResourceManagerApi}; use anyhow::Context; use serde_json::Value; use tempfile::TempDir; @@ -231,6 +231,16 @@ impl DistributionArtifactCleanup { workdir = %workdir.path().display(), "destroying Terraform setup artifacts" ); + let detach_script = workdir.path().join("detach-retained-keys.sh"); + if detach_script.exists() { + let mut detach = Command::new("sh"); + detach + .current_dir(workdir.path()) + .arg("./detach-retained-keys.sh") + .env("ALIEN_CONFIRM_DETACH_RETAINED_KEYS", "yes"); + apply_env(&mut detach, &env); + run_command(detach, "detach retained Terraform keys").await?; + } for attempt in 1..=3 { let mut cmd = Command::new("terraform"); cmd.current_dir(workdir.path()).args([ @@ -2425,6 +2435,7 @@ async fn wait_and_finalize(ctx: &mut TestContext) -> anyhow::Result<()> { anyhow::anyhow!("Deployment failed to reach running within {timeout:?}: {error}") })?; if ctx.model == DeploymentModel::Push + && ctx.app != TestApp::ByoEncryptionKey && matches!( ctx.platform, Platform::Aws | Platform::Gcp | Platform::Azure @@ -2908,13 +2919,26 @@ async fn wait_for_gcp_management_permissions( } }; - let resource_manager = alien_gcp_clients::ResourceManagerClient::new( - http.clone(), - impersonated_config.clone(), - ); - let result = resource_manager + // Probe the narrowest concrete permission this package requested. + // A Key-only management identity intentionally has no project-wide + // Resource Manager read access. + let result = if let Some(key) = optional_terraform_import_data::( + &resources, + "key", + )? { + alien_gcp_clients::CloudKmsClient::new(http.clone(), impersonated_config.clone()) + .get_crypto_key(&key.crypto_key_name) + .await + .map(|_| ()) + } else { + alien_gcp_clients::ResourceManagerClient::new( + http.clone(), + impersonated_config.clone(), + ) .get_project_metadata(target.project_id.clone()) - .await; + .await + .map(|_| ()) + }; match result { Ok(_) => { @@ -3334,6 +3358,8 @@ fn terraform_tfvars( &mut vars, azure_target, prepared.config.azure_mgmt.as_ref(), + &std::env::var("AZURE_TARGET_RESOURCE_GROUP") + .context("AZURE_TARGET_RESOURCE_GROUP is required")?, target, ); } @@ -3419,6 +3445,7 @@ fn insert_azure_tfvars( vars: &mut serde_json::Map, azure_target: &AzureConfig, azure_mgmt: Option<&AzureConfig>, + resource_group: &str, target: alien_terraform::TerraformTarget, ) { vars.insert( @@ -3437,10 +3464,7 @@ fn insert_azure_tfvars( ); vars.insert( "azure_resource_group_name".to_string(), - Value::String(format!( - "alien-e2e-{}", - &uuid::Uuid::new_v4().to_string()[..8] - )), + Value::String(resource_group.to_string()), ); if let Some(mgmt) = azure_mgmt { vars.insert( @@ -4407,6 +4431,7 @@ mod tests { &mut vars, &azure_target, Some(&azure_mgmt), + "target-rg", alien_terraform::TerraformTarget::Azure, ); @@ -4439,6 +4464,7 @@ mod tests { &mut vars, &azure_target, None, + "target-rg", alien_terraform::TerraformTarget::Aks, ); @@ -4457,6 +4483,7 @@ mod tests { &mut vars, &azure_target, None, + "target-rg", alien_terraform::TerraformTarget::Azure, ); diff --git a/crates/alien-test/src/e2e.rs b/crates/alien-test/src/e2e.rs index 99ea3fa81..b87e9073b 100644 --- a/crates/alien-test/src/e2e.rs +++ b/crates/alien-test/src/e2e.rs @@ -155,6 +155,9 @@ pub enum TestApp { /// declined resource and its grant never reach the cloud /// (`tests/e2e/test-apps/enabled-demo`). EnabledDemo, + /// A bindings-only Enterprise Key deployment used to qualify generated + /// setup and real remote cryptography on each cloud. + ByoEncryptionKey, } impl std::fmt::Display for TestApp { @@ -167,6 +170,7 @@ impl std::fmt::Display for TestApp { TestApp::ContainerRust => write!(f, "container-rust"), TestApp::RuntimeLessMixed => write!(f, "runtime-less-mixed"), TestApp::EnabledDemo => write!(f, "enabled-demo"), + TestApp::ByoEncryptionKey => write!(f, "byo-encryption-key"), } } } @@ -383,6 +387,7 @@ pub(crate) fn test_app_path(app: TestApp) -> &'static str { TestApp::ContainerRust => "test-apps/container-rust", TestApp::RuntimeLessMixed => "test-apps/runtime-less-mixed", TestApp::EnabledDemo => "test-apps/enabled-demo", + TestApp::ByoEncryptionKey => "test-apps/byo-encryption-key", } } @@ -401,6 +406,7 @@ fn deployment_environment_variables( | TestApp::ContainerRust | TestApp::RuntimeLessMixed | TestApp::EnabledDemo => None, + TestApp::ByoEncryptionKey => None, TestApp::FullStackMicroservices => { Some(vec![alien_manager_api::types::EnvironmentVariable { name: "APP_SECRET".to_string(), diff --git a/crates/alien-test/tests/common/remote_bindings.rs b/crates/alien-test/tests/common/remote_bindings.rs index 060a5115c..69722bf9e 100644 --- a/crates/alien-test/tests/common/remote_bindings.rs +++ b/crates/alien-test/tests/common/remote_bindings.rs @@ -5,13 +5,17 @@ //! manager authorization, credential attenuation, and object operations all //! run through their production paths. +use std::collections::BTreeMap; use std::future::Future; use std::net::SocketAddr; use std::pin::Pin; +use alien_azure_clients::{AzureStorageAccountsClient, AzureTokenCache, StorageAccountsApi}; use alien_bindings::RemoteBindings; -use alien_core::Platform; -use alien_test::TestDeployment; +use alien_core::{ + AzureClientConfig, AzureCredentials, KeyFingerprint, KeyOutputs, Platform, StorageOutputs, +}; +use alien_test::{TestContext, TestDeployment}; use anyhow::{bail, Context}; use axum::extract::{Path as AxumPath, State}; use axum::http::{HeaderMap, HeaderValue, StatusCode}; @@ -31,6 +35,9 @@ const PROJECT_ID: &str = "prj_cccccccccccccccccccccccccccc"; const DEPLOYMENT_GROUP_ID: &str = "dg_dddddddddddddddddddddddddddd"; const WORKSPACE_ID: &str = "ws_eeeeeeeeeeeeeeeeeeeeeeee"; const PAYLOAD: &[u8] = b"alien remote storage live-cloud e2e"; +const ENTERPRISE_KEY_BINDING: &str = "enterprise-key"; +const NATIVE_STORAGE_BINDING: &str = "encrypted-storage"; +const NATIVE_STORAGE_KEY: &str = ENTERPRISE_KEY_BINDING; #[derive(Clone)] struct DiscoveryState { @@ -213,6 +220,579 @@ pub fn check_remote_storage<'a>( }) } +/// Resolve the deployment's real cloud Key through the same public remote API +/// used by the hosted Encryption Gateway, then prove provider cryptography and +/// portable context behavior rather than merely inspecting generated setup. +pub fn check_remote_key<'a>( + deployment: &'a TestDeployment, + platform: Platform, +) -> Pin> + Send + 'a>> { + Box::pin(async move { + info!( + platform = %platform.as_str(), + "Checking remote Enterprise Key through assigned-manager discovery" + ); + let discovery = DiscoveryServer::start(deployment, platform).await?; + let bindings = + RemoteBindings::for_deployment(&deployment.id, &deployment.token, Some(&discovery.url)) + .await + .context("discover assigned manager for remote Key binding")?; + let key = bindings + .key(ENTERPRISE_KEY_BINDING) + .await + .context("resolve real remote Key binding")?; + + let plaintext = [0x5au8; 128]; + let context = BTreeMap::from([ + ("purpose".to_string(), "application-root".to_string()), + ("test".to_string(), deployment.id.clone()), + ]); + // Setup can finish before a newly attached cloud IAM policy is visible + // to the provider data plane. Keep the production client's short retry + // behavior, then give this setup qualification a bounded readiness + // window before declaring the generated access identity unusable. + let ciphertext = { + let max_attempts = 15; + let mut result = None; + for attempt in 1..=max_attempts { + match key.encrypt(&plaintext, Some(&context)).await { + Ok(ciphertext) => { + result = Some(ciphertext); + break; + } + Err(error) if attempt < max_attempts => { + info!( + attempt, + max_attempts, + platform = %platform.as_str(), + error = %error, + "Remote Key is not ready after setup; waiting for cloud IAM propagation" + ); + tokio::time::sleep(std::time::Duration::from_secs(5)).await; + } + Err(error) => return Err(error).context( + "encrypt through real remote Enterprise Key after setup readiness window", + ), + } + } + result.context("remote Enterprise Key readiness loop returned no ciphertext")? + }; + let decrypted = key + .decrypt(&ciphertext, Some(&context)) + .await + .context("decrypt through real remote Enterprise Key")?; + anyhow::ensure!(decrypted == plaintext, "remote Key plaintext changed"); + + let wrong_context = BTreeMap::from([ + ("purpose".to_string(), "different-purpose".to_string()), + ("test".to_string(), deployment.id.clone()), + ]); + anyhow::ensure!( + key.decrypt(&ciphertext, Some(&wrong_context)) + .await + .is_err(), + "remote Key must reject the wrong portable context" + ); + anyhow::ensure!( + key.encrypt(&[0u8; 129], Some(&context)).await.is_err(), + "remote Key must reject values above the portable 128-byte limit" + ); + info!(platform = %platform.as_str(), "Remote Enterprise Key check passed"); + Ok(()) + }) +} + +/// Write and read real object data, then inspect provider metadata to prove +/// that Storage.encryptionKey selected the intended customer-managed Key. +pub fn check_native_storage_encryption<'a>( + ctx: &'a TestContext, +) -> Pin> + Send + 'a>> { + Box::pin(async move { + let response = ctx + .deployment + .manager() + .client() + .get_deployment() + .id(&ctx.deployment.id) + .send() + .await + .map_err(|error| anyhow::anyhow!("get_deployment failed: {error}"))?; + let value = response + .into_inner() + .stack_state + .context("deployment is missing stack_state")?; + let state: alien_core::StackState = + serde_json::from_value(value).context("failed to parse stack_state")?; + let storage = state + .get_resource_outputs::(NATIVE_STORAGE_BINDING) + .context("encrypted Storage has no outputs")?; + let storage_internal = state + .resources + .get(NATIVE_STORAGE_BINDING) + .and_then(|resource| resource.internal_state.as_ref()); + let key = state + .get_resource_outputs::(NATIVE_STORAGE_KEY) + .context("native Storage Key has no outputs")?; + let env = ctx + .distribution_cleanups + .iter() + .map(|cleanup| cleanup.command_env()) + .find(|env| !env.is_empty()) + .context("no distribution cleanup environment for native Storage check")?; + + match (&ctx.platform, &key.fingerprint) { + (Platform::Aws, KeyFingerprint::Aws { key_arn }) => { + check_aws_native_storage(&storage.bucket_name, key_arn, env).await + } + (Platform::Gcp, KeyFingerprint::Gcp { crypto_key_name }) => { + check_gcp_native_storage(&storage.bucket_name, crypto_key_name, env).await + } + ( + Platform::Azure, + KeyFingerprint::Azure { + vault_resource_id, + key_name, + lineage_version_id: _, + }, + ) => { + let account = storage_internal + .and_then(|value| value.get("storageAccountName")) + .and_then(serde_json::Value::as_str) + .context("Azure Storage controller has no storageAccountName")?; + check_azure_native_storage( + &storage.bucket_name, + account, + vault_resource_id, + key_name, + &key.wrapping_key_id, + env, + ) + .await + } + (platform, fingerprint) => anyhow::bail!( + "native Storage test does not yet support {platform:?} fingerprint {fingerprint:?}" + ), + } + }) +} + +async fn check_gcp_native_storage( + bucket: &str, + crypto_key_name: &str, + env: &[(String, String)], +) -> anyhow::Result<()> { + let object = format!( + "gs://{bucket}/alien-e2e/native-encryption/{}.bin", + uuid::Uuid::new_v4().simple() + ); + let payload = b"alien native Storage encryption live-cloud e2e"; + let source = tempfile::NamedTempFile::new().context("create native Storage source file")?; + std::fs::write(source.path(), payload).context("write native Storage source file")?; + let destination = + tempfile::NamedTempFile::new().context("create native Storage destination file")?; + + let verification = async { + run_cloud_command( + "gcloud", + &[ + "storage", + "cp", + source.path().to_str().context("source path is not UTF-8")?, + &object, + "--quiet", + ], + env, + "GCP Storage upload", + ) + .await?; + let description = run_cloud_command( + "gcloud", + &["storage", "objects", "describe", &object, "--format=json"], + env, + "GCP Storage object describe", + ) + .await?; + let description: serde_json::Value = + serde_json::from_str(&description).context("parse GCP Storage object description")?; + let version_prefix = format!("{crypto_key_name}/cryptoKeyVersions/"); + anyhow::ensure!( + json_contains_string_prefix(&description, &version_prefix), + "GCP object did not use a version of the intended CryptoKey" + ); + run_cloud_command( + "gcloud", + &[ + "storage", + "cp", + &object, + destination + .path() + .to_str() + .context("destination path is not UTF-8")?, + "--quiet", + ], + env, + "GCP Storage download", + ) + .await?; + anyhow::ensure!( + std::fs::read(destination.path()).context("read downloaded GCP object")? == payload, + "GCP object payload changed" + ); + Ok(()) + } + .await; + + finish_native_storage_check( + verification, + run_cloud_command( + "gcloud", + &["storage", "rm", &object, "--quiet"], + env, + "GCP Storage object delete", + ) + .await + .map(|_| ()), + "GCP", + ) +} + +fn json_contains_string_prefix(value: &serde_json::Value, prefix: &str) -> bool { + match value { + serde_json::Value::String(value) => value.starts_with(prefix), + serde_json::Value::Array(values) => values + .iter() + .any(|value| json_contains_string_prefix(value, prefix)), + serde_json::Value::Object(values) => values + .values() + .any(|value| json_contains_string_prefix(value, prefix)), + _ => false, + } +} + +async fn check_azure_native_storage( + container: &str, + account: &str, + vault_resource_id: &str, + key_name: &str, + wrapping_key_id: &str, + env: &[(String, String)], +) -> anyhow::Result<()> { + let config = AzureClientConfig { + subscription_id: env_value(env, "ARM_SUBSCRIPTION_ID")?.to_string(), + tenant_id: env_value(env, "ARM_TENANT_ID")?.to_string(), + region: None, + credentials: AzureCredentials::ServicePrincipal { + client_id: env_value(env, "ARM_CLIENT_ID")?.to_string(), + client_secret: env_value(env, "ARM_CLIENT_SECRET")?.to_string(), + }, + service_overrides: None, + }; + let resource_group = resource_id_segment(vault_resource_id, "resourceGroups")?; + let management = AzureStorageAccountsClient::new( + reqwest::Client::new(), + AzureTokenCache::new(config.clone()), + ); + let account_properties = management + .get_storage_account_properties(resource_group, account) + .await + .map_err(|error| anyhow::anyhow!("get Azure Storage account properties: {error}"))?; + let encryption = account_properties + .properties + .and_then(|properties| properties.encryption) + .context("Azure Storage account has no encryption settings")?; + anyhow::ensure!( + encryption.key_source.to_string() == "Microsoft.Keyvault", + "Azure Storage account does not use a Key Vault key" + ); + let properties = encryption + .keyvaultproperties + .context("Azure Storage account has no Key Vault properties")?; + anyhow::ensure!( + properties.keyname.as_deref() == Some(key_name), + "Azure Storage account uses a different Key Vault key" + ); + anyhow::ensure!( + properties.current_versioned_key_identifier.as_deref() == Some(wrapping_key_id), + "Azure Storage account reports a different current key identifier" + ); + + let storage_key = management + .list_storage_account_keys(resource_group, account) + .await + .map_err(|error| anyhow::anyhow!("list Azure Storage account keys: {error}"))? + .keys + .into_iter() + .find_map(|key| key.value) + .context("Azure Storage account returned no access key")?; + let mut data_env = env.to_vec(); + data_env.push(("AZURE_STORAGE_ACCOUNT".to_string(), account.to_string())); + data_env.push(("AZURE_STORAGE_KEY".to_string(), storage_key)); + let object = format!( + "alien-e2e/native-encryption/{}.bin", + uuid::Uuid::new_v4().simple() + ); + let payload = b"alien native Storage encryption live-cloud e2e"; + let source = tempfile::NamedTempFile::new().context("create Azure Storage source file")?; + std::fs::write(source.path(), payload).context("write Azure Storage source file")?; + let destination = + tempfile::NamedTempFile::new().context("create Azure Storage destination file")?; + let verification = async { + run_cloud_command( + "az", + &[ + "storage", + "blob", + "upload", + "--container-name", + container, + "--name", + &object, + "--file", + source.path().to_str().context("source path is not UTF-8")?, + "--overwrite", + "true", + "--auth-mode", + "key", + "--only-show-errors", + "--output", + "none", + ], + &data_env, + "Azure Blob upload", + ) + .await?; + run_cloud_command( + "az", + &[ + "storage", + "blob", + "download", + "--container-name", + container, + "--name", + &object, + "--file", + destination + .path() + .to_str() + .context("destination path is not UTF-8")?, + "--auth-mode", + "key", + "--only-show-errors", + "--output", + "none", + ], + &data_env, + "Azure Blob download", + ) + .await?; + anyhow::ensure!( + std::fs::read(destination.path()).context("read downloaded Azure object")? == payload, + "Azure object payload changed" + ); + Ok(()) + } + .await; + let deletion = run_cloud_command( + "az", + &[ + "storage", + "blob", + "delete", + "--container-name", + container, + "--name", + &object, + "--auth-mode", + "key", + "--only-show-errors", + "--output", + "none", + ], + &data_env, + "Azure Blob delete", + ) + .await + .map(|_| ()); + finish_native_storage_check(verification, deletion, "Azure") +} + +fn env_value<'a>(env: &'a [(String, String)], name: &str) -> anyhow::Result<&'a str> { + env.iter() + .find_map(|(key, value)| (key == name).then_some(value.as_str())) + .with_context(|| format!("native Storage check is missing {name}")) +} + +fn resource_id_segment<'a>(resource_id: &'a str, segment: &str) -> anyhow::Result<&'a str> { + let mut parts = resource_id.split('/'); + while let Some(part) = parts.next() { + if part.eq_ignore_ascii_case(segment) { + return parts + .next() + .filter(|value| !value.is_empty()) + .with_context(|| format!("Azure resource ID has no value after {segment}")); + } + } + anyhow::bail!("Azure resource ID has no {segment} segment") +} + +fn finish_native_storage_check( + verification: anyhow::Result<()>, + deletion: anyhow::Result<()>, + provider: &str, +) -> anyhow::Result<()> { + match (verification, deletion) { + (Ok(()), Ok(())) => { + info!(provider, "Native Storage encryption check passed"); + Ok(()) + } + (Err(error), Ok(())) => Err(error), + (Ok(()), Err(error)) => Err(error), + (Err(error), Err(cleanup)) => Err(error.context(format!( + "native Storage object cleanup also failed: {cleanup:#}" + ))), + } +} + +async fn check_aws_native_storage( + bucket: &str, + key_arn: &str, + env: &[(String, String)], +) -> anyhow::Result<()> { + let object = format!( + "alien-e2e/native-encryption/{}.bin", + uuid::Uuid::new_v4().simple() + ); + let payload = b"alien native Storage encryption live-cloud e2e"; + let source = tempfile::NamedTempFile::new().context("create native Storage source file")?; + std::fs::write(source.path(), payload).context("write native Storage source file")?; + let destination = + tempfile::NamedTempFile::new().context("create native Storage destination file")?; + + let verification = async { + run_cloud_command( + "aws", + &[ + "s3api", + "put-object", + "--bucket", + bucket, + "--key", + &object, + "--body", + source.path().to_str().context("source path is not UTF-8")?, + "--output", + "json", + ], + env, + "AWS S3 put-object", + ) + .await?; + let head = run_cloud_command( + "aws", + &[ + "s3api", + "head-object", + "--bucket", + bucket, + "--key", + &object, + "--output", + "json", + ], + env, + "AWS S3 head-object", + ) + .await?; + let head: serde_json::Value = + serde_json::from_str(&head).context("parse AWS S3 head-object output")?; + anyhow::ensure!( + head.get("ServerSideEncryption") + .and_then(serde_json::Value::as_str) + == Some("aws:kms"), + "S3 object is not protected by SSE-KMS" + ); + anyhow::ensure!( + head.get("SSEKMSKeyId").and_then(serde_json::Value::as_str) == Some(key_arn), + "S3 object used a different KMS key" + ); + run_cloud_command( + "aws", + &[ + "s3api", + "get-object", + "--bucket", + bucket, + "--key", + &object, + destination + .path() + .to_str() + .context("destination path is not UTF-8")?, + ], + env, + "AWS S3 get-object", + ) + .await?; + anyhow::ensure!( + std::fs::read(destination.path()).context("read downloaded S3 object")? == payload, + "S3 object payload changed" + ); + Ok(()) + } + .await; + + let deletion = run_cloud_command( + "aws", + &[ + "s3api", + "delete-object", + "--bucket", + bucket, + "--key", + &object, + ], + env, + "AWS S3 delete-object", + ) + .await; + match (verification, deletion) { + (Ok(()), Ok(_)) => { + info!("Native AWS Storage encryption check passed"); + Ok(()) + } + (Err(error), Ok(_)) => Err(error), + (Ok(()), Err(error)) => Err(error), + (Err(error), Err(cleanup)) => Err(error.context(format!( + "native Storage object cleanup also failed: {cleanup:#}" + ))), + } +} + +async fn run_cloud_command( + program: &str, + args: &[&str], + env: &[(String, String)], + description: &str, +) -> anyhow::Result { + let mut command = tokio::process::Command::new(program); + command.args(args); + for (key, value) in env { + command.env(key, value); + } + let output = command + .output() + .await + .with_context(|| format!("failed to run {description}"))?; + anyhow::ensure!( + output.status.success(), + "{description} failed: {}", + String::from_utf8_lossy(&output.stderr) + ); + String::from_utf8(output.stdout).with_context(|| format!("{description} returned non-UTF-8")) +} + async fn verify_before_delete( storage: &dyn alien_bindings::RemoteStorage, prefix: &Path, diff --git a/crates/alien-test/tests/distribution.rs b/crates/alien-test/tests/distribution.rs index 91adcc135..3d628ad6d 100644 --- a/crates/alien-test/tests/distribution.rs +++ b/crates/alien-test/tests/distribution.rs @@ -65,6 +65,17 @@ async fn check_distribution_deployment(ctx: &mut alien_test::TestContext) { panic!("enabled-demo gate checks failed: {error:#}"); } } + TestApp::ByoEncryptionKey => { + if let Err(error) = + common::remote_bindings::check_remote_key(&ctx.deployment, ctx.platform).await + { + panic!("remote Enterprise Key checks failed: {error:#}"); + } + if let Err(error) = common::remote_bindings::check_native_storage_encryption(ctx).await + { + panic!("native Storage encryption checks failed: {error:#}"); + } + } } } @@ -158,7 +169,12 @@ async fn check_enabled_demo(ctx: &mut alien_test::TestContext) -> anyhow::Result // is the IAM policy carrying its id, which also proves the grant follows the gate. assert_cloud_gate_pair( &env, - &["iam", "get-account-authorization-details", "--output", "json"], + &[ + "iam", + "get-account-authorization-details", + "--output", + "json", + ], "optional-vault-on", "optional-vault-off", ) @@ -901,6 +917,18 @@ async fn terraform_aws_push_enabled_demo(ctx: &mut TerraformAwsPushEnabledDemo) check_distribution_deployment(&mut ctx.ctx).await; } +distribution_test_context!( + TerraformAwsPushByoEncryptionKey, + DistributionFlow::TerraformAwsPush, + TestApp::ByoEncryptionKey +); + +#[test_context(TerraformAwsPushByoEncryptionKey)] +#[tokio::test] +async fn terraform_aws_push_byo_encryption_key(ctx: &mut TerraformAwsPushByoEncryptionKey) { + check_distribution_deployment(&mut ctx.ctx).await; +} + distribution_test_context!( TerraformGcpPushRust, DistributionFlow::TerraformGcpPush, @@ -913,6 +941,18 @@ async fn terraform_gcp_push_comprehensive_rust(ctx: &mut TerraformGcpPushRust) { check_distribution_deployment(&mut ctx.ctx).await; } +distribution_test_context!( + TerraformGcpPushByoEncryptionKey, + DistributionFlow::TerraformGcpPush, + TestApp::ByoEncryptionKey +); + +#[test_context(TerraformGcpPushByoEncryptionKey)] +#[tokio::test] +async fn terraform_gcp_push_byo_encryption_key(ctx: &mut TerraformGcpPushByoEncryptionKey) { + check_distribution_deployment(&mut ctx.ctx).await; +} + distribution_test_context!( TerraformAzurePushRust, DistributionFlow::TerraformAzurePush, @@ -925,6 +965,18 @@ async fn terraform_azure_push_comprehensive_rust(ctx: &mut TerraformAzurePushRus check_distribution_deployment(&mut ctx.ctx).await; } +distribution_test_context!( + TerraformAzurePushByoEncryptionKey, + DistributionFlow::TerraformAzurePush, + TestApp::ByoEncryptionKey +); + +#[test_context(TerraformAzurePushByoEncryptionKey)] +#[tokio::test] +async fn terraform_azure_push_byo_encryption_key(ctx: &mut TerraformAzurePushByoEncryptionKey) { + check_distribution_deployment(&mut ctx.ctx).await; +} + // --------------------------------------------------------------------------- // Terraform + Helm pull // --------------------------------------------------------------------------- diff --git a/packages/bindings/src/__tests__/factories.test.ts b/packages/bindings/src/__tests__/factories.test.ts index 99ec909ac..d71d72c45 100644 --- a/packages/bindings/src/__tests__/factories.test.ts +++ b/packages/bindings/src/__tests__/factories.test.ts @@ -5,6 +5,7 @@ import type { NativeAddon, RawBindingsHandle, RawContainerHandle, + RawKeyHandle, RawKvHandle, RawPostgresConnection, RawPostgresHandle, @@ -90,6 +91,10 @@ function fakeAddon(): { addon: NativeAddon; constructions: unknown[] } { exists: async () => false, scan: async () => ({ items: [] }), } + const keyHandle: RawKeyHandle = { + encrypt: async plaintext => plaintext, + decrypt: async ciphertext => ciphertext, + } const queueHandle: RawQueueHandle = { sendJson: async () => {}, sendText: async () => {}, @@ -114,6 +119,7 @@ function fakeAddon(): { addon: NativeAddon; constructions: unknown[] } { const bindings: RawBindingsHandle = { storage: async () => storageHandle, + key: async () => keyHandle, kv: async () => kvHandle, queue: async () => queueHandle, vault: async () => vaultHandle, @@ -126,6 +132,7 @@ function fakeAddon(): { addon: NativeAddon; constructions: unknown[] } { constructions.push(undefined) } storage = bindings.storage + key = bindings.key kv = bindings.kv queue = bindings.queue vault = bindings.vault @@ -183,6 +190,19 @@ function addonForStorage(storageHandle: RawStorageHandle): NativeAddon { } } +function addonForKey(keyHandle: RawKeyHandle): NativeAddon { + class FakeBindingsHandle { + async key(): Promise { + return keyHandle + } + } + return { + BindingsHandle: FakeBindingsHandle as unknown as NativeAddon["BindingsHandle"], + RemoteBindingsHandle: unusedRemoteBindingsHandle(), + version: () => "test", + } +} + describe("createFactories laziness", () => { it("constructs factories without loading the addon; loads only on first op", async () => { const getAddon = vi.fn<() => NativeAddon>(() => { @@ -309,6 +329,22 @@ describe("createFactories kv surface", () => { }) }) +describe("createFactories key surface", () => { + it("forwards bytes and authenticated context without changing either", async () => { + const encrypt = vi.fn(async plaintext => plaintext) + const decrypt = vi.fn(async ciphertext => ciphertext) + const { key } = createFactories(() => addonForKey({ encrypt, decrypt })) + const plaintext = new Uint8Array([0, 1, 2, 255]) + const context = { project: "example", purpose: "root" } + + const ciphertext = await key("customer-key").encrypt(plaintext, { context }) + await key("customer-key").decrypt(ciphertext, { context }) + + expect(encrypt).toHaveBeenCalledWith(Buffer.from(plaintext), context) + expect(decrypt).toHaveBeenCalledWith(Buffer.from(plaintext), context) + }) +}) + describe("createFactories method mapping", () => { it("returns structured storage reads without discarding metadata or attributes", async () => { const result = { diff --git a/packages/bindings/src/__tests__/loader.test.ts b/packages/bindings/src/__tests__/loader.test.ts index 770dc85f6..8f7f3bdc8 100644 --- a/packages/bindings/src/__tests__/loader.test.ts +++ b/packages/bindings/src/__tests__/loader.test.ts @@ -4,6 +4,9 @@ import { assertAddonVersion, platformTriple } from "../loader.js" function addonReporting(version: string): NativeAddon { class BindingsHandle { + key(): never { + throw new Error("not used by version validation") + } storage(): never { throw new Error("not used by version validation") } diff --git a/packages/bindings/src/__tests__/remote.test.ts b/packages/bindings/src/__tests__/remote.test.ts index 55cbad0af..3687b0b63 100644 --- a/packages/bindings/src/__tests__/remote.test.ts +++ b/packages/bindings/src/__tests__/remote.test.ts @@ -4,6 +4,7 @@ import type { NativeAddon, RawBindingsHandle, RawContainerHandle, + RawKeyHandle, RawKvHandle, RawPostgresHandle, RawQueueHandle, @@ -46,8 +47,16 @@ function fakeRemoteAddon() { copy: async () => {}, signedUrl: async () => ({ url: "https://example.invalid", method: "GET", headers: {} }), } + const key: RawKeyHandle = { + encrypt: async (plaintext, context) => + Buffer.concat([plaintext, Buffer.from(context?.tenant ?? "")]), + decrypt: async ciphertext => ciphertext, + } + const resolveKey = vi.fn<(name: string) => Promise>(async () => key) class FakeBindingsHandle implements RawBindingsHandle { + key = resolveKey + async storage(): Promise { return localStorage } @@ -81,6 +90,8 @@ function fakeRemoteAddon() { ) => Promise storage = resolveStorage + + key = resolveKey } const forRemoteDeployment = vi.fn< @@ -98,6 +109,7 @@ function fakeRemoteAddon() { resolveStorage, head, put, + resolveKey, } } @@ -127,9 +139,27 @@ describe("Bindings.forRemoteDeployment", () => { expect("kv" in bindings).toBe(false) expect("queue" in bindings).toBe(false) expect("vault" in bindings).toBe(false) + expect("key" in bindings).toBe(true) expect(Object.keys(storage).sort()).toEqual(["delete", "get", "head", "list", "put"]) }) + it("resolves a typed remote Key and forwards bytes and context", async () => { + const fixture = fakeRemoteAddon() + loadAddon.mockReturnValue(fixture.addon) + const bindings = await Bindings.forRemoteDeployment({ + deploymentId: "dep_123", + token: "token_123", + }) + + const ciphertext = await bindings + .key("customer-key") + .encrypt(Buffer.from("root"), { context: { tenant: "acme" } }) + + expect(ciphertext.toString()).toBe("rootacme") + expect(fixture.resolveKey).toHaveBeenCalledOnce() + expect(fixture.resolveKey).toHaveBeenCalledWith("customer-key") + }) + it("reuses one native bindings handle and resolves each Storage handle lazily once", async () => { const fixture = fakeRemoteAddon() fixture.head.mockResolvedValue({ diff --git a/packages/bindings/src/factories.ts b/packages/bindings/src/factories.ts index dcde4b515..858a64b53 100644 --- a/packages/bindings/src/factories.ts +++ b/packages/bindings/src/factories.ts @@ -23,6 +23,7 @@ import type { NativeAddon, RawBindingsHandle, RawContainerHandle, + RawKeyHandle, RawKvHandle, RawPostgresConnection, RawPostgresHandle, @@ -34,6 +35,8 @@ import type { } from "./loader.js" import type { Container, + Key, + KeyOptions, Kv, KvEntry, KvScanResult, @@ -110,6 +113,15 @@ function makeStorage(handle: () => Promise): Storage { } } +function makeKey(handle: () => Promise): Key { + return { + encrypt: (plaintext, options?: KeyOptions) => + guard(handle, raw => raw.encrypt(toBuffer(plaintext), options?.context ?? null)), + decrypt: (ciphertext, options?: KeyOptions) => + guard(handle, raw => raw.decrypt(toBuffer(ciphertext), options?.context ?? null)), + } +} + function makeRemoteStorage(handle: () => Promise): RemoteStorage { return { get: path => guard(handle, raw => raw.get(path)), @@ -330,6 +342,7 @@ function makePostgres(handle: () => Promise): Postgres { /** The public factory surface. */ export interface Factories { storage(name: string): Storage + key(name: string): Key kv(name: string): Kv queue(name: string): Queue vault(name: string): Vault @@ -342,6 +355,7 @@ export function createFactories(getAddon: () => NativeAddon): Factories { const getBindings = bindingsFromAddon(getAddon) return { storage: name => makeStorage(lazyHandle(async () => (await getBindings()).storage(name))), + key: name => makeKey(lazyHandle(async () => (await getBindings()).key(name))), kv: name => makeKv(lazyHandle(async () => (await getBindings()).kv(name))), queue: name => makeQueue(lazyHandle(async () => (await getBindings()).queue(name))), vault: name => makeVault(lazyHandle(async () => (await getBindings()).vault(name))), @@ -362,3 +376,16 @@ export function createRemoteStorageFactory(bindings: RawRemoteBindingsHandle) { return storage } } + +/** Build the remote Key factory around one native bindings handle. */ +export function createRemoteKeyFactory(bindings: RawRemoteBindingsHandle) { + const keys = new Map() + return (name: string): Key => { + let key = keys.get(name) + if (!key) { + key = makeKey(lazyHandle(() => bindings.key(name))) + keys.set(name, key) + } + return key + } +} diff --git a/packages/bindings/src/index.ts b/packages/bindings/src/index.ts index 5b323794a..bc9099dee 100644 --- a/packages/bindings/src/index.ts +++ b/packages/bindings/src/index.ts @@ -19,6 +19,8 @@ const factories = createFactories(loadAddon) /** Resolve the storage binding named `name`. */ export const storage = factories.storage +/** Resolve the provider-backed key binding named `name`. */ +export const key = factories.key /** Resolve the key-value binding named `name`. */ export const kv = factories.kv /** Resolve the queue binding named `name`. */ @@ -41,6 +43,8 @@ export { export type { Container, + Key, + KeyOptions, Kv, KvDeleteOptions, KvEntry, diff --git a/packages/bindings/src/loader.ts b/packages/bindings/src/loader.ts index e06d43679..1c3f7421e 100644 --- a/packages/bindings/src/loader.ts +++ b/packages/bindings/src/loader.ts @@ -91,6 +91,11 @@ export interface RawStorageHandle { signedUrl(method: string, path: string, expiresInSecs: number): Promise } +export interface RawKeyHandle { + encrypt(plaintext: Buffer, context?: Record | null): Promise + decrypt(ciphertext: Buffer, context?: Record | null): Promise +} + /** Raw napi remote Storage v0 handle. */ export interface RawRemoteStorageHandle { get(path: string): Promise @@ -165,6 +170,7 @@ export interface RawVaultHandle { /** Raw napi bindings entry point. Construction validates the environment. */ export interface RawBindingsHandle { storage(name: string): Promise + key(name: string): Promise kv(name: string): Promise queue(name: string): Promise vault(name: string): Promise @@ -172,9 +178,10 @@ export interface RawBindingsHandle { postgres(name: string): Promise } -/** Raw napi remote bindings entry point. Storage is the entire v0 surface. */ +/** Raw napi remote bindings entry point. */ export interface RawRemoteBindingsHandle { storage(name: string): Promise + key(name: string): Promise } /** Native environment-backed bindings class. */ diff --git a/packages/bindings/src/native.ts b/packages/bindings/src/native.ts index 9d47459be..aa76b84ac 100644 --- a/packages/bindings/src/native.ts +++ b/packages/bindings/src/native.ts @@ -40,6 +40,8 @@ const factories = createFactories(() => addon) /** Resolve the storage binding named `name`. */ export const storage = factories.storage +/** Resolve the provider-backed key binding named `name`. */ +export const key = factories.key /** Resolve the key-value binding named `name`. */ export const kv = factories.kv /** Resolve the queue binding named `name`. */ @@ -61,6 +63,8 @@ export { export type { Container, + Key, + KeyOptions, Kv, KvDeleteOptions, KvEntry, diff --git a/packages/bindings/src/remote.ts b/packages/bindings/src/remote.ts index e43bb6d56..b5cc5e4c4 100644 --- a/packages/bindings/src/remote.ts +++ b/packages/bindings/src/remote.ts @@ -1,7 +1,7 @@ import { unwrapNapiError } from "./errors.js" -import { createRemoteStorageFactory } from "./factories.js" +import { createRemoteKeyFactory, createRemoteStorageFactory } from "./factories.js" import { loadAddon } from "./loader.js" -import type { RemoteStorage } from "./types.js" +import type { Key, RemoteStorage } from "./types.js" /** Options for accessing Storage resources in an existing deployment. */ export interface RemoteDeploymentBindingsOptions { @@ -16,9 +16,11 @@ export interface RemoteDeploymentBindingsOptions { /** Remote bindings for an existing deployment. */ export class Bindings { readonly #storage: (name: string) => RemoteStorage + readonly #key: (name: string) => Key - private constructor(storage: (name: string) => RemoteStorage) { + private constructor(storage: (name: string) => RemoteStorage, key: (name: string) => Key) { this.#storage = storage + this.#key = key } /** Discover the deployment's manager and prepare remote Storage bindings. */ @@ -30,7 +32,7 @@ export class Bindings { options.token, options.apiBaseUrl, ) - return new Bindings(createRemoteStorageFactory(bindings)) + return new Bindings(createRemoteStorageFactory(bindings), createRemoteKeyFactory(bindings)) } catch (error) { throw unwrapNapiError(error) } @@ -40,4 +42,9 @@ export class Bindings { storage(name: string): RemoteStorage { return this.#storage(name) } + + /** Resolve a remote Key binding by resource name. */ + key(name: string): Key { + return this.#key(name) + } } diff --git a/packages/bindings/src/types.ts b/packages/bindings/src/types.ts index 7afeeaf4a..45cfea9cf 100644 --- a/packages/bindings/src/types.ts +++ b/packages/bindings/src/types.ts @@ -122,6 +122,17 @@ export interface Storage { signedUrl(options: SignedUrlOptions): Promise } +/** Optional authenticated metadata for a Key operation. */ +export interface KeyOptions { + context?: Record +} + +/** A provider-backed key for encrypting and decrypting values up to 128 bytes. */ +export interface Key { + encrypt(plaintext: Buffer | Uint8Array, options?: KeyOptions): Promise + decrypt(ciphertext: Buffer | Uint8Array, options?: KeyOptions): Promise +} + /** Storage operations available from an external deployment binding. */ export type RemoteStorage = Pick diff --git a/packages/core/src/__tests__/storage-encryption-key.test.ts b/packages/core/src/__tests__/storage-encryption-key.test.ts new file mode 100644 index 000000000..fc89375e5 --- /dev/null +++ b/packages/core/src/__tests__/storage-encryption-key.test.ts @@ -0,0 +1,22 @@ +import { describe, expect, it } from "vitest" +import { Key } from "../key.js" +import { Storage } from "../storage.js" + +describe("Storage.encryptionKey", () => { + it("stores a typed Key reference", () => { + const key = new Key("customer-key").build() + const storage = new Storage("customer-data").encryptionKey(key).build() + + expect(storage.config).toMatchObject({ + type: "storage", + encryptionKey: { type: "key", id: "customer-key" }, + }) + }) + + it("rejects non-Key resources", () => { + const otherStorage = new Storage("not-a-key").build() + expect(() => new Storage("customer-data").encryptionKey(otherStorage)).toThrow( + "requires an alien.Key", + ) + }) +}) diff --git a/packages/core/src/generated/index.ts b/packages/core/src/generated/index.ts index c2b587083..0977e1d0a 100644 --- a/packages/core/src/generated/index.ts +++ b/packages/core/src/generated/index.ts @@ -28,6 +28,8 @@ export type { AwsEmailDomainImportData } from "./zod/aws-email-domain-import-dat export type { AwsEmailImportData } from "./zod/aws-email-import-data-schema.js"; export type { AwsFailureDomainSubnets } from "./zod/aws-failure-domain-subnets-schema.js"; export type { AwsIamRoleServiceAccountHeartbeatData } from "./zod/aws-iam-role-service-account-heartbeat-data-schema.js"; +export type { AwsKeyImportData } from "./zod/aws-key-import-data-schema.js"; +export type { AwsKmsKeyHeartbeatData } from "./zod/aws-kms-key-heartbeat-data-schema.js"; export type { AwsKvImportData } from "./zod/aws-kv-import-data-schema.js"; export type { AwsLambdaWorkerHeartbeatData } from "./zod/aws-lambda-worker-heartbeat-data-schema.js"; export type { AwsManagementConfig } from "./zod/aws-management-config-schema.js"; @@ -70,7 +72,9 @@ export type { AzureDaemonHeartbeatData } from "./zod/azure-daemon-heartbeat-data export type { AzureFlexibleServerPostgresHeartbeatData } from "./zod/azure-flexible-server-postgres-heartbeat-data-schema.js"; export type { AzureFlexibleServerPostgresImportData } from "./zod/azure-flexible-server-postgres-import-data-schema.js"; export type { AzureFoundryAiHeartbeatData } from "./zod/azure-foundry-ai-heartbeat-data-schema.js"; +export type { AzureKeyImportData } from "./zod/azure-key-import-data-schema.js"; export type { AzureKeyVaultHeartbeatData } from "./zod/azure-key-vault-heartbeat-data-schema.js"; +export type { AzureKeyVaultKeyHeartbeatData } from "./zod/azure-key-vault-key-heartbeat-data-schema.js"; export type { AzureKvImportData } from "./zod/azure-kv-import-data-schema.js"; export type { AzureManagedIdentityServiceAccountHeartbeatData } from "./zod/azure-managed-identity-service-account-heartbeat-data-schema.js"; export type { AzureManagementConfig } from "./zod/azure-management-config-schema.js"; @@ -171,6 +175,7 @@ export type { GcpArtifactRegistryHeartbeatData } from "./zod/gcp-artifact-regist export type { GcpArtifactRegistryImportData } from "./zod/gcp-artifact-registry-import-data-schema.js"; export type { GcpBuildImportData } from "./zod/gcp-build-import-data-schema.js"; export type { GcpCloudBuildHeartbeatData } from "./zod/gcp-cloud-build-heartbeat-data-schema.js"; +export type { GcpCloudKmsKeyHeartbeatData } from "./zod/gcp-cloud-kms-key-heartbeat-data-schema.js"; export type { GcpCloudRunWorkerHeartbeatData } from "./zod/gcp-cloud-run-worker-heartbeat-data-schema.js"; export type { GcpCloudSqlPostgresHeartbeatData } from "./zod/gcp-cloud-sql-postgres-heartbeat-data-schema.js"; export type { GcpCloudStorageHeartbeatData } from "./zod/gcp-cloud-storage-heartbeat-data-schema.js"; @@ -180,6 +185,7 @@ export type { GcpCondition } from "./zod/gcp-condition-schema.js"; export type { GcpCustomCertificateConfig } from "./zod/gcp-custom-certificate-config-schema.js"; export type { GcpDaemonHeartbeatData } from "./zod/gcp-daemon-heartbeat-data-schema.js"; export type { GcpFirestoreKvHeartbeatData } from "./zod/gcp-firestore-kv-heartbeat-data-schema.js"; +export type { GcpKeyImportData } from "./zod/gcp-key-import-data-schema.js"; export type { GcpKvImportData } from "./zod/gcp-kv-import-data-schema.js"; export type { GcpManagementConfig } from "./zod/gcp-management-config-schema.js"; export type { GcpNetworkImportData } from "./zod/gcp-network-import-data-schema.js"; @@ -212,6 +218,11 @@ export type { HorizonWorkloadSchedulingMode } from "./zod/horizon-workload-sched export type { HttpMethod } from "./zod/http-method-schema.js"; export type { ImportSourceKind } from "./zod/import-source-kind-schema.js"; export type { ImportedResource } from "./zod/imported-resource-schema.js"; +export type { KeyFingerprint } from "./zod/key-fingerprint-schema.js"; +export type { KeyHeartbeatData } from "./zod/key-heartbeat-data-schema.js"; +export type { KeyHeartbeatStatus } from "./zod/key-heartbeat-status-schema.js"; +export type { KeyOutputs } from "./zod/key-outputs-schema.js"; +export type { Key } from "./zod/key-schema.js"; export type { KubernetesBuildHeartbeatData } from "./zod/kubernetes-build-heartbeat-data-schema.js"; export type { KubernetesCertificateMode } from "./zod/kubernetes-certificate-mode-schema.js"; export type { KubernetesCloudReference } from "./zod/kubernetes-cloud-reference-schema.js"; @@ -416,6 +427,8 @@ export { AwsEmailDomainImportDataSchema } from "./zod/aws-email-domain-import-da export { AwsEmailImportDataSchema } from "./zod/aws-email-import-data-schema.js"; export { AwsFailureDomainSubnetsSchema } from "./zod/aws-failure-domain-subnets-schema.js"; export { AwsIamRoleServiceAccountHeartbeatDataSchema } from "./zod/aws-iam-role-service-account-heartbeat-data-schema.js"; +export { AwsKeyImportDataSchema } from "./zod/aws-key-import-data-schema.js"; +export { AwsKmsKeyHeartbeatDataSchema } from "./zod/aws-kms-key-heartbeat-data-schema.js"; export { AwsKvImportDataSchema } from "./zod/aws-kv-import-data-schema.js"; export { AwsLambdaWorkerHeartbeatDataSchema } from "./zod/aws-lambda-worker-heartbeat-data-schema.js"; export { AwsManagementConfigSchema } from "./zod/aws-management-config-schema.js"; @@ -458,7 +471,9 @@ export { AzureDaemonHeartbeatDataSchema } from "./zod/azure-daemon-heartbeat-dat export { AzureFlexibleServerPostgresHeartbeatDataSchema } from "./zod/azure-flexible-server-postgres-heartbeat-data-schema.js"; export { AzureFlexibleServerPostgresImportDataSchema } from "./zod/azure-flexible-server-postgres-import-data-schema.js"; export { AzureFoundryAiHeartbeatDataSchema } from "./zod/azure-foundry-ai-heartbeat-data-schema.js"; +export { AzureKeyImportDataSchema } from "./zod/azure-key-import-data-schema.js"; export { AzureKeyVaultHeartbeatDataSchema } from "./zod/azure-key-vault-heartbeat-data-schema.js"; +export { AzureKeyVaultKeyHeartbeatDataSchema } from "./zod/azure-key-vault-key-heartbeat-data-schema.js"; export { AzureKvImportDataSchema } from "./zod/azure-kv-import-data-schema.js"; export { AzureManagedIdentityServiceAccountHeartbeatDataSchema } from "./zod/azure-managed-identity-service-account-heartbeat-data-schema.js"; export { AzureManagementConfigSchema } from "./zod/azure-management-config-schema.js"; @@ -559,6 +574,7 @@ export { GcpArtifactRegistryHeartbeatDataSchema } from "./zod/gcp-artifact-regis export { GcpArtifactRegistryImportDataSchema } from "./zod/gcp-artifact-registry-import-data-schema.js"; export { GcpBuildImportDataSchema } from "./zod/gcp-build-import-data-schema.js"; export { GcpCloudBuildHeartbeatDataSchema } from "./zod/gcp-cloud-build-heartbeat-data-schema.js"; +export { GcpCloudKmsKeyHeartbeatDataSchema } from "./zod/gcp-cloud-kms-key-heartbeat-data-schema.js"; export { GcpCloudRunWorkerHeartbeatDataSchema } from "./zod/gcp-cloud-run-worker-heartbeat-data-schema.js"; export { GcpCloudSqlPostgresHeartbeatDataSchema } from "./zod/gcp-cloud-sql-postgres-heartbeat-data-schema.js"; export { GcpCloudStorageHeartbeatDataSchema } from "./zod/gcp-cloud-storage-heartbeat-data-schema.js"; @@ -568,6 +584,7 @@ export { GcpConditionSchema } from "./zod/gcp-condition-schema.js"; export { GcpCustomCertificateConfigSchema } from "./zod/gcp-custom-certificate-config-schema.js"; export { GcpDaemonHeartbeatDataSchema } from "./zod/gcp-daemon-heartbeat-data-schema.js"; export { GcpFirestoreKvHeartbeatDataSchema } from "./zod/gcp-firestore-kv-heartbeat-data-schema.js"; +export { GcpKeyImportDataSchema } from "./zod/gcp-key-import-data-schema.js"; export { GcpKvImportDataSchema } from "./zod/gcp-kv-import-data-schema.js"; export { GcpManagementConfigSchema } from "./zod/gcp-management-config-schema.js"; export { GcpNetworkImportDataSchema } from "./zod/gcp-network-import-data-schema.js"; @@ -600,6 +617,11 @@ export { HorizonWorkloadSchedulingModeSchema } from "./zod/horizon-workload-sche export { HttpMethodSchema } from "./zod/http-method-schema.js"; export { ImportSourceKindSchema } from "./zod/import-source-kind-schema.js"; export { ImportedResourceSchema } from "./zod/imported-resource-schema.js"; +export { KeyFingerprintSchema } from "./zod/key-fingerprint-schema.js"; +export { KeyHeartbeatDataSchema } from "./zod/key-heartbeat-data-schema.js"; +export { KeyHeartbeatStatusSchema } from "./zod/key-heartbeat-status-schema.js"; +export { KeyOutputsSchema } from "./zod/key-outputs-schema.js"; +export { KeySchema } from "./zod/key-schema.js"; export { KubernetesBuildHeartbeatDataSchema } from "./zod/kubernetes-build-heartbeat-data-schema.js"; export { KubernetesCertificateModeSchema } from "./zod/kubernetes-certificate-mode-schema.js"; export { KubernetesCloudReferenceSchema } from "./zod/kubernetes-cloud-reference-schema.js"; diff --git a/packages/core/src/generated/schemas/awsKeyImportData.json b/packages/core/src/generated/schemas/awsKeyImportData.json new file mode 100644 index 000000000..7ba28f9d3 --- /dev/null +++ b/packages/core/src/generated/schemas/awsKeyImportData.json @@ -0,0 +1 @@ +{"type":"object","description":"AWS KMS key created by the customer-installed setup stack.","required":["keyArn"],"properties":{"keyArn":{"type":"string","description":"Immutable KMS key ARN. Alias ARNs are not accepted."}},"x-readme-ref-name":"AwsKeyImportData"} \ No newline at end of file diff --git a/packages/core/src/generated/schemas/awsKmsKeyHeartbeatData.json b/packages/core/src/generated/schemas/awsKmsKeyHeartbeatData.json new file mode 100644 index 000000000..7509bb57d --- /dev/null +++ b/packages/core/src/generated/schemas/awsKmsKeyHeartbeatData.json @@ -0,0 +1 @@ +{"type":"object","required":["status","keyArn","keyState","enabled","keySpec","keyUsage"],"properties":{"enabled":{"type":"boolean"},"keyArn":{"type":"string"},"keySpec":{"type":"string"},"keyState":{"type":"string"},"keyUsage":{"type":"string"},"status":{"type":"object","required":["health","lifecycle"],"properties":{"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]}},"x-readme-ref-name":"KeyHeartbeatStatus"}},"x-readme-ref-name":"AwsKmsKeyHeartbeatData"} \ No newline at end of file diff --git a/packages/core/src/generated/schemas/azureKeyImportData.json b/packages/core/src/generated/schemas/azureKeyImportData.json new file mode 100644 index 000000000..d797a6634 --- /dev/null +++ b/packages/core/src/generated/schemas/azureKeyImportData.json @@ -0,0 +1 @@ +{"type":"object","description":"Azure Key Vault key created by the customer-installed setup stack.","required":["vaultResourceId","keyName","lineageVersionId","keyId"],"properties":{"keyId":{"type":"string","description":"Full versioned Key Vault key ID used for new wrapping operations."},"keyName":{"type":"string","description":"Key name within the vault."},"lineageVersionId":{"type":"string","description":"Version ID that identifies the original key lineage."},"vaultResourceId":{"type":"string","description":"ARM resource ID of the dedicated Key Vault."}},"x-readme-ref-name":"AzureKeyImportData"} \ No newline at end of file diff --git a/packages/core/src/generated/schemas/azureKeyVaultKeyHeartbeatData.json b/packages/core/src/generated/schemas/azureKeyVaultKeyHeartbeatData.json new file mode 100644 index 000000000..5e5a10c17 --- /dev/null +++ b/packages/core/src/generated/schemas/azureKeyVaultKeyHeartbeatData.json @@ -0,0 +1 @@ +{"type":"object","required":["status","keyId","keyType","keyOperations"],"properties":{"enabled":{"type":["boolean","null"]},"keyId":{"type":"string"},"keyOperations":{"type":"array","items":{"type":"string"}},"keyType":{"type":"string"},"recoveryLevel":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle"],"properties":{"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]}},"x-readme-ref-name":"KeyHeartbeatStatus"}},"x-readme-ref-name":"AzureKeyVaultKeyHeartbeatData"} \ No newline at end of file diff --git a/packages/core/src/generated/schemas/gcpCloudKmsKeyHeartbeatData.json b/packages/core/src/generated/schemas/gcpCloudKmsKeyHeartbeatData.json new file mode 100644 index 000000000..bc9b9e8a0 --- /dev/null +++ b/packages/core/src/generated/schemas/gcpCloudKmsKeyHeartbeatData.json @@ -0,0 +1 @@ +{"type":"object","required":["status","cryptoKeyName","purpose"],"properties":{"algorithm":{"type":["string","null"]},"cryptoKeyName":{"type":"string"},"primaryState":{"type":["string","null"]},"primaryVersion":{"type":["string","null"]},"purpose":{"type":"string"},"status":{"type":"object","required":["health","lifecycle"],"properties":{"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]}},"x-readme-ref-name":"KeyHeartbeatStatus"}},"x-readme-ref-name":"GcpCloudKmsKeyHeartbeatData"} \ No newline at end of file diff --git a/packages/core/src/generated/schemas/gcpKeyImportData.json b/packages/core/src/generated/schemas/gcpKeyImportData.json new file mode 100644 index 000000000..6d576a114 --- /dev/null +++ b/packages/core/src/generated/schemas/gcpKeyImportData.json @@ -0,0 +1 @@ +{"type":"object","description":"GCP Cloud KMS key created by the customer-installed setup stack.","required":["cryptoKeyName","primaryVersion"],"properties":{"cryptoKeyName":{"type":"string","description":"Full CryptoKey resource name, without a CryptoKeyVersion."},"primaryVersion":{"type":"string","description":"Full primary CryptoKeyVersion resource name used for new wrapping operations."}},"x-readme-ref-name":"GcpKeyImportData"} \ No newline at end of file diff --git a/packages/core/src/generated/schemas/key.json b/packages/core/src/generated/schemas/key.json new file mode 100644 index 000000000..3e5f89db4 --- /dev/null +++ b/packages/core/src/generated/schemas/key.json @@ -0,0 +1 @@ +{"type":"object","description":"A customer-managed encryption key.","required":["id"],"properties":{"id":{"type":"string","description":"Identifier for the key resource."}},"additionalProperties":false,"x-readme-ref-name":"Key"} \ No newline at end of file diff --git a/packages/core/src/generated/schemas/keyFingerprint.json b/packages/core/src/generated/schemas/keyFingerprint.json new file mode 100644 index 000000000..61051dca7 --- /dev/null +++ b/packages/core/src/generated/schemas/keyFingerprint.json @@ -0,0 +1 @@ +{"oneOf":[{"type":"object","description":"An immutable AWS KMS key ARN. Alias ARNs are not accepted.","required":["key_arn","provider"],"properties":{"key_arn":{"type":"string"},"provider":{"type":"string","enum":["aws"]}}},{"type":"object","description":"A full GCP CryptoKey resource name, without a CryptoKeyVersion.","required":["crypto_key_name","provider"],"properties":{"crypto_key_name":{"type":"string"},"provider":{"type":"string","enum":["gcp"]}}},{"type":"object","description":"An Azure Key Vault key family pinned to its original lineage.","required":["vault_resource_id","key_name","lineage_version_id","provider"],"properties":{"key_name":{"type":"string"},"lineage_version_id":{"type":"string"},"provider":{"type":"string","enum":["azure"]},"vault_resource_id":{"type":"string"}}}],"description":"Stable identity of a provider key family.\n\nProvider-native version rotation does not change this value. Replacing the\nprovider key does.","x-readme-ref-name":"KeyFingerprint"} \ No newline at end of file diff --git a/packages/core/src/generated/schemas/keyHeartbeatData.json b/packages/core/src/generated/schemas/keyHeartbeatData.json new file mode 100644 index 000000000..322bbc8c7 --- /dev/null +++ b/packages/core/src/generated/schemas/keyHeartbeatData.json @@ -0,0 +1 @@ +{"oneOf":[{"type":"object","required":["data","provider"],"properties":{"data":{"type":"object","required":["status","keyArn","keyState","enabled","keySpec","keyUsage"],"properties":{"enabled":{"type":"boolean"},"keyArn":{"type":"string"},"keySpec":{"type":"string"},"keyState":{"type":"string"},"keyUsage":{"type":"string"},"status":{"type":"object","required":["health","lifecycle"],"properties":{"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]}},"x-readme-ref-name":"KeyHeartbeatStatus"}},"x-readme-ref-name":"AwsKmsKeyHeartbeatData"},"provider":{"type":"string","enum":["aws-kms"]}}},{"type":"object","required":["data","provider"],"properties":{"data":{"type":"object","required":["status","cryptoKeyName","purpose"],"properties":{"algorithm":{"type":["string","null"]},"cryptoKeyName":{"type":"string"},"primaryState":{"type":["string","null"]},"primaryVersion":{"type":["string","null"]},"purpose":{"type":"string"},"status":{"type":"object","required":["health","lifecycle"],"properties":{"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]}},"x-readme-ref-name":"KeyHeartbeatStatus"}},"x-readme-ref-name":"GcpCloudKmsKeyHeartbeatData"},"provider":{"type":"string","enum":["gcp-cloud-kms"]}}},{"type":"object","required":["data","provider"],"properties":{"data":{"type":"object","required":["status","keyId","keyType","keyOperations"],"properties":{"enabled":{"type":["boolean","null"]},"keyId":{"type":"string"},"keyOperations":{"type":"array","items":{"type":"string"}},"keyType":{"type":"string"},"recoveryLevel":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle"],"properties":{"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]}},"x-readme-ref-name":"KeyHeartbeatStatus"}},"x-readme-ref-name":"AzureKeyVaultKeyHeartbeatData"},"provider":{"type":"string","enum":["azure-key-vault"]}}}],"x-readme-ref-name":"KeyHeartbeatData"} \ No newline at end of file diff --git a/packages/core/src/generated/schemas/keyHeartbeatStatus.json b/packages/core/src/generated/schemas/keyHeartbeatStatus.json new file mode 100644 index 000000000..4c8b0062c --- /dev/null +++ b/packages/core/src/generated/schemas/keyHeartbeatStatus.json @@ -0,0 +1 @@ +{"type":"object","required":["health","lifecycle"],"properties":{"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]}},"x-readme-ref-name":"KeyHeartbeatStatus"} \ No newline at end of file diff --git a/packages/core/src/generated/schemas/keyOutputs.json b/packages/core/src/generated/schemas/keyOutputs.json new file mode 100644 index 000000000..8a128dcd0 --- /dev/null +++ b/packages/core/src/generated/schemas/keyOutputs.json @@ -0,0 +1 @@ +{"type":"object","description":"Outputs generated by a successfully provisioned Key.","required":["fingerprint","wrappingKeyId"],"properties":{"fingerprint":{"description":"Stable provider key-family identity.","oneOf":[{"type":"object","description":"An immutable AWS KMS key ARN. Alias ARNs are not accepted.","required":["key_arn","provider"],"properties":{"key_arn":{"type":"string"},"provider":{"type":"string","enum":["aws"]}}},{"type":"object","description":"A full GCP CryptoKey resource name, without a CryptoKeyVersion.","required":["crypto_key_name","provider"],"properties":{"crypto_key_name":{"type":"string"},"provider":{"type":"string","enum":["gcp"]}}},{"type":"object","description":"An Azure Key Vault key family pinned to its original lineage.","required":["vault_resource_id","key_name","lineage_version_id","provider"],"properties":{"key_name":{"type":"string"},"lineage_version_id":{"type":"string"},"provider":{"type":"string","enum":["azure"]},"vault_resource_id":{"type":"string"}}}],"x-readme-ref-name":"KeyFingerprint"},"wrappingKeyId":{"type":"string","description":"Exact provider key version used for new wrapping operations."}},"additionalProperties":false,"x-readme-ref-name":"KeyOutputs"} \ No newline at end of file diff --git a/packages/core/src/generated/schemas/resourceHeartbeat.json b/packages/core/src/generated/schemas/resourceHeartbeat.json index f04b1a554..71ee4def3 100644 --- a/packages/core/src/generated/schemas/resourceHeartbeat.json +++ b/packages/core/src/generated/schemas/resourceHeartbeat.json @@ -1 +1 @@ -{"type":"object","required":["resourceId","resourceType","controllerPlatform","backend","observedAt","data","raw"],"properties":{"backend":{"type":"string","enum":["aws","gcp","azure","kubernetes","local","managed","external","test"],"x-readme-ref-name":"HeartbeatBackend"},"controllerPlatform":{"type":"string","description":"Represents the target cloud platform.","enum":["aws","gcp","azure","kubernetes","machines","local","test"],"x-readme-ref-name":"Platform"},"data":{"oneOf":[{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","name","lifecyclePresent","encryptionConfigPresent","publicAccessBlockPresent"],"properties":{"blockPublicAcls":{"type":["boolean","null"]},"blockPublicPolicy":{"type":["boolean","null"]},"bucketAclPresent":{"type":["boolean","null"]},"bucketLocation":{"type":["string","null"]},"bucketPolicyPresent":{"type":["boolean","null"]},"encryptionConfigPresent":{"type":"boolean"},"encryptionEnabled":{"type":["boolean","null"]},"ignorePublicAcls":{"type":["boolean","null"]},"lifecyclePresent":{"type":"boolean"},"lifecycleRuleCount":{"type":["integer","null"],"format":"int64","minimum":0},"name":{"type":"string"},"publicAccessBlockPresent":{"type":"boolean"},"region":{"type":["string","null"]},"restrictPublicBuckets":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"versioningEnabled":{"type":["boolean","null"]},"versioningStatus":{"type":["string","null"]}},"x-readme-ref-name":"AwsS3StorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsS3"]}}}]},{"allOf":[{"type":"object","required":["status","name","lifecyclePresent","encryptionConfigPresent"],"properties":{"bucketId":{"type":["string","null"]},"defaultKmsKeyName":{"type":["string","null"]},"encryptionConfigPresent":{"type":"boolean"},"lifecyclePresent":{"type":"boolean"},"lifecycleRuleCount":{"type":["integer","null"],"format":"int64","minimum":0},"location":{"type":["string","null"]},"locationType":{"type":["string","null"]},"name":{"type":"string"},"publicAccessPrevention":{"type":["string","null"]},"retentionPeriod":{"type":["string","null"]},"retentionPolicyEffectiveTime":{"type":["string","null"]},"retentionPolicyIsLocked":{"type":["boolean","null"]},"softDeleteEffectiveTime":{"type":["string","null"]},"softDeleteRetentionDurationSeconds":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"storageClass":{"type":["string","null"]},"uniformBucketLevelAccessEnabled":{"type":["boolean","null"]},"uniformBucketLevelAccessLockedTime":{"type":["string","null"]},"versioningEnabled":{"type":["boolean","null"]}},"x-readme-ref-name":"GcpCloudStorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpCloudStorage"]}}}]},{"allOf":[{"type":"object","required":["status","name"],"properties":{"accessTier":{"type":["string","null"]},"accountKind":{"type":["string","null"]},"allowBlobPublicAccess":{"type":["boolean","null"]},"blobDeleteRetentionDays":{"type":["integer","null"],"format":"int64","minimum":0},"blobDeleteRetentionEnabled":{"type":["boolean","null"]},"blobEncryptionEnabled":{"type":["boolean","null"]},"blobVersioningEnabled":{"type":["boolean","null"]},"changeFeedEnabled":{"type":["boolean","null"]},"changeFeedRetentionDays":{"type":["integer","null"],"format":"int64","minimum":0},"containerDeleteRetentionDays":{"type":["integer","null"],"format":"int64","minimum":0},"containerDeleteRetentionEnabled":{"type":["boolean","null"]},"containerPublicAccess":{"type":["string","null"]},"encryptionKeySource":{"type":["string","null"]},"fileEncryptionEnabled":{"type":["boolean","null"]},"location":{"type":["string","null"]},"name":{"type":"string"},"primaryLocation":{"type":["string","null"]},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":["string","null"]},"queueEncryptionEnabled":{"type":["boolean","null"]},"resourceGroup":{"type":["string","null"]},"secondaryLocation":{"type":["string","null"]},"skuName":{"type":["string","null"]},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"statusOfPrimary":{"type":["string","null"]},"statusOfSecondary":{"type":["string","null"]},"storageAccountName":{"type":["string","null"]},"tableEncryptionEnabled":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureBlobStorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureBlob"]}}}]},{"allOf":[{"type":"object","required":["status","path","pathExists"],"properties":{"isDirectory":{"type":["boolean","null"]},"modifiedAt":{"type":["string","null"],"format":"date-time"},"path":{"type":"string"},"pathExists":{"type":"boolean"},"readonly":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"}},"x-readme-ref-name":"LocalStorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"StorageHeartbeatData"},"resourceType":{"type":"string","enum":["storage"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","functionName","layerCount","functionUrlCorsPresent","triggerCount"],"properties":{"codeSha256":{"type":["string","null"]},"functionName":{"type":"string"},"functionUrlAuthType":{"type":["string","null"]},"functionUrlCorsPresent":{"type":"boolean"},"lastModified":{"type":["string","null"]},"lastUpdateStatus":{"type":["string","null"]},"lastUpdateStatusReason":{"type":["string","null"]},"lastUpdateStatusReasonCode":{"type":["string","null"]},"layerCount":{"type":"integer","format":"int32","minimum":0},"memorySizeMb":{"type":["integer","null"],"format":"int64"},"packageType":{"type":["string","null"]},"revisionId":{"type":["string","null"]},"runtime":{"type":["string","null"]},"state":{"type":["string","null"]},"stateReason":{"type":["string","null"]},"stateReasonCode":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"timeoutSeconds":{"type":["integer","null"],"format":"int64"},"triggerCount":{"type":"integer","format":"int32","minimum":0},"version":{"type":["string","null"]}},"x-readme-ref-name":"AwsLambdaWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsLambda"]}}}]},{"allOf":[{"type":"object","required":["status","service","urls","trafficCount"],"properties":{"containerImage":{"type":["string","null"]},"cpuLimit":{"type":["string","null"]},"generation":{"type":["integer","null"],"format":"int64"},"latestCreatedRevision":{"type":["string","null"]},"latestReadyRevision":{"type":["string","null"]},"maxInstanceCount":{"type":["integer","null"],"format":"int32"},"memoryLimit":{"type":["string","null"]},"minInstanceCount":{"type":["integer","null"],"format":"int32"},"observedGeneration":{"type":["integer","null"],"format":"int64"},"region":{"type":["string","null"]},"service":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"trafficCount":{"type":"integer","format":"int32","minimum":0},"uri":{"type":["string","null"]},"urls":{"type":"array","items":{"type":"string"}}},"x-readme-ref-name":"GcpCloudRunWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpCloudRun"]}}}]},{"allOf":[{"type":"object","required":["status","appName"],"properties":{"appName":{"type":"string"},"cpu":{"type":["number","null"],"format":"double"},"environmentName":{"type":["string","null"]},"ingressFqdn":{"type":["string","null"]},"maxReplicas":{"type":["integer","null"],"format":"int32"},"memory":{"type":["string","null"]},"minReplicas":{"type":["integer","null"],"format":"int32"},"provisioningState":{"type":["string","null"]},"revision":{"type":["string","null"]},"runningStatus":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"AzureContainerAppsWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureContainerApps"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","name","workloadKind","replicas","pods","triggerCount","events"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":"string"},"pods":{"type":"array","items":{"type":"object","required":["name","ready","restartCount","ownerReferences"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"ownerReferences":{"type":"array","items":{"type":"object","required":["kind","name","uid","controller"],"properties":{"controller":{"type":"boolean"},"kind":{"type":"string"},"name":{"type":"string"},"uid":{"type":"string"}},"x-readme-ref-name":"KubernetesOwnerReference"}},"phase":{"type":["string","null"]},"podIp":{"type":["string","null"]},"ready":{"type":"boolean"},"restartCount":{"type":"integer","format":"int32","minimum":0},"terminatedReason":{"type":["string","null"]},"uid":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesPodRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"restarts":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"triggerCount":{"type":"integer","format":"int32","minimum":0},"workload":{"oneOf":[{"type":"null"},{"type":"object","required":["conditions"],"properties":{"availableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"lastTransitionTime":{"type":["string","null"],"format":"date-time"},"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesWorkloadCondition"}},"desiredGeneration":{"type":["integer","null"],"format":"int64"},"desiredReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"observedGeneration":{"type":["integer","null"],"format":"int64"},"readyReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"rolloutReason":{"type":["string","null"]},"updatedReplicas":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"KubernetesWorkloadStatus"}]},"workloadKind":{"type":"string","enum":["deployment","statefulSet","daemonSet","replicaSet","pod"],"x-readme-ref-name":"KubernetesWorkloadKind"}},"x-readme-ref-name":"KubernetesWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetes"]}}}]},{"allOf":[{"type":"object","required":["status","commandSupported","imagePathPresent","triggerCount","events"],"properties":{"commandSupported":{"type":"boolean"},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["timestamp","severity","kind","message"],"properties":{"kind":{"type":"string"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"subject":{"oneOf":[{"type":"null"},{"type":"object","required":["kind"],"properties":{"id":{"type":["string","null"]},"kind":{"type":"string"},"name":{"type":["string","null"]}},"x-readme-ref-name":"LocalRuntimeEventSubject"}]},"timestamp":{"type":"string","format":"date-time"}},"x-readme-ref-name":"LocalRuntimeEventSnapshot"}},"imagePathPresent":{"type":"boolean"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"process":{"oneOf":[{"type":"null"},{"type":"object","required":["unitId","name","kind","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"kind":{"type":"string","enum":["container","process","daemon"],"x-readme-ref-name":"LocalRuntimeUnitKind"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"phase":{"type":["string","null"]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":"boolean"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"unitId":{"type":"string"}},"x-readme-ref-name":"LocalRuntimeUnitStatus"}]},"readinessProbeOk":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"triggerCount":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"LocalWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"WorkerHeartbeatData"},"resourceType":{"type":"string","enum":["worker"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","containerId","schedulingMode","replicas","attentionCount","replicaUnits","events"],"properties":{"attentionCount":{"type":"integer","format":"int32","minimum":0},"containerId":{"type":"string"},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"image":{"type":["string","null"]},"latestUpdateTimestamp":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"observedImage":{"type":["string","null"]},"replicaUnits":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"schedulingMode":{"type":"string","enum":["replicated","stateful","daemon"],"x-readme-ref-name":"HorizonWorkloadSchedulingMode"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"HorizonContainerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["horizonPlatform"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","name","workloadKind","replicas","pods","events"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":"string"},"pods":{"type":"array","items":{"type":"object","required":["name","ready","restartCount","ownerReferences"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"ownerReferences":{"type":"array","items":{"type":"object","required":["kind","name","uid","controller"],"properties":{"controller":{"type":"boolean"},"kind":{"type":"string"},"name":{"type":"string"},"uid":{"type":"string"}},"x-readme-ref-name":"KubernetesOwnerReference"}},"phase":{"type":["string","null"]},"podIp":{"type":["string","null"]},"ready":{"type":"boolean"},"restartCount":{"type":"integer","format":"int32","minimum":0},"terminatedReason":{"type":["string","null"]},"uid":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesPodRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"restarts":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"workload":{"oneOf":[{"type":"null"},{"type":"object","required":["conditions"],"properties":{"availableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"lastTransitionTime":{"type":["string","null"],"format":"date-time"},"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesWorkloadCondition"}},"desiredGeneration":{"type":["integer","null"],"format":"int64"},"desiredReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"observedGeneration":{"type":["integer","null"],"format":"int64"},"readyReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"rolloutReason":{"type":["string","null"]},"updatedReplicas":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"KubernetesWorkloadStatus"}]},"workloadKind":{"type":"string","enum":["deployment","statefulSet","daemonSet","replicaSet","pod"],"x-readme-ref-name":"KubernetesWorkloadKind"}},"x-readme-ref-name":"KubernetesContainerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetes"]}}}]},{"allOf":[{"type":"object","required":["status","portCount","bindMountCount","runtimeReachable","events"],"properties":{"bindMountCount":{"type":"integer","format":"int32","minimum":0},"containerId":{"type":["string","null"]},"containerUnit":{"oneOf":[{"type":"null"},{"type":"object","required":["unitId","name","kind","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"kind":{"type":"string","enum":["container","process","daemon"],"x-readme-ref-name":"LocalRuntimeUnitKind"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"phase":{"type":["string","null"]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":"boolean"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"unitId":{"type":"string"}},"x-readme-ref-name":"LocalRuntimeUnitStatus"}]},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["timestamp","severity","kind","message"],"properties":{"kind":{"type":"string"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"subject":{"oneOf":[{"type":"null"},{"type":"object","required":["kind"],"properties":{"id":{"type":["string","null"]},"kind":{"type":"string"},"name":{"type":["string","null"]}},"x-readme-ref-name":"LocalRuntimeEventSubject"}]},"timestamp":{"type":"string","format":"date-time"}},"x-readme-ref-name":"LocalRuntimeEventSnapshot"}},"image":{"type":["string","null"]},"localUrl":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":["string","null"]},"portCount":{"type":"integer","format":"int32","minimum":0},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"runtimeReachable":{"type":"boolean"},"runtimeStatus":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"LocalContainerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ContainerHeartbeatData"},"resourceType":{"type":"string","enum":["container"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"AwsDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["aws"]}}}]},{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"GcpDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcp"]}}}]},{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"AzureDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azure"]}}}]},{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"MachinesDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["machines"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","name","replicas","commandSupported","pods","events"],"properties":{"commandSupported":{"type":"boolean"},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":"string"},"pods":{"type":"array","items":{"type":"object","required":["name","ready","restartCount","ownerReferences"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"ownerReferences":{"type":"array","items":{"type":"object","required":["kind","name","uid","controller"],"properties":{"controller":{"type":"boolean"},"kind":{"type":"string"},"name":{"type":"string"},"uid":{"type":"string"}},"x-readme-ref-name":"KubernetesOwnerReference"}},"phase":{"type":["string","null"]},"podIp":{"type":["string","null"]},"ready":{"type":"boolean"},"restartCount":{"type":"integer","format":"int32","minimum":0},"terminatedReason":{"type":["string","null"]},"uid":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesPodRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"restarts":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"workload":{"oneOf":[{"type":"null"},{"type":"object","required":["conditions"],"properties":{"availableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"lastTransitionTime":{"type":["string","null"],"format":"date-time"},"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesWorkloadCondition"}},"desiredGeneration":{"type":["integer","null"],"format":"int64"},"desiredReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"observedGeneration":{"type":["integer","null"],"format":"int64"},"readyReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"rolloutReason":{"type":["string","null"]},"updatedReplicas":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"KubernetesWorkloadStatus"}]}},"x-readme-ref-name":"KubernetesDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetes"]}}}]},{"allOf":[{"type":"object","required":["status","runtimeId","commandSupported","imagePathPresent","events"],"properties":{"commandSupported":{"type":"boolean"},"daemonInstance":{"oneOf":[{"type":"null"},{"type":"object","required":["unitId","name","kind","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"kind":{"type":"string","enum":["container","process","daemon"],"x-readme-ref-name":"LocalRuntimeUnitKind"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"phase":{"type":["string","null"]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":"boolean"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"unitId":{"type":"string"}},"x-readme-ref-name":"LocalRuntimeUnitStatus"}]},"daemonName":{"type":"string"},"events":{"type":"array","items":{"type":"object","required":["timestamp","severity","kind","message"],"properties":{"kind":{"type":"string"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"subject":{"oneOf":[{"type":"null"},{"type":"object","required":["kind"],"properties":{"id":{"type":["string","null"]},"kind":{"type":"string"},"name":{"type":["string","null"]}},"x-readme-ref-name":"LocalRuntimeEventSubject"}]},"timestamp":{"type":"string","format":"date-time"}},"x-readme-ref-name":"LocalRuntimeEventSnapshot"}},"exitReason":{"type":["string","null"]},"imagePathPresent":{"type":"boolean"},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"runtimeId":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"LocalDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"DaemonHeartbeatData"},"resourceType":{"type":"string","enum":["daemon"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","providerFleets"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"providerFleets":{"type":"array","items":{"type":"object","required":["groupId","providerId","currentMachines","desiredMachines"],"properties":{"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"groupId":{"type":"string"},"location":{"type":["string","null"]},"providerId":{"type":"string"}},"x-readme-ref-name":"ProviderFleetStatus"}},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"AwsComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["aws"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","providerFleets"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"providerFleets":{"type":"array","items":{"type":"object","required":["groupId","providerId","currentMachines","desiredMachines"],"properties":{"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"groupId":{"type":"string"},"location":{"type":["string","null"]},"providerId":{"type":"string"}},"x-readme-ref-name":"ProviderFleetStatus"}},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"GcpComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcp"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","providerFleets"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"providerFleets":{"type":"array","items":{"type":"object","required":["groupId","providerId","currentMachines","desiredMachines"],"properties":{"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"groupId":{"type":"string"},"location":{"type":["string","null"]},"providerId":{"type":"string"}},"x-readme-ref-name":"ProviderFleetStatus"}},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"AzureComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azure"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","machines"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"machines":{"type":"array","items":{"type":"object","required":["machineId","status","capacityGroup","zone","lastHeartbeat","replicaCount","drainForce"],"properties":{"capacityGroup":{"type":"string"},"cpuCores":{"type":["number","null"],"format":"double"},"drainBlockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainForce":{"type":"boolean"},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"horizondVersion":{"type":["string","null"]},"lastHeartbeat":{"type":"string"},"machineId":{"type":"string"},"memoryBytes":{"type":["integer","null"],"format":"int64"},"overlayIp":{"type":["string","null"]},"publicIp":{"type":["string","null"]},"replicaCount":{"type":"integer","format":"int64"},"status":{"type":"string"},"zone":{"type":"string"}},"x-readme-ref-name":"MachinesComputeMachineStatus"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"MachinesComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["machines"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","dockerAvailable","networkAvailable"],"properties":{"dockerApiVersion":{"type":["string","null"]},"dockerArch":{"type":["string","null"]},"dockerAvailable":{"type":"boolean"},"dockerOs":{"type":["string","null"]},"dockerVersion":{"type":["string","null"]},"hostIdentifier":{"type":["string","null"]},"name":{"type":"string"},"networkAvailable":{"type":"boolean"},"networkName":{"type":["string","null"]},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"runningContainers":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"},"trackedContainers":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"LocalComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ComputeClusterHeartbeatData"},"resourceType":{"type":"string","enum":["compute-cluster"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","nodeCounts","podCounts","name","events"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":["string","null"]},"nodeCounts":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"nodeStatuses":{"type":"array","items":{"type":"object","required":["name","ready","roles","labels","allocatable","capacity"],"properties":{"allocatable":{"type":"object","properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"pods":{"type":["integer","null"],"format":"int64","minimum":0}},"x-readme-ref-name":"KubernetesNodeResources"},"capacity":{"type":"object","properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"pods":{"type":["integer","null"],"format":"int64","minimum":0}},"x-readme-ref-name":"KubernetesNodeResources"},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesNodeConditionStatus"}},"containerRuntimeVersion":{"type":["string","null"]},"kubeletVersion":{"type":["string","null"]},"labels":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"name":{"type":"string"},"ready":{"type":"boolean"},"roles":{"type":"array","items":{"type":"string"}},"uid":{"type":["string","null"]},"usage":{"oneOf":[{"type":"null"},{"type":"object","properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"KubernetesNodeUsage"}]}},"x-readme-ref-name":"KubernetesClusterNodeStatus"}},"podCounts":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"version":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesClusterHeartbeatData"},"resourceType":{"type":"string","enum":["kubernetes-cluster"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","name","approximateCounts"],"properties":{"approximateCounts":{"type":"boolean"},"approximateDelayedMessages":{"type":["integer","null"],"format":"int64","minimum":0},"approximateInFlightMessages":{"type":["integer","null"],"format":"int64","minimum":0},"approximateVisibleMessages":{"type":["integer","null"],"format":"int64","minimum":0},"contentBasedDeduplication":{"type":["boolean","null"]},"deduplicationScope":{"type":["string","null"]},"delaySeconds":{"type":["integer","null"],"format":"int32","minimum":0},"fifoQueue":{"type":["boolean","null"]},"fifoThroughputLimit":{"type":["string","null"]},"kmsDataKeyReusePeriodSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"kmsMasterKeyId":{"type":["string","null"]},"maximumMessageSize":{"type":["integer","null"],"format":"int32","minimum":0},"messageRetentionPeriodSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"name":{"type":"string"},"queueArn":{"type":["string","null"]},"queueUrl":{"type":["string","null"]},"receiveMessageWaitTimeSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"redriveAllowPolicy":{"type":["string","null"]},"redrivePolicy":{"type":["string","null"]},"region":{"type":["string","null"]},"sqsManagedSseEnabled":{"type":["boolean","null"]},"sseEnabled":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"visibilityTimeoutSeconds":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"AwsSqsQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsSqs"]}}}]},{"allOf":[{"type":"object","required":["status","topicName","topicLabels","subscriptionLabels","messageStorageAllowedPersistenceRegions","subscriptionPushAttributes"],"properties":{"endpoint":{"type":["string","null"]},"kmsKeyName":{"type":["string","null"]},"messageStorageAllowedPersistenceRegions":{"type":"array","items":{"type":"string"}},"messageStorageEnforceInTransit":{"type":["boolean","null"]},"projectId":{"type":["string","null"]},"schemaEncoding":{"type":["string","null"]},"schemaFirstRevisionId":{"type":["string","null"]},"schemaLastRevisionId":{"type":["string","null"]},"schemaName":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"subscriptionAckDeadlineSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"subscriptionDeadLetterMaxDeliveryAttempts":{"type":["integer","null"],"format":"int32","minimum":0},"subscriptionDeadLetterTopic":{"type":["string","null"]},"subscriptionDetached":{"type":["boolean","null"]},"subscriptionEnableMessageOrdering":{"type":["boolean","null"]},"subscriptionFilter":{"type":["string","null"]},"subscriptionFullName":{"type":["string","null"]},"subscriptionLabels":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"subscriptionMessageRetentionDuration":{"type":["string","null"]},"subscriptionName":{"type":["string","null"]},"subscriptionPushAttributes":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"subscriptionPushConfigPresent":{"type":["boolean","null"]},"subscriptionPushEndpoint":{"type":["string","null"]},"subscriptionPushNoWrapperWriteMetadata":{"type":["boolean","null"]},"subscriptionPushOidcAudience":{"type":["string","null"]},"subscriptionPushOidcServiceAccountEmail":{"type":["string","null"]},"subscriptionPushPubsubWrapperWriteMetadata":{"type":["boolean","null"]},"subscriptionRetainAckedMessages":{"type":["boolean","null"]},"subscriptionState":{"type":["string","null"]},"topicFullName":{"type":["string","null"]},"topicLabels":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"topicMessageRetentionDuration":{"type":["string","null"]},"topicName":{"type":"string"},"topicState":{"type":["string","null"]}},"x-readme-ref-name":"GcpPubSubQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpPubSub"]}}}]},{"allOf":[{"type":"object","required":["status","name","namespaceName"],"properties":{"accessedAt":{"type":["string","null"]},"activeMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"autoDeleteOnIdle":{"type":["string","null"]},"createdAt":{"type":["string","null"]},"deadLetterMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"deadLetteringOnMessageExpiration":{"type":["boolean","null"]},"defaultMessageTimeToLive":{"type":["string","null"]},"duplicateDetectionHistoryTimeWindow":{"type":["string","null"]},"enableBatchedOperations":{"type":["boolean","null"]},"enableExpress":{"type":["boolean","null"]},"enablePartitioning":{"type":["boolean","null"]},"endpoint":{"type":["string","null"]},"forwardDeadLetteredMessagesTo":{"type":["string","null"]},"forwardTo":{"type":["string","null"]},"lockDuration":{"type":["string","null"]},"maxDeliveryCount":{"type":["integer","null"],"format":"int32","minimum":0},"maxMessageSizeInKilobytes":{"type":["integer","null"],"format":"int64","minimum":0},"maxSizeInMegabytes":{"type":["integer","null"],"format":"int32","minimum":0},"messageCount":{"type":["integer","null"],"format":"int64","minimum":0},"name":{"type":"string"},"namespaceName":{"type":"string"},"queueStatus":{"type":["string","null"]},"requiresDuplicateDetection":{"type":["boolean","null"]},"requiresSession":{"type":["boolean","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"scheduledMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"sizeInBytes":{"type":["integer","null"],"format":"int64","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"transferDeadLetterMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"transferMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"updatedAt":{"type":["string","null"]}},"x-readme-ref-name":"AzureServiceBusQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureServiceBus"]}}}]},{"allOf":[{"type":"object","required":["status","name"],"properties":{"name":{"type":"string"},"path":{"type":["string","null"]},"serviceStatus":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"}},"x-readme-ref-name":"LocalQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"QueueHeartbeatData"},"resourceType":{"type":"string","enum":["queue"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","name","keySchema"],"properties":{"billingMode":{"type":["string","null"]},"deletionProtectionEnabled":{"type":["boolean","null"]},"globalSecondaryIndexCount":{"type":["integer","null"],"format":"int32","minimum":0},"itemCount":{"type":["integer","null"],"format":"int64","minimum":0},"keySchema":{"type":"array","items":{"type":"object","required":["attributeName","keyType"],"properties":{"attributeName":{"type":"string"},"keyType":{"type":"string"}},"x-readme-ref-name":"AwsDynamoDbKeySchemaElement"}},"localSecondaryIndexCount":{"type":["integer","null"],"format":"int32","minimum":0},"name":{"type":"string"},"region":{"type":["string","null"]},"replicaCount":{"type":["integer","null"],"format":"int32","minimum":0},"restoreInProgress":{"type":["boolean","null"]},"sseStatus":{"type":["string","null"]},"sseType":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"},"streamEnabled":{"type":["boolean","null"]},"streamViewType":{"type":["string","null"]},"tableArn":{"type":["string","null"]},"tableClass":{"type":["string","null"]},"tableSizeBytes":{"type":["integer","null"],"format":"int64","minimum":0},"tableStatus":{"type":["string","null"]},"ttlAttributeName":{"type":["string","null"]},"ttlStatus":{"type":["string","null"]}},"x-readme-ref-name":"AwsDynamoDbKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsDynamoDb"]}}}]},{"allOf":[{"type":"object","required":["status","databaseName","cmekEnabled","sourceInfoPresent"],"properties":{"appEngineIntegrationMode":{"type":["string","null"]},"cmekEnabled":{"type":"boolean"},"concurrencyMode":{"type":["string","null"]},"createTime":{"type":["string","null"]},"databaseEdition":{"type":["string","null"]},"databaseName":{"type":"string"},"databaseType":{"type":["string","null"]},"deleteProtectionState":{"type":["string","null"]},"deleteTime":{"type":["string","null"]},"earliestVersionTime":{"type":["string","null"]},"endpoint":{"type":["string","null"]},"locationId":{"type":["string","null"]},"pointInTimeRecoveryEnablement":{"type":["string","null"]},"projectId":{"type":["string","null"]},"sourceInfoPresent":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"},"updateTime":{"type":["string","null"]},"versionRetentionPeriod":{"type":["string","null"]}},"x-readme-ref-name":"GcpFirestoreKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpFirestore"]}}}]},{"allOf":[{"type":"object","required":["status","tableName","storageAccountName","tableExists"],"properties":{"endpoint":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"signedIdentifierCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"},"storageAccountKind":{"type":["string","null"]},"storageAccountLocation":{"type":["string","null"]},"storageAccountName":{"type":"string"},"storageAccountPrimaryStatus":{"type":["string","null"]},"storageAccountProvisioningState":{"type":["string","null"]},"storageAccountResourceId":{"type":["string","null"]},"tableExists":{"type":"boolean"},"tableName":{"type":"string"}},"x-readme-ref-name":"AzureTableKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureTable"]}}}]},{"allOf":[{"type":"object","required":["status","name","path","pathExists","cloudMetadataSupported"],"properties":{"cloudMetadataSupported":{"type":"boolean"},"isDirectory":{"type":["boolean","null"]},"name":{"type":"string"},"path":{"type":"string"},"pathExists":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"}},"x-readme-ref-name":"LocalKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"KvHeartbeatData"},"resourceType":{"type":"string","enum":["kv"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"description":"AWS Aurora Serverless v2 backend.","type":"object","required":["status","clusterIdentifier","neverPauses"],"properties":{"clusterIdentifier":{"type":"string"},"endpoint":{"type":["string","null"]},"engineVersion":{"type":["string","null"]},"neverPauses":{"type":"boolean","description":"True when a `minCapacity: 0` instance has not reached 0 ACU over the observation\nwindow — it is silently paying always-on prices (auto-pause verification)."},"serverlessCapacity":{"type":["number","null"],"format":"double","description":"Latest sampled `ServerlessDatabaseCapacity` (ACU)."},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"}},"x-readme-ref-name":"AuroraPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["aurora"]}}}],"description":"AWS Aurora Serverless v2 backend."},{"allOf":[{"description":"GCP Cloud SQL backend.","type":"object","required":["status","instanceName"],"properties":{"databaseVersion":{"type":["string","null"]},"instanceName":{"type":"string"},"state":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"}},"x-readme-ref-name":"GcpCloudSqlPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["cloudSql"]}}}],"description":"GCP Cloud SQL backend."},{"allOf":[{"description":"Azure Flexible Server backend.","type":"object","required":["status","serverName"],"properties":{"serverName":{"type":"string"},"state":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"},"version":{"type":["string","null"]}},"x-readme-ref-name":"AzureFlexibleServerPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["flexibleServer"]}}}],"description":"Azure Flexible Server backend."},{"allOf":[{"description":"Local embedded Postgres backend.","type":"object","required":["status","name","version","processRunning"],"properties":{"name":{"type":"string"},"port":{"type":["integer","null"],"format":"int32","minimum":0},"processRunning":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"},"version":{"type":"string"}},"x-readme-ref-name":"LocalPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}],"description":"Local embedded Postgres backend."}],"x-readme-ref-name":"PostgresHeartbeatData"},"resourceType":{"type":"string","enum":["postgres"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","accountId","region","prefix","parameterMetadataSampled"],"properties":{"accountId":{"type":"string"},"hasMoreParameters":{"type":["boolean","null"]},"latestModifiedAt":{"type":["string","null"],"format":"date-time"},"parameterMetadataSampled":{"type":"boolean"},"prefix":{"type":"string"},"region":{"type":"string"},"sampledAdvancedTierCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledKmsKeyMetadataPresentCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledParameterCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledSecureStringCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledStringCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledStringListCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"AwsParameterStoreVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsParameterStore"]}}}]},{"allOf":[{"type":"object","required":["status","projectId","location","prefix","secretMetadataListed"],"properties":{"location":{"type":"string"},"prefix":{"type":"string"},"projectId":{"type":"string"},"secretMetadataListed":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"GcpSecretManagerVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpSecretManager"]}}}]},{"allOf":[{"type":"object","required":["status","name","softDeleteEnabled","softDeleteRetentionDays","rbacAuthorizationEnabled","publicNetworkAccess","accessPolicyCount","privateEndpointConnectionCount","secretMetadataListed"],"properties":{"accessPolicyCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":["string","null"]},"name":{"type":"string"},"privateEndpointConnectionCount":{"type":"integer","format":"int32","minimum":0},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":"string"},"purgeProtectionEnabled":{"type":["boolean","null"]},"rbacAuthorizationEnabled":{"type":"boolean"},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"secretMetadataListed":{"type":"boolean"},"skuFamily":{"type":["string","null"]},"skuName":{"type":["string","null"]},"softDeleteEnabled":{"type":"boolean"},"softDeleteRetentionDays":{"type":"integer","format":"int32"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"},"vaultUri":{"type":["string","null"]}},"x-readme-ref-name":"AzureKeyVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureKeyVault"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","prefix","secretMetadataListed"],"properties":{"namespace":{"type":"string"},"prefix":{"type":"string"},"secretMetadataListed":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"KubernetesSecretVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetesSecret"]}}}]},{"allOf":[{"type":"object","required":["status","path","pathExists","secretMetadataListed"],"properties":{"isDirectory":{"type":["boolean","null"]},"modifiedAt":{"type":["string","null"],"format":"date-time"},"path":{"type":"string"},"pathExists":{"type":"boolean"},"readonly":{"type":["boolean","null"]},"secretMetadataListed":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"LocalVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"VaultHeartbeatData"},"resourceType":{"type":"string","enum":["vault"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","roleName","roleArn","roleId","path","createDate","assumeRolePolicyPresent","tagCount","managedTagCount","attachedPolicyCount","attachedPolicyNames","inlinePolicyCount","inlinePolicyNames","stackPermissionsApplied"],"properties":{"assumeRolePolicyPresent":{"type":"boolean"},"attachedPolicyCount":{"type":"integer","format":"int32","minimum":0},"attachedPolicyNames":{"type":"array","items":{"type":"string"}},"createDate":{"type":"string"},"description":{"type":["string","null"]},"inlinePolicyCount":{"type":"integer","format":"int32","minimum":0},"inlinePolicyNames":{"type":"array","items":{"type":"string"}},"lastUsedDate":{"type":["string","null"]},"lastUsedRegion":{"type":["string","null"]},"managedTagCount":{"type":"integer","format":"int32","minimum":0},"maxSessionDuration":{"type":["integer","null"],"format":"int32"},"path":{"type":"string"},"permissionsBoundaryArn":{"type":["string","null"]},"permissionsBoundaryType":{"type":["string","null"]},"roleArn":{"type":"string"},"roleId":{"type":"string"},"roleName":{"type":"string"},"stackPermissionsApplied":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"},"tagCount":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"AwsIamRoleServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsIamRole"]}}}]},{"allOf":[{"type":"object","required":["status","email","projectBindingCount","projectRoles","serviceAccountBindingCount","serviceAccountRoles"],"properties":{"description":{"type":["string","null"]},"disabled":{"type":["boolean","null"]},"displayName":{"type":["string","null"]},"email":{"type":"string"},"etag":{"type":["string","null"]},"name":{"type":["string","null"]},"oauth2ClientId":{"type":["string","null"]},"projectBindingCount":{"type":"integer","format":"int32","minimum":0},"projectId":{"type":["string","null"]},"projectRoles":{"type":"array","items":{"type":"string"}},"serviceAccountBindingCount":{"type":"integer","format":"int32","minimum":0},"serviceAccountRoles":{"type":"array","items":{"type":"string"}},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"},"uniqueId":{"type":["string","null"]}},"x-readme-ref-name":"GcpServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpServiceAccount"]}}}]},{"allOf":[{"type":"object","required":["status","name","resourceId","resourceGroup","location","managedTagCount","roleAssignmentCount","roleAssignmentIds","customRoleDefinitionCount","customRoleDefinitionIds","stackPermissionsApplied"],"properties":{"clientId":{"type":["string","null"]},"customRoleDefinitionCount":{"type":"integer","format":"int32","minimum":0},"customRoleDefinitionIds":{"type":"array","items":{"type":"string"}},"isolationScope":{"type":["string","null"]},"location":{"type":"string"},"managedTagCount":{"type":"integer","format":"int32","minimum":0},"name":{"type":"string"},"principalId":{"type":["string","null"]},"resourceGroup":{"type":"string"},"resourceId":{"type":"string"},"roleAssignmentCount":{"type":"integer","format":"int32","minimum":0},"roleAssignmentIds":{"type":"array","items":{"type":"string"}},"stackPermissionsApplied":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"},"tenantId":{"type":["string","null"]},"type":{"type":["string","null"]}},"x-readme-ref-name":"AzureManagedIdentityServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureManagedIdentity"]}}}]},{"allOf":[{"type":"object","required":["status","identity","configured"],"properties":{"configured":{"type":"boolean"},"identity":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"}},"x-readme-ref-name":"LocalServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ServiceAccountHeartbeatData"},"resourceType":{"type":"string","enum":["service-account"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","publicSubnetIds","privateSubnetIds","availabilityZones","routeTableCount","isByoVpc"],"properties":{"availabilityZones":{"type":"array","items":{"type":"string"}},"cidrBlock":{"type":["string","null"]},"internetGatewayId":{"type":["string","null"]},"isByoVpc":{"type":"boolean"},"natGatewayId":{"type":["string","null"]},"privateSubnetIds":{"type":"array","items":{"type":"string"}},"publicSubnetIds":{"type":"array","items":{"type":"string"}},"routeTableCount":{"type":"integer","format":"int32","minimum":0},"securityGroupId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"NetworkHeartbeatStatus"},"vpcId":{"type":["string","null"]},"vpcState":{"type":["string","null"]}},"x-readme-ref-name":"AwsVpcNetworkHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsVpc"]}}}]},{"allOf":[{"type":"object","required":["status","isByoVpc"],"properties":{"cidrBlock":{"type":["string","null"]},"cloudNatName":{"type":["string","null"]},"firewallName":{"type":["string","null"]},"isByoVpc":{"type":"boolean"},"networkName":{"type":["string","null"]},"networkSelfLink":{"type":["string","null"]},"region":{"type":["string","null"]},"routerName":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"NetworkHeartbeatStatus"},"subnetworkName":{"type":["string","null"]},"subnetworkSelfLink":{"type":["string","null"]}},"x-readme-ref-name":"GcpVpcNetworkHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpVpc"]}}}]},{"allOf":[{"type":"object","required":["status","isByoVnet"],"properties":{"applicationGatewaySubnetName":{"type":["string","null"]},"cidrBlock":{"type":["string","null"]},"isByoVnet":{"type":"boolean"},"lastByoVnetVerificationErrorCode":{"type":["string","null"]},"location":{"type":["string","null"]},"natGatewayId":{"type":["string","null"]},"nsgId":{"type":["string","null"]},"privateEndpointSubnetName":{"type":["string","null"]},"privateSubnetName":{"type":["string","null"]},"publicIpId":{"type":["string","null"]},"publicSubnetName":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"NetworkHeartbeatStatus"},"vnetName":{"type":["string","null"]},"vnetResourceId":{"type":["string","null"]}},"x-readme-ref-name":"AzureVnetNetworkHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureVnet"]}}}]}],"x-readme-ref-name":"NetworkHeartbeatData"},"resourceType":{"type":"string","enum":["network"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","managementPermissionsApplied"],"properties":{"managementPermissionsApplied":{"type":"boolean"},"roleArn":{"type":["string","null"]},"roleName":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"RemoteStackManagementHeartbeatStatus"}},"x-readme-ref-name":"AwsRemoteStackManagementHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsIamRole"]}}}]},{"allOf":[{"type":"object","required":["status","roleBound","impersonationGranted"],"properties":{"impersonationGranted":{"type":"boolean"},"roleBound":{"type":"boolean"},"serviceAccountEmail":{"type":["string","null"]},"serviceAccountUniqueId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"RemoteStackManagementHeartbeatStatus"}},"x-readme-ref-name":"GcpRemoteStackManagementHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpServiceAccount"]}}}]},{"allOf":[{"type":"object","required":["status","roleAssignmentIds"],"properties":{"ficName":{"type":["string","null"]},"roleAssignmentIds":{"type":"array","items":{"type":"string"}},"roleDefinitionId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"RemoteStackManagementHeartbeatStatus"},"tenantId":{"type":["string","null"]},"uamiClientId":{"type":["string","null"]},"uamiPrincipalId":{"type":["string","null"]},"uamiResourceId":{"type":["string","null"]}},"x-readme-ref-name":"AzureRemoteStackManagementHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureManagedIdentity"]}}}]}],"x-readme-ref-name":"RemoteStackManagementHeartbeatData"},"resourceType":{"type":"string","enum":["remote-stack-management"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","registryId","region","registryUri","repositoryPrefix","repositoryCount","repositoriesTruncated","repositories"],"properties":{"pullRoleArn":{"type":["string","null"]},"pushRoleArn":{"type":["string","null"]},"region":{"type":"string"},"registryId":{"type":"string"},"registryUri":{"type":"string"},"repositories":{"type":"array","items":{"type":"object","required":["repositoryArn","registryId","repositoryName","repositoryUri","createdAt","kmsKeyPresent"],"properties":{"createdAt":{"type":"number","format":"double"},"encryptionType":{"type":["string","null"]},"imageTagMutability":{"type":["string","null"]},"kmsKeyPresent":{"type":"boolean"},"registryId":{"type":"string"},"repositoryArn":{"type":"string"},"repositoryName":{"type":"string"},"repositoryUri":{"type":"string"},"scanOnPush":{"type":["boolean","null"]}},"x-readme-ref-name":"AwsEcrRepositoryHeartbeatData"}},"repositoriesTruncated":{"type":"boolean"},"repositoryCount":{"type":"integer","format":"int32","minimum":0},"repositoryPrefix":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"}},"x-readme-ref-name":"AwsEcrArtifactRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsEcr"]}}}]},{"allOf":[{"type":"object","required":["status","projectId","location","repositoryId","labelCount","cleanupPolicyCount","kmsKeyNamePresent","iamPolicyEtagPresent","iamBindingCount","iamRoles"],"properties":{"cleanupPolicyCount":{"type":"integer","format":"int32","minimum":0},"cleanupPolicyDryRun":{"type":["boolean","null"]},"createTime":{"type":["string","null"]},"description":{"type":["string","null"]},"format":{"type":["string","null"]},"iamBindingCount":{"type":"integer","format":"int32","minimum":0},"iamPolicyEtagPresent":{"type":"boolean"},"iamRoles":{"type":"array","items":{"type":"string"}},"kmsKeyNamePresent":{"type":"boolean"},"labelCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":"string"},"mode":{"type":["string","null"]},"name":{"type":["string","null"]},"projectId":{"type":"string"},"pullServiceAccountEmail":{"type":["string","null"]},"pushServiceAccountEmail":{"type":["string","null"]},"repositoryId":{"type":"string"},"satisfiesPzs":{"type":["boolean","null"]},"sizeBytes":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"},"updateTime":{"type":["string","null"]}},"x-readme-ref-name":"GcpArtifactRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpArtifactRegistry"]}}}]},{"allOf":[{"type":"object","required":["status","name","resourceGroup","location","skuName","adminUserEnabled","anonymousPullEnabled","publicNetworkAccess","networkRuleBypassOptions","ipRuleCount","encryptionKeyVaultUriPresent","encryptionKeyIdentifierPresent","policiesPresent","policyCount","privateEndpointConnectionCount","dataEndpointHostNames","zoneRedundancy","managedTagCount"],"properties":{"adminUserEnabled":{"type":"boolean"},"anonymousPullEnabled":{"type":"boolean"},"creationDate":{"type":["string","null"]},"dataEndpointEnabled":{"type":["boolean","null"]},"dataEndpointHostNames":{"type":"array","items":{"type":"string"}},"encryptionKeyIdentifierPresent":{"type":"boolean"},"encryptionKeyVaultUriPresent":{"type":"boolean"},"encryptionStatus":{"type":["string","null"]},"ipRuleCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":"string"},"loginServer":{"type":["string","null"]},"managedTagCount":{"type":"integer","format":"int32","minimum":0},"name":{"type":"string"},"networkRuleBypassOptions":{"type":"string"},"networkRuleDefaultAction":{"type":["string","null"]},"policiesPresent":{"type":"boolean"},"policyCount":{"type":"integer","format":"int32","minimum":0},"privateEndpointConnectionCount":{"type":"integer","format":"int32","minimum":0},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":"string"},"resourceGroup":{"type":"string"},"resourceId":{"type":["string","null"]},"skuName":{"type":"string"},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"},"type":{"type":["string","null"]},"zoneRedundancy":{"type":"string"}},"x-readme-ref-name":"AzureContainerRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureContainerRegistry"]}}}]},{"allOf":[{"type":"object","required":["status","registryUrl","reachable"],"properties":{"reachable":{"type":"boolean"},"registryUrl":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"}},"x-readme-ref-name":"LocalArtifactRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ArtifactRegistryHeartbeatData"},"resourceType":{"type":"string","enum":["artifact-registry"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","projectName","environmentVariableCount","serviceRolePresent","encryptionKeyPresent"],"properties":{"artifactsEncryptionDisabled":{"type":["boolean","null"]},"artifactsType":{"type":["string","null"]},"cloudWatchLogsStatus":{"type":["string","null"]},"computeType":{"type":["string","null"]},"created":{"type":["number","null"],"format":"double"},"description":{"type":["string","null"]},"encryptionKeyPresent":{"type":"boolean"},"environmentImage":{"type":["string","null"]},"environmentType":{"type":["string","null"]},"environmentVariableCount":{"type":"integer","format":"int32","minimum":0},"imagePullCredentialsType":{"type":["string","null"]},"lastModified":{"type":["number","null"],"format":"double"},"privilegedMode":{"type":["boolean","null"]},"projectArn":{"type":["string","null"]},"projectName":{"type":"string"},"queuedTimeoutInMinutes":{"type":["integer","null"],"format":"int32"},"s3LogsStatus":{"type":["string","null"]},"serviceRolePresent":{"type":"boolean"},"sourceType":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"},"timeoutInMinutes":{"type":["integer","null"],"format":"int32"}},"x-readme-ref-name":"AwsCodeBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsCodeBuild"]}}}]},{"allOf":[{"type":"object","required":["status","projectId","location","buildConfigId","environmentVariableCount"],"properties":{"buildConfigId":{"type":"string"},"environmentVariableCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":"string"},"projectId":{"type":"string"},"serviceAccount":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"}},"x-readme-ref-name":"GcpCloudBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpCloudBuild"]}}}]},{"allOf":[{"type":"object","required":["status","managedEnvironmentId","resourceGroupName","environmentVariableCount"],"properties":{"environmentVariableCount":{"type":"integer","format":"int32","minimum":0},"managedEnvironmentId":{"type":"string"},"managedIdentityId":{"type":["string","null"]},"resourceGroupName":{"type":"string"},"resourcePrefix":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"}},"x-readme-ref-name":"AzureContainerAppsBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureContainerApps"]}}}]},{"allOf":[{"type":"object","required":["status","jobName","namespace","conditionCount","events"],"properties":{"active":{"type":["integer","null"],"format":"int32"},"completionTime":{"type":["string","null"],"format":"date-time"},"conditionCount":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"failed":{"type":["integer","null"],"format":"int32"},"imageDigest":{"type":["string","null"]},"jobName":{"type":"string"},"namespace":{"type":"string"},"startTime":{"type":["string","null"],"format":"date-time"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"},"succeeded":{"type":["integer","null"],"format":"int32"}},"x-readme-ref-name":"KubernetesBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetesJob"]}}}]}],"x-readme-ref-name":"BuildHeartbeatData"},"resourceType":{"type":"string","enum":["build"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","projectId","serviceName","enabled"],"properties":{"enabled":{"type":"boolean"},"lastOperationName":{"type":["string","null"]},"projectId":{"type":"string"},"serviceName":{"type":"string"},"serviceResourceName":{"type":["string","null"]},"state":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceActivationHeartbeatStatus"},"title":{"type":["string","null"]}},"x-readme-ref-name":"GcpServiceUsageActivationHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpServiceUsage"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","resourceTypeCount","registered"],"properties":{"namespace":{"type":"string"},"providerId":{"type":["string","null"]},"registered":{"type":"boolean"},"registrationPolicy":{"type":["string","null"]},"registrationState":{"type":["string","null"]},"resourceTypeCount":{"type":"integer","format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceActivationHeartbeatStatus"}},"x-readme-ref-name":"AzureResourceProviderActivationHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureResourceProvider"]}}}]}],"x-readme-ref-name":"ServiceActivationHeartbeatData"},"resourceType":{"type":"string","enum":["service_activation"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","managedTags"],"properties":{"location":{"type":["string","null"]},"managedTags":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"name":{"type":"string"},"provisioningState":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AzureResourceGroupHeartbeatStatus"}},"x-readme-ref-name":"AzureResourceGroupHeartbeatData"},"resourceType":{"type":"string","enum":["azure_resource_group"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","primaryEndpoints","secondaryEndpoints"],"properties":{"allowBlobPublicAccess":{"type":["boolean","null"]},"allowSharedKeyAccess":{"type":["boolean","null"]},"encryptionKeySource":{"type":["string","null"]},"kind":{"type":["string","null"]},"location":{"type":["string","null"]},"minimumTlsVersion":{"type":["string","null"]},"name":{"type":"string"},"networkBypass":{"type":["string","null"]},"networkDefaultAction":{"type":["string","null"]},"networkIpRuleCount":{"type":["integer","null"],"format":"int32","minimum":0},"networkResourceAccessRuleCount":{"type":["integer","null"],"format":"int32","minimum":0},"networkVirtualNetworkRuleCount":{"type":["integer","null"],"format":"int32","minimum":0},"primaryEndpoints":{"type":"object","properties":{"blob":{"type":["string","null"]},"dfs":{"type":["string","null"]},"file":{"type":["string","null"]},"queue":{"type":["string","null"]},"table":{"type":["string","null"]},"web":{"type":["string","null"]}},"x-readme-ref-name":"AzureStorageAccountEndpoints"},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":["string","null"]},"requireInfrastructureEncryption":{"type":["boolean","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"secondaryEndpoints":{"type":"object","properties":{"blob":{"type":["string","null"]},"dfs":{"type":["string","null"]},"file":{"type":["string","null"]},"queue":{"type":["string","null"]},"table":{"type":["string","null"]},"web":{"type":["string","null"]}},"x-readme-ref-name":"AzureStorageAccountEndpoints"},"skuName":{"type":["string","null"]},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"supportsHttpsTrafficOnly":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureStorageAccountHeartbeatData"},"resourceType":{"type":"string","enum":["azure_storage_account"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","workloadProfileCount","workloadProfiles"],"properties":{"customDomainVerificationId":{"type":["string","null"]},"defaultDomain":{"type":["string","null"]},"eventStreamEndpoint":{"type":["string","null"]},"infrastructureResourceGroup":{"type":["string","null"]},"kind":{"type":["string","null"]},"location":{"type":["string","null"]},"name":{"type":"string"},"provisioningState":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"staticIp":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AzureContainerAppsEnvironmentHeartbeatStatus"},"workloadProfileCount":{"type":"integer","format":"int32","minimum":0},"workloadProfiles":{"type":"array","items":{"type":"object","required":["name","workloadProfileType"],"properties":{"maximumCount":{"type":["integer","null"],"format":"int32"},"minimumCount":{"type":["integer","null"],"format":"int32"},"name":{"type":"string"},"workloadProfileType":{"type":"string"}},"x-readme-ref-name":"AzureContainerAppsEnvironmentWorkloadProfile"}},"zoneRedundant":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureContainerAppsEnvironmentHeartbeatData"},"resourceType":{"type":"string","enum":["azure_container_apps_environment"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","privateEndpointConnectionCount"],"properties":{"createdAt":{"type":["string","null"]},"disableLocalAuth":{"type":["boolean","null"]},"location":{"type":["string","null"]},"metricId":{"type":["string","null"]},"minimumTlsVersion":{"type":["string","null"]},"name":{"type":"string"},"namespaceStatus":{"type":["string","null"]},"premiumMessagingPartitions":{"type":["integer","null"],"format":"int32"},"privateEndpointConnectionCount":{"type":"integer","format":"int32","minimum":0},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"serviceBusEndpoint":{"type":["string","null"]},"skuCapacity":{"type":["integer","null"],"format":"int32"},"skuName":{"type":["string","null"]},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"updatedAt":{"type":["string","null"]},"zoneRedundant":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureServiceBusNamespaceHeartbeatData"},"resourceType":{"type":"string","enum":["azure_service_bus_namespace"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","region"],"properties":{"region":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"AwsBedrockAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsBedrock"]}}}]},{"allOf":[{"type":"object","required":["status","project","location"],"properties":{"location":{"type":"string"},"project":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"GcpVertexAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpVertex"]}}}]},{"allOf":[{"type":"object","required":["status","accountName"],"properties":{"accountName":{"type":"string"},"endpoint":{"type":["string","null"]},"location":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"AzureFoundryAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureFoundry"]}}}]},{"allOf":[{"type":"object","required":["status","provider"],"properties":{"provider":{"type":"string","description":"The BYO-key provider serving this binding (e.g. \"openai\"). Used on the Local\nplatform, where the app brings its own provider key instead of an ambient cloud."},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"ExternalAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["external"]}}}]}],"x-readme-ref-name":"AiHeartbeatData"},"resourceType":{"type":"string","enum":["ai"]}}}],"x-readme-ref-name":"ResourceHeartbeatData"},"deploymentId":{"type":["string","null"]},"observedAt":{"type":"string","format":"date-time"},"raw":{"type":"array","items":{"type":"object","required":["source","format","collectedAt","body","truncated"],"properties":{"body":{"type":"string"},"collectedAt":{"type":"string","format":"date-time"},"format":{"type":"string","enum":["json","yaml","text"],"x-readme-ref-name":"RawHeartbeatSnippetFormat"},"source":{"type":"string"},"truncated":{"type":"boolean"}},"x-readme-ref-name":"RawHeartbeatSnippet"}},"resourceId":{"type":"string","description":"Alien resource id, such as the `alien.Container` or `alien.Storage`\nresource id from the stack."},"resourceType":{"type":"string","description":"Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.","examples":["worker","storage","queue","redis","postgres"],"x-readme-ref-name":"ResourceType"}},"x-readme-ref-name":"ResourceHeartbeat"} \ No newline at end of file +{"type":"object","required":["resourceId","resourceType","controllerPlatform","backend","observedAt","data","raw"],"properties":{"backend":{"type":"string","enum":["aws","gcp","azure","kubernetes","local","managed","external","test"],"x-readme-ref-name":"HeartbeatBackend"},"controllerPlatform":{"type":"string","description":"Represents the target cloud platform.","enum":["aws","gcp","azure","kubernetes","machines","local","test"],"x-readme-ref-name":"Platform"},"data":{"oneOf":[{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","name","lifecyclePresent","encryptionConfigPresent","publicAccessBlockPresent"],"properties":{"blockPublicAcls":{"type":["boolean","null"]},"blockPublicPolicy":{"type":["boolean","null"]},"bucketAclPresent":{"type":["boolean","null"]},"bucketLocation":{"type":["string","null"]},"bucketPolicyPresent":{"type":["boolean","null"]},"encryptionConfigPresent":{"type":"boolean"},"encryptionEnabled":{"type":["boolean","null"]},"ignorePublicAcls":{"type":["boolean","null"]},"lifecyclePresent":{"type":"boolean"},"lifecycleRuleCount":{"type":["integer","null"],"format":"int64","minimum":0},"name":{"type":"string"},"publicAccessBlockPresent":{"type":"boolean"},"region":{"type":["string","null"]},"restrictPublicBuckets":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"versioningEnabled":{"type":["boolean","null"]},"versioningStatus":{"type":["string","null"]}},"x-readme-ref-name":"AwsS3StorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsS3"]}}}]},{"allOf":[{"type":"object","required":["status","name","lifecyclePresent","encryptionConfigPresent"],"properties":{"bucketId":{"type":["string","null"]},"defaultKmsKeyName":{"type":["string","null"]},"encryptionConfigPresent":{"type":"boolean"},"lifecyclePresent":{"type":"boolean"},"lifecycleRuleCount":{"type":["integer","null"],"format":"int64","minimum":0},"location":{"type":["string","null"]},"locationType":{"type":["string","null"]},"name":{"type":"string"},"publicAccessPrevention":{"type":["string","null"]},"retentionPeriod":{"type":["string","null"]},"retentionPolicyEffectiveTime":{"type":["string","null"]},"retentionPolicyIsLocked":{"type":["boolean","null"]},"softDeleteEffectiveTime":{"type":["string","null"]},"softDeleteRetentionDurationSeconds":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"storageClass":{"type":["string","null"]},"uniformBucketLevelAccessEnabled":{"type":["boolean","null"]},"uniformBucketLevelAccessLockedTime":{"type":["string","null"]},"versioningEnabled":{"type":["boolean","null"]}},"x-readme-ref-name":"GcpCloudStorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpCloudStorage"]}}}]},{"allOf":[{"type":"object","required":["status","name"],"properties":{"accessTier":{"type":["string","null"]},"accountKind":{"type":["string","null"]},"allowBlobPublicAccess":{"type":["boolean","null"]},"blobDeleteRetentionDays":{"type":["integer","null"],"format":"int64","minimum":0},"blobDeleteRetentionEnabled":{"type":["boolean","null"]},"blobEncryptionEnabled":{"type":["boolean","null"]},"blobVersioningEnabled":{"type":["boolean","null"]},"changeFeedEnabled":{"type":["boolean","null"]},"changeFeedRetentionDays":{"type":["integer","null"],"format":"int64","minimum":0},"containerDeleteRetentionDays":{"type":["integer","null"],"format":"int64","minimum":0},"containerDeleteRetentionEnabled":{"type":["boolean","null"]},"containerPublicAccess":{"type":["string","null"]},"encryptionKeySource":{"type":["string","null"]},"fileEncryptionEnabled":{"type":["boolean","null"]},"location":{"type":["string","null"]},"name":{"type":"string"},"primaryLocation":{"type":["string","null"]},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":["string","null"]},"queueEncryptionEnabled":{"type":["boolean","null"]},"resourceGroup":{"type":["string","null"]},"secondaryLocation":{"type":["string","null"]},"skuName":{"type":["string","null"]},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"statusOfPrimary":{"type":["string","null"]},"statusOfSecondary":{"type":["string","null"]},"storageAccountName":{"type":["string","null"]},"tableEncryptionEnabled":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureBlobStorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureBlob"]}}}]},{"allOf":[{"type":"object","required":["status","path","pathExists"],"properties":{"isDirectory":{"type":["boolean","null"]},"modifiedAt":{"type":["string","null"],"format":"date-time"},"path":{"type":"string"},"pathExists":{"type":"boolean"},"readonly":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"}},"x-readme-ref-name":"LocalStorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"StorageHeartbeatData"},"resourceType":{"type":"string","enum":["storage"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","functionName","layerCount","functionUrlCorsPresent","triggerCount"],"properties":{"codeSha256":{"type":["string","null"]},"functionName":{"type":"string"},"functionUrlAuthType":{"type":["string","null"]},"functionUrlCorsPresent":{"type":"boolean"},"lastModified":{"type":["string","null"]},"lastUpdateStatus":{"type":["string","null"]},"lastUpdateStatusReason":{"type":["string","null"]},"lastUpdateStatusReasonCode":{"type":["string","null"]},"layerCount":{"type":"integer","format":"int32","minimum":0},"memorySizeMb":{"type":["integer","null"],"format":"int64"},"packageType":{"type":["string","null"]},"revisionId":{"type":["string","null"]},"runtime":{"type":["string","null"]},"state":{"type":["string","null"]},"stateReason":{"type":["string","null"]},"stateReasonCode":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"timeoutSeconds":{"type":["integer","null"],"format":"int64"},"triggerCount":{"type":"integer","format":"int32","minimum":0},"version":{"type":["string","null"]}},"x-readme-ref-name":"AwsLambdaWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsLambda"]}}}]},{"allOf":[{"type":"object","required":["status","service","urls","trafficCount"],"properties":{"containerImage":{"type":["string","null"]},"cpuLimit":{"type":["string","null"]},"generation":{"type":["integer","null"],"format":"int64"},"latestCreatedRevision":{"type":["string","null"]},"latestReadyRevision":{"type":["string","null"]},"maxInstanceCount":{"type":["integer","null"],"format":"int32"},"memoryLimit":{"type":["string","null"]},"minInstanceCount":{"type":["integer","null"],"format":"int32"},"observedGeneration":{"type":["integer","null"],"format":"int64"},"region":{"type":["string","null"]},"service":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"trafficCount":{"type":"integer","format":"int32","minimum":0},"uri":{"type":["string","null"]},"urls":{"type":"array","items":{"type":"string"}}},"x-readme-ref-name":"GcpCloudRunWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpCloudRun"]}}}]},{"allOf":[{"type":"object","required":["status","appName"],"properties":{"appName":{"type":"string"},"cpu":{"type":["number","null"],"format":"double"},"environmentName":{"type":["string","null"]},"ingressFqdn":{"type":["string","null"]},"maxReplicas":{"type":["integer","null"],"format":"int32"},"memory":{"type":["string","null"]},"minReplicas":{"type":["integer","null"],"format":"int32"},"provisioningState":{"type":["string","null"]},"revision":{"type":["string","null"]},"runningStatus":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"AzureContainerAppsWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureContainerApps"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","name","workloadKind","replicas","pods","triggerCount","events"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":"string"},"pods":{"type":"array","items":{"type":"object","required":["name","ready","restartCount","ownerReferences"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"ownerReferences":{"type":"array","items":{"type":"object","required":["kind","name","uid","controller"],"properties":{"controller":{"type":"boolean"},"kind":{"type":"string"},"name":{"type":"string"},"uid":{"type":"string"}},"x-readme-ref-name":"KubernetesOwnerReference"}},"phase":{"type":["string","null"]},"podIp":{"type":["string","null"]},"ready":{"type":"boolean"},"restartCount":{"type":"integer","format":"int32","minimum":0},"terminatedReason":{"type":["string","null"]},"uid":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesPodRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"restarts":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"triggerCount":{"type":"integer","format":"int32","minimum":0},"workload":{"oneOf":[{"type":"null"},{"type":"object","required":["conditions"],"properties":{"availableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"lastTransitionTime":{"type":["string","null"],"format":"date-time"},"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesWorkloadCondition"}},"desiredGeneration":{"type":["integer","null"],"format":"int64"},"desiredReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"observedGeneration":{"type":["integer","null"],"format":"int64"},"readyReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"rolloutReason":{"type":["string","null"]},"updatedReplicas":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"KubernetesWorkloadStatus"}]},"workloadKind":{"type":"string","enum":["deployment","statefulSet","daemonSet","replicaSet","pod"],"x-readme-ref-name":"KubernetesWorkloadKind"}},"x-readme-ref-name":"KubernetesWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetes"]}}}]},{"allOf":[{"type":"object","required":["status","commandSupported","imagePathPresent","triggerCount","events"],"properties":{"commandSupported":{"type":"boolean"},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["timestamp","severity","kind","message"],"properties":{"kind":{"type":"string"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"subject":{"oneOf":[{"type":"null"},{"type":"object","required":["kind"],"properties":{"id":{"type":["string","null"]},"kind":{"type":"string"},"name":{"type":["string","null"]}},"x-readme-ref-name":"LocalRuntimeEventSubject"}]},"timestamp":{"type":"string","format":"date-time"}},"x-readme-ref-name":"LocalRuntimeEventSnapshot"}},"imagePathPresent":{"type":"boolean"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"process":{"oneOf":[{"type":"null"},{"type":"object","required":["unitId","name","kind","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"kind":{"type":"string","enum":["container","process","daemon"],"x-readme-ref-name":"LocalRuntimeUnitKind"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"phase":{"type":["string","null"]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":"boolean"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"unitId":{"type":"string"}},"x-readme-ref-name":"LocalRuntimeUnitStatus"}]},"readinessProbeOk":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"triggerCount":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"LocalWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"WorkerHeartbeatData"},"resourceType":{"type":"string","enum":["worker"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","containerId","schedulingMode","replicas","attentionCount","replicaUnits","events"],"properties":{"attentionCount":{"type":"integer","format":"int32","minimum":0},"containerId":{"type":"string"},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"image":{"type":["string","null"]},"latestUpdateTimestamp":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"observedImage":{"type":["string","null"]},"replicaUnits":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"schedulingMode":{"type":"string","enum":["replicated","stateful","daemon"],"x-readme-ref-name":"HorizonWorkloadSchedulingMode"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"HorizonContainerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["horizonPlatform"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","name","workloadKind","replicas","pods","events"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":"string"},"pods":{"type":"array","items":{"type":"object","required":["name","ready","restartCount","ownerReferences"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"ownerReferences":{"type":"array","items":{"type":"object","required":["kind","name","uid","controller"],"properties":{"controller":{"type":"boolean"},"kind":{"type":"string"},"name":{"type":"string"},"uid":{"type":"string"}},"x-readme-ref-name":"KubernetesOwnerReference"}},"phase":{"type":["string","null"]},"podIp":{"type":["string","null"]},"ready":{"type":"boolean"},"restartCount":{"type":"integer","format":"int32","minimum":0},"terminatedReason":{"type":["string","null"]},"uid":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesPodRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"restarts":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"workload":{"oneOf":[{"type":"null"},{"type":"object","required":["conditions"],"properties":{"availableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"lastTransitionTime":{"type":["string","null"],"format":"date-time"},"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesWorkloadCondition"}},"desiredGeneration":{"type":["integer","null"],"format":"int64"},"desiredReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"observedGeneration":{"type":["integer","null"],"format":"int64"},"readyReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"rolloutReason":{"type":["string","null"]},"updatedReplicas":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"KubernetesWorkloadStatus"}]},"workloadKind":{"type":"string","enum":["deployment","statefulSet","daemonSet","replicaSet","pod"],"x-readme-ref-name":"KubernetesWorkloadKind"}},"x-readme-ref-name":"KubernetesContainerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetes"]}}}]},{"allOf":[{"type":"object","required":["status","portCount","bindMountCount","runtimeReachable","events"],"properties":{"bindMountCount":{"type":"integer","format":"int32","minimum":0},"containerId":{"type":["string","null"]},"containerUnit":{"oneOf":[{"type":"null"},{"type":"object","required":["unitId","name","kind","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"kind":{"type":"string","enum":["container","process","daemon"],"x-readme-ref-name":"LocalRuntimeUnitKind"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"phase":{"type":["string","null"]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":"boolean"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"unitId":{"type":"string"}},"x-readme-ref-name":"LocalRuntimeUnitStatus"}]},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["timestamp","severity","kind","message"],"properties":{"kind":{"type":"string"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"subject":{"oneOf":[{"type":"null"},{"type":"object","required":["kind"],"properties":{"id":{"type":["string","null"]},"kind":{"type":"string"},"name":{"type":["string","null"]}},"x-readme-ref-name":"LocalRuntimeEventSubject"}]},"timestamp":{"type":"string","format":"date-time"}},"x-readme-ref-name":"LocalRuntimeEventSnapshot"}},"image":{"type":["string","null"]},"localUrl":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":["string","null"]},"portCount":{"type":"integer","format":"int32","minimum":0},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"runtimeReachable":{"type":"boolean"},"runtimeStatus":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"LocalContainerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ContainerHeartbeatData"},"resourceType":{"type":"string","enum":["container"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"AwsDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["aws"]}}}]},{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"GcpDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcp"]}}}]},{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"AzureDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azure"]}}}]},{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"MachinesDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["machines"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","name","replicas","commandSupported","pods","events"],"properties":{"commandSupported":{"type":"boolean"},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":"string"},"pods":{"type":"array","items":{"type":"object","required":["name","ready","restartCount","ownerReferences"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"ownerReferences":{"type":"array","items":{"type":"object","required":["kind","name","uid","controller"],"properties":{"controller":{"type":"boolean"},"kind":{"type":"string"},"name":{"type":"string"},"uid":{"type":"string"}},"x-readme-ref-name":"KubernetesOwnerReference"}},"phase":{"type":["string","null"]},"podIp":{"type":["string","null"]},"ready":{"type":"boolean"},"restartCount":{"type":"integer","format":"int32","minimum":0},"terminatedReason":{"type":["string","null"]},"uid":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesPodRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"restarts":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"workload":{"oneOf":[{"type":"null"},{"type":"object","required":["conditions"],"properties":{"availableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"lastTransitionTime":{"type":["string","null"],"format":"date-time"},"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesWorkloadCondition"}},"desiredGeneration":{"type":["integer","null"],"format":"int64"},"desiredReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"observedGeneration":{"type":["integer","null"],"format":"int64"},"readyReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"rolloutReason":{"type":["string","null"]},"updatedReplicas":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"KubernetesWorkloadStatus"}]}},"x-readme-ref-name":"KubernetesDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetes"]}}}]},{"allOf":[{"type":"object","required":["status","runtimeId","commandSupported","imagePathPresent","events"],"properties":{"commandSupported":{"type":"boolean"},"daemonInstance":{"oneOf":[{"type":"null"},{"type":"object","required":["unitId","name","kind","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"kind":{"type":"string","enum":["container","process","daemon"],"x-readme-ref-name":"LocalRuntimeUnitKind"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"phase":{"type":["string","null"]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":"boolean"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"unitId":{"type":"string"}},"x-readme-ref-name":"LocalRuntimeUnitStatus"}]},"daemonName":{"type":"string"},"events":{"type":"array","items":{"type":"object","required":["timestamp","severity","kind","message"],"properties":{"kind":{"type":"string"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"subject":{"oneOf":[{"type":"null"},{"type":"object","required":["kind"],"properties":{"id":{"type":["string","null"]},"kind":{"type":"string"},"name":{"type":["string","null"]}},"x-readme-ref-name":"LocalRuntimeEventSubject"}]},"timestamp":{"type":"string","format":"date-time"}},"x-readme-ref-name":"LocalRuntimeEventSnapshot"}},"exitReason":{"type":["string","null"]},"imagePathPresent":{"type":"boolean"},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"runtimeId":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"LocalDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"DaemonHeartbeatData"},"resourceType":{"type":"string","enum":["daemon"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","providerFleets"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"providerFleets":{"type":"array","items":{"type":"object","required":["groupId","providerId","currentMachines","desiredMachines"],"properties":{"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"groupId":{"type":"string"},"location":{"type":["string","null"]},"providerId":{"type":"string"}},"x-readme-ref-name":"ProviderFleetStatus"}},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"AwsComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["aws"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","providerFleets"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"providerFleets":{"type":"array","items":{"type":"object","required":["groupId","providerId","currentMachines","desiredMachines"],"properties":{"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"groupId":{"type":"string"},"location":{"type":["string","null"]},"providerId":{"type":"string"}},"x-readme-ref-name":"ProviderFleetStatus"}},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"GcpComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcp"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","providerFleets"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"providerFleets":{"type":"array","items":{"type":"object","required":["groupId","providerId","currentMachines","desiredMachines"],"properties":{"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"groupId":{"type":"string"},"location":{"type":["string","null"]},"providerId":{"type":"string"}},"x-readme-ref-name":"ProviderFleetStatus"}},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"AzureComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azure"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","machines"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"machines":{"type":"array","items":{"type":"object","required":["machineId","status","capacityGroup","zone","lastHeartbeat","replicaCount","drainForce"],"properties":{"capacityGroup":{"type":"string"},"cpuCores":{"type":["number","null"],"format":"double"},"drainBlockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainForce":{"type":"boolean"},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"horizondVersion":{"type":["string","null"]},"lastHeartbeat":{"type":"string"},"machineId":{"type":"string"},"memoryBytes":{"type":["integer","null"],"format":"int64"},"overlayIp":{"type":["string","null"]},"publicIp":{"type":["string","null"]},"replicaCount":{"type":"integer","format":"int64"},"status":{"type":"string"},"zone":{"type":"string"}},"x-readme-ref-name":"MachinesComputeMachineStatus"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"MachinesComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["machines"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","dockerAvailable","networkAvailable"],"properties":{"dockerApiVersion":{"type":["string","null"]},"dockerArch":{"type":["string","null"]},"dockerAvailable":{"type":"boolean"},"dockerOs":{"type":["string","null"]},"dockerVersion":{"type":["string","null"]},"hostIdentifier":{"type":["string","null"]},"name":{"type":"string"},"networkAvailable":{"type":"boolean"},"networkName":{"type":["string","null"]},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"runningContainers":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"},"trackedContainers":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"LocalComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ComputeClusterHeartbeatData"},"resourceType":{"type":"string","enum":["compute-cluster"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","nodeCounts","podCounts","name","events"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":["string","null"]},"nodeCounts":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"nodeStatuses":{"type":"array","items":{"type":"object","required":["name","ready","roles","labels","allocatable","capacity"],"properties":{"allocatable":{"type":"object","properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"pods":{"type":["integer","null"],"format":"int64","minimum":0}},"x-readme-ref-name":"KubernetesNodeResources"},"capacity":{"type":"object","properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"pods":{"type":["integer","null"],"format":"int64","minimum":0}},"x-readme-ref-name":"KubernetesNodeResources"},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesNodeConditionStatus"}},"containerRuntimeVersion":{"type":["string","null"]},"kubeletVersion":{"type":["string","null"]},"labels":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"name":{"type":"string"},"ready":{"type":"boolean"},"roles":{"type":"array","items":{"type":"string"}},"uid":{"type":["string","null"]},"usage":{"oneOf":[{"type":"null"},{"type":"object","properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"KubernetesNodeUsage"}]}},"x-readme-ref-name":"KubernetesClusterNodeStatus"}},"podCounts":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"version":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesClusterHeartbeatData"},"resourceType":{"type":"string","enum":["kubernetes-cluster"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","name","approximateCounts"],"properties":{"approximateCounts":{"type":"boolean"},"approximateDelayedMessages":{"type":["integer","null"],"format":"int64","minimum":0},"approximateInFlightMessages":{"type":["integer","null"],"format":"int64","minimum":0},"approximateVisibleMessages":{"type":["integer","null"],"format":"int64","minimum":0},"contentBasedDeduplication":{"type":["boolean","null"]},"deduplicationScope":{"type":["string","null"]},"delaySeconds":{"type":["integer","null"],"format":"int32","minimum":0},"fifoQueue":{"type":["boolean","null"]},"fifoThroughputLimit":{"type":["string","null"]},"kmsDataKeyReusePeriodSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"kmsMasterKeyId":{"type":["string","null"]},"maximumMessageSize":{"type":["integer","null"],"format":"int32","minimum":0},"messageRetentionPeriodSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"name":{"type":"string"},"queueArn":{"type":["string","null"]},"queueUrl":{"type":["string","null"]},"receiveMessageWaitTimeSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"redriveAllowPolicy":{"type":["string","null"]},"redrivePolicy":{"type":["string","null"]},"region":{"type":["string","null"]},"sqsManagedSseEnabled":{"type":["boolean","null"]},"sseEnabled":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"visibilityTimeoutSeconds":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"AwsSqsQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsSqs"]}}}]},{"allOf":[{"type":"object","required":["status","topicName","topicLabels","subscriptionLabels","messageStorageAllowedPersistenceRegions","subscriptionPushAttributes"],"properties":{"endpoint":{"type":["string","null"]},"kmsKeyName":{"type":["string","null"]},"messageStorageAllowedPersistenceRegions":{"type":"array","items":{"type":"string"}},"messageStorageEnforceInTransit":{"type":["boolean","null"]},"projectId":{"type":["string","null"]},"schemaEncoding":{"type":["string","null"]},"schemaFirstRevisionId":{"type":["string","null"]},"schemaLastRevisionId":{"type":["string","null"]},"schemaName":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"subscriptionAckDeadlineSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"subscriptionDeadLetterMaxDeliveryAttempts":{"type":["integer","null"],"format":"int32","minimum":0},"subscriptionDeadLetterTopic":{"type":["string","null"]},"subscriptionDetached":{"type":["boolean","null"]},"subscriptionEnableMessageOrdering":{"type":["boolean","null"]},"subscriptionFilter":{"type":["string","null"]},"subscriptionFullName":{"type":["string","null"]},"subscriptionLabels":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"subscriptionMessageRetentionDuration":{"type":["string","null"]},"subscriptionName":{"type":["string","null"]},"subscriptionPushAttributes":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"subscriptionPushConfigPresent":{"type":["boolean","null"]},"subscriptionPushEndpoint":{"type":["string","null"]},"subscriptionPushNoWrapperWriteMetadata":{"type":["boolean","null"]},"subscriptionPushOidcAudience":{"type":["string","null"]},"subscriptionPushOidcServiceAccountEmail":{"type":["string","null"]},"subscriptionPushPubsubWrapperWriteMetadata":{"type":["boolean","null"]},"subscriptionRetainAckedMessages":{"type":["boolean","null"]},"subscriptionState":{"type":["string","null"]},"topicFullName":{"type":["string","null"]},"topicLabels":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"topicMessageRetentionDuration":{"type":["string","null"]},"topicName":{"type":"string"},"topicState":{"type":["string","null"]}},"x-readme-ref-name":"GcpPubSubQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpPubSub"]}}}]},{"allOf":[{"type":"object","required":["status","name","namespaceName"],"properties":{"accessedAt":{"type":["string","null"]},"activeMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"autoDeleteOnIdle":{"type":["string","null"]},"createdAt":{"type":["string","null"]},"deadLetterMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"deadLetteringOnMessageExpiration":{"type":["boolean","null"]},"defaultMessageTimeToLive":{"type":["string","null"]},"duplicateDetectionHistoryTimeWindow":{"type":["string","null"]},"enableBatchedOperations":{"type":["boolean","null"]},"enableExpress":{"type":["boolean","null"]},"enablePartitioning":{"type":["boolean","null"]},"endpoint":{"type":["string","null"]},"forwardDeadLetteredMessagesTo":{"type":["string","null"]},"forwardTo":{"type":["string","null"]},"lockDuration":{"type":["string","null"]},"maxDeliveryCount":{"type":["integer","null"],"format":"int32","minimum":0},"maxMessageSizeInKilobytes":{"type":["integer","null"],"format":"int64","minimum":0},"maxSizeInMegabytes":{"type":["integer","null"],"format":"int32","minimum":0},"messageCount":{"type":["integer","null"],"format":"int64","minimum":0},"name":{"type":"string"},"namespaceName":{"type":"string"},"queueStatus":{"type":["string","null"]},"requiresDuplicateDetection":{"type":["boolean","null"]},"requiresSession":{"type":["boolean","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"scheduledMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"sizeInBytes":{"type":["integer","null"],"format":"int64","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"transferDeadLetterMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"transferMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"updatedAt":{"type":["string","null"]}},"x-readme-ref-name":"AzureServiceBusQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureServiceBus"]}}}]},{"allOf":[{"type":"object","required":["status","name"],"properties":{"name":{"type":"string"},"path":{"type":["string","null"]},"serviceStatus":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"}},"x-readme-ref-name":"LocalQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"QueueHeartbeatData"},"resourceType":{"type":"string","enum":["queue"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","name","keySchema"],"properties":{"billingMode":{"type":["string","null"]},"deletionProtectionEnabled":{"type":["boolean","null"]},"globalSecondaryIndexCount":{"type":["integer","null"],"format":"int32","minimum":0},"itemCount":{"type":["integer","null"],"format":"int64","minimum":0},"keySchema":{"type":"array","items":{"type":"object","required":["attributeName","keyType"],"properties":{"attributeName":{"type":"string"},"keyType":{"type":"string"}},"x-readme-ref-name":"AwsDynamoDbKeySchemaElement"}},"localSecondaryIndexCount":{"type":["integer","null"],"format":"int32","minimum":0},"name":{"type":"string"},"region":{"type":["string","null"]},"replicaCount":{"type":["integer","null"],"format":"int32","minimum":0},"restoreInProgress":{"type":["boolean","null"]},"sseStatus":{"type":["string","null"]},"sseType":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"},"streamEnabled":{"type":["boolean","null"]},"streamViewType":{"type":["string","null"]},"tableArn":{"type":["string","null"]},"tableClass":{"type":["string","null"]},"tableSizeBytes":{"type":["integer","null"],"format":"int64","minimum":0},"tableStatus":{"type":["string","null"]},"ttlAttributeName":{"type":["string","null"]},"ttlStatus":{"type":["string","null"]}},"x-readme-ref-name":"AwsDynamoDbKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsDynamoDb"]}}}]},{"allOf":[{"type":"object","required":["status","databaseName","cmekEnabled","sourceInfoPresent"],"properties":{"appEngineIntegrationMode":{"type":["string","null"]},"cmekEnabled":{"type":"boolean"},"concurrencyMode":{"type":["string","null"]},"createTime":{"type":["string","null"]},"databaseEdition":{"type":["string","null"]},"databaseName":{"type":"string"},"databaseType":{"type":["string","null"]},"deleteProtectionState":{"type":["string","null"]},"deleteTime":{"type":["string","null"]},"earliestVersionTime":{"type":["string","null"]},"endpoint":{"type":["string","null"]},"locationId":{"type":["string","null"]},"pointInTimeRecoveryEnablement":{"type":["string","null"]},"projectId":{"type":["string","null"]},"sourceInfoPresent":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"},"updateTime":{"type":["string","null"]},"versionRetentionPeriod":{"type":["string","null"]}},"x-readme-ref-name":"GcpFirestoreKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpFirestore"]}}}]},{"allOf":[{"type":"object","required":["status","tableName","storageAccountName","tableExists"],"properties":{"endpoint":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"signedIdentifierCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"},"storageAccountKind":{"type":["string","null"]},"storageAccountLocation":{"type":["string","null"]},"storageAccountName":{"type":"string"},"storageAccountPrimaryStatus":{"type":["string","null"]},"storageAccountProvisioningState":{"type":["string","null"]},"storageAccountResourceId":{"type":["string","null"]},"tableExists":{"type":"boolean"},"tableName":{"type":"string"}},"x-readme-ref-name":"AzureTableKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureTable"]}}}]},{"allOf":[{"type":"object","required":["status","name","path","pathExists","cloudMetadataSupported"],"properties":{"cloudMetadataSupported":{"type":"boolean"},"isDirectory":{"type":["boolean","null"]},"name":{"type":"string"},"path":{"type":"string"},"pathExists":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"}},"x-readme-ref-name":"LocalKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"KvHeartbeatData"},"resourceType":{"type":"string","enum":["kv"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"description":"AWS Aurora Serverless v2 backend.","type":"object","required":["status","clusterIdentifier","neverPauses"],"properties":{"clusterIdentifier":{"type":"string"},"endpoint":{"type":["string","null"]},"engineVersion":{"type":["string","null"]},"neverPauses":{"type":"boolean","description":"True when a `minCapacity: 0` instance has not reached 0 ACU over the observation\nwindow — it is silently paying always-on prices (auto-pause verification)."},"serverlessCapacity":{"type":["number","null"],"format":"double","description":"Latest sampled `ServerlessDatabaseCapacity` (ACU)."},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"}},"x-readme-ref-name":"AuroraPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["aurora"]}}}],"description":"AWS Aurora Serverless v2 backend."},{"allOf":[{"description":"GCP Cloud SQL backend.","type":"object","required":["status","instanceName"],"properties":{"databaseVersion":{"type":["string","null"]},"instanceName":{"type":"string"},"state":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"}},"x-readme-ref-name":"GcpCloudSqlPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["cloudSql"]}}}],"description":"GCP Cloud SQL backend."},{"allOf":[{"description":"Azure Flexible Server backend.","type":"object","required":["status","serverName"],"properties":{"serverName":{"type":"string"},"state":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"},"version":{"type":["string","null"]}},"x-readme-ref-name":"AzureFlexibleServerPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["flexibleServer"]}}}],"description":"Azure Flexible Server backend."},{"allOf":[{"description":"Local embedded Postgres backend.","type":"object","required":["status","name","version","processRunning"],"properties":{"name":{"type":"string"},"port":{"type":["integer","null"],"format":"int32","minimum":0},"processRunning":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"},"version":{"type":"string"}},"x-readme-ref-name":"LocalPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}],"description":"Local embedded Postgres backend."}],"x-readme-ref-name":"PostgresHeartbeatData"},"resourceType":{"type":"string","enum":["postgres"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","accountId","region","prefix","parameterMetadataSampled"],"properties":{"accountId":{"type":"string"},"hasMoreParameters":{"type":["boolean","null"]},"latestModifiedAt":{"type":["string","null"],"format":"date-time"},"parameterMetadataSampled":{"type":"boolean"},"prefix":{"type":"string"},"region":{"type":"string"},"sampledAdvancedTierCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledKmsKeyMetadataPresentCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledParameterCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledSecureStringCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledStringCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledStringListCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"AwsParameterStoreVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsParameterStore"]}}}]},{"allOf":[{"type":"object","required":["status","projectId","location","prefix","secretMetadataListed"],"properties":{"location":{"type":"string"},"prefix":{"type":"string"},"projectId":{"type":"string"},"secretMetadataListed":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"GcpSecretManagerVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpSecretManager"]}}}]},{"allOf":[{"type":"object","required":["status","name","softDeleteEnabled","softDeleteRetentionDays","rbacAuthorizationEnabled","publicNetworkAccess","accessPolicyCount","privateEndpointConnectionCount","secretMetadataListed"],"properties":{"accessPolicyCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":["string","null"]},"name":{"type":"string"},"privateEndpointConnectionCount":{"type":"integer","format":"int32","minimum":0},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":"string"},"purgeProtectionEnabled":{"type":["boolean","null"]},"rbacAuthorizationEnabled":{"type":"boolean"},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"secretMetadataListed":{"type":"boolean"},"skuFamily":{"type":["string","null"]},"skuName":{"type":["string","null"]},"softDeleteEnabled":{"type":"boolean"},"softDeleteRetentionDays":{"type":"integer","format":"int32"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"},"vaultUri":{"type":["string","null"]}},"x-readme-ref-name":"AzureKeyVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureKeyVault"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","prefix","secretMetadataListed"],"properties":{"namespace":{"type":"string"},"prefix":{"type":"string"},"secretMetadataListed":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"KubernetesSecretVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetesSecret"]}}}]},{"allOf":[{"type":"object","required":["status","path","pathExists","secretMetadataListed"],"properties":{"isDirectory":{"type":["boolean","null"]},"modifiedAt":{"type":["string","null"],"format":"date-time"},"path":{"type":"string"},"pathExists":{"type":"boolean"},"readonly":{"type":["boolean","null"]},"secretMetadataListed":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"LocalVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"VaultHeartbeatData"},"resourceType":{"type":"string","enum":["vault"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","roleName","roleArn","roleId","path","createDate","assumeRolePolicyPresent","tagCount","managedTagCount","attachedPolicyCount","attachedPolicyNames","inlinePolicyCount","inlinePolicyNames","stackPermissionsApplied"],"properties":{"assumeRolePolicyPresent":{"type":"boolean"},"attachedPolicyCount":{"type":"integer","format":"int32","minimum":0},"attachedPolicyNames":{"type":"array","items":{"type":"string"}},"createDate":{"type":"string"},"description":{"type":["string","null"]},"inlinePolicyCount":{"type":"integer","format":"int32","minimum":0},"inlinePolicyNames":{"type":"array","items":{"type":"string"}},"lastUsedDate":{"type":["string","null"]},"lastUsedRegion":{"type":["string","null"]},"managedTagCount":{"type":"integer","format":"int32","minimum":0},"maxSessionDuration":{"type":["integer","null"],"format":"int32"},"path":{"type":"string"},"permissionsBoundaryArn":{"type":["string","null"]},"permissionsBoundaryType":{"type":["string","null"]},"roleArn":{"type":"string"},"roleId":{"type":"string"},"roleName":{"type":"string"},"stackPermissionsApplied":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"},"tagCount":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"AwsIamRoleServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsIamRole"]}}}]},{"allOf":[{"type":"object","required":["status","email","projectBindingCount","projectRoles","serviceAccountBindingCount","serviceAccountRoles"],"properties":{"description":{"type":["string","null"]},"disabled":{"type":["boolean","null"]},"displayName":{"type":["string","null"]},"email":{"type":"string"},"etag":{"type":["string","null"]},"name":{"type":["string","null"]},"oauth2ClientId":{"type":["string","null"]},"projectBindingCount":{"type":"integer","format":"int32","minimum":0},"projectId":{"type":["string","null"]},"projectRoles":{"type":"array","items":{"type":"string"}},"serviceAccountBindingCount":{"type":"integer","format":"int32","minimum":0},"serviceAccountRoles":{"type":"array","items":{"type":"string"}},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"},"uniqueId":{"type":["string","null"]}},"x-readme-ref-name":"GcpServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpServiceAccount"]}}}]},{"allOf":[{"type":"object","required":["status","name","resourceId","resourceGroup","location","managedTagCount","roleAssignmentCount","roleAssignmentIds","customRoleDefinitionCount","customRoleDefinitionIds","stackPermissionsApplied"],"properties":{"clientId":{"type":["string","null"]},"customRoleDefinitionCount":{"type":"integer","format":"int32","minimum":0},"customRoleDefinitionIds":{"type":"array","items":{"type":"string"}},"isolationScope":{"type":["string","null"]},"location":{"type":"string"},"managedTagCount":{"type":"integer","format":"int32","minimum":0},"name":{"type":"string"},"principalId":{"type":["string","null"]},"resourceGroup":{"type":"string"},"resourceId":{"type":"string"},"roleAssignmentCount":{"type":"integer","format":"int32","minimum":0},"roleAssignmentIds":{"type":"array","items":{"type":"string"}},"stackPermissionsApplied":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"},"tenantId":{"type":["string","null"]},"type":{"type":["string","null"]}},"x-readme-ref-name":"AzureManagedIdentityServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureManagedIdentity"]}}}]},{"allOf":[{"type":"object","required":["status","identity","configured"],"properties":{"configured":{"type":"boolean"},"identity":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"}},"x-readme-ref-name":"LocalServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ServiceAccountHeartbeatData"},"resourceType":{"type":"string","enum":["service-account"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","publicSubnetIds","privateSubnetIds","availabilityZones","routeTableCount","isByoVpc"],"properties":{"availabilityZones":{"type":"array","items":{"type":"string"}},"cidrBlock":{"type":["string","null"]},"internetGatewayId":{"type":["string","null"]},"isByoVpc":{"type":"boolean"},"natGatewayId":{"type":["string","null"]},"privateSubnetIds":{"type":"array","items":{"type":"string"}},"publicSubnetIds":{"type":"array","items":{"type":"string"}},"routeTableCount":{"type":"integer","format":"int32","minimum":0},"securityGroupId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"NetworkHeartbeatStatus"},"vpcId":{"type":["string","null"]},"vpcState":{"type":["string","null"]}},"x-readme-ref-name":"AwsVpcNetworkHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsVpc"]}}}]},{"allOf":[{"type":"object","required":["status","isByoVpc"],"properties":{"cidrBlock":{"type":["string","null"]},"cloudNatName":{"type":["string","null"]},"firewallName":{"type":["string","null"]},"isByoVpc":{"type":"boolean"},"networkName":{"type":["string","null"]},"networkSelfLink":{"type":["string","null"]},"region":{"type":["string","null"]},"routerName":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"NetworkHeartbeatStatus"},"subnetworkName":{"type":["string","null"]},"subnetworkSelfLink":{"type":["string","null"]}},"x-readme-ref-name":"GcpVpcNetworkHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpVpc"]}}}]},{"allOf":[{"type":"object","required":["status","isByoVnet"],"properties":{"applicationGatewaySubnetName":{"type":["string","null"]},"cidrBlock":{"type":["string","null"]},"isByoVnet":{"type":"boolean"},"lastByoVnetVerificationErrorCode":{"type":["string","null"]},"location":{"type":["string","null"]},"natGatewayId":{"type":["string","null"]},"nsgId":{"type":["string","null"]},"privateEndpointSubnetName":{"type":["string","null"]},"privateSubnetName":{"type":["string","null"]},"publicIpId":{"type":["string","null"]},"publicSubnetName":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"NetworkHeartbeatStatus"},"vnetName":{"type":["string","null"]},"vnetResourceId":{"type":["string","null"]}},"x-readme-ref-name":"AzureVnetNetworkHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureVnet"]}}}]}],"x-readme-ref-name":"NetworkHeartbeatData"},"resourceType":{"type":"string","enum":["network"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","managementPermissionsApplied"],"properties":{"managementPermissionsApplied":{"type":"boolean"},"roleArn":{"type":["string","null"]},"roleName":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"RemoteStackManagementHeartbeatStatus"}},"x-readme-ref-name":"AwsRemoteStackManagementHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsIamRole"]}}}]},{"allOf":[{"type":"object","required":["status","roleBound","impersonationGranted"],"properties":{"impersonationGranted":{"type":"boolean"},"roleBound":{"type":"boolean"},"serviceAccountEmail":{"type":["string","null"]},"serviceAccountUniqueId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"RemoteStackManagementHeartbeatStatus"}},"x-readme-ref-name":"GcpRemoteStackManagementHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpServiceAccount"]}}}]},{"allOf":[{"type":"object","required":["status","roleAssignmentIds"],"properties":{"ficName":{"type":["string","null"]},"roleAssignmentIds":{"type":"array","items":{"type":"string"}},"roleDefinitionId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"RemoteStackManagementHeartbeatStatus"},"tenantId":{"type":["string","null"]},"uamiClientId":{"type":["string","null"]},"uamiPrincipalId":{"type":["string","null"]},"uamiResourceId":{"type":["string","null"]}},"x-readme-ref-name":"AzureRemoteStackManagementHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureManagedIdentity"]}}}]}],"x-readme-ref-name":"RemoteStackManagementHeartbeatData"},"resourceType":{"type":"string","enum":["remote-stack-management"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","registryId","region","registryUri","repositoryPrefix","repositoryCount","repositoriesTruncated","repositories"],"properties":{"pullRoleArn":{"type":["string","null"]},"pushRoleArn":{"type":["string","null"]},"region":{"type":"string"},"registryId":{"type":"string"},"registryUri":{"type":"string"},"repositories":{"type":"array","items":{"type":"object","required":["repositoryArn","registryId","repositoryName","repositoryUri","createdAt","kmsKeyPresent"],"properties":{"createdAt":{"type":"number","format":"double"},"encryptionType":{"type":["string","null"]},"imageTagMutability":{"type":["string","null"]},"kmsKeyPresent":{"type":"boolean"},"registryId":{"type":"string"},"repositoryArn":{"type":"string"},"repositoryName":{"type":"string"},"repositoryUri":{"type":"string"},"scanOnPush":{"type":["boolean","null"]}},"x-readme-ref-name":"AwsEcrRepositoryHeartbeatData"}},"repositoriesTruncated":{"type":"boolean"},"repositoryCount":{"type":"integer","format":"int32","minimum":0},"repositoryPrefix":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"}},"x-readme-ref-name":"AwsEcrArtifactRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsEcr"]}}}]},{"allOf":[{"type":"object","required":["status","projectId","location","repositoryId","labelCount","cleanupPolicyCount","kmsKeyNamePresent","iamPolicyEtagPresent","iamBindingCount","iamRoles"],"properties":{"cleanupPolicyCount":{"type":"integer","format":"int32","minimum":0},"cleanupPolicyDryRun":{"type":["boolean","null"]},"createTime":{"type":["string","null"]},"description":{"type":["string","null"]},"format":{"type":["string","null"]},"iamBindingCount":{"type":"integer","format":"int32","minimum":0},"iamPolicyEtagPresent":{"type":"boolean"},"iamRoles":{"type":"array","items":{"type":"string"}},"kmsKeyNamePresent":{"type":"boolean"},"labelCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":"string"},"mode":{"type":["string","null"]},"name":{"type":["string","null"]},"projectId":{"type":"string"},"pullServiceAccountEmail":{"type":["string","null"]},"pushServiceAccountEmail":{"type":["string","null"]},"repositoryId":{"type":"string"},"satisfiesPzs":{"type":["boolean","null"]},"sizeBytes":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"},"updateTime":{"type":["string","null"]}},"x-readme-ref-name":"GcpArtifactRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpArtifactRegistry"]}}}]},{"allOf":[{"type":"object","required":["status","name","resourceGroup","location","skuName","adminUserEnabled","anonymousPullEnabled","publicNetworkAccess","networkRuleBypassOptions","ipRuleCount","encryptionKeyVaultUriPresent","encryptionKeyIdentifierPresent","policiesPresent","policyCount","privateEndpointConnectionCount","dataEndpointHostNames","zoneRedundancy","managedTagCount"],"properties":{"adminUserEnabled":{"type":"boolean"},"anonymousPullEnabled":{"type":"boolean"},"creationDate":{"type":["string","null"]},"dataEndpointEnabled":{"type":["boolean","null"]},"dataEndpointHostNames":{"type":"array","items":{"type":"string"}},"encryptionKeyIdentifierPresent":{"type":"boolean"},"encryptionKeyVaultUriPresent":{"type":"boolean"},"encryptionStatus":{"type":["string","null"]},"ipRuleCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":"string"},"loginServer":{"type":["string","null"]},"managedTagCount":{"type":"integer","format":"int32","minimum":0},"name":{"type":"string"},"networkRuleBypassOptions":{"type":"string"},"networkRuleDefaultAction":{"type":["string","null"]},"policiesPresent":{"type":"boolean"},"policyCount":{"type":"integer","format":"int32","minimum":0},"privateEndpointConnectionCount":{"type":"integer","format":"int32","minimum":0},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":"string"},"resourceGroup":{"type":"string"},"resourceId":{"type":["string","null"]},"skuName":{"type":"string"},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"},"type":{"type":["string","null"]},"zoneRedundancy":{"type":"string"}},"x-readme-ref-name":"AzureContainerRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureContainerRegistry"]}}}]},{"allOf":[{"type":"object","required":["status","registryUrl","reachable"],"properties":{"reachable":{"type":"boolean"},"registryUrl":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"}},"x-readme-ref-name":"LocalArtifactRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ArtifactRegistryHeartbeatData"},"resourceType":{"type":"string","enum":["artifact-registry"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","projectName","environmentVariableCount","serviceRolePresent","encryptionKeyPresent"],"properties":{"artifactsEncryptionDisabled":{"type":["boolean","null"]},"artifactsType":{"type":["string","null"]},"cloudWatchLogsStatus":{"type":["string","null"]},"computeType":{"type":["string","null"]},"created":{"type":["number","null"],"format":"double"},"description":{"type":["string","null"]},"encryptionKeyPresent":{"type":"boolean"},"environmentImage":{"type":["string","null"]},"environmentType":{"type":["string","null"]},"environmentVariableCount":{"type":"integer","format":"int32","minimum":0},"imagePullCredentialsType":{"type":["string","null"]},"lastModified":{"type":["number","null"],"format":"double"},"privilegedMode":{"type":["boolean","null"]},"projectArn":{"type":["string","null"]},"projectName":{"type":"string"},"queuedTimeoutInMinutes":{"type":["integer","null"],"format":"int32"},"s3LogsStatus":{"type":["string","null"]},"serviceRolePresent":{"type":"boolean"},"sourceType":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"},"timeoutInMinutes":{"type":["integer","null"],"format":"int32"}},"x-readme-ref-name":"AwsCodeBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsCodeBuild"]}}}]},{"allOf":[{"type":"object","required":["status","projectId","location","buildConfigId","environmentVariableCount"],"properties":{"buildConfigId":{"type":"string"},"environmentVariableCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":"string"},"projectId":{"type":"string"},"serviceAccount":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"}},"x-readme-ref-name":"GcpCloudBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpCloudBuild"]}}}]},{"allOf":[{"type":"object","required":["status","managedEnvironmentId","resourceGroupName","environmentVariableCount"],"properties":{"environmentVariableCount":{"type":"integer","format":"int32","minimum":0},"managedEnvironmentId":{"type":"string"},"managedIdentityId":{"type":["string","null"]},"resourceGroupName":{"type":"string"},"resourcePrefix":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"}},"x-readme-ref-name":"AzureContainerAppsBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureContainerApps"]}}}]},{"allOf":[{"type":"object","required":["status","jobName","namespace","conditionCount","events"],"properties":{"active":{"type":["integer","null"],"format":"int32"},"completionTime":{"type":["string","null"],"format":"date-time"},"conditionCount":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"failed":{"type":["integer","null"],"format":"int32"},"imageDigest":{"type":["string","null"]},"jobName":{"type":"string"},"namespace":{"type":"string"},"startTime":{"type":["string","null"],"format":"date-time"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"},"succeeded":{"type":["integer","null"],"format":"int32"}},"x-readme-ref-name":"KubernetesBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetesJob"]}}}]}],"x-readme-ref-name":"BuildHeartbeatData"},"resourceType":{"type":"string","enum":["build"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","projectId","serviceName","enabled"],"properties":{"enabled":{"type":"boolean"},"lastOperationName":{"type":["string","null"]},"projectId":{"type":"string"},"serviceName":{"type":"string"},"serviceResourceName":{"type":["string","null"]},"state":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceActivationHeartbeatStatus"},"title":{"type":["string","null"]}},"x-readme-ref-name":"GcpServiceUsageActivationHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpServiceUsage"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","resourceTypeCount","registered"],"properties":{"namespace":{"type":"string"},"providerId":{"type":["string","null"]},"registered":{"type":"boolean"},"registrationPolicy":{"type":["string","null"]},"registrationState":{"type":["string","null"]},"resourceTypeCount":{"type":"integer","format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceActivationHeartbeatStatus"}},"x-readme-ref-name":"AzureResourceProviderActivationHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureResourceProvider"]}}}]}],"x-readme-ref-name":"ServiceActivationHeartbeatData"},"resourceType":{"type":"string","enum":["service_activation"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","managedTags"],"properties":{"location":{"type":["string","null"]},"managedTags":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"name":{"type":"string"},"provisioningState":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AzureResourceGroupHeartbeatStatus"}},"x-readme-ref-name":"AzureResourceGroupHeartbeatData"},"resourceType":{"type":"string","enum":["azure_resource_group"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","primaryEndpoints","secondaryEndpoints"],"properties":{"allowBlobPublicAccess":{"type":["boolean","null"]},"allowSharedKeyAccess":{"type":["boolean","null"]},"encryptionKeySource":{"type":["string","null"]},"kind":{"type":["string","null"]},"location":{"type":["string","null"]},"minimumTlsVersion":{"type":["string","null"]},"name":{"type":"string"},"networkBypass":{"type":["string","null"]},"networkDefaultAction":{"type":["string","null"]},"networkIpRuleCount":{"type":["integer","null"],"format":"int32","minimum":0},"networkResourceAccessRuleCount":{"type":["integer","null"],"format":"int32","minimum":0},"networkVirtualNetworkRuleCount":{"type":["integer","null"],"format":"int32","minimum":0},"primaryEndpoints":{"type":"object","properties":{"blob":{"type":["string","null"]},"dfs":{"type":["string","null"]},"file":{"type":["string","null"]},"queue":{"type":["string","null"]},"table":{"type":["string","null"]},"web":{"type":["string","null"]}},"x-readme-ref-name":"AzureStorageAccountEndpoints"},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":["string","null"]},"requireInfrastructureEncryption":{"type":["boolean","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"secondaryEndpoints":{"type":"object","properties":{"blob":{"type":["string","null"]},"dfs":{"type":["string","null"]},"file":{"type":["string","null"]},"queue":{"type":["string","null"]},"table":{"type":["string","null"]},"web":{"type":["string","null"]}},"x-readme-ref-name":"AzureStorageAccountEndpoints"},"skuName":{"type":["string","null"]},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"supportsHttpsTrafficOnly":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureStorageAccountHeartbeatData"},"resourceType":{"type":"string","enum":["azure_storage_account"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","workloadProfileCount","workloadProfiles"],"properties":{"customDomainVerificationId":{"type":["string","null"]},"defaultDomain":{"type":["string","null"]},"eventStreamEndpoint":{"type":["string","null"]},"infrastructureResourceGroup":{"type":["string","null"]},"kind":{"type":["string","null"]},"location":{"type":["string","null"]},"name":{"type":"string"},"provisioningState":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"staticIp":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AzureContainerAppsEnvironmentHeartbeatStatus"},"workloadProfileCount":{"type":"integer","format":"int32","minimum":0},"workloadProfiles":{"type":"array","items":{"type":"object","required":["name","workloadProfileType"],"properties":{"maximumCount":{"type":["integer","null"],"format":"int32"},"minimumCount":{"type":["integer","null"],"format":"int32"},"name":{"type":"string"},"workloadProfileType":{"type":"string"}},"x-readme-ref-name":"AzureContainerAppsEnvironmentWorkloadProfile"}},"zoneRedundant":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureContainerAppsEnvironmentHeartbeatData"},"resourceType":{"type":"string","enum":["azure_container_apps_environment"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","privateEndpointConnectionCount"],"properties":{"createdAt":{"type":["string","null"]},"disableLocalAuth":{"type":["boolean","null"]},"location":{"type":["string","null"]},"metricId":{"type":["string","null"]},"minimumTlsVersion":{"type":["string","null"]},"name":{"type":"string"},"namespaceStatus":{"type":["string","null"]},"premiumMessagingPartitions":{"type":["integer","null"],"format":"int32"},"privateEndpointConnectionCount":{"type":"integer","format":"int32","minimum":0},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"serviceBusEndpoint":{"type":["string","null"]},"skuCapacity":{"type":["integer","null"],"format":"int32"},"skuName":{"type":["string","null"]},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"updatedAt":{"type":["string","null"]},"zoneRedundant":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureServiceBusNamespaceHeartbeatData"},"resourceType":{"type":"string","enum":["azure_service_bus_namespace"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","region"],"properties":{"region":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"AwsBedrockAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsBedrock"]}}}]},{"allOf":[{"type":"object","required":["status","project","location"],"properties":{"location":{"type":"string"},"project":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"GcpVertexAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpVertex"]}}}]},{"allOf":[{"type":"object","required":["status","accountName"],"properties":{"accountName":{"type":"string"},"endpoint":{"type":["string","null"]},"location":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"AzureFoundryAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureFoundry"]}}}]},{"allOf":[{"type":"object","required":["status","provider"],"properties":{"provider":{"type":"string","description":"The BYO-key provider serving this binding (e.g. \"openai\"). Used on the Local\nplatform, where the app brings its own provider key instead of an ambient cloud."},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"ExternalAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["external"]}}}]}],"x-readme-ref-name":"AiHeartbeatData"},"resourceType":{"type":"string","enum":["ai"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"type":"object","required":["data","provider"],"properties":{"data":{"type":"object","required":["status","keyArn","keyState","enabled","keySpec","keyUsage"],"properties":{"enabled":{"type":"boolean"},"keyArn":{"type":"string"},"keySpec":{"type":"string"},"keyState":{"type":"string"},"keyUsage":{"type":"string"},"status":{"type":"object","required":["health","lifecycle"],"properties":{"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]}},"x-readme-ref-name":"KeyHeartbeatStatus"}},"x-readme-ref-name":"AwsKmsKeyHeartbeatData"},"provider":{"type":"string","enum":["aws-kms"]}}},{"type":"object","required":["data","provider"],"properties":{"data":{"type":"object","required":["status","cryptoKeyName","purpose"],"properties":{"algorithm":{"type":["string","null"]},"cryptoKeyName":{"type":"string"},"primaryState":{"type":["string","null"]},"primaryVersion":{"type":["string","null"]},"purpose":{"type":"string"},"status":{"type":"object","required":["health","lifecycle"],"properties":{"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]}},"x-readme-ref-name":"KeyHeartbeatStatus"}},"x-readme-ref-name":"GcpCloudKmsKeyHeartbeatData"},"provider":{"type":"string","enum":["gcp-cloud-kms"]}}},{"type":"object","required":["data","provider"],"properties":{"data":{"type":"object","required":["status","keyId","keyType","keyOperations"],"properties":{"enabled":{"type":["boolean","null"]},"keyId":{"type":"string"},"keyOperations":{"type":"array","items":{"type":"string"}},"keyType":{"type":"string"},"recoveryLevel":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle"],"properties":{"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]}},"x-readme-ref-name":"KeyHeartbeatStatus"}},"x-readme-ref-name":"AzureKeyVaultKeyHeartbeatData"},"provider":{"type":"string","enum":["azure-key-vault"]}}}],"x-readme-ref-name":"KeyHeartbeatData"},"resourceType":{"type":"string","enum":["key"]}}}],"x-readme-ref-name":"ResourceHeartbeatData"},"deploymentId":{"type":["string","null"]},"observedAt":{"type":"string","format":"date-time"},"raw":{"type":"array","items":{"type":"object","required":["source","format","collectedAt","body","truncated"],"properties":{"body":{"type":"string"},"collectedAt":{"type":"string","format":"date-time"},"format":{"type":"string","enum":["json","yaml","text"],"x-readme-ref-name":"RawHeartbeatSnippetFormat"},"source":{"type":"string"},"truncated":{"type":"boolean"}},"x-readme-ref-name":"RawHeartbeatSnippet"}},"resourceId":{"type":"string","description":"Alien resource id, such as the `alien.Container` or `alien.Storage`\nresource id from the stack."},"resourceType":{"type":"string","description":"Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.","examples":["worker","storage","queue","redis","postgres"],"x-readme-ref-name":"ResourceType"}},"x-readme-ref-name":"ResourceHeartbeat"} \ No newline at end of file diff --git a/packages/core/src/generated/schemas/resourceHeartbeatData.json b/packages/core/src/generated/schemas/resourceHeartbeatData.json index b4a3eca10..f894b9cf0 100644 --- a/packages/core/src/generated/schemas/resourceHeartbeatData.json +++ b/packages/core/src/generated/schemas/resourceHeartbeatData.json @@ -1 +1 @@ -{"oneOf":[{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","name","lifecyclePresent","encryptionConfigPresent","publicAccessBlockPresent"],"properties":{"blockPublicAcls":{"type":["boolean","null"]},"blockPublicPolicy":{"type":["boolean","null"]},"bucketAclPresent":{"type":["boolean","null"]},"bucketLocation":{"type":["string","null"]},"bucketPolicyPresent":{"type":["boolean","null"]},"encryptionConfigPresent":{"type":"boolean"},"encryptionEnabled":{"type":["boolean","null"]},"ignorePublicAcls":{"type":["boolean","null"]},"lifecyclePresent":{"type":"boolean"},"lifecycleRuleCount":{"type":["integer","null"],"format":"int64","minimum":0},"name":{"type":"string"},"publicAccessBlockPresent":{"type":"boolean"},"region":{"type":["string","null"]},"restrictPublicBuckets":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"versioningEnabled":{"type":["boolean","null"]},"versioningStatus":{"type":["string","null"]}},"x-readme-ref-name":"AwsS3StorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsS3"]}}}]},{"allOf":[{"type":"object","required":["status","name","lifecyclePresent","encryptionConfigPresent"],"properties":{"bucketId":{"type":["string","null"]},"defaultKmsKeyName":{"type":["string","null"]},"encryptionConfigPresent":{"type":"boolean"},"lifecyclePresent":{"type":"boolean"},"lifecycleRuleCount":{"type":["integer","null"],"format":"int64","minimum":0},"location":{"type":["string","null"]},"locationType":{"type":["string","null"]},"name":{"type":"string"},"publicAccessPrevention":{"type":["string","null"]},"retentionPeriod":{"type":["string","null"]},"retentionPolicyEffectiveTime":{"type":["string","null"]},"retentionPolicyIsLocked":{"type":["boolean","null"]},"softDeleteEffectiveTime":{"type":["string","null"]},"softDeleteRetentionDurationSeconds":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"storageClass":{"type":["string","null"]},"uniformBucketLevelAccessEnabled":{"type":["boolean","null"]},"uniformBucketLevelAccessLockedTime":{"type":["string","null"]},"versioningEnabled":{"type":["boolean","null"]}},"x-readme-ref-name":"GcpCloudStorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpCloudStorage"]}}}]},{"allOf":[{"type":"object","required":["status","name"],"properties":{"accessTier":{"type":["string","null"]},"accountKind":{"type":["string","null"]},"allowBlobPublicAccess":{"type":["boolean","null"]},"blobDeleteRetentionDays":{"type":["integer","null"],"format":"int64","minimum":0},"blobDeleteRetentionEnabled":{"type":["boolean","null"]},"blobEncryptionEnabled":{"type":["boolean","null"]},"blobVersioningEnabled":{"type":["boolean","null"]},"changeFeedEnabled":{"type":["boolean","null"]},"changeFeedRetentionDays":{"type":["integer","null"],"format":"int64","minimum":0},"containerDeleteRetentionDays":{"type":["integer","null"],"format":"int64","minimum":0},"containerDeleteRetentionEnabled":{"type":["boolean","null"]},"containerPublicAccess":{"type":["string","null"]},"encryptionKeySource":{"type":["string","null"]},"fileEncryptionEnabled":{"type":["boolean","null"]},"location":{"type":["string","null"]},"name":{"type":"string"},"primaryLocation":{"type":["string","null"]},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":["string","null"]},"queueEncryptionEnabled":{"type":["boolean","null"]},"resourceGroup":{"type":["string","null"]},"secondaryLocation":{"type":["string","null"]},"skuName":{"type":["string","null"]},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"statusOfPrimary":{"type":["string","null"]},"statusOfSecondary":{"type":["string","null"]},"storageAccountName":{"type":["string","null"]},"tableEncryptionEnabled":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureBlobStorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureBlob"]}}}]},{"allOf":[{"type":"object","required":["status","path","pathExists"],"properties":{"isDirectory":{"type":["boolean","null"]},"modifiedAt":{"type":["string","null"],"format":"date-time"},"path":{"type":"string"},"pathExists":{"type":"boolean"},"readonly":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"}},"x-readme-ref-name":"LocalStorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"StorageHeartbeatData"},"resourceType":{"type":"string","enum":["storage"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","functionName","layerCount","functionUrlCorsPresent","triggerCount"],"properties":{"codeSha256":{"type":["string","null"]},"functionName":{"type":"string"},"functionUrlAuthType":{"type":["string","null"]},"functionUrlCorsPresent":{"type":"boolean"},"lastModified":{"type":["string","null"]},"lastUpdateStatus":{"type":["string","null"]},"lastUpdateStatusReason":{"type":["string","null"]},"lastUpdateStatusReasonCode":{"type":["string","null"]},"layerCount":{"type":"integer","format":"int32","minimum":0},"memorySizeMb":{"type":["integer","null"],"format":"int64"},"packageType":{"type":["string","null"]},"revisionId":{"type":["string","null"]},"runtime":{"type":["string","null"]},"state":{"type":["string","null"]},"stateReason":{"type":["string","null"]},"stateReasonCode":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"timeoutSeconds":{"type":["integer","null"],"format":"int64"},"triggerCount":{"type":"integer","format":"int32","minimum":0},"version":{"type":["string","null"]}},"x-readme-ref-name":"AwsLambdaWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsLambda"]}}}]},{"allOf":[{"type":"object","required":["status","service","urls","trafficCount"],"properties":{"containerImage":{"type":["string","null"]},"cpuLimit":{"type":["string","null"]},"generation":{"type":["integer","null"],"format":"int64"},"latestCreatedRevision":{"type":["string","null"]},"latestReadyRevision":{"type":["string","null"]},"maxInstanceCount":{"type":["integer","null"],"format":"int32"},"memoryLimit":{"type":["string","null"]},"minInstanceCount":{"type":["integer","null"],"format":"int32"},"observedGeneration":{"type":["integer","null"],"format":"int64"},"region":{"type":["string","null"]},"service":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"trafficCount":{"type":"integer","format":"int32","minimum":0},"uri":{"type":["string","null"]},"urls":{"type":"array","items":{"type":"string"}}},"x-readme-ref-name":"GcpCloudRunWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpCloudRun"]}}}]},{"allOf":[{"type":"object","required":["status","appName"],"properties":{"appName":{"type":"string"},"cpu":{"type":["number","null"],"format":"double"},"environmentName":{"type":["string","null"]},"ingressFqdn":{"type":["string","null"]},"maxReplicas":{"type":["integer","null"],"format":"int32"},"memory":{"type":["string","null"]},"minReplicas":{"type":["integer","null"],"format":"int32"},"provisioningState":{"type":["string","null"]},"revision":{"type":["string","null"]},"runningStatus":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"AzureContainerAppsWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureContainerApps"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","name","workloadKind","replicas","pods","triggerCount","events"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":"string"},"pods":{"type":"array","items":{"type":"object","required":["name","ready","restartCount","ownerReferences"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"ownerReferences":{"type":"array","items":{"type":"object","required":["kind","name","uid","controller"],"properties":{"controller":{"type":"boolean"},"kind":{"type":"string"},"name":{"type":"string"},"uid":{"type":"string"}},"x-readme-ref-name":"KubernetesOwnerReference"}},"phase":{"type":["string","null"]},"podIp":{"type":["string","null"]},"ready":{"type":"boolean"},"restartCount":{"type":"integer","format":"int32","minimum":0},"terminatedReason":{"type":["string","null"]},"uid":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesPodRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"restarts":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"triggerCount":{"type":"integer","format":"int32","minimum":0},"workload":{"oneOf":[{"type":"null"},{"type":"object","required":["conditions"],"properties":{"availableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"lastTransitionTime":{"type":["string","null"],"format":"date-time"},"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesWorkloadCondition"}},"desiredGeneration":{"type":["integer","null"],"format":"int64"},"desiredReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"observedGeneration":{"type":["integer","null"],"format":"int64"},"readyReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"rolloutReason":{"type":["string","null"]},"updatedReplicas":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"KubernetesWorkloadStatus"}]},"workloadKind":{"type":"string","enum":["deployment","statefulSet","daemonSet","replicaSet","pod"],"x-readme-ref-name":"KubernetesWorkloadKind"}},"x-readme-ref-name":"KubernetesWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetes"]}}}]},{"allOf":[{"type":"object","required":["status","commandSupported","imagePathPresent","triggerCount","events"],"properties":{"commandSupported":{"type":"boolean"},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["timestamp","severity","kind","message"],"properties":{"kind":{"type":"string"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"subject":{"oneOf":[{"type":"null"},{"type":"object","required":["kind"],"properties":{"id":{"type":["string","null"]},"kind":{"type":"string"},"name":{"type":["string","null"]}},"x-readme-ref-name":"LocalRuntimeEventSubject"}]},"timestamp":{"type":"string","format":"date-time"}},"x-readme-ref-name":"LocalRuntimeEventSnapshot"}},"imagePathPresent":{"type":"boolean"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"process":{"oneOf":[{"type":"null"},{"type":"object","required":["unitId","name","kind","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"kind":{"type":"string","enum":["container","process","daemon"],"x-readme-ref-name":"LocalRuntimeUnitKind"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"phase":{"type":["string","null"]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":"boolean"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"unitId":{"type":"string"}},"x-readme-ref-name":"LocalRuntimeUnitStatus"}]},"readinessProbeOk":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"triggerCount":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"LocalWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"WorkerHeartbeatData"},"resourceType":{"type":"string","enum":["worker"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","containerId","schedulingMode","replicas","attentionCount","replicaUnits","events"],"properties":{"attentionCount":{"type":"integer","format":"int32","minimum":0},"containerId":{"type":"string"},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"image":{"type":["string","null"]},"latestUpdateTimestamp":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"observedImage":{"type":["string","null"]},"replicaUnits":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"schedulingMode":{"type":"string","enum":["replicated","stateful","daemon"],"x-readme-ref-name":"HorizonWorkloadSchedulingMode"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"HorizonContainerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["horizonPlatform"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","name","workloadKind","replicas","pods","events"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":"string"},"pods":{"type":"array","items":{"type":"object","required":["name","ready","restartCount","ownerReferences"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"ownerReferences":{"type":"array","items":{"type":"object","required":["kind","name","uid","controller"],"properties":{"controller":{"type":"boolean"},"kind":{"type":"string"},"name":{"type":"string"},"uid":{"type":"string"}},"x-readme-ref-name":"KubernetesOwnerReference"}},"phase":{"type":["string","null"]},"podIp":{"type":["string","null"]},"ready":{"type":"boolean"},"restartCount":{"type":"integer","format":"int32","minimum":0},"terminatedReason":{"type":["string","null"]},"uid":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesPodRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"restarts":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"workload":{"oneOf":[{"type":"null"},{"type":"object","required":["conditions"],"properties":{"availableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"lastTransitionTime":{"type":["string","null"],"format":"date-time"},"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesWorkloadCondition"}},"desiredGeneration":{"type":["integer","null"],"format":"int64"},"desiredReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"observedGeneration":{"type":["integer","null"],"format":"int64"},"readyReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"rolloutReason":{"type":["string","null"]},"updatedReplicas":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"KubernetesWorkloadStatus"}]},"workloadKind":{"type":"string","enum":["deployment","statefulSet","daemonSet","replicaSet","pod"],"x-readme-ref-name":"KubernetesWorkloadKind"}},"x-readme-ref-name":"KubernetesContainerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetes"]}}}]},{"allOf":[{"type":"object","required":["status","portCount","bindMountCount","runtimeReachable","events"],"properties":{"bindMountCount":{"type":"integer","format":"int32","minimum":0},"containerId":{"type":["string","null"]},"containerUnit":{"oneOf":[{"type":"null"},{"type":"object","required":["unitId","name","kind","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"kind":{"type":"string","enum":["container","process","daemon"],"x-readme-ref-name":"LocalRuntimeUnitKind"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"phase":{"type":["string","null"]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":"boolean"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"unitId":{"type":"string"}},"x-readme-ref-name":"LocalRuntimeUnitStatus"}]},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["timestamp","severity","kind","message"],"properties":{"kind":{"type":"string"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"subject":{"oneOf":[{"type":"null"},{"type":"object","required":["kind"],"properties":{"id":{"type":["string","null"]},"kind":{"type":"string"},"name":{"type":["string","null"]}},"x-readme-ref-name":"LocalRuntimeEventSubject"}]},"timestamp":{"type":"string","format":"date-time"}},"x-readme-ref-name":"LocalRuntimeEventSnapshot"}},"image":{"type":["string","null"]},"localUrl":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":["string","null"]},"portCount":{"type":"integer","format":"int32","minimum":0},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"runtimeReachable":{"type":"boolean"},"runtimeStatus":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"LocalContainerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ContainerHeartbeatData"},"resourceType":{"type":"string","enum":["container"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"AwsDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["aws"]}}}]},{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"GcpDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcp"]}}}]},{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"AzureDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azure"]}}}]},{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"MachinesDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["machines"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","name","replicas","commandSupported","pods","events"],"properties":{"commandSupported":{"type":"boolean"},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":"string"},"pods":{"type":"array","items":{"type":"object","required":["name","ready","restartCount","ownerReferences"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"ownerReferences":{"type":"array","items":{"type":"object","required":["kind","name","uid","controller"],"properties":{"controller":{"type":"boolean"},"kind":{"type":"string"},"name":{"type":"string"},"uid":{"type":"string"}},"x-readme-ref-name":"KubernetesOwnerReference"}},"phase":{"type":["string","null"]},"podIp":{"type":["string","null"]},"ready":{"type":"boolean"},"restartCount":{"type":"integer","format":"int32","minimum":0},"terminatedReason":{"type":["string","null"]},"uid":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesPodRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"restarts":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"workload":{"oneOf":[{"type":"null"},{"type":"object","required":["conditions"],"properties":{"availableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"lastTransitionTime":{"type":["string","null"],"format":"date-time"},"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesWorkloadCondition"}},"desiredGeneration":{"type":["integer","null"],"format":"int64"},"desiredReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"observedGeneration":{"type":["integer","null"],"format":"int64"},"readyReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"rolloutReason":{"type":["string","null"]},"updatedReplicas":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"KubernetesWorkloadStatus"}]}},"x-readme-ref-name":"KubernetesDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetes"]}}}]},{"allOf":[{"type":"object","required":["status","runtimeId","commandSupported","imagePathPresent","events"],"properties":{"commandSupported":{"type":"boolean"},"daemonInstance":{"oneOf":[{"type":"null"},{"type":"object","required":["unitId","name","kind","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"kind":{"type":"string","enum":["container","process","daemon"],"x-readme-ref-name":"LocalRuntimeUnitKind"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"phase":{"type":["string","null"]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":"boolean"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"unitId":{"type":"string"}},"x-readme-ref-name":"LocalRuntimeUnitStatus"}]},"daemonName":{"type":"string"},"events":{"type":"array","items":{"type":"object","required":["timestamp","severity","kind","message"],"properties":{"kind":{"type":"string"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"subject":{"oneOf":[{"type":"null"},{"type":"object","required":["kind"],"properties":{"id":{"type":["string","null"]},"kind":{"type":"string"},"name":{"type":["string","null"]}},"x-readme-ref-name":"LocalRuntimeEventSubject"}]},"timestamp":{"type":"string","format":"date-time"}},"x-readme-ref-name":"LocalRuntimeEventSnapshot"}},"exitReason":{"type":["string","null"]},"imagePathPresent":{"type":"boolean"},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"runtimeId":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"LocalDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"DaemonHeartbeatData"},"resourceType":{"type":"string","enum":["daemon"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","providerFleets"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"providerFleets":{"type":"array","items":{"type":"object","required":["groupId","providerId","currentMachines","desiredMachines"],"properties":{"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"groupId":{"type":"string"},"location":{"type":["string","null"]},"providerId":{"type":"string"}},"x-readme-ref-name":"ProviderFleetStatus"}},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"AwsComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["aws"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","providerFleets"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"providerFleets":{"type":"array","items":{"type":"object","required":["groupId","providerId","currentMachines","desiredMachines"],"properties":{"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"groupId":{"type":"string"},"location":{"type":["string","null"]},"providerId":{"type":"string"}},"x-readme-ref-name":"ProviderFleetStatus"}},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"GcpComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcp"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","providerFleets"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"providerFleets":{"type":"array","items":{"type":"object","required":["groupId","providerId","currentMachines","desiredMachines"],"properties":{"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"groupId":{"type":"string"},"location":{"type":["string","null"]},"providerId":{"type":"string"}},"x-readme-ref-name":"ProviderFleetStatus"}},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"AzureComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azure"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","machines"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"machines":{"type":"array","items":{"type":"object","required":["machineId","status","capacityGroup","zone","lastHeartbeat","replicaCount","drainForce"],"properties":{"capacityGroup":{"type":"string"},"cpuCores":{"type":["number","null"],"format":"double"},"drainBlockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainForce":{"type":"boolean"},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"horizondVersion":{"type":["string","null"]},"lastHeartbeat":{"type":"string"},"machineId":{"type":"string"},"memoryBytes":{"type":["integer","null"],"format":"int64"},"overlayIp":{"type":["string","null"]},"publicIp":{"type":["string","null"]},"replicaCount":{"type":"integer","format":"int64"},"status":{"type":"string"},"zone":{"type":"string"}},"x-readme-ref-name":"MachinesComputeMachineStatus"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"MachinesComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["machines"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","dockerAvailable","networkAvailable"],"properties":{"dockerApiVersion":{"type":["string","null"]},"dockerArch":{"type":["string","null"]},"dockerAvailable":{"type":"boolean"},"dockerOs":{"type":["string","null"]},"dockerVersion":{"type":["string","null"]},"hostIdentifier":{"type":["string","null"]},"name":{"type":"string"},"networkAvailable":{"type":"boolean"},"networkName":{"type":["string","null"]},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"runningContainers":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"},"trackedContainers":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"LocalComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ComputeClusterHeartbeatData"},"resourceType":{"type":"string","enum":["compute-cluster"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","nodeCounts","podCounts","name","events"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":["string","null"]},"nodeCounts":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"nodeStatuses":{"type":"array","items":{"type":"object","required":["name","ready","roles","labels","allocatable","capacity"],"properties":{"allocatable":{"type":"object","properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"pods":{"type":["integer","null"],"format":"int64","minimum":0}},"x-readme-ref-name":"KubernetesNodeResources"},"capacity":{"type":"object","properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"pods":{"type":["integer","null"],"format":"int64","minimum":0}},"x-readme-ref-name":"KubernetesNodeResources"},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesNodeConditionStatus"}},"containerRuntimeVersion":{"type":["string","null"]},"kubeletVersion":{"type":["string","null"]},"labels":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"name":{"type":"string"},"ready":{"type":"boolean"},"roles":{"type":"array","items":{"type":"string"}},"uid":{"type":["string","null"]},"usage":{"oneOf":[{"type":"null"},{"type":"object","properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"KubernetesNodeUsage"}]}},"x-readme-ref-name":"KubernetesClusterNodeStatus"}},"podCounts":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"version":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesClusterHeartbeatData"},"resourceType":{"type":"string","enum":["kubernetes-cluster"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","name","approximateCounts"],"properties":{"approximateCounts":{"type":"boolean"},"approximateDelayedMessages":{"type":["integer","null"],"format":"int64","minimum":0},"approximateInFlightMessages":{"type":["integer","null"],"format":"int64","minimum":0},"approximateVisibleMessages":{"type":["integer","null"],"format":"int64","minimum":0},"contentBasedDeduplication":{"type":["boolean","null"]},"deduplicationScope":{"type":["string","null"]},"delaySeconds":{"type":["integer","null"],"format":"int32","minimum":0},"fifoQueue":{"type":["boolean","null"]},"fifoThroughputLimit":{"type":["string","null"]},"kmsDataKeyReusePeriodSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"kmsMasterKeyId":{"type":["string","null"]},"maximumMessageSize":{"type":["integer","null"],"format":"int32","minimum":0},"messageRetentionPeriodSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"name":{"type":"string"},"queueArn":{"type":["string","null"]},"queueUrl":{"type":["string","null"]},"receiveMessageWaitTimeSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"redriveAllowPolicy":{"type":["string","null"]},"redrivePolicy":{"type":["string","null"]},"region":{"type":["string","null"]},"sqsManagedSseEnabled":{"type":["boolean","null"]},"sseEnabled":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"visibilityTimeoutSeconds":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"AwsSqsQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsSqs"]}}}]},{"allOf":[{"type":"object","required":["status","topicName","topicLabels","subscriptionLabels","messageStorageAllowedPersistenceRegions","subscriptionPushAttributes"],"properties":{"endpoint":{"type":["string","null"]},"kmsKeyName":{"type":["string","null"]},"messageStorageAllowedPersistenceRegions":{"type":"array","items":{"type":"string"}},"messageStorageEnforceInTransit":{"type":["boolean","null"]},"projectId":{"type":["string","null"]},"schemaEncoding":{"type":["string","null"]},"schemaFirstRevisionId":{"type":["string","null"]},"schemaLastRevisionId":{"type":["string","null"]},"schemaName":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"subscriptionAckDeadlineSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"subscriptionDeadLetterMaxDeliveryAttempts":{"type":["integer","null"],"format":"int32","minimum":0},"subscriptionDeadLetterTopic":{"type":["string","null"]},"subscriptionDetached":{"type":["boolean","null"]},"subscriptionEnableMessageOrdering":{"type":["boolean","null"]},"subscriptionFilter":{"type":["string","null"]},"subscriptionFullName":{"type":["string","null"]},"subscriptionLabels":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"subscriptionMessageRetentionDuration":{"type":["string","null"]},"subscriptionName":{"type":["string","null"]},"subscriptionPushAttributes":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"subscriptionPushConfigPresent":{"type":["boolean","null"]},"subscriptionPushEndpoint":{"type":["string","null"]},"subscriptionPushNoWrapperWriteMetadata":{"type":["boolean","null"]},"subscriptionPushOidcAudience":{"type":["string","null"]},"subscriptionPushOidcServiceAccountEmail":{"type":["string","null"]},"subscriptionPushPubsubWrapperWriteMetadata":{"type":["boolean","null"]},"subscriptionRetainAckedMessages":{"type":["boolean","null"]},"subscriptionState":{"type":["string","null"]},"topicFullName":{"type":["string","null"]},"topicLabels":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"topicMessageRetentionDuration":{"type":["string","null"]},"topicName":{"type":"string"},"topicState":{"type":["string","null"]}},"x-readme-ref-name":"GcpPubSubQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpPubSub"]}}}]},{"allOf":[{"type":"object","required":["status","name","namespaceName"],"properties":{"accessedAt":{"type":["string","null"]},"activeMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"autoDeleteOnIdle":{"type":["string","null"]},"createdAt":{"type":["string","null"]},"deadLetterMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"deadLetteringOnMessageExpiration":{"type":["boolean","null"]},"defaultMessageTimeToLive":{"type":["string","null"]},"duplicateDetectionHistoryTimeWindow":{"type":["string","null"]},"enableBatchedOperations":{"type":["boolean","null"]},"enableExpress":{"type":["boolean","null"]},"enablePartitioning":{"type":["boolean","null"]},"endpoint":{"type":["string","null"]},"forwardDeadLetteredMessagesTo":{"type":["string","null"]},"forwardTo":{"type":["string","null"]},"lockDuration":{"type":["string","null"]},"maxDeliveryCount":{"type":["integer","null"],"format":"int32","minimum":0},"maxMessageSizeInKilobytes":{"type":["integer","null"],"format":"int64","minimum":0},"maxSizeInMegabytes":{"type":["integer","null"],"format":"int32","minimum":0},"messageCount":{"type":["integer","null"],"format":"int64","minimum":0},"name":{"type":"string"},"namespaceName":{"type":"string"},"queueStatus":{"type":["string","null"]},"requiresDuplicateDetection":{"type":["boolean","null"]},"requiresSession":{"type":["boolean","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"scheduledMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"sizeInBytes":{"type":["integer","null"],"format":"int64","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"transferDeadLetterMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"transferMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"updatedAt":{"type":["string","null"]}},"x-readme-ref-name":"AzureServiceBusQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureServiceBus"]}}}]},{"allOf":[{"type":"object","required":["status","name"],"properties":{"name":{"type":"string"},"path":{"type":["string","null"]},"serviceStatus":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"}},"x-readme-ref-name":"LocalQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"QueueHeartbeatData"},"resourceType":{"type":"string","enum":["queue"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","name","keySchema"],"properties":{"billingMode":{"type":["string","null"]},"deletionProtectionEnabled":{"type":["boolean","null"]},"globalSecondaryIndexCount":{"type":["integer","null"],"format":"int32","minimum":0},"itemCount":{"type":["integer","null"],"format":"int64","minimum":0},"keySchema":{"type":"array","items":{"type":"object","required":["attributeName","keyType"],"properties":{"attributeName":{"type":"string"},"keyType":{"type":"string"}},"x-readme-ref-name":"AwsDynamoDbKeySchemaElement"}},"localSecondaryIndexCount":{"type":["integer","null"],"format":"int32","minimum":0},"name":{"type":"string"},"region":{"type":["string","null"]},"replicaCount":{"type":["integer","null"],"format":"int32","minimum":0},"restoreInProgress":{"type":["boolean","null"]},"sseStatus":{"type":["string","null"]},"sseType":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"},"streamEnabled":{"type":["boolean","null"]},"streamViewType":{"type":["string","null"]},"tableArn":{"type":["string","null"]},"tableClass":{"type":["string","null"]},"tableSizeBytes":{"type":["integer","null"],"format":"int64","minimum":0},"tableStatus":{"type":["string","null"]},"ttlAttributeName":{"type":["string","null"]},"ttlStatus":{"type":["string","null"]}},"x-readme-ref-name":"AwsDynamoDbKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsDynamoDb"]}}}]},{"allOf":[{"type":"object","required":["status","databaseName","cmekEnabled","sourceInfoPresent"],"properties":{"appEngineIntegrationMode":{"type":["string","null"]},"cmekEnabled":{"type":"boolean"},"concurrencyMode":{"type":["string","null"]},"createTime":{"type":["string","null"]},"databaseEdition":{"type":["string","null"]},"databaseName":{"type":"string"},"databaseType":{"type":["string","null"]},"deleteProtectionState":{"type":["string","null"]},"deleteTime":{"type":["string","null"]},"earliestVersionTime":{"type":["string","null"]},"endpoint":{"type":["string","null"]},"locationId":{"type":["string","null"]},"pointInTimeRecoveryEnablement":{"type":["string","null"]},"projectId":{"type":["string","null"]},"sourceInfoPresent":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"},"updateTime":{"type":["string","null"]},"versionRetentionPeriod":{"type":["string","null"]}},"x-readme-ref-name":"GcpFirestoreKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpFirestore"]}}}]},{"allOf":[{"type":"object","required":["status","tableName","storageAccountName","tableExists"],"properties":{"endpoint":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"signedIdentifierCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"},"storageAccountKind":{"type":["string","null"]},"storageAccountLocation":{"type":["string","null"]},"storageAccountName":{"type":"string"},"storageAccountPrimaryStatus":{"type":["string","null"]},"storageAccountProvisioningState":{"type":["string","null"]},"storageAccountResourceId":{"type":["string","null"]},"tableExists":{"type":"boolean"},"tableName":{"type":"string"}},"x-readme-ref-name":"AzureTableKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureTable"]}}}]},{"allOf":[{"type":"object","required":["status","name","path","pathExists","cloudMetadataSupported"],"properties":{"cloudMetadataSupported":{"type":"boolean"},"isDirectory":{"type":["boolean","null"]},"name":{"type":"string"},"path":{"type":"string"},"pathExists":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"}},"x-readme-ref-name":"LocalKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"KvHeartbeatData"},"resourceType":{"type":"string","enum":["kv"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"description":"AWS Aurora Serverless v2 backend.","type":"object","required":["status","clusterIdentifier","neverPauses"],"properties":{"clusterIdentifier":{"type":"string"},"endpoint":{"type":["string","null"]},"engineVersion":{"type":["string","null"]},"neverPauses":{"type":"boolean","description":"True when a `minCapacity: 0` instance has not reached 0 ACU over the observation\nwindow — it is silently paying always-on prices (auto-pause verification)."},"serverlessCapacity":{"type":["number","null"],"format":"double","description":"Latest sampled `ServerlessDatabaseCapacity` (ACU)."},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"}},"x-readme-ref-name":"AuroraPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["aurora"]}}}],"description":"AWS Aurora Serverless v2 backend."},{"allOf":[{"description":"GCP Cloud SQL backend.","type":"object","required":["status","instanceName"],"properties":{"databaseVersion":{"type":["string","null"]},"instanceName":{"type":"string"},"state":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"}},"x-readme-ref-name":"GcpCloudSqlPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["cloudSql"]}}}],"description":"GCP Cloud SQL backend."},{"allOf":[{"description":"Azure Flexible Server backend.","type":"object","required":["status","serverName"],"properties":{"serverName":{"type":"string"},"state":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"},"version":{"type":["string","null"]}},"x-readme-ref-name":"AzureFlexibleServerPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["flexibleServer"]}}}],"description":"Azure Flexible Server backend."},{"allOf":[{"description":"Local embedded Postgres backend.","type":"object","required":["status","name","version","processRunning"],"properties":{"name":{"type":"string"},"port":{"type":["integer","null"],"format":"int32","minimum":0},"processRunning":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"},"version":{"type":"string"}},"x-readme-ref-name":"LocalPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}],"description":"Local embedded Postgres backend."}],"x-readme-ref-name":"PostgresHeartbeatData"},"resourceType":{"type":"string","enum":["postgres"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","accountId","region","prefix","parameterMetadataSampled"],"properties":{"accountId":{"type":"string"},"hasMoreParameters":{"type":["boolean","null"]},"latestModifiedAt":{"type":["string","null"],"format":"date-time"},"parameterMetadataSampled":{"type":"boolean"},"prefix":{"type":"string"},"region":{"type":"string"},"sampledAdvancedTierCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledKmsKeyMetadataPresentCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledParameterCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledSecureStringCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledStringCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledStringListCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"AwsParameterStoreVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsParameterStore"]}}}]},{"allOf":[{"type":"object","required":["status","projectId","location","prefix","secretMetadataListed"],"properties":{"location":{"type":"string"},"prefix":{"type":"string"},"projectId":{"type":"string"},"secretMetadataListed":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"GcpSecretManagerVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpSecretManager"]}}}]},{"allOf":[{"type":"object","required":["status","name","softDeleteEnabled","softDeleteRetentionDays","rbacAuthorizationEnabled","publicNetworkAccess","accessPolicyCount","privateEndpointConnectionCount","secretMetadataListed"],"properties":{"accessPolicyCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":["string","null"]},"name":{"type":"string"},"privateEndpointConnectionCount":{"type":"integer","format":"int32","minimum":0},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":"string"},"purgeProtectionEnabled":{"type":["boolean","null"]},"rbacAuthorizationEnabled":{"type":"boolean"},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"secretMetadataListed":{"type":"boolean"},"skuFamily":{"type":["string","null"]},"skuName":{"type":["string","null"]},"softDeleteEnabled":{"type":"boolean"},"softDeleteRetentionDays":{"type":"integer","format":"int32"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"},"vaultUri":{"type":["string","null"]}},"x-readme-ref-name":"AzureKeyVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureKeyVault"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","prefix","secretMetadataListed"],"properties":{"namespace":{"type":"string"},"prefix":{"type":"string"},"secretMetadataListed":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"KubernetesSecretVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetesSecret"]}}}]},{"allOf":[{"type":"object","required":["status","path","pathExists","secretMetadataListed"],"properties":{"isDirectory":{"type":["boolean","null"]},"modifiedAt":{"type":["string","null"],"format":"date-time"},"path":{"type":"string"},"pathExists":{"type":"boolean"},"readonly":{"type":["boolean","null"]},"secretMetadataListed":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"LocalVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"VaultHeartbeatData"},"resourceType":{"type":"string","enum":["vault"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","roleName","roleArn","roleId","path","createDate","assumeRolePolicyPresent","tagCount","managedTagCount","attachedPolicyCount","attachedPolicyNames","inlinePolicyCount","inlinePolicyNames","stackPermissionsApplied"],"properties":{"assumeRolePolicyPresent":{"type":"boolean"},"attachedPolicyCount":{"type":"integer","format":"int32","minimum":0},"attachedPolicyNames":{"type":"array","items":{"type":"string"}},"createDate":{"type":"string"},"description":{"type":["string","null"]},"inlinePolicyCount":{"type":"integer","format":"int32","minimum":0},"inlinePolicyNames":{"type":"array","items":{"type":"string"}},"lastUsedDate":{"type":["string","null"]},"lastUsedRegion":{"type":["string","null"]},"managedTagCount":{"type":"integer","format":"int32","minimum":0},"maxSessionDuration":{"type":["integer","null"],"format":"int32"},"path":{"type":"string"},"permissionsBoundaryArn":{"type":["string","null"]},"permissionsBoundaryType":{"type":["string","null"]},"roleArn":{"type":"string"},"roleId":{"type":"string"},"roleName":{"type":"string"},"stackPermissionsApplied":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"},"tagCount":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"AwsIamRoleServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsIamRole"]}}}]},{"allOf":[{"type":"object","required":["status","email","projectBindingCount","projectRoles","serviceAccountBindingCount","serviceAccountRoles"],"properties":{"description":{"type":["string","null"]},"disabled":{"type":["boolean","null"]},"displayName":{"type":["string","null"]},"email":{"type":"string"},"etag":{"type":["string","null"]},"name":{"type":["string","null"]},"oauth2ClientId":{"type":["string","null"]},"projectBindingCount":{"type":"integer","format":"int32","minimum":0},"projectId":{"type":["string","null"]},"projectRoles":{"type":"array","items":{"type":"string"}},"serviceAccountBindingCount":{"type":"integer","format":"int32","minimum":0},"serviceAccountRoles":{"type":"array","items":{"type":"string"}},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"},"uniqueId":{"type":["string","null"]}},"x-readme-ref-name":"GcpServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpServiceAccount"]}}}]},{"allOf":[{"type":"object","required":["status","name","resourceId","resourceGroup","location","managedTagCount","roleAssignmentCount","roleAssignmentIds","customRoleDefinitionCount","customRoleDefinitionIds","stackPermissionsApplied"],"properties":{"clientId":{"type":["string","null"]},"customRoleDefinitionCount":{"type":"integer","format":"int32","minimum":0},"customRoleDefinitionIds":{"type":"array","items":{"type":"string"}},"isolationScope":{"type":["string","null"]},"location":{"type":"string"},"managedTagCount":{"type":"integer","format":"int32","minimum":0},"name":{"type":"string"},"principalId":{"type":["string","null"]},"resourceGroup":{"type":"string"},"resourceId":{"type":"string"},"roleAssignmentCount":{"type":"integer","format":"int32","minimum":0},"roleAssignmentIds":{"type":"array","items":{"type":"string"}},"stackPermissionsApplied":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"},"tenantId":{"type":["string","null"]},"type":{"type":["string","null"]}},"x-readme-ref-name":"AzureManagedIdentityServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureManagedIdentity"]}}}]},{"allOf":[{"type":"object","required":["status","identity","configured"],"properties":{"configured":{"type":"boolean"},"identity":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"}},"x-readme-ref-name":"LocalServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ServiceAccountHeartbeatData"},"resourceType":{"type":"string","enum":["service-account"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","publicSubnetIds","privateSubnetIds","availabilityZones","routeTableCount","isByoVpc"],"properties":{"availabilityZones":{"type":"array","items":{"type":"string"}},"cidrBlock":{"type":["string","null"]},"internetGatewayId":{"type":["string","null"]},"isByoVpc":{"type":"boolean"},"natGatewayId":{"type":["string","null"]},"privateSubnetIds":{"type":"array","items":{"type":"string"}},"publicSubnetIds":{"type":"array","items":{"type":"string"}},"routeTableCount":{"type":"integer","format":"int32","minimum":0},"securityGroupId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"NetworkHeartbeatStatus"},"vpcId":{"type":["string","null"]},"vpcState":{"type":["string","null"]}},"x-readme-ref-name":"AwsVpcNetworkHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsVpc"]}}}]},{"allOf":[{"type":"object","required":["status","isByoVpc"],"properties":{"cidrBlock":{"type":["string","null"]},"cloudNatName":{"type":["string","null"]},"firewallName":{"type":["string","null"]},"isByoVpc":{"type":"boolean"},"networkName":{"type":["string","null"]},"networkSelfLink":{"type":["string","null"]},"region":{"type":["string","null"]},"routerName":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"NetworkHeartbeatStatus"},"subnetworkName":{"type":["string","null"]},"subnetworkSelfLink":{"type":["string","null"]}},"x-readme-ref-name":"GcpVpcNetworkHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpVpc"]}}}]},{"allOf":[{"type":"object","required":["status","isByoVnet"],"properties":{"applicationGatewaySubnetName":{"type":["string","null"]},"cidrBlock":{"type":["string","null"]},"isByoVnet":{"type":"boolean"},"lastByoVnetVerificationErrorCode":{"type":["string","null"]},"location":{"type":["string","null"]},"natGatewayId":{"type":["string","null"]},"nsgId":{"type":["string","null"]},"privateEndpointSubnetName":{"type":["string","null"]},"privateSubnetName":{"type":["string","null"]},"publicIpId":{"type":["string","null"]},"publicSubnetName":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"NetworkHeartbeatStatus"},"vnetName":{"type":["string","null"]},"vnetResourceId":{"type":["string","null"]}},"x-readme-ref-name":"AzureVnetNetworkHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureVnet"]}}}]}],"x-readme-ref-name":"NetworkHeartbeatData"},"resourceType":{"type":"string","enum":["network"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","managementPermissionsApplied"],"properties":{"managementPermissionsApplied":{"type":"boolean"},"roleArn":{"type":["string","null"]},"roleName":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"RemoteStackManagementHeartbeatStatus"}},"x-readme-ref-name":"AwsRemoteStackManagementHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsIamRole"]}}}]},{"allOf":[{"type":"object","required":["status","roleBound","impersonationGranted"],"properties":{"impersonationGranted":{"type":"boolean"},"roleBound":{"type":"boolean"},"serviceAccountEmail":{"type":["string","null"]},"serviceAccountUniqueId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"RemoteStackManagementHeartbeatStatus"}},"x-readme-ref-name":"GcpRemoteStackManagementHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpServiceAccount"]}}}]},{"allOf":[{"type":"object","required":["status","roleAssignmentIds"],"properties":{"ficName":{"type":["string","null"]},"roleAssignmentIds":{"type":"array","items":{"type":"string"}},"roleDefinitionId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"RemoteStackManagementHeartbeatStatus"},"tenantId":{"type":["string","null"]},"uamiClientId":{"type":["string","null"]},"uamiPrincipalId":{"type":["string","null"]},"uamiResourceId":{"type":["string","null"]}},"x-readme-ref-name":"AzureRemoteStackManagementHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureManagedIdentity"]}}}]}],"x-readme-ref-name":"RemoteStackManagementHeartbeatData"},"resourceType":{"type":"string","enum":["remote-stack-management"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","registryId","region","registryUri","repositoryPrefix","repositoryCount","repositoriesTruncated","repositories"],"properties":{"pullRoleArn":{"type":["string","null"]},"pushRoleArn":{"type":["string","null"]},"region":{"type":"string"},"registryId":{"type":"string"},"registryUri":{"type":"string"},"repositories":{"type":"array","items":{"type":"object","required":["repositoryArn","registryId","repositoryName","repositoryUri","createdAt","kmsKeyPresent"],"properties":{"createdAt":{"type":"number","format":"double"},"encryptionType":{"type":["string","null"]},"imageTagMutability":{"type":["string","null"]},"kmsKeyPresent":{"type":"boolean"},"registryId":{"type":"string"},"repositoryArn":{"type":"string"},"repositoryName":{"type":"string"},"repositoryUri":{"type":"string"},"scanOnPush":{"type":["boolean","null"]}},"x-readme-ref-name":"AwsEcrRepositoryHeartbeatData"}},"repositoriesTruncated":{"type":"boolean"},"repositoryCount":{"type":"integer","format":"int32","minimum":0},"repositoryPrefix":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"}},"x-readme-ref-name":"AwsEcrArtifactRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsEcr"]}}}]},{"allOf":[{"type":"object","required":["status","projectId","location","repositoryId","labelCount","cleanupPolicyCount","kmsKeyNamePresent","iamPolicyEtagPresent","iamBindingCount","iamRoles"],"properties":{"cleanupPolicyCount":{"type":"integer","format":"int32","minimum":0},"cleanupPolicyDryRun":{"type":["boolean","null"]},"createTime":{"type":["string","null"]},"description":{"type":["string","null"]},"format":{"type":["string","null"]},"iamBindingCount":{"type":"integer","format":"int32","minimum":0},"iamPolicyEtagPresent":{"type":"boolean"},"iamRoles":{"type":"array","items":{"type":"string"}},"kmsKeyNamePresent":{"type":"boolean"},"labelCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":"string"},"mode":{"type":["string","null"]},"name":{"type":["string","null"]},"projectId":{"type":"string"},"pullServiceAccountEmail":{"type":["string","null"]},"pushServiceAccountEmail":{"type":["string","null"]},"repositoryId":{"type":"string"},"satisfiesPzs":{"type":["boolean","null"]},"sizeBytes":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"},"updateTime":{"type":["string","null"]}},"x-readme-ref-name":"GcpArtifactRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpArtifactRegistry"]}}}]},{"allOf":[{"type":"object","required":["status","name","resourceGroup","location","skuName","adminUserEnabled","anonymousPullEnabled","publicNetworkAccess","networkRuleBypassOptions","ipRuleCount","encryptionKeyVaultUriPresent","encryptionKeyIdentifierPresent","policiesPresent","policyCount","privateEndpointConnectionCount","dataEndpointHostNames","zoneRedundancy","managedTagCount"],"properties":{"adminUserEnabled":{"type":"boolean"},"anonymousPullEnabled":{"type":"boolean"},"creationDate":{"type":["string","null"]},"dataEndpointEnabled":{"type":["boolean","null"]},"dataEndpointHostNames":{"type":"array","items":{"type":"string"}},"encryptionKeyIdentifierPresent":{"type":"boolean"},"encryptionKeyVaultUriPresent":{"type":"boolean"},"encryptionStatus":{"type":["string","null"]},"ipRuleCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":"string"},"loginServer":{"type":["string","null"]},"managedTagCount":{"type":"integer","format":"int32","minimum":0},"name":{"type":"string"},"networkRuleBypassOptions":{"type":"string"},"networkRuleDefaultAction":{"type":["string","null"]},"policiesPresent":{"type":"boolean"},"policyCount":{"type":"integer","format":"int32","minimum":0},"privateEndpointConnectionCount":{"type":"integer","format":"int32","minimum":0},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":"string"},"resourceGroup":{"type":"string"},"resourceId":{"type":["string","null"]},"skuName":{"type":"string"},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"},"type":{"type":["string","null"]},"zoneRedundancy":{"type":"string"}},"x-readme-ref-name":"AzureContainerRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureContainerRegistry"]}}}]},{"allOf":[{"type":"object","required":["status","registryUrl","reachable"],"properties":{"reachable":{"type":"boolean"},"registryUrl":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"}},"x-readme-ref-name":"LocalArtifactRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ArtifactRegistryHeartbeatData"},"resourceType":{"type":"string","enum":["artifact-registry"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","projectName","environmentVariableCount","serviceRolePresent","encryptionKeyPresent"],"properties":{"artifactsEncryptionDisabled":{"type":["boolean","null"]},"artifactsType":{"type":["string","null"]},"cloudWatchLogsStatus":{"type":["string","null"]},"computeType":{"type":["string","null"]},"created":{"type":["number","null"],"format":"double"},"description":{"type":["string","null"]},"encryptionKeyPresent":{"type":"boolean"},"environmentImage":{"type":["string","null"]},"environmentType":{"type":["string","null"]},"environmentVariableCount":{"type":"integer","format":"int32","minimum":0},"imagePullCredentialsType":{"type":["string","null"]},"lastModified":{"type":["number","null"],"format":"double"},"privilegedMode":{"type":["boolean","null"]},"projectArn":{"type":["string","null"]},"projectName":{"type":"string"},"queuedTimeoutInMinutes":{"type":["integer","null"],"format":"int32"},"s3LogsStatus":{"type":["string","null"]},"serviceRolePresent":{"type":"boolean"},"sourceType":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"},"timeoutInMinutes":{"type":["integer","null"],"format":"int32"}},"x-readme-ref-name":"AwsCodeBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsCodeBuild"]}}}]},{"allOf":[{"type":"object","required":["status","projectId","location","buildConfigId","environmentVariableCount"],"properties":{"buildConfigId":{"type":"string"},"environmentVariableCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":"string"},"projectId":{"type":"string"},"serviceAccount":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"}},"x-readme-ref-name":"GcpCloudBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpCloudBuild"]}}}]},{"allOf":[{"type":"object","required":["status","managedEnvironmentId","resourceGroupName","environmentVariableCount"],"properties":{"environmentVariableCount":{"type":"integer","format":"int32","minimum":0},"managedEnvironmentId":{"type":"string"},"managedIdentityId":{"type":["string","null"]},"resourceGroupName":{"type":"string"},"resourcePrefix":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"}},"x-readme-ref-name":"AzureContainerAppsBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureContainerApps"]}}}]},{"allOf":[{"type":"object","required":["status","jobName","namespace","conditionCount","events"],"properties":{"active":{"type":["integer","null"],"format":"int32"},"completionTime":{"type":["string","null"],"format":"date-time"},"conditionCount":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"failed":{"type":["integer","null"],"format":"int32"},"imageDigest":{"type":["string","null"]},"jobName":{"type":"string"},"namespace":{"type":"string"},"startTime":{"type":["string","null"],"format":"date-time"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"},"succeeded":{"type":["integer","null"],"format":"int32"}},"x-readme-ref-name":"KubernetesBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetesJob"]}}}]}],"x-readme-ref-name":"BuildHeartbeatData"},"resourceType":{"type":"string","enum":["build"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","projectId","serviceName","enabled"],"properties":{"enabled":{"type":"boolean"},"lastOperationName":{"type":["string","null"]},"projectId":{"type":"string"},"serviceName":{"type":"string"},"serviceResourceName":{"type":["string","null"]},"state":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceActivationHeartbeatStatus"},"title":{"type":["string","null"]}},"x-readme-ref-name":"GcpServiceUsageActivationHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpServiceUsage"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","resourceTypeCount","registered"],"properties":{"namespace":{"type":"string"},"providerId":{"type":["string","null"]},"registered":{"type":"boolean"},"registrationPolicy":{"type":["string","null"]},"registrationState":{"type":["string","null"]},"resourceTypeCount":{"type":"integer","format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceActivationHeartbeatStatus"}},"x-readme-ref-name":"AzureResourceProviderActivationHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureResourceProvider"]}}}]}],"x-readme-ref-name":"ServiceActivationHeartbeatData"},"resourceType":{"type":"string","enum":["service_activation"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","managedTags"],"properties":{"location":{"type":["string","null"]},"managedTags":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"name":{"type":"string"},"provisioningState":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AzureResourceGroupHeartbeatStatus"}},"x-readme-ref-name":"AzureResourceGroupHeartbeatData"},"resourceType":{"type":"string","enum":["azure_resource_group"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","primaryEndpoints","secondaryEndpoints"],"properties":{"allowBlobPublicAccess":{"type":["boolean","null"]},"allowSharedKeyAccess":{"type":["boolean","null"]},"encryptionKeySource":{"type":["string","null"]},"kind":{"type":["string","null"]},"location":{"type":["string","null"]},"minimumTlsVersion":{"type":["string","null"]},"name":{"type":"string"},"networkBypass":{"type":["string","null"]},"networkDefaultAction":{"type":["string","null"]},"networkIpRuleCount":{"type":["integer","null"],"format":"int32","minimum":0},"networkResourceAccessRuleCount":{"type":["integer","null"],"format":"int32","minimum":0},"networkVirtualNetworkRuleCount":{"type":["integer","null"],"format":"int32","minimum":0},"primaryEndpoints":{"type":"object","properties":{"blob":{"type":["string","null"]},"dfs":{"type":["string","null"]},"file":{"type":["string","null"]},"queue":{"type":["string","null"]},"table":{"type":["string","null"]},"web":{"type":["string","null"]}},"x-readme-ref-name":"AzureStorageAccountEndpoints"},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":["string","null"]},"requireInfrastructureEncryption":{"type":["boolean","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"secondaryEndpoints":{"type":"object","properties":{"blob":{"type":["string","null"]},"dfs":{"type":["string","null"]},"file":{"type":["string","null"]},"queue":{"type":["string","null"]},"table":{"type":["string","null"]},"web":{"type":["string","null"]}},"x-readme-ref-name":"AzureStorageAccountEndpoints"},"skuName":{"type":["string","null"]},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"supportsHttpsTrafficOnly":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureStorageAccountHeartbeatData"},"resourceType":{"type":"string","enum":["azure_storage_account"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","workloadProfileCount","workloadProfiles"],"properties":{"customDomainVerificationId":{"type":["string","null"]},"defaultDomain":{"type":["string","null"]},"eventStreamEndpoint":{"type":["string","null"]},"infrastructureResourceGroup":{"type":["string","null"]},"kind":{"type":["string","null"]},"location":{"type":["string","null"]},"name":{"type":"string"},"provisioningState":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"staticIp":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AzureContainerAppsEnvironmentHeartbeatStatus"},"workloadProfileCount":{"type":"integer","format":"int32","minimum":0},"workloadProfiles":{"type":"array","items":{"type":"object","required":["name","workloadProfileType"],"properties":{"maximumCount":{"type":["integer","null"],"format":"int32"},"minimumCount":{"type":["integer","null"],"format":"int32"},"name":{"type":"string"},"workloadProfileType":{"type":"string"}},"x-readme-ref-name":"AzureContainerAppsEnvironmentWorkloadProfile"}},"zoneRedundant":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureContainerAppsEnvironmentHeartbeatData"},"resourceType":{"type":"string","enum":["azure_container_apps_environment"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","privateEndpointConnectionCount"],"properties":{"createdAt":{"type":["string","null"]},"disableLocalAuth":{"type":["boolean","null"]},"location":{"type":["string","null"]},"metricId":{"type":["string","null"]},"minimumTlsVersion":{"type":["string","null"]},"name":{"type":"string"},"namespaceStatus":{"type":["string","null"]},"premiumMessagingPartitions":{"type":["integer","null"],"format":"int32"},"privateEndpointConnectionCount":{"type":"integer","format":"int32","minimum":0},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"serviceBusEndpoint":{"type":["string","null"]},"skuCapacity":{"type":["integer","null"],"format":"int32"},"skuName":{"type":["string","null"]},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"updatedAt":{"type":["string","null"]},"zoneRedundant":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureServiceBusNamespaceHeartbeatData"},"resourceType":{"type":"string","enum":["azure_service_bus_namespace"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","region"],"properties":{"region":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"AwsBedrockAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsBedrock"]}}}]},{"allOf":[{"type":"object","required":["status","project","location"],"properties":{"location":{"type":"string"},"project":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"GcpVertexAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpVertex"]}}}]},{"allOf":[{"type":"object","required":["status","accountName"],"properties":{"accountName":{"type":"string"},"endpoint":{"type":["string","null"]},"location":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"AzureFoundryAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureFoundry"]}}}]},{"allOf":[{"type":"object","required":["status","provider"],"properties":{"provider":{"type":"string","description":"The BYO-key provider serving this binding (e.g. \"openai\"). Used on the Local\nplatform, where the app brings its own provider key instead of an ambient cloud."},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"ExternalAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["external"]}}}]}],"x-readme-ref-name":"AiHeartbeatData"},"resourceType":{"type":"string","enum":["ai"]}}}],"x-readme-ref-name":"ResourceHeartbeatData"} \ No newline at end of file +{"oneOf":[{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","name","lifecyclePresent","encryptionConfigPresent","publicAccessBlockPresent"],"properties":{"blockPublicAcls":{"type":["boolean","null"]},"blockPublicPolicy":{"type":["boolean","null"]},"bucketAclPresent":{"type":["boolean","null"]},"bucketLocation":{"type":["string","null"]},"bucketPolicyPresent":{"type":["boolean","null"]},"encryptionConfigPresent":{"type":"boolean"},"encryptionEnabled":{"type":["boolean","null"]},"ignorePublicAcls":{"type":["boolean","null"]},"lifecyclePresent":{"type":"boolean"},"lifecycleRuleCount":{"type":["integer","null"],"format":"int64","minimum":0},"name":{"type":"string"},"publicAccessBlockPresent":{"type":"boolean"},"region":{"type":["string","null"]},"restrictPublicBuckets":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"versioningEnabled":{"type":["boolean","null"]},"versioningStatus":{"type":["string","null"]}},"x-readme-ref-name":"AwsS3StorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsS3"]}}}]},{"allOf":[{"type":"object","required":["status","name","lifecyclePresent","encryptionConfigPresent"],"properties":{"bucketId":{"type":["string","null"]},"defaultKmsKeyName":{"type":["string","null"]},"encryptionConfigPresent":{"type":"boolean"},"lifecyclePresent":{"type":"boolean"},"lifecycleRuleCount":{"type":["integer","null"],"format":"int64","minimum":0},"location":{"type":["string","null"]},"locationType":{"type":["string","null"]},"name":{"type":"string"},"publicAccessPrevention":{"type":["string","null"]},"retentionPeriod":{"type":["string","null"]},"retentionPolicyEffectiveTime":{"type":["string","null"]},"retentionPolicyIsLocked":{"type":["boolean","null"]},"softDeleteEffectiveTime":{"type":["string","null"]},"softDeleteRetentionDurationSeconds":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"storageClass":{"type":["string","null"]},"uniformBucketLevelAccessEnabled":{"type":["boolean","null"]},"uniformBucketLevelAccessLockedTime":{"type":["string","null"]},"versioningEnabled":{"type":["boolean","null"]}},"x-readme-ref-name":"GcpCloudStorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpCloudStorage"]}}}]},{"allOf":[{"type":"object","required":["status","name"],"properties":{"accessTier":{"type":["string","null"]},"accountKind":{"type":["string","null"]},"allowBlobPublicAccess":{"type":["boolean","null"]},"blobDeleteRetentionDays":{"type":["integer","null"],"format":"int64","minimum":0},"blobDeleteRetentionEnabled":{"type":["boolean","null"]},"blobEncryptionEnabled":{"type":["boolean","null"]},"blobVersioningEnabled":{"type":["boolean","null"]},"changeFeedEnabled":{"type":["boolean","null"]},"changeFeedRetentionDays":{"type":["integer","null"],"format":"int64","minimum":0},"containerDeleteRetentionDays":{"type":["integer","null"],"format":"int64","minimum":0},"containerDeleteRetentionEnabled":{"type":["boolean","null"]},"containerPublicAccess":{"type":["string","null"]},"encryptionKeySource":{"type":["string","null"]},"fileEncryptionEnabled":{"type":["boolean","null"]},"location":{"type":["string","null"]},"name":{"type":"string"},"primaryLocation":{"type":["string","null"]},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":["string","null"]},"queueEncryptionEnabled":{"type":["boolean","null"]},"resourceGroup":{"type":["string","null"]},"secondaryLocation":{"type":["string","null"]},"skuName":{"type":["string","null"]},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"statusOfPrimary":{"type":["string","null"]},"statusOfSecondary":{"type":["string","null"]},"storageAccountName":{"type":["string","null"]},"tableEncryptionEnabled":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureBlobStorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureBlob"]}}}]},{"allOf":[{"type":"object","required":["status","path","pathExists"],"properties":{"isDirectory":{"type":["boolean","null"]},"modifiedAt":{"type":["string","null"],"format":"date-time"},"path":{"type":"string"},"pathExists":{"type":"boolean"},"readonly":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"}},"x-readme-ref-name":"LocalStorageHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"StorageHeartbeatData"},"resourceType":{"type":"string","enum":["storage"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","functionName","layerCount","functionUrlCorsPresent","triggerCount"],"properties":{"codeSha256":{"type":["string","null"]},"functionName":{"type":"string"},"functionUrlAuthType":{"type":["string","null"]},"functionUrlCorsPresent":{"type":"boolean"},"lastModified":{"type":["string","null"]},"lastUpdateStatus":{"type":["string","null"]},"lastUpdateStatusReason":{"type":["string","null"]},"lastUpdateStatusReasonCode":{"type":["string","null"]},"layerCount":{"type":"integer","format":"int32","minimum":0},"memorySizeMb":{"type":["integer","null"],"format":"int64"},"packageType":{"type":["string","null"]},"revisionId":{"type":["string","null"]},"runtime":{"type":["string","null"]},"state":{"type":["string","null"]},"stateReason":{"type":["string","null"]},"stateReasonCode":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"timeoutSeconds":{"type":["integer","null"],"format":"int64"},"triggerCount":{"type":"integer","format":"int32","minimum":0},"version":{"type":["string","null"]}},"x-readme-ref-name":"AwsLambdaWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsLambda"]}}}]},{"allOf":[{"type":"object","required":["status","service","urls","trafficCount"],"properties":{"containerImage":{"type":["string","null"]},"cpuLimit":{"type":["string","null"]},"generation":{"type":["integer","null"],"format":"int64"},"latestCreatedRevision":{"type":["string","null"]},"latestReadyRevision":{"type":["string","null"]},"maxInstanceCount":{"type":["integer","null"],"format":"int32"},"memoryLimit":{"type":["string","null"]},"minInstanceCount":{"type":["integer","null"],"format":"int32"},"observedGeneration":{"type":["integer","null"],"format":"int64"},"region":{"type":["string","null"]},"service":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"trafficCount":{"type":"integer","format":"int32","minimum":0},"uri":{"type":["string","null"]},"urls":{"type":"array","items":{"type":"string"}}},"x-readme-ref-name":"GcpCloudRunWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpCloudRun"]}}}]},{"allOf":[{"type":"object","required":["status","appName"],"properties":{"appName":{"type":"string"},"cpu":{"type":["number","null"],"format":"double"},"environmentName":{"type":["string","null"]},"ingressFqdn":{"type":["string","null"]},"maxReplicas":{"type":["integer","null"],"format":"int32"},"memory":{"type":["string","null"]},"minReplicas":{"type":["integer","null"],"format":"int32"},"provisioningState":{"type":["string","null"]},"revision":{"type":["string","null"]},"runningStatus":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"AzureContainerAppsWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureContainerApps"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","name","workloadKind","replicas","pods","triggerCount","events"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":"string"},"pods":{"type":"array","items":{"type":"object","required":["name","ready","restartCount","ownerReferences"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"ownerReferences":{"type":"array","items":{"type":"object","required":["kind","name","uid","controller"],"properties":{"controller":{"type":"boolean"},"kind":{"type":"string"},"name":{"type":"string"},"uid":{"type":"string"}},"x-readme-ref-name":"KubernetesOwnerReference"}},"phase":{"type":["string","null"]},"podIp":{"type":["string","null"]},"ready":{"type":"boolean"},"restartCount":{"type":"integer","format":"int32","minimum":0},"terminatedReason":{"type":["string","null"]},"uid":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesPodRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"restarts":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"triggerCount":{"type":"integer","format":"int32","minimum":0},"workload":{"oneOf":[{"type":"null"},{"type":"object","required":["conditions"],"properties":{"availableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"lastTransitionTime":{"type":["string","null"],"format":"date-time"},"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesWorkloadCondition"}},"desiredGeneration":{"type":["integer","null"],"format":"int64"},"desiredReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"observedGeneration":{"type":["integer","null"],"format":"int64"},"readyReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"rolloutReason":{"type":["string","null"]},"updatedReplicas":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"KubernetesWorkloadStatus"}]},"workloadKind":{"type":"string","enum":["deployment","statefulSet","daemonSet","replicaSet","pod"],"x-readme-ref-name":"KubernetesWorkloadKind"}},"x-readme-ref-name":"KubernetesWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetes"]}}}]},{"allOf":[{"type":"object","required":["status","commandSupported","imagePathPresent","triggerCount","events"],"properties":{"commandSupported":{"type":"boolean"},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["timestamp","severity","kind","message"],"properties":{"kind":{"type":"string"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"subject":{"oneOf":[{"type":"null"},{"type":"object","required":["kind"],"properties":{"id":{"type":["string","null"]},"kind":{"type":"string"},"name":{"type":["string","null"]}},"x-readme-ref-name":"LocalRuntimeEventSubject"}]},"timestamp":{"type":"string","format":"date-time"}},"x-readme-ref-name":"LocalRuntimeEventSnapshot"}},"imagePathPresent":{"type":"boolean"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"process":{"oneOf":[{"type":"null"},{"type":"object","required":["unitId","name","kind","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"kind":{"type":"string","enum":["container","process","daemon"],"x-readme-ref-name":"LocalRuntimeUnitKind"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"phase":{"type":["string","null"]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":"boolean"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"unitId":{"type":"string"}},"x-readme-ref-name":"LocalRuntimeUnitStatus"}]},"readinessProbeOk":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"triggerCount":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"LocalWorkerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"WorkerHeartbeatData"},"resourceType":{"type":"string","enum":["worker"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","containerId","schedulingMode","replicas","attentionCount","replicaUnits","events"],"properties":{"attentionCount":{"type":"integer","format":"int32","minimum":0},"containerId":{"type":"string"},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"image":{"type":["string","null"]},"latestUpdateTimestamp":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"observedImage":{"type":["string","null"]},"replicaUnits":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"schedulingMode":{"type":"string","enum":["replicated","stateful","daemon"],"x-readme-ref-name":"HorizonWorkloadSchedulingMode"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"HorizonContainerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["horizonPlatform"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","name","workloadKind","replicas","pods","events"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":"string"},"pods":{"type":"array","items":{"type":"object","required":["name","ready","restartCount","ownerReferences"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"ownerReferences":{"type":"array","items":{"type":"object","required":["kind","name","uid","controller"],"properties":{"controller":{"type":"boolean"},"kind":{"type":"string"},"name":{"type":"string"},"uid":{"type":"string"}},"x-readme-ref-name":"KubernetesOwnerReference"}},"phase":{"type":["string","null"]},"podIp":{"type":["string","null"]},"ready":{"type":"boolean"},"restartCount":{"type":"integer","format":"int32","minimum":0},"terminatedReason":{"type":["string","null"]},"uid":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesPodRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"restarts":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"workload":{"oneOf":[{"type":"null"},{"type":"object","required":["conditions"],"properties":{"availableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"lastTransitionTime":{"type":["string","null"],"format":"date-time"},"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesWorkloadCondition"}},"desiredGeneration":{"type":["integer","null"],"format":"int64"},"desiredReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"observedGeneration":{"type":["integer","null"],"format":"int64"},"readyReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"rolloutReason":{"type":["string","null"]},"updatedReplicas":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"KubernetesWorkloadStatus"}]},"workloadKind":{"type":"string","enum":["deployment","statefulSet","daemonSet","replicaSet","pod"],"x-readme-ref-name":"KubernetesWorkloadKind"}},"x-readme-ref-name":"KubernetesContainerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetes"]}}}]},{"allOf":[{"type":"object","required":["status","portCount","bindMountCount","runtimeReachable","events"],"properties":{"bindMountCount":{"type":"integer","format":"int32","minimum":0},"containerId":{"type":["string","null"]},"containerUnit":{"oneOf":[{"type":"null"},{"type":"object","required":["unitId","name","kind","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"kind":{"type":"string","enum":["container","process","daemon"],"x-readme-ref-name":"LocalRuntimeUnitKind"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"phase":{"type":["string","null"]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":"boolean"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"unitId":{"type":"string"}},"x-readme-ref-name":"LocalRuntimeUnitStatus"}]},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["timestamp","severity","kind","message"],"properties":{"kind":{"type":"string"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"subject":{"oneOf":[{"type":"null"},{"type":"object","required":["kind"],"properties":{"id":{"type":["string","null"]},"kind":{"type":"string"},"name":{"type":["string","null"]}},"x-readme-ref-name":"LocalRuntimeEventSubject"}]},"timestamp":{"type":"string","format":"date-time"}},"x-readme-ref-name":"LocalRuntimeEventSnapshot"}},"image":{"type":["string","null"]},"localUrl":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":["string","null"]},"portCount":{"type":"integer","format":"int32","minimum":0},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"runtimeReachable":{"type":"boolean"},"runtimeStatus":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"LocalContainerHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ContainerHeartbeatData"},"resourceType":{"type":"string","enum":["container"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"AwsDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["aws"]}}}]},{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"GcpDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcp"]}}}]},{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"AzureDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azure"]}}}]},{"allOf":[{"type":"object","required":["status","horizonClusterId","horizonStatus","capacityGroup","desiredMachines","assignedMachines","healthyInstances","unavailableInstances","commandSupported","latestUpdateTimestamp","daemonInstances","events"],"properties":{"assignedMachines":{"type":"integer","format":"int32","minimum":0},"capacityGroup":{"type":"string"},"commandSupported":{"type":"boolean"},"daemonInstances":{"type":"array","items":{"type":"object","required":["replicaId","name","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"ip":{"type":["string","null"]},"machineId":{"type":["string","null"]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"message":{"type":["string","null"]},"metricsHealthy":{"type":["boolean","null"]},"metricsLastUpdated":{"type":["string","null"]},"metricsStatus":{"type":["string","null"]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"phase":{"type":["string","null"]},"ready":{"type":"boolean"},"reason":{"type":["string","null"]},"replicaId":{"type":"string"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":["string","null"]},"terminatedReason":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeUnitStatus"}},"daemonName":{"type":"string"},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"eventId":{"type":["string","null"]},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"details":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"id":{"type":["string","null"]},"kind":{"type":["string","null"]},"machineId":{"type":["string","null"]},"name":{"type":["string","null"]},"replicaId":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"ManagedRuntimeEventSnapshot"}},"healthyInstances":{"type":"integer","format":"int32","minimum":0},"horizonClusterId":{"type":"string"},"horizonStatus":{"type":"string"},"horizonStatusMessage":{"type":["string","null"]},"horizonStatusReason":{"type":["string","null"]},"latestUpdateTimestamp":{"type":"string"},"observedImage":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"unavailableInstances":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"MachinesDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["machines"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","name","replicas","commandSupported","pods","events"],"properties":{"commandSupported":{"type":"boolean"},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":"string"},"pods":{"type":"array","items":{"type":"object","required":["name","ready","restartCount","ownerReferences"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodeName":{"type":["string","null"]},"ownerReferences":{"type":"array","items":{"type":"object","required":["kind","name","uid","controller"],"properties":{"controller":{"type":"boolean"},"kind":{"type":"string"},"name":{"type":"string"},"uid":{"type":"string"}},"x-readme-ref-name":"KubernetesOwnerReference"}},"phase":{"type":["string","null"]},"podIp":{"type":["string","null"]},"ready":{"type":"boolean"},"restartCount":{"type":"integer","format":"int32","minimum":0},"terminatedReason":{"type":["string","null"]},"uid":{"type":["string","null"]},"waitingReason":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesPodRuntimeUnitStatus"}},"replicas":{"type":"object","properties":{"available":{"type":["integer","null"],"format":"int32","minimum":0},"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"misscheduled":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0},"updated":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"WorkloadReplicaStatus"},"restarts":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"workload":{"oneOf":[{"type":"null"},{"type":"object","required":["conditions"],"properties":{"availableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"lastTransitionTime":{"type":["string","null"],"format":"date-time"},"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesWorkloadCondition"}},"desiredGeneration":{"type":["integer","null"],"format":"int64"},"desiredReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"observedGeneration":{"type":["integer","null"],"format":"int64"},"readyReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"rolloutReason":{"type":["string","null"]},"updatedReplicas":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"KubernetesWorkloadStatus"}]}},"x-readme-ref-name":"KubernetesDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetes"]}}}]},{"allOf":[{"type":"object","required":["status","runtimeId","commandSupported","imagePathPresent","events"],"properties":{"commandSupported":{"type":"boolean"},"daemonInstance":{"oneOf":[{"type":"null"},{"type":"object","required":["unitId","name","kind","ready"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"kind":{"type":"string","enum":["container","process","daemon"],"x-readme-ref-name":"LocalRuntimeUnitKind"},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"phase":{"type":["string","null"]},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":"boolean"},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"unitId":{"type":"string"}},"x-readme-ref-name":"LocalRuntimeUnitStatus"}]},"daemonName":{"type":"string"},"events":{"type":"array","items":{"type":"object","required":["timestamp","severity","kind","message"],"properties":{"kind":{"type":"string"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"subject":{"oneOf":[{"type":"null"},{"type":"object","required":["kind"],"properties":{"id":{"type":["string","null"]},"kind":{"type":"string"},"name":{"type":["string","null"]}},"x-readme-ref-name":"LocalRuntimeEventSubject"}]},"timestamp":{"type":"string","format":"date-time"}},"x-readme-ref-name":"LocalRuntimeEventSnapshot"}},"exitReason":{"type":["string","null"]},"imagePathPresent":{"type":"boolean"},"pid":{"type":["integer","null"],"format":"int32","minimum":0},"restartCount":{"type":["integer","null"],"format":"int32","minimum":0},"runtimeId":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"}},"x-readme-ref-name":"LocalDaemonHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"DaemonHeartbeatData"},"resourceType":{"type":"string","enum":["daemon"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","providerFleets"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"providerFleets":{"type":"array","items":{"type":"object","required":["groupId","providerId","currentMachines","desiredMachines"],"properties":{"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"groupId":{"type":"string"},"location":{"type":["string","null"]},"providerId":{"type":"string"}},"x-readme-ref-name":"ProviderFleetStatus"}},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"AwsComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["aws"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","providerFleets"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"providerFleets":{"type":"array","items":{"type":"object","required":["groupId","providerId","currentMachines","desiredMachines"],"properties":{"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"groupId":{"type":"string"},"location":{"type":["string","null"]},"providerId":{"type":"string"}},"x-readme-ref-name":"ProviderFleetStatus"}},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"GcpComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcp"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","providerFleets"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"providerFleets":{"type":"array","items":{"type":"object","required":["groupId","providerId","currentMachines","desiredMachines"],"properties":{"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"groupId":{"type":"string"},"location":{"type":["string","null"]},"providerId":{"type":"string"}},"x-readme-ref-name":"ProviderFleetStatus"}},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"AzureComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azure"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","capacityGroups","machines"],"properties":{"backendClusterId":{"type":["string","null"]},"capacityGroups":{"type":"array","items":{"type":"object","required":["groupId","currentMachines","desiredMachines"],"properties":{"capacityBlocker":{"oneOf":[{"type":"null"},{"type":"object","required":["category","message","observedAt"],"properties":{"category":{"type":"string","enum":["quota","capacity","allocation","other"],"x-readme-ref-name":"ComputeCapacityBlockerCategory"},"message":{"type":"string"},"observedAt":{"type":"string","format":"date-time"},"providerCode":{"type":["string","null"]},"providerReference":{"type":["string","null"]}},"x-readme-ref-name":"ComputeCapacityBlocker"}]},"currentMachines":{"type":"integer","format":"int32","minimum":0},"desiredMachines":{"type":"integer","format":"int32","minimum":0},"drainProgress":{"oneOf":[{"type":"null"},{"type":"object","required":["machineId","status","replicaCount","force","stalled"],"properties":{"blockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"force":{"type":"boolean"},"machineId":{"type":"string"},"replicaCount":{"type":"integer","format":"int64"},"stalled":{"type":"boolean"},"status":{"type":"string","enum":["draining","drained","terminating"],"x-readme-ref-name":"ComputeDrainProgressStatus"}},"x-readme-ref-name":"ComputeDrainProgress"}]},"groupId":{"type":"string"},"instanceType":{"type":["string","null"]},"maxMachines":{"type":["integer","null"],"format":"int32","minimum":0},"minMachines":{"type":["integer","null"],"format":"int32","minimum":0},"recommendation":{"oneOf":[{"type":"null"},{"type":"object","required":["desiredMachines"],"properties":{"desiredMachines":{"type":"integer","format":"int32","minimum":0},"reason":{"type":["string","null"]},"unschedulableReplicas":{"type":["integer","null"],"format":"int32","minimum":0},"utilization":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"ComputeCapacityRecommendation"}]}},"x-readme-ref-name":"ComputeCapacityGroupStatus"}},"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"machines":{"type":"array","items":{"type":"object","required":["machineId","status","capacityGroup","zone","lastHeartbeat","replicaCount","drainForce"],"properties":{"capacityGroup":{"type":"string"},"cpuCores":{"type":["number","null"],"format":"double"},"drainBlockers":{"type":"array","items":{"type":"object","required":["workloadName","replicaId","schedulingMode","state","reason"],"properties":{"reason":{"type":"string"},"replicaId":{"type":"string"},"schedulingMode":{"type":"string"},"state":{"type":"string"},"workloadName":{"type":"string"}},"x-readme-ref-name":"ComputeDrainBlocker"}},"drainDeadlineAt":{"type":["string","null"]},"drainForce":{"type":"boolean"},"drainRequestedAt":{"type":["string","null"]},"drainedAt":{"type":["string","null"]},"horizondVersion":{"type":["string","null"]},"lastHeartbeat":{"type":"string"},"machineId":{"type":"string"},"memoryBytes":{"type":["integer","null"],"format":"int64"},"overlayIp":{"type":["string","null"]},"publicIp":{"type":["string","null"]},"replicaCount":{"type":"integer","format":"int64"},"status":{"type":"string"},"zone":{"type":"string"}},"x-readme-ref-name":"MachinesComputeMachineStatus"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"}},"x-readme-ref-name":"MachinesComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["machines"]}}}]},{"allOf":[{"type":"object","required":["status","nodes","name","dockerAvailable","networkAvailable"],"properties":{"dockerApiVersion":{"type":["string","null"]},"dockerArch":{"type":["string","null"]},"dockerAvailable":{"type":"boolean"},"dockerOs":{"type":["string","null"]},"dockerVersion":{"type":["string","null"]},"hostIdentifier":{"type":["string","null"]},"name":{"type":"string"},"networkAvailable":{"type":"boolean"},"networkName":{"type":["string","null"]},"nodes":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"runningContainers":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ComputeClusterHeartbeatStatus"},"trackedContainers":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"LocalComputeClusterHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ComputeClusterHeartbeatData"},"resourceType":{"type":"string","enum":["compute-cluster"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","nodeCounts","podCounts","name","events"],"properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"name":{"type":"string"},"namespace":{"type":["string","null"]},"nodeCounts":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"nodeStatuses":{"type":"array","items":{"type":"object","required":["name","ready","roles","labels","allocatable","capacity"],"properties":{"allocatable":{"type":"object","properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"pods":{"type":["integer","null"],"format":"int64","minimum":0}},"x-readme-ref-name":"KubernetesNodeResources"},"capacity":{"type":"object","properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"pods":{"type":["integer","null"],"format":"int64","minimum":0}},"x-readme-ref-name":"KubernetesNodeResources"},"conditions":{"type":"array","items":{"type":"object","required":["type","status"],"properties":{"message":{"type":["string","null"]},"reason":{"type":["string","null"]},"status":{"type":"string"},"type":{"type":"string"}},"x-readme-ref-name":"KubernetesNodeConditionStatus"}},"containerRuntimeVersion":{"type":["string","null"]},"kubeletVersion":{"type":["string","null"]},"labels":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"name":{"type":"string"},"ready":{"type":"boolean"},"roles":{"type":"array","items":{"type":"string"}},"uid":{"type":["string","null"]},"usage":{"oneOf":[{"type":"null"},{"type":"object","properties":{"cpu":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]},"memory":{"oneOf":[{"type":"null"},{"type":"object","required":["value","unit"],"properties":{"unit":{"type":"string","enum":["count","percent","bytes","cores","milliseconds","requests-per-second"],"x-readme-ref-name":"MetricUnit"},"value":{"type":"number","format":"double"}},"x-readme-ref-name":"MetricSample"}]}},"x-readme-ref-name":"KubernetesNodeUsage"}]}},"x-readme-ref-name":"KubernetesClusterNodeStatus"}},"podCounts":{"type":"object","properties":{"current":{"type":["integer","null"],"format":"int32","minimum":0},"desired":{"type":["integer","null"],"format":"int32","minimum":0},"ready":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"ObservedCounts"},"region":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"WorkloadHeartbeatStatus"},"version":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesClusterHeartbeatData"},"resourceType":{"type":"string","enum":["kubernetes-cluster"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","name","approximateCounts"],"properties":{"approximateCounts":{"type":"boolean"},"approximateDelayedMessages":{"type":["integer","null"],"format":"int64","minimum":0},"approximateInFlightMessages":{"type":["integer","null"],"format":"int64","minimum":0},"approximateVisibleMessages":{"type":["integer","null"],"format":"int64","minimum":0},"contentBasedDeduplication":{"type":["boolean","null"]},"deduplicationScope":{"type":["string","null"]},"delaySeconds":{"type":["integer","null"],"format":"int32","minimum":0},"fifoQueue":{"type":["boolean","null"]},"fifoThroughputLimit":{"type":["string","null"]},"kmsDataKeyReusePeriodSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"kmsMasterKeyId":{"type":["string","null"]},"maximumMessageSize":{"type":["integer","null"],"format":"int32","minimum":0},"messageRetentionPeriodSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"name":{"type":"string"},"queueArn":{"type":["string","null"]},"queueUrl":{"type":["string","null"]},"receiveMessageWaitTimeSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"redriveAllowPolicy":{"type":["string","null"]},"redrivePolicy":{"type":["string","null"]},"region":{"type":["string","null"]},"sqsManagedSseEnabled":{"type":["boolean","null"]},"sseEnabled":{"type":["boolean","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"visibilityTimeoutSeconds":{"type":["integer","null"],"format":"int32","minimum":0}},"x-readme-ref-name":"AwsSqsQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsSqs"]}}}]},{"allOf":[{"type":"object","required":["status","topicName","topicLabels","subscriptionLabels","messageStorageAllowedPersistenceRegions","subscriptionPushAttributes"],"properties":{"endpoint":{"type":["string","null"]},"kmsKeyName":{"type":["string","null"]},"messageStorageAllowedPersistenceRegions":{"type":"array","items":{"type":"string"}},"messageStorageEnforceInTransit":{"type":["boolean","null"]},"projectId":{"type":["string","null"]},"schemaEncoding":{"type":["string","null"]},"schemaFirstRevisionId":{"type":["string","null"]},"schemaLastRevisionId":{"type":["string","null"]},"schemaName":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"subscriptionAckDeadlineSeconds":{"type":["integer","null"],"format":"int32","minimum":0},"subscriptionDeadLetterMaxDeliveryAttempts":{"type":["integer","null"],"format":"int32","minimum":0},"subscriptionDeadLetterTopic":{"type":["string","null"]},"subscriptionDetached":{"type":["boolean","null"]},"subscriptionEnableMessageOrdering":{"type":["boolean","null"]},"subscriptionFilter":{"type":["string","null"]},"subscriptionFullName":{"type":["string","null"]},"subscriptionLabels":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"subscriptionMessageRetentionDuration":{"type":["string","null"]},"subscriptionName":{"type":["string","null"]},"subscriptionPushAttributes":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"subscriptionPushConfigPresent":{"type":["boolean","null"]},"subscriptionPushEndpoint":{"type":["string","null"]},"subscriptionPushNoWrapperWriteMetadata":{"type":["boolean","null"]},"subscriptionPushOidcAudience":{"type":["string","null"]},"subscriptionPushOidcServiceAccountEmail":{"type":["string","null"]},"subscriptionPushPubsubWrapperWriteMetadata":{"type":["boolean","null"]},"subscriptionRetainAckedMessages":{"type":["boolean","null"]},"subscriptionState":{"type":["string","null"]},"topicFullName":{"type":["string","null"]},"topicLabels":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"topicMessageRetentionDuration":{"type":["string","null"]},"topicName":{"type":"string"},"topicState":{"type":["string","null"]}},"x-readme-ref-name":"GcpPubSubQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpPubSub"]}}}]},{"allOf":[{"type":"object","required":["status","name","namespaceName"],"properties":{"accessedAt":{"type":["string","null"]},"activeMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"autoDeleteOnIdle":{"type":["string","null"]},"createdAt":{"type":["string","null"]},"deadLetterMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"deadLetteringOnMessageExpiration":{"type":["boolean","null"]},"defaultMessageTimeToLive":{"type":["string","null"]},"duplicateDetectionHistoryTimeWindow":{"type":["string","null"]},"enableBatchedOperations":{"type":["boolean","null"]},"enableExpress":{"type":["boolean","null"]},"enablePartitioning":{"type":["boolean","null"]},"endpoint":{"type":["string","null"]},"forwardDeadLetteredMessagesTo":{"type":["string","null"]},"forwardTo":{"type":["string","null"]},"lockDuration":{"type":["string","null"]},"maxDeliveryCount":{"type":["integer","null"],"format":"int32","minimum":0},"maxMessageSizeInKilobytes":{"type":["integer","null"],"format":"int64","minimum":0},"maxSizeInMegabytes":{"type":["integer","null"],"format":"int32","minimum":0},"messageCount":{"type":["integer","null"],"format":"int64","minimum":0},"name":{"type":"string"},"namespaceName":{"type":"string"},"queueStatus":{"type":["string","null"]},"requiresDuplicateDetection":{"type":["boolean","null"]},"requiresSession":{"type":["boolean","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"scheduledMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"sizeInBytes":{"type":["integer","null"],"format":"int64","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"transferDeadLetterMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"transferMessageCount":{"type":["integer","null"],"format":"int64","minimum":0},"updatedAt":{"type":["string","null"]}},"x-readme-ref-name":"AzureServiceBusQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureServiceBus"]}}}]},{"allOf":[{"type":"object","required":["status","name"],"properties":{"name":{"type":"string"},"path":{"type":["string","null"]},"serviceStatus":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"}},"x-readme-ref-name":"LocalQueueHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"QueueHeartbeatData"},"resourceType":{"type":"string","enum":["queue"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","name","keySchema"],"properties":{"billingMode":{"type":["string","null"]},"deletionProtectionEnabled":{"type":["boolean","null"]},"globalSecondaryIndexCount":{"type":["integer","null"],"format":"int32","minimum":0},"itemCount":{"type":["integer","null"],"format":"int64","minimum":0},"keySchema":{"type":"array","items":{"type":"object","required":["attributeName","keyType"],"properties":{"attributeName":{"type":"string"},"keyType":{"type":"string"}},"x-readme-ref-name":"AwsDynamoDbKeySchemaElement"}},"localSecondaryIndexCount":{"type":["integer","null"],"format":"int32","minimum":0},"name":{"type":"string"},"region":{"type":["string","null"]},"replicaCount":{"type":["integer","null"],"format":"int32","minimum":0},"restoreInProgress":{"type":["boolean","null"]},"sseStatus":{"type":["string","null"]},"sseType":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"},"streamEnabled":{"type":["boolean","null"]},"streamViewType":{"type":["string","null"]},"tableArn":{"type":["string","null"]},"tableClass":{"type":["string","null"]},"tableSizeBytes":{"type":["integer","null"],"format":"int64","minimum":0},"tableStatus":{"type":["string","null"]},"ttlAttributeName":{"type":["string","null"]},"ttlStatus":{"type":["string","null"]}},"x-readme-ref-name":"AwsDynamoDbKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsDynamoDb"]}}}]},{"allOf":[{"type":"object","required":["status","databaseName","cmekEnabled","sourceInfoPresent"],"properties":{"appEngineIntegrationMode":{"type":["string","null"]},"cmekEnabled":{"type":"boolean"},"concurrencyMode":{"type":["string","null"]},"createTime":{"type":["string","null"]},"databaseEdition":{"type":["string","null"]},"databaseName":{"type":"string"},"databaseType":{"type":["string","null"]},"deleteProtectionState":{"type":["string","null"]},"deleteTime":{"type":["string","null"]},"earliestVersionTime":{"type":["string","null"]},"endpoint":{"type":["string","null"]},"locationId":{"type":["string","null"]},"pointInTimeRecoveryEnablement":{"type":["string","null"]},"projectId":{"type":["string","null"]},"sourceInfoPresent":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"},"updateTime":{"type":["string","null"]},"versionRetentionPeriod":{"type":["string","null"]}},"x-readme-ref-name":"GcpFirestoreKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpFirestore"]}}}]},{"allOf":[{"type":"object","required":["status","tableName","storageAccountName","tableExists"],"properties":{"endpoint":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"signedIdentifierCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"},"storageAccountKind":{"type":["string","null"]},"storageAccountLocation":{"type":["string","null"]},"storageAccountName":{"type":"string"},"storageAccountPrimaryStatus":{"type":["string","null"]},"storageAccountProvisioningState":{"type":["string","null"]},"storageAccountResourceId":{"type":["string","null"]},"tableExists":{"type":"boolean"},"tableName":{"type":"string"}},"x-readme-ref-name":"AzureTableKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureTable"]}}}]},{"allOf":[{"type":"object","required":["status","name","path","pathExists","cloudMetadataSupported"],"properties":{"cloudMetadataSupported":{"type":"boolean"},"isDirectory":{"type":["boolean","null"]},"name":{"type":"string"},"path":{"type":"string"},"pathExists":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"KvHeartbeatStatus"}},"x-readme-ref-name":"LocalKvHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"KvHeartbeatData"},"resourceType":{"type":"string","enum":["kv"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"description":"AWS Aurora Serverless v2 backend.","type":"object","required":["status","clusterIdentifier","neverPauses"],"properties":{"clusterIdentifier":{"type":"string"},"endpoint":{"type":["string","null"]},"engineVersion":{"type":["string","null"]},"neverPauses":{"type":"boolean","description":"True when a `minCapacity: 0` instance has not reached 0 ACU over the observation\nwindow — it is silently paying always-on prices (auto-pause verification)."},"serverlessCapacity":{"type":["number","null"],"format":"double","description":"Latest sampled `ServerlessDatabaseCapacity` (ACU)."},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"}},"x-readme-ref-name":"AuroraPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["aurora"]}}}],"description":"AWS Aurora Serverless v2 backend."},{"allOf":[{"description":"GCP Cloud SQL backend.","type":"object","required":["status","instanceName"],"properties":{"databaseVersion":{"type":["string","null"]},"instanceName":{"type":"string"},"state":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"}},"x-readme-ref-name":"GcpCloudSqlPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["cloudSql"]}}}],"description":"GCP Cloud SQL backend."},{"allOf":[{"description":"Azure Flexible Server backend.","type":"object","required":["status","serverName"],"properties":{"serverName":{"type":"string"},"state":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"},"version":{"type":["string","null"]}},"x-readme-ref-name":"AzureFlexibleServerPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["flexibleServer"]}}}],"description":"Azure Flexible Server backend."},{"allOf":[{"description":"Local embedded Postgres backend.","type":"object","required":["status","name","version","processRunning"],"properties":{"name":{"type":"string"},"port":{"type":["integer","null"],"format":"int32","minimum":0},"processRunning":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"PostgresHeartbeatStatus"},"version":{"type":"string"}},"x-readme-ref-name":"LocalPostgresHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}],"description":"Local embedded Postgres backend."}],"x-readme-ref-name":"PostgresHeartbeatData"},"resourceType":{"type":"string","enum":["postgres"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","accountId","region","prefix","parameterMetadataSampled"],"properties":{"accountId":{"type":"string"},"hasMoreParameters":{"type":["boolean","null"]},"latestModifiedAt":{"type":["string","null"],"format":"date-time"},"parameterMetadataSampled":{"type":"boolean"},"prefix":{"type":"string"},"region":{"type":"string"},"sampledAdvancedTierCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledKmsKeyMetadataPresentCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledParameterCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledSecureStringCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledStringCount":{"type":["integer","null"],"format":"int32","minimum":0},"sampledStringListCount":{"type":["integer","null"],"format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"AwsParameterStoreVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsParameterStore"]}}}]},{"allOf":[{"type":"object","required":["status","projectId","location","prefix","secretMetadataListed"],"properties":{"location":{"type":"string"},"prefix":{"type":"string"},"projectId":{"type":"string"},"secretMetadataListed":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"GcpSecretManagerVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpSecretManager"]}}}]},{"allOf":[{"type":"object","required":["status","name","softDeleteEnabled","softDeleteRetentionDays","rbacAuthorizationEnabled","publicNetworkAccess","accessPolicyCount","privateEndpointConnectionCount","secretMetadataListed"],"properties":{"accessPolicyCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":["string","null"]},"name":{"type":"string"},"privateEndpointConnectionCount":{"type":"integer","format":"int32","minimum":0},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":"string"},"purgeProtectionEnabled":{"type":["boolean","null"]},"rbacAuthorizationEnabled":{"type":"boolean"},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"secretMetadataListed":{"type":"boolean"},"skuFamily":{"type":["string","null"]},"skuName":{"type":["string","null"]},"softDeleteEnabled":{"type":"boolean"},"softDeleteRetentionDays":{"type":"integer","format":"int32"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"},"vaultUri":{"type":["string","null"]}},"x-readme-ref-name":"AzureKeyVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureKeyVault"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","prefix","secretMetadataListed"],"properties":{"namespace":{"type":"string"},"prefix":{"type":"string"},"secretMetadataListed":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"KubernetesSecretVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetesSecret"]}}}]},{"allOf":[{"type":"object","required":["status","path","pathExists","secretMetadataListed"],"properties":{"isDirectory":{"type":["boolean","null"]},"modifiedAt":{"type":["string","null"],"format":"date-time"},"path":{"type":"string"},"pathExists":{"type":"boolean"},"readonly":{"type":["boolean","null"]},"secretMetadataListed":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"VaultHeartbeatStatus"}},"x-readme-ref-name":"LocalVaultHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"VaultHeartbeatData"},"resourceType":{"type":"string","enum":["vault"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","roleName","roleArn","roleId","path","createDate","assumeRolePolicyPresent","tagCount","managedTagCount","attachedPolicyCount","attachedPolicyNames","inlinePolicyCount","inlinePolicyNames","stackPermissionsApplied"],"properties":{"assumeRolePolicyPresent":{"type":"boolean"},"attachedPolicyCount":{"type":"integer","format":"int32","minimum":0},"attachedPolicyNames":{"type":"array","items":{"type":"string"}},"createDate":{"type":"string"},"description":{"type":["string","null"]},"inlinePolicyCount":{"type":"integer","format":"int32","minimum":0},"inlinePolicyNames":{"type":"array","items":{"type":"string"}},"lastUsedDate":{"type":["string","null"]},"lastUsedRegion":{"type":["string","null"]},"managedTagCount":{"type":"integer","format":"int32","minimum":0},"maxSessionDuration":{"type":["integer","null"],"format":"int32"},"path":{"type":"string"},"permissionsBoundaryArn":{"type":["string","null"]},"permissionsBoundaryType":{"type":["string","null"]},"roleArn":{"type":"string"},"roleId":{"type":"string"},"roleName":{"type":"string"},"stackPermissionsApplied":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"},"tagCount":{"type":"integer","format":"int32","minimum":0}},"x-readme-ref-name":"AwsIamRoleServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsIamRole"]}}}]},{"allOf":[{"type":"object","required":["status","email","projectBindingCount","projectRoles","serviceAccountBindingCount","serviceAccountRoles"],"properties":{"description":{"type":["string","null"]},"disabled":{"type":["boolean","null"]},"displayName":{"type":["string","null"]},"email":{"type":"string"},"etag":{"type":["string","null"]},"name":{"type":["string","null"]},"oauth2ClientId":{"type":["string","null"]},"projectBindingCount":{"type":"integer","format":"int32","minimum":0},"projectId":{"type":["string","null"]},"projectRoles":{"type":"array","items":{"type":"string"}},"serviceAccountBindingCount":{"type":"integer","format":"int32","minimum":0},"serviceAccountRoles":{"type":"array","items":{"type":"string"}},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"},"uniqueId":{"type":["string","null"]}},"x-readme-ref-name":"GcpServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpServiceAccount"]}}}]},{"allOf":[{"type":"object","required":["status","name","resourceId","resourceGroup","location","managedTagCount","roleAssignmentCount","roleAssignmentIds","customRoleDefinitionCount","customRoleDefinitionIds","stackPermissionsApplied"],"properties":{"clientId":{"type":["string","null"]},"customRoleDefinitionCount":{"type":"integer","format":"int32","minimum":0},"customRoleDefinitionIds":{"type":"array","items":{"type":"string"}},"isolationScope":{"type":["string","null"]},"location":{"type":"string"},"managedTagCount":{"type":"integer","format":"int32","minimum":0},"name":{"type":"string"},"principalId":{"type":["string","null"]},"resourceGroup":{"type":"string"},"resourceId":{"type":"string"},"roleAssignmentCount":{"type":"integer","format":"int32","minimum":0},"roleAssignmentIds":{"type":"array","items":{"type":"string"}},"stackPermissionsApplied":{"type":"boolean"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"},"tenantId":{"type":["string","null"]},"type":{"type":["string","null"]}},"x-readme-ref-name":"AzureManagedIdentityServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureManagedIdentity"]}}}]},{"allOf":[{"type":"object","required":["status","identity","configured"],"properties":{"configured":{"type":"boolean"},"identity":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceAccountHeartbeatStatus"}},"x-readme-ref-name":"LocalServiceAccountHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ServiceAccountHeartbeatData"},"resourceType":{"type":"string","enum":["service-account"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","publicSubnetIds","privateSubnetIds","availabilityZones","routeTableCount","isByoVpc"],"properties":{"availabilityZones":{"type":"array","items":{"type":"string"}},"cidrBlock":{"type":["string","null"]},"internetGatewayId":{"type":["string","null"]},"isByoVpc":{"type":"boolean"},"natGatewayId":{"type":["string","null"]},"privateSubnetIds":{"type":"array","items":{"type":"string"}},"publicSubnetIds":{"type":"array","items":{"type":"string"}},"routeTableCount":{"type":"integer","format":"int32","minimum":0},"securityGroupId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"NetworkHeartbeatStatus"},"vpcId":{"type":["string","null"]},"vpcState":{"type":["string","null"]}},"x-readme-ref-name":"AwsVpcNetworkHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsVpc"]}}}]},{"allOf":[{"type":"object","required":["status","isByoVpc"],"properties":{"cidrBlock":{"type":["string","null"]},"cloudNatName":{"type":["string","null"]},"firewallName":{"type":["string","null"]},"isByoVpc":{"type":"boolean"},"networkName":{"type":["string","null"]},"networkSelfLink":{"type":["string","null"]},"region":{"type":["string","null"]},"routerName":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"NetworkHeartbeatStatus"},"subnetworkName":{"type":["string","null"]},"subnetworkSelfLink":{"type":["string","null"]}},"x-readme-ref-name":"GcpVpcNetworkHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpVpc"]}}}]},{"allOf":[{"type":"object","required":["status","isByoVnet"],"properties":{"applicationGatewaySubnetName":{"type":["string","null"]},"cidrBlock":{"type":["string","null"]},"isByoVnet":{"type":"boolean"},"lastByoVnetVerificationErrorCode":{"type":["string","null"]},"location":{"type":["string","null"]},"natGatewayId":{"type":["string","null"]},"nsgId":{"type":["string","null"]},"privateEndpointSubnetName":{"type":["string","null"]},"privateSubnetName":{"type":["string","null"]},"publicIpId":{"type":["string","null"]},"publicSubnetName":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"NetworkHeartbeatStatus"},"vnetName":{"type":["string","null"]},"vnetResourceId":{"type":["string","null"]}},"x-readme-ref-name":"AzureVnetNetworkHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureVnet"]}}}]}],"x-readme-ref-name":"NetworkHeartbeatData"},"resourceType":{"type":"string","enum":["network"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","managementPermissionsApplied"],"properties":{"managementPermissionsApplied":{"type":"boolean"},"roleArn":{"type":["string","null"]},"roleName":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"RemoteStackManagementHeartbeatStatus"}},"x-readme-ref-name":"AwsRemoteStackManagementHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsIamRole"]}}}]},{"allOf":[{"type":"object","required":["status","roleBound","impersonationGranted"],"properties":{"impersonationGranted":{"type":"boolean"},"roleBound":{"type":"boolean"},"serviceAccountEmail":{"type":["string","null"]},"serviceAccountUniqueId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"RemoteStackManagementHeartbeatStatus"}},"x-readme-ref-name":"GcpRemoteStackManagementHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpServiceAccount"]}}}]},{"allOf":[{"type":"object","required":["status","roleAssignmentIds"],"properties":{"ficName":{"type":["string","null"]},"roleAssignmentIds":{"type":"array","items":{"type":"string"}},"roleDefinitionId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"RemoteStackManagementHeartbeatStatus"},"tenantId":{"type":["string","null"]},"uamiClientId":{"type":["string","null"]},"uamiPrincipalId":{"type":["string","null"]},"uamiResourceId":{"type":["string","null"]}},"x-readme-ref-name":"AzureRemoteStackManagementHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureManagedIdentity"]}}}]}],"x-readme-ref-name":"RemoteStackManagementHeartbeatData"},"resourceType":{"type":"string","enum":["remote-stack-management"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","registryId","region","registryUri","repositoryPrefix","repositoryCount","repositoriesTruncated","repositories"],"properties":{"pullRoleArn":{"type":["string","null"]},"pushRoleArn":{"type":["string","null"]},"region":{"type":"string"},"registryId":{"type":"string"},"registryUri":{"type":"string"},"repositories":{"type":"array","items":{"type":"object","required":["repositoryArn","registryId","repositoryName","repositoryUri","createdAt","kmsKeyPresent"],"properties":{"createdAt":{"type":"number","format":"double"},"encryptionType":{"type":["string","null"]},"imageTagMutability":{"type":["string","null"]},"kmsKeyPresent":{"type":"boolean"},"registryId":{"type":"string"},"repositoryArn":{"type":"string"},"repositoryName":{"type":"string"},"repositoryUri":{"type":"string"},"scanOnPush":{"type":["boolean","null"]}},"x-readme-ref-name":"AwsEcrRepositoryHeartbeatData"}},"repositoriesTruncated":{"type":"boolean"},"repositoryCount":{"type":"integer","format":"int32","minimum":0},"repositoryPrefix":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"}},"x-readme-ref-name":"AwsEcrArtifactRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsEcr"]}}}]},{"allOf":[{"type":"object","required":["status","projectId","location","repositoryId","labelCount","cleanupPolicyCount","kmsKeyNamePresent","iamPolicyEtagPresent","iamBindingCount","iamRoles"],"properties":{"cleanupPolicyCount":{"type":"integer","format":"int32","minimum":0},"cleanupPolicyDryRun":{"type":["boolean","null"]},"createTime":{"type":["string","null"]},"description":{"type":["string","null"]},"format":{"type":["string","null"]},"iamBindingCount":{"type":"integer","format":"int32","minimum":0},"iamPolicyEtagPresent":{"type":"boolean"},"iamRoles":{"type":"array","items":{"type":"string"}},"kmsKeyNamePresent":{"type":"boolean"},"labelCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":"string"},"mode":{"type":["string","null"]},"name":{"type":["string","null"]},"projectId":{"type":"string"},"pullServiceAccountEmail":{"type":["string","null"]},"pushServiceAccountEmail":{"type":["string","null"]},"repositoryId":{"type":"string"},"satisfiesPzs":{"type":["boolean","null"]},"sizeBytes":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"},"updateTime":{"type":["string","null"]}},"x-readme-ref-name":"GcpArtifactRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpArtifactRegistry"]}}}]},{"allOf":[{"type":"object","required":["status","name","resourceGroup","location","skuName","adminUserEnabled","anonymousPullEnabled","publicNetworkAccess","networkRuleBypassOptions","ipRuleCount","encryptionKeyVaultUriPresent","encryptionKeyIdentifierPresent","policiesPresent","policyCount","privateEndpointConnectionCount","dataEndpointHostNames","zoneRedundancy","managedTagCount"],"properties":{"adminUserEnabled":{"type":"boolean"},"anonymousPullEnabled":{"type":"boolean"},"creationDate":{"type":["string","null"]},"dataEndpointEnabled":{"type":["boolean","null"]},"dataEndpointHostNames":{"type":"array","items":{"type":"string"}},"encryptionKeyIdentifierPresent":{"type":"boolean"},"encryptionKeyVaultUriPresent":{"type":"boolean"},"encryptionStatus":{"type":["string","null"]},"ipRuleCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":"string"},"loginServer":{"type":["string","null"]},"managedTagCount":{"type":"integer","format":"int32","minimum":0},"name":{"type":"string"},"networkRuleBypassOptions":{"type":"string"},"networkRuleDefaultAction":{"type":["string","null"]},"policiesPresent":{"type":"boolean"},"policyCount":{"type":"integer","format":"int32","minimum":0},"privateEndpointConnectionCount":{"type":"integer","format":"int32","minimum":0},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":"string"},"resourceGroup":{"type":"string"},"resourceId":{"type":["string","null"]},"skuName":{"type":"string"},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"},"type":{"type":["string","null"]},"zoneRedundancy":{"type":"string"}},"x-readme-ref-name":"AzureContainerRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureContainerRegistry"]}}}]},{"allOf":[{"type":"object","required":["status","registryUrl","reachable"],"properties":{"reachable":{"type":"boolean"},"registryUrl":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ArtifactRegistryHeartbeatStatus"}},"x-readme-ref-name":"LocalArtifactRegistryHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["local"]}}}]}],"x-readme-ref-name":"ArtifactRegistryHeartbeatData"},"resourceType":{"type":"string","enum":["artifact-registry"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","projectName","environmentVariableCount","serviceRolePresent","encryptionKeyPresent"],"properties":{"artifactsEncryptionDisabled":{"type":["boolean","null"]},"artifactsType":{"type":["string","null"]},"cloudWatchLogsStatus":{"type":["string","null"]},"computeType":{"type":["string","null"]},"created":{"type":["number","null"],"format":"double"},"description":{"type":["string","null"]},"encryptionKeyPresent":{"type":"boolean"},"environmentImage":{"type":["string","null"]},"environmentType":{"type":["string","null"]},"environmentVariableCount":{"type":"integer","format":"int32","minimum":0},"imagePullCredentialsType":{"type":["string","null"]},"lastModified":{"type":["number","null"],"format":"double"},"privilegedMode":{"type":["boolean","null"]},"projectArn":{"type":["string","null"]},"projectName":{"type":"string"},"queuedTimeoutInMinutes":{"type":["integer","null"],"format":"int32"},"s3LogsStatus":{"type":["string","null"]},"serviceRolePresent":{"type":"boolean"},"sourceType":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"},"timeoutInMinutes":{"type":["integer","null"],"format":"int32"}},"x-readme-ref-name":"AwsCodeBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsCodeBuild"]}}}]},{"allOf":[{"type":"object","required":["status","projectId","location","buildConfigId","environmentVariableCount"],"properties":{"buildConfigId":{"type":"string"},"environmentVariableCount":{"type":"integer","format":"int32","minimum":0},"location":{"type":"string"},"projectId":{"type":"string"},"serviceAccount":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"}},"x-readme-ref-name":"GcpCloudBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpCloudBuild"]}}}]},{"allOf":[{"type":"object","required":["status","managedEnvironmentId","resourceGroupName","environmentVariableCount"],"properties":{"environmentVariableCount":{"type":"integer","format":"int32","minimum":0},"managedEnvironmentId":{"type":"string"},"managedIdentityId":{"type":["string","null"]},"resourceGroupName":{"type":"string"},"resourcePrefix":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"}},"x-readme-ref-name":"AzureContainerAppsBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureContainerApps"]}}}]},{"allOf":[{"type":"object","required":["status","jobName","namespace","conditionCount","events"],"properties":{"active":{"type":["integer","null"],"format":"int32"},"completionTime":{"type":["string","null"],"format":"date-time"},"conditionCount":{"type":"integer","format":"int32","minimum":0},"events":{"type":"array","items":{"type":"object","required":["reason","message"],"properties":{"count":{"type":["integer","null"],"format":"int32"},"eventTime":{"type":["string","null"],"format":"date-time"},"firstTimestamp":{"type":["string","null"],"format":"date-time"},"involvedObject":{"oneOf":[{"type":"null"},{"type":"object","properties":{"apiVersion":{"type":["string","null"]},"fieldPath":{"type":["string","null"]},"kind":{"type":["string","null"]},"name":{"type":["string","null"]},"namespace":{"type":["string","null"]},"resourceVersion":{"type":["string","null"]},"uid":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventInvolvedObject"}]},"lastTimestamp":{"type":["string","null"],"format":"date-time"},"message":{"type":"string"},"raw":{"oneOf":[{"type":"null"},{"x-readme-ref-name":"Value"}]},"reason":{"type":"string"},"source":{"oneOf":[{"type":"null"},{"type":"object","properties":{"component":{"type":["string","null"]},"host":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSource"}]},"type":{"type":["string","null"]}},"x-readme-ref-name":"KubernetesEventSnapshot"}},"failed":{"type":["integer","null"],"format":"int32"},"imageDigest":{"type":["string","null"]},"jobName":{"type":"string"},"namespace":{"type":"string"},"startTime":{"type":["string","null"],"format":"date-time"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"BuildHeartbeatStatus"},"succeeded":{"type":["integer","null"],"format":"int32"}},"x-readme-ref-name":"KubernetesBuildHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["kubernetesJob"]}}}]}],"x-readme-ref-name":"BuildHeartbeatData"},"resourceType":{"type":"string","enum":["build"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","projectId","serviceName","enabled"],"properties":{"enabled":{"type":"boolean"},"lastOperationName":{"type":["string","null"]},"projectId":{"type":"string"},"serviceName":{"type":"string"},"serviceResourceName":{"type":["string","null"]},"state":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceActivationHeartbeatStatus"},"title":{"type":["string","null"]}},"x-readme-ref-name":"GcpServiceUsageActivationHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpServiceUsage"]}}}]},{"allOf":[{"type":"object","required":["status","namespace","resourceTypeCount","registered"],"properties":{"namespace":{"type":"string"},"providerId":{"type":["string","null"]},"registered":{"type":"boolean"},"registrationPolicy":{"type":["string","null"]},"registrationState":{"type":["string","null"]},"resourceTypeCount":{"type":"integer","format":"int32","minimum":0},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"ServiceActivationHeartbeatStatus"}},"x-readme-ref-name":"AzureResourceProviderActivationHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureResourceProvider"]}}}]}],"x-readme-ref-name":"ServiceActivationHeartbeatData"},"resourceType":{"type":"string","enum":["service_activation"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","managedTags"],"properties":{"location":{"type":["string","null"]},"managedTags":{"type":"object","additionalProperties":{"type":"string"},"propertyNames":{"type":"string"}},"name":{"type":"string"},"provisioningState":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AzureResourceGroupHeartbeatStatus"}},"x-readme-ref-name":"AzureResourceGroupHeartbeatData"},"resourceType":{"type":"string","enum":["azure_resource_group"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","primaryEndpoints","secondaryEndpoints"],"properties":{"allowBlobPublicAccess":{"type":["boolean","null"]},"allowSharedKeyAccess":{"type":["boolean","null"]},"encryptionKeySource":{"type":["string","null"]},"kind":{"type":["string","null"]},"location":{"type":["string","null"]},"minimumTlsVersion":{"type":["string","null"]},"name":{"type":"string"},"networkBypass":{"type":["string","null"]},"networkDefaultAction":{"type":["string","null"]},"networkIpRuleCount":{"type":["integer","null"],"format":"int32","minimum":0},"networkResourceAccessRuleCount":{"type":["integer","null"],"format":"int32","minimum":0},"networkVirtualNetworkRuleCount":{"type":["integer","null"],"format":"int32","minimum":0},"primaryEndpoints":{"type":"object","properties":{"blob":{"type":["string","null"]},"dfs":{"type":["string","null"]},"file":{"type":["string","null"]},"queue":{"type":["string","null"]},"table":{"type":["string","null"]},"web":{"type":["string","null"]}},"x-readme-ref-name":"AzureStorageAccountEndpoints"},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":["string","null"]},"requireInfrastructureEncryption":{"type":["boolean","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"secondaryEndpoints":{"type":"object","properties":{"blob":{"type":["string","null"]},"dfs":{"type":["string","null"]},"file":{"type":["string","null"]},"queue":{"type":["string","null"]},"table":{"type":["string","null"]},"web":{"type":["string","null"]}},"x-readme-ref-name":"AzureStorageAccountEndpoints"},"skuName":{"type":["string","null"]},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"StorageHeartbeatStatus"},"supportsHttpsTrafficOnly":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureStorageAccountHeartbeatData"},"resourceType":{"type":"string","enum":["azure_storage_account"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","workloadProfileCount","workloadProfiles"],"properties":{"customDomainVerificationId":{"type":["string","null"]},"defaultDomain":{"type":["string","null"]},"eventStreamEndpoint":{"type":["string","null"]},"infrastructureResourceGroup":{"type":["string","null"]},"kind":{"type":["string","null"]},"location":{"type":["string","null"]},"name":{"type":"string"},"provisioningState":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"staticIp":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AzureContainerAppsEnvironmentHeartbeatStatus"},"workloadProfileCount":{"type":"integer","format":"int32","minimum":0},"workloadProfiles":{"type":"array","items":{"type":"object","required":["name","workloadProfileType"],"properties":{"maximumCount":{"type":["integer","null"],"format":"int32"},"minimumCount":{"type":["integer","null"],"format":"int32"},"name":{"type":"string"},"workloadProfileType":{"type":"string"}},"x-readme-ref-name":"AzureContainerAppsEnvironmentWorkloadProfile"}},"zoneRedundant":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureContainerAppsEnvironmentHeartbeatData"},"resourceType":{"type":"string","enum":["azure_container_apps_environment"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"type":"object","required":["status","name","privateEndpointConnectionCount"],"properties":{"createdAt":{"type":["string","null"]},"disableLocalAuth":{"type":["boolean","null"]},"location":{"type":["string","null"]},"metricId":{"type":["string","null"]},"minimumTlsVersion":{"type":["string","null"]},"name":{"type":"string"},"namespaceStatus":{"type":["string","null"]},"premiumMessagingPartitions":{"type":["integer","null"],"format":"int32"},"privateEndpointConnectionCount":{"type":"integer","format":"int32","minimum":0},"provisioningState":{"type":["string","null"]},"publicNetworkAccess":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"resourceId":{"type":["string","null"]},"serviceBusEndpoint":{"type":["string","null"]},"skuCapacity":{"type":["integer","null"],"format":"int32"},"skuName":{"type":["string","null"]},"skuTier":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"QueueHeartbeatStatus"},"updatedAt":{"type":["string","null"]},"zoneRedundant":{"type":["boolean","null"]}},"x-readme-ref-name":"AzureServiceBusNamespaceHeartbeatData"},"resourceType":{"type":"string","enum":["azure_service_bus_namespace"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"allOf":[{"type":"object","required":["status","region"],"properties":{"region":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"AwsBedrockAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["awsBedrock"]}}}]},{"allOf":[{"type":"object","required":["status","project","location"],"properties":{"location":{"type":"string"},"project":{"type":"string"},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"GcpVertexAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["gcpVertex"]}}}]},{"allOf":[{"type":"object","required":["status","accountName"],"properties":{"accountName":{"type":"string"},"endpoint":{"type":["string","null"]},"location":{"type":["string","null"]},"resourceGroup":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"AzureFoundryAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["azureFoundry"]}}}]},{"allOf":[{"type":"object","required":["status","provider"],"properties":{"provider":{"type":"string","description":"The BYO-key provider serving this binding (e.g. \"openai\"). Used on the Local\nplatform, where the app brings its own provider key instead of an ambient cloud."},"status":{"type":"object","required":["health","lifecycle","stale","partial","collectionIssues"],"properties":{"collectionIssues":{"type":"array","items":{"type":"object","required":["source","reason","severity","message"],"properties":{"message":{"type":"string"},"reason":{"type":"string","enum":["forbidden","not-installed","api-unavailable","collection-failed","timed-out"],"x-readme-ref-name":"HeartbeatCollectionIssueReason"},"severity":{"type":"string","enum":["info","warning","error"],"x-readme-ref-name":"HeartbeatIssueSeverity"},"source":{"type":"string"}},"x-readme-ref-name":"HeartbeatCollectionIssue"}},"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]},"partial":{"type":"boolean"},"stale":{"type":"boolean"}},"x-readme-ref-name":"AiHeartbeatStatus"}},"x-readme-ref-name":"ExternalAiHeartbeatData"},{"type":"object","required":["backend"],"properties":{"backend":{"type":"string","enum":["external"]}}}]}],"x-readme-ref-name":"AiHeartbeatData"},"resourceType":{"type":"string","enum":["ai"]}}},{"type":"object","required":["data","resourceType"],"properties":{"data":{"oneOf":[{"type":"object","required":["data","provider"],"properties":{"data":{"type":"object","required":["status","keyArn","keyState","enabled","keySpec","keyUsage"],"properties":{"enabled":{"type":"boolean"},"keyArn":{"type":"string"},"keySpec":{"type":"string"},"keyState":{"type":"string"},"keyUsage":{"type":"string"},"status":{"type":"object","required":["health","lifecycle"],"properties":{"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]}},"x-readme-ref-name":"KeyHeartbeatStatus"}},"x-readme-ref-name":"AwsKmsKeyHeartbeatData"},"provider":{"type":"string","enum":["aws-kms"]}}},{"type":"object","required":["data","provider"],"properties":{"data":{"type":"object","required":["status","cryptoKeyName","purpose"],"properties":{"algorithm":{"type":["string","null"]},"cryptoKeyName":{"type":"string"},"primaryState":{"type":["string","null"]},"primaryVersion":{"type":["string","null"]},"purpose":{"type":"string"},"status":{"type":"object","required":["health","lifecycle"],"properties":{"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]}},"x-readme-ref-name":"KeyHeartbeatStatus"}},"x-readme-ref-name":"GcpCloudKmsKeyHeartbeatData"},"provider":{"type":"string","enum":["gcp-cloud-kms"]}}},{"type":"object","required":["data","provider"],"properties":{"data":{"type":"object","required":["status","keyId","keyType","keyOperations"],"properties":{"enabled":{"type":["boolean","null"]},"keyId":{"type":"string"},"keyOperations":{"type":"array","items":{"type":"string"}},"keyType":{"type":"string"},"recoveryLevel":{"type":["string","null"]},"status":{"type":"object","required":["health","lifecycle"],"properties":{"health":{"type":"string","enum":["unknown","healthy","degraded","unhealthy"],"x-readme-ref-name":"ObservedHealth"},"lifecycle":{"type":"string","enum":["unknown","creating","updating","running","scaling","stopping","stopped","deleting","deleted","failed"],"x-readme-ref-name":"ProviderLifecycleState"},"message":{"type":["string","null"]}},"x-readme-ref-name":"KeyHeartbeatStatus"}},"x-readme-ref-name":"AzureKeyVaultKeyHeartbeatData"},"provider":{"type":"string","enum":["azure-key-vault"]}}}],"x-readme-ref-name":"KeyHeartbeatData"},"resourceType":{"type":"string","enum":["key"]}}}],"x-readme-ref-name":"ResourceHeartbeatData"} \ No newline at end of file diff --git a/packages/core/src/generated/schemas/storage.json b/packages/core/src/generated/schemas/storage.json index 8b314a1fc..6f4582e42 100644 --- a/packages/core/src/generated/schemas/storage.json +++ b/packages/core/src/generated/schemas/storage.json @@ -1 +1 @@ -{"type":"object","description":"Represents an object storage bucket.","required":["id"],"properties":{"corsAllowedOrigins":{"type":"array","items":{"type":"string"},"description":"Browser origins allowed to read objects through signed URLs.\n\nWhen non-empty, providers configure CORS for `GET` and `HEAD` requests.\nAn origin of `*` is appropriate for private buckets whose signed URLs\nare bearer credentials and do not use browser cookies.\nDefault: `[]` (CORS disabled)."},"id":{"type":"string","description":"Name of the the storage bucket.\nFor names with dots, each dot-separated label must be ≤ 63 characters."},"lifecycleRules":{"type":"array","items":{"type":"object","description":"Defines a rule for managing the lifecycle of objects within a storage bucket.","required":["days"],"properties":{"days":{"type":"integer","format":"int32","description":"Number of days after which objects matching the rule expire.","minimum":0},"prefix":{"type":["string","null"],"description":"Optional prefix to filter objects the rule applies to. If None, applies to all objects."}},"additionalProperties":false,"x-readme-ref-name":"LifecycleRule"},"description":"List of rules for automatic object management (e.g., expiration).\nDefault: `[]` (empty list)"},"publicRead":{"type":"boolean","description":"Allows public read access to objects without authentication.\nDefault: `false`"},"versioning":{"type":"boolean","description":"Enables object versioning.\nDefault: `false`"}},"additionalProperties":false,"x-readme-ref-name":"Storage"} \ No newline at end of file +{"type":"object","description":"Represents an object storage bucket.","required":["id"],"properties":{"corsAllowedOrigins":{"type":"array","items":{"type":"string"},"description":"Browser origins allowed to read objects through signed URLs.\n\nWhen non-empty, providers configure CORS for `GET` and `HEAD` requests.\nAn origin of `*` is appropriate for private buckets whose signed URLs\nare bearer credentials and do not use browser cookies.\nDefault: `[]` (CORS disabled)."},"encryptionKey":{"oneOf":[{"type":"null"},{"description":"Customer-managed Key used by the provider's native storage encryption.","type":"object","required":["type","id"],"properties":{"id":{"type":"string"},"type":{"type":"string","description":"Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.","examples":["worker","storage","queue","redis","postgres"],"x-readme-ref-name":"ResourceType"}},"x-readme-ref-name":"ResourceRef"}]},"id":{"type":"string","description":"Name of the the storage bucket.\nFor names with dots, each dot-separated label must be ≤ 63 characters."},"lifecycleRules":{"type":"array","items":{"type":"object","description":"Defines a rule for managing the lifecycle of objects within a storage bucket.","required":["days"],"properties":{"days":{"type":"integer","format":"int32","description":"Number of days after which objects matching the rule expire.","minimum":0},"prefix":{"type":["string","null"],"description":"Optional prefix to filter objects the rule applies to. If None, applies to all objects."}},"additionalProperties":false,"x-readme-ref-name":"LifecycleRule"},"description":"List of rules for automatic object management (e.g., expiration).\nDefault: `[]` (empty list)"},"publicRead":{"type":"boolean","description":"Allows public read access to objects without authentication.\nDefault: `false`"},"versioning":{"type":"boolean","description":"Enables object versioning.\nDefault: `false`"}},"additionalProperties":false,"x-readme-ref-name":"Storage"} \ No newline at end of file diff --git a/packages/core/src/generated/zod/aws-key-import-data-schema.ts b/packages/core/src/generated/zod/aws-key-import-data-schema.ts new file mode 100644 index 000000000..ca0ea093b --- /dev/null +++ b/packages/core/src/generated/zod/aws-key-import-data-schema.ts @@ -0,0 +1,15 @@ +/** +* Generated by Kubb (https://kubb.dev/). +* Do not edit manually. +*/ + +import * as z from "zod"; + +/** + * @description AWS KMS key created by the customer-installed setup stack. + */ +export const AwsKeyImportDataSchema = z.object({ + "keyArn": z.string().describe("Immutable KMS key ARN. Alias ARNs are not accepted.") + }).describe("AWS KMS key created by the customer-installed setup stack.") + +export type AwsKeyImportData = z.infer \ No newline at end of file diff --git a/packages/core/src/generated/zod/aws-kms-key-heartbeat-data-schema.ts b/packages/core/src/generated/zod/aws-kms-key-heartbeat-data-schema.ts new file mode 100644 index 000000000..a09261049 --- /dev/null +++ b/packages/core/src/generated/zod/aws-kms-key-heartbeat-data-schema.ts @@ -0,0 +1,20 @@ +/** +* Generated by Kubb (https://kubb.dev/). +* Do not edit manually. +*/ + +import * as z from "zod"; +import { KeyHeartbeatStatusSchema } from "./key-heartbeat-status-schema.js"; + +export const AwsKmsKeyHeartbeatDataSchema = z.object({ + "enabled": z.boolean(), +"keyArn": z.string(), +"keySpec": z.string(), +"keyState": z.string(), +"keyUsage": z.string(), +get "status"(){ + return KeyHeartbeatStatusSchema + } + }) + +export type AwsKmsKeyHeartbeatData = z.infer \ No newline at end of file diff --git a/packages/core/src/generated/zod/azure-key-import-data-schema.ts b/packages/core/src/generated/zod/azure-key-import-data-schema.ts new file mode 100644 index 000000000..7d5b64f1f --- /dev/null +++ b/packages/core/src/generated/zod/azure-key-import-data-schema.ts @@ -0,0 +1,18 @@ +/** +* Generated by Kubb (https://kubb.dev/). +* Do not edit manually. +*/ + +import * as z from "zod"; + +/** + * @description Azure Key Vault key created by the customer-installed setup stack. + */ +export const AzureKeyImportDataSchema = z.object({ + "keyId": z.string().describe("Full versioned Key Vault key ID used for new wrapping operations."), +"keyName": z.string().describe("Key name within the vault."), +"lineageVersionId": z.string().describe("Version ID that identifies the original key lineage."), +"vaultResourceId": z.string().describe("ARM resource ID of the dedicated Key Vault.") + }).describe("Azure Key Vault key created by the customer-installed setup stack.") + +export type AzureKeyImportData = z.infer \ No newline at end of file diff --git a/packages/core/src/generated/zod/azure-key-vault-key-heartbeat-data-schema.ts b/packages/core/src/generated/zod/azure-key-vault-key-heartbeat-data-schema.ts new file mode 100644 index 000000000..7253fd8fd --- /dev/null +++ b/packages/core/src/generated/zod/azure-key-vault-key-heartbeat-data-schema.ts @@ -0,0 +1,20 @@ +/** +* Generated by Kubb (https://kubb.dev/). +* Do not edit manually. +*/ + +import * as z from "zod"; +import { KeyHeartbeatStatusSchema } from "./key-heartbeat-status-schema.js"; + +export const AzureKeyVaultKeyHeartbeatDataSchema = z.object({ + "enabled": z.boolean().nullish(), +"keyId": z.string(), +"keyOperations": z.array(z.string()), +"keyType": z.string(), +"recoveryLevel": z.string().nullish(), +get "status"(){ + return KeyHeartbeatStatusSchema + } + }) + +export type AzureKeyVaultKeyHeartbeatData = z.infer \ No newline at end of file diff --git a/packages/core/src/generated/zod/gcp-cloud-kms-key-heartbeat-data-schema.ts b/packages/core/src/generated/zod/gcp-cloud-kms-key-heartbeat-data-schema.ts new file mode 100644 index 000000000..ab3bd640f --- /dev/null +++ b/packages/core/src/generated/zod/gcp-cloud-kms-key-heartbeat-data-schema.ts @@ -0,0 +1,20 @@ +/** +* Generated by Kubb (https://kubb.dev/). +* Do not edit manually. +*/ + +import * as z from "zod"; +import { KeyHeartbeatStatusSchema } from "./key-heartbeat-status-schema.js"; + +export const GcpCloudKmsKeyHeartbeatDataSchema = z.object({ + "algorithm": z.string().nullish(), +"cryptoKeyName": z.string(), +"primaryState": z.string().nullish(), +"primaryVersion": z.string().nullish(), +"purpose": z.string(), +get "status"(){ + return KeyHeartbeatStatusSchema + } + }) + +export type GcpCloudKmsKeyHeartbeatData = z.infer \ No newline at end of file diff --git a/packages/core/src/generated/zod/gcp-key-import-data-schema.ts b/packages/core/src/generated/zod/gcp-key-import-data-schema.ts new file mode 100644 index 000000000..ae6fa97cc --- /dev/null +++ b/packages/core/src/generated/zod/gcp-key-import-data-schema.ts @@ -0,0 +1,16 @@ +/** +* Generated by Kubb (https://kubb.dev/). +* Do not edit manually. +*/ + +import * as z from "zod"; + +/** + * @description GCP Cloud KMS key created by the customer-installed setup stack. + */ +export const GcpKeyImportDataSchema = z.object({ + "cryptoKeyName": z.string().describe("Full CryptoKey resource name, without a CryptoKeyVersion."), +"primaryVersion": z.string().describe("Full primary CryptoKeyVersion resource name used for new wrapping operations.") + }).describe("GCP Cloud KMS key created by the customer-installed setup stack.") + +export type GcpKeyImportData = z.infer \ No newline at end of file diff --git a/packages/core/src/generated/zod/index.ts b/packages/core/src/generated/zod/index.ts index 625adf3c7..cb654209f 100644 --- a/packages/core/src/generated/zod/index.ts +++ b/packages/core/src/generated/zod/index.ts @@ -28,6 +28,8 @@ export type { AwsEmailDomainImportData } from "./aws-email-domain-import-data-sc export type { AwsEmailImportData } from "./aws-email-import-data-schema.js"; export type { AwsFailureDomainSubnets } from "./aws-failure-domain-subnets-schema.js"; export type { AwsIamRoleServiceAccountHeartbeatData } from "./aws-iam-role-service-account-heartbeat-data-schema.js"; +export type { AwsKeyImportData } from "./aws-key-import-data-schema.js"; +export type { AwsKmsKeyHeartbeatData } from "./aws-kms-key-heartbeat-data-schema.js"; export type { AwsKvImportData } from "./aws-kv-import-data-schema.js"; export type { AwsLambdaWorkerHeartbeatData } from "./aws-lambda-worker-heartbeat-data-schema.js"; export type { AwsManagementConfig } from "./aws-management-config-schema.js"; @@ -70,7 +72,9 @@ export type { AzureDaemonHeartbeatData } from "./azure-daemon-heartbeat-data-sch export type { AzureFlexibleServerPostgresHeartbeatData } from "./azure-flexible-server-postgres-heartbeat-data-schema.js"; export type { AzureFlexibleServerPostgresImportData } from "./azure-flexible-server-postgres-import-data-schema.js"; export type { AzureFoundryAiHeartbeatData } from "./azure-foundry-ai-heartbeat-data-schema.js"; +export type { AzureKeyImportData } from "./azure-key-import-data-schema.js"; export type { AzureKeyVaultHeartbeatData } from "./azure-key-vault-heartbeat-data-schema.js"; +export type { AzureKeyVaultKeyHeartbeatData } from "./azure-key-vault-key-heartbeat-data-schema.js"; export type { AzureKvImportData } from "./azure-kv-import-data-schema.js"; export type { AzureManagedIdentityServiceAccountHeartbeatData } from "./azure-managed-identity-service-account-heartbeat-data-schema.js"; export type { AzureManagementConfig } from "./azure-management-config-schema.js"; @@ -171,6 +175,7 @@ export type { GcpArtifactRegistryHeartbeatData } from "./gcp-artifact-registry-h export type { GcpArtifactRegistryImportData } from "./gcp-artifact-registry-import-data-schema.js"; export type { GcpBuildImportData } from "./gcp-build-import-data-schema.js"; export type { GcpCloudBuildHeartbeatData } from "./gcp-cloud-build-heartbeat-data-schema.js"; +export type { GcpCloudKmsKeyHeartbeatData } from "./gcp-cloud-kms-key-heartbeat-data-schema.js"; export type { GcpCloudRunWorkerHeartbeatData } from "./gcp-cloud-run-worker-heartbeat-data-schema.js"; export type { GcpCloudSqlPostgresHeartbeatData } from "./gcp-cloud-sql-postgres-heartbeat-data-schema.js"; export type { GcpCloudStorageHeartbeatData } from "./gcp-cloud-storage-heartbeat-data-schema.js"; @@ -180,6 +185,7 @@ export type { GcpCondition } from "./gcp-condition-schema.js"; export type { GcpCustomCertificateConfig } from "./gcp-custom-certificate-config-schema.js"; export type { GcpDaemonHeartbeatData } from "./gcp-daemon-heartbeat-data-schema.js"; export type { GcpFirestoreKvHeartbeatData } from "./gcp-firestore-kv-heartbeat-data-schema.js"; +export type { GcpKeyImportData } from "./gcp-key-import-data-schema.js"; export type { GcpKvImportData } from "./gcp-kv-import-data-schema.js"; export type { GcpManagementConfig } from "./gcp-management-config-schema.js"; export type { GcpNetworkImportData } from "./gcp-network-import-data-schema.js"; @@ -212,6 +218,11 @@ export type { HorizonWorkloadSchedulingMode } from "./horizon-workload-schedulin export type { HttpMethod } from "./http-method-schema.js"; export type { ImportSourceKind } from "./import-source-kind-schema.js"; export type { ImportedResource } from "./imported-resource-schema.js"; +export type { KeyFingerprint } from "./key-fingerprint-schema.js"; +export type { KeyHeartbeatData } from "./key-heartbeat-data-schema.js"; +export type { KeyHeartbeatStatus } from "./key-heartbeat-status-schema.js"; +export type { KeyOutputs } from "./key-outputs-schema.js"; +export type { Key } from "./key-schema.js"; export type { KubernetesBuildHeartbeatData } from "./kubernetes-build-heartbeat-data-schema.js"; export type { KubernetesCertificateMode } from "./kubernetes-certificate-mode-schema.js"; export type { KubernetesCloudReference } from "./kubernetes-cloud-reference-schema.js"; @@ -416,6 +427,8 @@ export { AwsEmailDomainImportDataSchema } from "./aws-email-domain-import-data-s export { AwsEmailImportDataSchema } from "./aws-email-import-data-schema.js"; export { AwsFailureDomainSubnetsSchema } from "./aws-failure-domain-subnets-schema.js"; export { AwsIamRoleServiceAccountHeartbeatDataSchema } from "./aws-iam-role-service-account-heartbeat-data-schema.js"; +export { AwsKeyImportDataSchema } from "./aws-key-import-data-schema.js"; +export { AwsKmsKeyHeartbeatDataSchema } from "./aws-kms-key-heartbeat-data-schema.js"; export { AwsKvImportDataSchema } from "./aws-kv-import-data-schema.js"; export { AwsLambdaWorkerHeartbeatDataSchema } from "./aws-lambda-worker-heartbeat-data-schema.js"; export { AwsManagementConfigSchema } from "./aws-management-config-schema.js"; @@ -458,7 +471,9 @@ export { AzureDaemonHeartbeatDataSchema } from "./azure-daemon-heartbeat-data-sc export { AzureFlexibleServerPostgresHeartbeatDataSchema } from "./azure-flexible-server-postgres-heartbeat-data-schema.js"; export { AzureFlexibleServerPostgresImportDataSchema } from "./azure-flexible-server-postgres-import-data-schema.js"; export { AzureFoundryAiHeartbeatDataSchema } from "./azure-foundry-ai-heartbeat-data-schema.js"; +export { AzureKeyImportDataSchema } from "./azure-key-import-data-schema.js"; export { AzureKeyVaultHeartbeatDataSchema } from "./azure-key-vault-heartbeat-data-schema.js"; +export { AzureKeyVaultKeyHeartbeatDataSchema } from "./azure-key-vault-key-heartbeat-data-schema.js"; export { AzureKvImportDataSchema } from "./azure-kv-import-data-schema.js"; export { AzureManagedIdentityServiceAccountHeartbeatDataSchema } from "./azure-managed-identity-service-account-heartbeat-data-schema.js"; export { AzureManagementConfigSchema } from "./azure-management-config-schema.js"; @@ -559,6 +574,7 @@ export { GcpArtifactRegistryHeartbeatDataSchema } from "./gcp-artifact-registry- export { GcpArtifactRegistryImportDataSchema } from "./gcp-artifact-registry-import-data-schema.js"; export { GcpBuildImportDataSchema } from "./gcp-build-import-data-schema.js"; export { GcpCloudBuildHeartbeatDataSchema } from "./gcp-cloud-build-heartbeat-data-schema.js"; +export { GcpCloudKmsKeyHeartbeatDataSchema } from "./gcp-cloud-kms-key-heartbeat-data-schema.js"; export { GcpCloudRunWorkerHeartbeatDataSchema } from "./gcp-cloud-run-worker-heartbeat-data-schema.js"; export { GcpCloudSqlPostgresHeartbeatDataSchema } from "./gcp-cloud-sql-postgres-heartbeat-data-schema.js"; export { GcpCloudStorageHeartbeatDataSchema } from "./gcp-cloud-storage-heartbeat-data-schema.js"; @@ -568,6 +584,7 @@ export { GcpConditionSchema } from "./gcp-condition-schema.js"; export { GcpCustomCertificateConfigSchema } from "./gcp-custom-certificate-config-schema.js"; export { GcpDaemonHeartbeatDataSchema } from "./gcp-daemon-heartbeat-data-schema.js"; export { GcpFirestoreKvHeartbeatDataSchema } from "./gcp-firestore-kv-heartbeat-data-schema.js"; +export { GcpKeyImportDataSchema } from "./gcp-key-import-data-schema.js"; export { GcpKvImportDataSchema } from "./gcp-kv-import-data-schema.js"; export { GcpManagementConfigSchema } from "./gcp-management-config-schema.js"; export { GcpNetworkImportDataSchema } from "./gcp-network-import-data-schema.js"; @@ -600,6 +617,11 @@ export { HorizonWorkloadSchedulingModeSchema } from "./horizon-workload-scheduli export { HttpMethodSchema } from "./http-method-schema.js"; export { ImportSourceKindSchema } from "./import-source-kind-schema.js"; export { ImportedResourceSchema } from "./imported-resource-schema.js"; +export { KeyFingerprintSchema } from "./key-fingerprint-schema.js"; +export { KeyHeartbeatDataSchema } from "./key-heartbeat-data-schema.js"; +export { KeyHeartbeatStatusSchema } from "./key-heartbeat-status-schema.js"; +export { KeyOutputsSchema } from "./key-outputs-schema.js"; +export { KeySchema } from "./key-schema.js"; export { KubernetesBuildHeartbeatDataSchema } from "./kubernetes-build-heartbeat-data-schema.js"; export { KubernetesCertificateModeSchema } from "./kubernetes-certificate-mode-schema.js"; export { KubernetesCloudReferenceSchema } from "./kubernetes-cloud-reference-schema.js"; diff --git a/packages/core/src/generated/zod/key-fingerprint-schema.ts b/packages/core/src/generated/zod/key-fingerprint-schema.ts new file mode 100644 index 000000000..3d0e04f6f --- /dev/null +++ b/packages/core/src/generated/zod/key-fingerprint-schema.ts @@ -0,0 +1,24 @@ +/** +* Generated by Kubb (https://kubb.dev/). +* Do not edit manually. +*/ + +import * as z from "zod"; + +/** + * @description Stable identity of a provider key family.\n\nProvider-native version rotation does not change this value. Replacing the\nprovider key does. + */ +export const KeyFingerprintSchema = z.union([z.object({ + "key_arn": z.string(), +"provider": z.enum(["aws"]) + }), z.object({ + "crypto_key_name": z.string(), +"provider": z.enum(["gcp"]) + }), z.object({ + "key_name": z.string(), +"lineage_version_id": z.string(), +"provider": z.enum(["azure"]), +"vault_resource_id": z.string() + })]).describe("Stable identity of a provider key family.\n\nProvider-native version rotation does not change this value. Replacing the\nprovider key does.") + +export type KeyFingerprint = z.infer \ No newline at end of file diff --git a/packages/core/src/generated/zod/key-heartbeat-data-schema.ts b/packages/core/src/generated/zod/key-heartbeat-data-schema.ts new file mode 100644 index 000000000..81d570a0b --- /dev/null +++ b/packages/core/src/generated/zod/key-heartbeat-data-schema.ts @@ -0,0 +1,28 @@ +/** +* Generated by Kubb (https://kubb.dev/). +* Do not edit manually. +*/ + +import * as z from "zod"; +import { AwsKmsKeyHeartbeatDataSchema } from "./aws-kms-key-heartbeat-data-schema.js"; +import { AzureKeyVaultKeyHeartbeatDataSchema } from "./azure-key-vault-key-heartbeat-data-schema.js"; +import { GcpCloudKmsKeyHeartbeatDataSchema } from "./gcp-cloud-kms-key-heartbeat-data-schema.js"; + +export const KeyHeartbeatDataSchema = z.union([z.object({ + get "data"(){ + return AwsKmsKeyHeartbeatDataSchema + }, +"provider": z.enum(["aws-kms"]) + }), z.object({ + get "data"(){ + return GcpCloudKmsKeyHeartbeatDataSchema + }, +"provider": z.enum(["gcp-cloud-kms"]) + }), z.object({ + get "data"(){ + return AzureKeyVaultKeyHeartbeatDataSchema + }, +"provider": z.enum(["azure-key-vault"]) + })]) + +export type KeyHeartbeatData = z.infer \ No newline at end of file diff --git a/packages/core/src/generated/zod/key-heartbeat-status-schema.ts b/packages/core/src/generated/zod/key-heartbeat-status-schema.ts new file mode 100644 index 000000000..996d931c5 --- /dev/null +++ b/packages/core/src/generated/zod/key-heartbeat-status-schema.ts @@ -0,0 +1,20 @@ +/** +* Generated by Kubb (https://kubb.dev/). +* Do not edit manually. +*/ + +import * as z from "zod"; +import { ObservedHealthSchema } from "./observed-health-schema.js"; +import { ProviderLifecycleStateSchema } from "./provider-lifecycle-state-schema.js"; + +export const KeyHeartbeatStatusSchema = z.object({ + get "health"(){ + return ObservedHealthSchema + }, +get "lifecycle"(){ + return ProviderLifecycleStateSchema + }, +"message": z.string().nullish() + }) + +export type KeyHeartbeatStatus = z.infer \ No newline at end of file diff --git a/packages/core/src/generated/zod/key-outputs-schema.ts b/packages/core/src/generated/zod/key-outputs-schema.ts new file mode 100644 index 000000000..ea93f2dda --- /dev/null +++ b/packages/core/src/generated/zod/key-outputs-schema.ts @@ -0,0 +1,19 @@ +/** +* Generated by Kubb (https://kubb.dev/). +* Do not edit manually. +*/ + +import * as z from "zod"; +import { KeyFingerprintSchema } from "./key-fingerprint-schema.js"; + +/** + * @description Outputs generated by a successfully provisioned Key. + */ +export const KeyOutputsSchema = z.object({ + get "fingerprint"(){ + return KeyFingerprintSchema.describe("Stable identity of a provider key family.\n\nProvider-native version rotation does not change this value. Replacing the\nprovider key does.") + }, +"wrappingKeyId": z.string().describe("Exact provider key version used for new wrapping operations.") + }).describe("Outputs generated by a successfully provisioned Key.") + +export type KeyOutputs = z.infer \ No newline at end of file diff --git a/packages/core/src/generated/zod/key-schema.ts b/packages/core/src/generated/zod/key-schema.ts new file mode 100644 index 000000000..360ab7eab --- /dev/null +++ b/packages/core/src/generated/zod/key-schema.ts @@ -0,0 +1,15 @@ +/** +* Generated by Kubb (https://kubb.dev/). +* Do not edit manually. +*/ + +import * as z from "zod"; + +/** + * @description A customer-managed encryption key. + */ +export const KeySchema = z.object({ + "id": z.string().describe("Identifier for the key resource.") + }).describe("A customer-managed encryption key.") + +export type Key = z.infer \ No newline at end of file diff --git a/packages/core/src/generated/zod/resource-heartbeat-data-schema.ts b/packages/core/src/generated/zod/resource-heartbeat-data-schema.ts index af19316e6..d59f3f55b 100644 --- a/packages/core/src/generated/zod/resource-heartbeat-data-schema.ts +++ b/packages/core/src/generated/zod/resource-heartbeat-data-schema.ts @@ -14,6 +14,7 @@ import { BuildHeartbeatDataSchema } from "./build-heartbeat-data-schema.js"; import { ComputeClusterHeartbeatDataSchema } from "./compute-cluster-heartbeat-data-schema.js"; import { ContainerHeartbeatDataSchema } from "./container-heartbeat-data-schema.js"; import { DaemonHeartbeatDataSchema } from "./daemon-heartbeat-data-schema.js"; +import { KeyHeartbeatDataSchema } from "./key-heartbeat-data-schema.js"; import { KubernetesClusterHeartbeatDataSchema } from "./kubernetes-cluster-heartbeat-data-schema.js"; import { KvHeartbeatDataSchema } from "./kv-heartbeat-data-schema.js"; import { NetworkHeartbeatDataSchema } from "./network-heartbeat-data-schema.js"; @@ -131,6 +132,11 @@ export const ResourceHeartbeatDataSchema = z.union([z.object({ return AiHeartbeatDataSchema }, "resourceType": z.enum(["ai"]) + }), z.object({ + get "data"(){ + return KeyHeartbeatDataSchema + }, +"resourceType": z.enum(["key"]) })]) export type ResourceHeartbeatData = z.infer \ No newline at end of file diff --git a/packages/core/src/generated/zod/storage-schema.ts b/packages/core/src/generated/zod/storage-schema.ts index 6aaedea18..fe2c883bd 100644 --- a/packages/core/src/generated/zod/storage-schema.ts +++ b/packages/core/src/generated/zod/storage-schema.ts @@ -5,12 +5,16 @@ import * as z from "zod"; import { LifecycleRuleSchema } from "./lifecycle-rule-schema.js"; +import { ResourceRefSchema } from "./resource-ref-schema.js"; /** * @description Represents an object storage bucket. */ export const StorageSchema = z.object({ "corsAllowedOrigins": z.optional(z.array(z.string()).describe("Browser origins allowed to read objects through signed URLs.\n\nWhen non-empty, providers configure CORS for `GET` and `HEAD` requests.\nAn origin of `*` is appropriate for private buckets whose signed URLs\nare bearer credentials and do not use browser cookies.\nDefault: `[]` (CORS disabled).")), +get "encryptionKey"(){ + return z.union([ResourceRefSchema, z.null()]).optional() + }, "id": z.string().describe("Name of the the storage bucket.\nFor names with dots, each dot-separated label must be ≤ 63 characters."), get "lifecycleRules"(){ return z.array(LifecycleRuleSchema.describe("Defines a rule for managing the lifecycle of objects within a storage bucket.")).describe("List of rules for automatic object management (e.g., expiration).\nDefault: `[]` (empty list)").optional() diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts index 6dce13bbb..a4af44daa 100644 --- a/packages/core/src/index.ts +++ b/packages/core/src/index.ts @@ -1,6 +1,5 @@ // ResourceBuilder is internal glue shared by the builders, not an extension // point. Exporting it would commit us to its shape at the next publish. - export * from "./ai.js" export * from "./artifact-registry.js" export * from "./build.js" @@ -12,6 +11,7 @@ export * from "./email.js" export * from "./error.js" export * from "./get-resource-outputs.js" export * from "./input.js" +export * from "./key.js" export * from "./kv.js" export * from "./postgres.js" export * from "./queue.js" diff --git a/packages/core/src/key.ts b/packages/core/src/key.ts new file mode 100644 index 000000000..fda0f9c79 --- /dev/null +++ b/packages/core/src/key.ts @@ -0,0 +1,24 @@ +import { type Key as KeyConfig, KeySchema, type ResourceType } from "./generated/index.js" +import { type Resource, ResourceBuilder } from "./resource.js" + +export type { Key as KeyConfig, KeyFingerprint, KeyOutputs } from "./generated/index.js" +export { KeySchema as KeyConfigSchema } from "./generated/index.js" + +/** A customer-managed encryption key. */ +export class Key extends ResourceBuilder { + private _config: Partial = {} + + public constructor(id: string) { + super() + this._config.id = id + } + + public static any(): ResourceType { + return "key" + } + + public build(): Resource { + const config = KeySchema.parse(this._config) + return this.resource({ type: "key", ...config }) + } +} diff --git a/packages/core/src/storage.ts b/packages/core/src/storage.ts index 7260d70bf..d26497cb9 100644 --- a/packages/core/src/storage.ts +++ b/packages/core/src/storage.ts @@ -82,6 +82,20 @@ export class Storage extends ResourceBuilder { return this } + /** + * Uses an Alien Key for provider-native encryption of objects in this Storage resource. + * The Key and Storage must both be added to the same stack. + */ + public encryptionKey(key: Resource): this { + if (key.config.type !== "key") { + throw new Error( + `Storage.encryptionKey() requires an alien.Key, received '${key.config.type}'`, + ) + } + this._config.encryptionKey = key.ref() + return this + } + /** * Builds and validates the storage configuration. * @returns An immutable Resource representing the configured storage bucket. diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 13fbd4d47..e59203e15 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -321,6 +321,19 @@ importers: specifier: ^4.0.0 version: 4.1.10(@types/node@24.13.3)(msw@2.12.7(@types/node@24.13.3)(typescript@5.9.3))(vite@7.3.0(@types/node@24.13.3)(jiti@2.7.0)(lightningcss@1.31.1)(tsx@4.21.0)) + tests/e2e/test-apps/byo-encryption-key: + dependencies: + '@alienplatform/core': + specifier: link:../../../../packages/core + version: link:../../../../packages/core + devDependencies: + '@alienplatform/typescript-config': + specifier: link:../../../../packages/config-typescript + version: link:../../../../packages/config-typescript + typescript: + specifier: ^5.7.3 + version: 5.8.3 + tests/e2e/test-apps/comprehensive-rust: devDependencies: '@alienplatform/core': diff --git a/tests/e2e/test-apps/byo-encryption-key/alien.ts b/tests/e2e/test-apps/byo-encryption-key/alien.ts new file mode 100644 index 000000000..060cd8597 --- /dev/null +++ b/tests/e2e/test-apps/byo-encryption-key/alien.ts @@ -0,0 +1,9 @@ +import * as alien from "@alienplatform/core" + +const enterpriseKey = new alien.Key("enterprise-key").build() +const storage = new alien.Storage("encrypted-storage").encryptionKey(enterpriseKey).build() + +export default new alien.Stack("byo-encryption-key") + .add(enterpriseKey, "frozen", { remoteAccess: true }) + .add(storage, "frozen") + .build() diff --git a/tests/e2e/test-apps/byo-encryption-key/package.json b/tests/e2e/test-apps/byo-encryption-key/package.json new file mode 100644 index 000000000..d83f7467c --- /dev/null +++ b/tests/e2e/test-apps/byo-encryption-key/package.json @@ -0,0 +1,13 @@ +{ + "name": "byo-encryption-key", + "version": "1.0.0", + "type": "module", + "private": true, + "dependencies": { + "@alienplatform/core": "workspace:*" + }, + "devDependencies": { + "@alienplatform/typescript-config": "workspace:*", + "typescript": "^5.7.3" + } +} diff --git a/tests/e2e/test-apps/byo-encryption-key/tsconfig.json b/tests/e2e/test-apps/byo-encryption-key/tsconfig.json new file mode 100644 index 000000000..b929b06a3 --- /dev/null +++ b/tests/e2e/test-apps/byo-encryption-key/tsconfig.json @@ -0,0 +1,3 @@ +{ + "extends": "@alienplatform/typescript-config/base.json" +}