From 4aab171a42d567a1a0916864ad4883f0b4d9751c Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Wed, 22 Jul 2026 17:26:14 +0000 Subject: [PATCH] Regenerate client from commit 8e56bc6 of spec repo --- .generator/schemas/v2/openapi.yaml | 83 ++++++++ src/datadogV2/model/mod.rs | 8 + src/datadogV2/model/model_entity_v3.rs | 8 + .../model/model_entity_v3_repository.rs | 193 ++++++++++++++++++ .../model_entity_v3_repository_datadog.rs | 170 +++++++++++++++ .../model/model_entity_v3_repository_kind.rs | 48 +++++ .../model/model_entity_v3_repository_spec.rs | 176 ++++++++++++++++ 7 files changed, 686 insertions(+) create mode 100644 src/datadogV2/model/model_entity_v3_repository.rs create mode 100644 src/datadogV2/model/model_entity_v3_repository_datadog.rs create mode 100644 src/datadogV2/model/model_entity_v3_repository_kind.rs create mode 100644 src/datadogV2/model/model_entity_v3_repository_spec.rs diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 90e1196820..7fd739443a 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -34676,6 +34676,7 @@ components: - $ref: "#/components/schemas/EntityV3Queue" - $ref: "#/components/schemas/EntityV3System" - $ref: "#/components/schemas/EntityV3API" + - $ref: "#/components/schemas/EntityV3Repository" EntityV3API: additionalProperties: false description: Schema for API entities. @@ -35151,6 +35152,88 @@ components: description: The type of queue. type: string type: object + EntityV3Repository: + additionalProperties: false + description: Schema for repository entities. + properties: + apiVersion: + $ref: "#/components/schemas/EntityV3APIVersion" + datadog: + $ref: "#/components/schemas/EntityV3RepositoryDatadog" + extensions: + additionalProperties: {} + description: Custom extensions. This is the free-formed field to send client-side metadata. No Datadog features are affected by this field. + type: object + integrations: + $ref: "#/components/schemas/EntityV3Integrations" + kind: + $ref: "#/components/schemas/EntityV3RepositoryKind" + metadata: + $ref: "#/components/schemas/EntityV3Metadata" + spec: + $ref: "#/components/schemas/EntityV3RepositorySpec" + required: + - apiVersion + - kind + - metadata + type: object + EntityV3RepositoryDatadog: + additionalProperties: false + description: Datadog product integrations for the repository entity. + properties: + codeLocations: + $ref: "#/components/schemas/EntityV3DatadogCodeLocations" + events: + $ref: "#/components/schemas/EntityV3DatadogEvents" + logs: + $ref: "#/components/schemas/EntityV3DatadogLogs" + performanceData: + $ref: "#/components/schemas/EntityV3DatadogPerformance" + pipelines: + $ref: "#/components/schemas/EntityV3DatadogPipelines" + type: object + EntityV3RepositoryKind: + description: The definition of Entity V3 Repository Kind object. + enum: + - repository + example: repository + type: string + x-enum-varnames: + - REPOSITORY + EntityV3RepositorySpec: + additionalProperties: false + description: The definition of Entity V3 Repository Spec object. + properties: + componentOf: + description: A list of components the repository is a part of. + items: + description: A component entity reference string. + type: string + type: array + dependencyOf: + description: A list of components that the repository is a dependency of. + items: + description: A component entity reference string. + type: string + type: array + dependsOn: + description: A list of components that the repository depends on. + items: + description: A component entity reference string. + type: string + type: array + lifecycle: + description: The lifecycle state of the repository. + minLength: 1 + type: string + tier: + description: The importance of the repository. + minLength: 1 + type: string + type: + description: The type of repository. + type: string + type: object EntityV3Service: additionalProperties: false description: Schema for service entities. diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index afd71a72d4..2766679832 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -2020,6 +2020,14 @@ pub mod model_entity_v3_api_spec_interface_definition; pub use self::model_entity_v3_api_spec_interface_definition::EntityV3APISpecInterfaceDefinition; pub mod model_entity_v3_api_spec_interface; pub use self::model_entity_v3_api_spec_interface::EntityV3APISpecInterface; +pub mod model_entity_v3_repository; +pub use self::model_entity_v3_repository::EntityV3Repository; +pub mod model_entity_v3_repository_datadog; +pub use self::model_entity_v3_repository_datadog::EntityV3RepositoryDatadog; +pub mod model_entity_v3_repository_kind; +pub use self::model_entity_v3_repository_kind::EntityV3RepositoryKind; +pub mod model_entity_v3_repository_spec; +pub use self::model_entity_v3_repository_spec::EntityV3RepositorySpec; pub mod model_entity_v3; pub use self::model_entity_v3::EntityV3; pub mod model_entity_response_included_schema_type; diff --git a/src/datadogV2/model/model_entity_v3.rs b/src/datadogV2/model/model_entity_v3.rs index 57d802589f..abfa755502 100644 --- a/src/datadogV2/model/model_entity_v3.rs +++ b/src/datadogV2/model/model_entity_v3.rs @@ -13,6 +13,7 @@ pub enum EntityV3 { EntityV3Queue(Box), EntityV3System(Box), EntityV3API(Box), + EntityV3Repository(Box), UnparsedObject(crate::datadog::UnparsedObject), } @@ -57,6 +58,13 @@ impl<'de> Deserialize<'de> for EntityV3 { return Ok(EntityV3::EntityV3API(_v)); } } + if let Ok(_v) = serde_json::from_value::>( + value.clone(), + ) { + if !_v._unparsed { + return Ok(EntityV3::EntityV3Repository(_v)); + } + } return Ok(EntityV3::UnparsedObject(crate::datadog::UnparsedObject { value, diff --git a/src/datadogV2/model/model_entity_v3_repository.rs b/src/datadogV2/model/model_entity_v3_repository.rs new file mode 100644 index 0000000000..b345e48132 --- /dev/null +++ b/src/datadogV2/model/model_entity_v3_repository.rs @@ -0,0 +1,193 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Schema for repository entities. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct EntityV3Repository { + /// The version of the schema data that was used to populate this entity's data. This could be via the API, Terraform, or YAML file in a repository. The field is known as schema-version in the previous version. + #[serde(rename = "apiVersion")] + pub api_version: crate::datadogV2::model::EntityV3APIVersion, + /// Datadog product integrations for the repository entity. + #[serde(rename = "datadog")] + pub datadog: Option, + /// Custom extensions. This is the free-formed field to send client-side metadata. No Datadog features are affected by this field. + #[serde(rename = "extensions")] + pub extensions: Option>, + /// A base schema for defining third-party integrations. + #[serde(rename = "integrations")] + pub integrations: Option, + /// The definition of Entity V3 Repository Kind object. + #[serde(rename = "kind")] + pub kind: crate::datadogV2::model::EntityV3RepositoryKind, + /// The definition of Entity V3 Metadata object. + #[serde(rename = "metadata")] + pub metadata: crate::datadogV2::model::EntityV3Metadata, + /// The definition of Entity V3 Repository Spec object. + #[serde(rename = "spec")] + pub spec: Option, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl EntityV3Repository { + pub fn new( + api_version: crate::datadogV2::model::EntityV3APIVersion, + kind: crate::datadogV2::model::EntityV3RepositoryKind, + metadata: crate::datadogV2::model::EntityV3Metadata, + ) -> EntityV3Repository { + EntityV3Repository { + api_version, + datadog: None, + extensions: None, + integrations: None, + kind, + metadata, + spec: None, + _unparsed: false, + } + } + + pub fn datadog(mut self, value: crate::datadogV2::model::EntityV3RepositoryDatadog) -> Self { + self.datadog = Some(value); + self + } + + pub fn extensions( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.extensions = Some(value); + self + } + + pub fn integrations(mut self, value: crate::datadogV2::model::EntityV3Integrations) -> Self { + self.integrations = Some(value); + self + } + + pub fn spec(mut self, value: crate::datadogV2::model::EntityV3RepositorySpec) -> Self { + self.spec = Some(value); + self + } +} + +impl<'de> Deserialize<'de> for EntityV3Repository { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct EntityV3RepositoryVisitor; + impl<'a> Visitor<'a> for EntityV3RepositoryVisitor { + type Value = EntityV3Repository; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut api_version: Option = None; + let mut datadog: Option = None; + let mut extensions: Option> = + None; + let mut integrations: Option = None; + let mut kind: Option = None; + let mut metadata: Option = None; + let mut spec: Option = None; + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "apiVersion" => { + api_version = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _api_version) = api_version { + match _api_version { + crate::datadogV2::model::EntityV3APIVersion::UnparsedObject( + _api_version, + ) => { + _unparsed = true; + } + _ => {} + } + } + } + "datadog" => { + if v.is_null() { + continue; + } + datadog = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "extensions" => { + if v.is_null() { + continue; + } + extensions = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "integrations" => { + if v.is_null() { + continue; + } + integrations = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "kind" => { + kind = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _kind) = kind { + match _kind { + crate::datadogV2::model::EntityV3RepositoryKind::UnparsedObject(_kind) => { + _unparsed = true; + }, + _ => {} + } + } + } + "metadata" => { + metadata = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "spec" => { + if v.is_null() { + continue; + } + spec = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + return Err(serde::de::Error::custom( + "Additional properties not allowed", + )); + } + } + } + let api_version = + api_version.ok_or_else(|| M::Error::missing_field("api_version"))?; + let kind = kind.ok_or_else(|| M::Error::missing_field("kind"))?; + let metadata = metadata.ok_or_else(|| M::Error::missing_field("metadata"))?; + + let content = EntityV3Repository { + api_version, + datadog, + extensions, + integrations, + kind, + metadata, + spec, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(EntityV3RepositoryVisitor) + } +} diff --git a/src/datadogV2/model/model_entity_v3_repository_datadog.rs b/src/datadogV2/model/model_entity_v3_repository_datadog.rs new file mode 100644 index 0000000000..c073afd2a5 --- /dev/null +++ b/src/datadogV2/model/model_entity_v3_repository_datadog.rs @@ -0,0 +1,170 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Datadog product integrations for the repository entity. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct EntityV3RepositoryDatadog { + /// Schema for mapping source code locations to an entity. + #[serde(rename = "codeLocations")] + pub code_locations: Option>, + /// Events associations. + #[serde(rename = "events")] + pub events: Option>, + /// Logs association. + #[serde(rename = "logs")] + pub logs: Option>, + /// Performance stats association. + #[serde(rename = "performanceData")] + pub performance_data: Option, + /// CI Pipelines association. + #[serde(rename = "pipelines")] + pub pipelines: Option, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl EntityV3RepositoryDatadog { + pub fn new() -> EntityV3RepositoryDatadog { + EntityV3RepositoryDatadog { + code_locations: None, + events: None, + logs: None, + performance_data: None, + pipelines: None, + _unparsed: false, + } + } + + pub fn code_locations( + mut self, + value: Vec, + ) -> Self { + self.code_locations = Some(value); + self + } + + pub fn events(mut self, value: Vec) -> Self { + self.events = Some(value); + self + } + + pub fn logs(mut self, value: Vec) -> Self { + self.logs = Some(value); + self + } + + pub fn performance_data( + mut self, + value: crate::datadogV2::model::EntityV3DatadogPerformance, + ) -> Self { + self.performance_data = Some(value); + self + } + + pub fn pipelines(mut self, value: crate::datadogV2::model::EntityV3DatadogPipelines) -> Self { + self.pipelines = Some(value); + self + } +} + +impl Default for EntityV3RepositoryDatadog { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for EntityV3RepositoryDatadog { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct EntityV3RepositoryDatadogVisitor; + impl<'a> Visitor<'a> for EntityV3RepositoryDatadogVisitor { + type Value = EntityV3RepositoryDatadog; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut code_locations: Option< + Vec, + > = None; + let mut events: Option> = + None; + let mut logs: Option> = None; + let mut performance_data: Option< + crate::datadogV2::model::EntityV3DatadogPerformance, + > = None; + let mut pipelines: Option = None; + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "codeLocations" => { + if v.is_null() { + continue; + } + code_locations = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "events" => { + if v.is_null() { + continue; + } + events = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "logs" => { + if v.is_null() { + continue; + } + logs = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "performanceData" => { + if v.is_null() { + continue; + } + performance_data = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "pipelines" => { + if v.is_null() { + continue; + } + pipelines = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + return Err(serde::de::Error::custom( + "Additional properties not allowed", + )); + } + } + } + + let content = EntityV3RepositoryDatadog { + code_locations, + events, + logs, + performance_data, + pipelines, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(EntityV3RepositoryDatadogVisitor) + } +} diff --git a/src/datadogV2/model/model_entity_v3_repository_kind.rs b/src/datadogV2/model/model_entity_v3_repository_kind.rs new file mode 100644 index 0000000000..19f8fa55ae --- /dev/null +++ b/src/datadogV2/model/model_entity_v3_repository_kind.rs @@ -0,0 +1,48 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum EntityV3RepositoryKind { + REPOSITORY, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for EntityV3RepositoryKind { + fn to_string(&self) -> String { + match self { + Self::REPOSITORY => String::from("repository"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for EntityV3RepositoryKind { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for EntityV3RepositoryKind { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "repository" => Self::REPOSITORY, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_entity_v3_repository_spec.rs b/src/datadogV2/model/model_entity_v3_repository_spec.rs new file mode 100644 index 0000000000..ad8f165a14 --- /dev/null +++ b/src/datadogV2/model/model_entity_v3_repository_spec.rs @@ -0,0 +1,176 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// The definition of Entity V3 Repository Spec object. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct EntityV3RepositorySpec { + /// A list of components the repository is a part of. + #[serde(rename = "componentOf")] + pub component_of: Option>, + /// A list of components that the repository is a dependency of. + #[serde(rename = "dependencyOf")] + pub dependency_of: Option>, + /// A list of components that the repository depends on. + #[serde(rename = "dependsOn")] + pub depends_on: Option>, + /// The lifecycle state of the repository. + #[serde(rename = "lifecycle")] + pub lifecycle: Option, + /// The importance of the repository. + #[serde(rename = "tier")] + pub tier: Option, + /// The type of repository. + #[serde(rename = "type")] + pub type_: Option, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl EntityV3RepositorySpec { + pub fn new() -> EntityV3RepositorySpec { + EntityV3RepositorySpec { + component_of: None, + dependency_of: None, + depends_on: None, + lifecycle: None, + tier: None, + type_: None, + _unparsed: false, + } + } + + pub fn component_of(mut self, value: Vec) -> Self { + self.component_of = Some(value); + self + } + + pub fn dependency_of(mut self, value: Vec) -> Self { + self.dependency_of = Some(value); + self + } + + pub fn depends_on(mut self, value: Vec) -> Self { + self.depends_on = Some(value); + self + } + + pub fn lifecycle(mut self, value: String) -> Self { + self.lifecycle = Some(value); + self + } + + pub fn tier(mut self, value: String) -> Self { + self.tier = Some(value); + self + } + + pub fn type_(mut self, value: String) -> Self { + self.type_ = Some(value); + self + } +} + +impl Default for EntityV3RepositorySpec { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for EntityV3RepositorySpec { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct EntityV3RepositorySpecVisitor; + impl<'a> Visitor<'a> for EntityV3RepositorySpecVisitor { + type Value = EntityV3RepositorySpec; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut component_of: Option> = None; + let mut dependency_of: Option> = None; + let mut depends_on: Option> = None; + let mut lifecycle: Option = None; + let mut tier: Option = None; + let mut type_: Option = None; + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "componentOf" => { + if v.is_null() { + continue; + } + component_of = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "dependencyOf" => { + if v.is_null() { + continue; + } + dependency_of = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "dependsOn" => { + if v.is_null() { + continue; + } + depends_on = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "lifecycle" => { + if v.is_null() { + continue; + } + lifecycle = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "tier" => { + if v.is_null() { + continue; + } + tier = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + if v.is_null() { + continue; + } + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + return Err(serde::de::Error::custom( + "Additional properties not allowed", + )); + } + } + } + + let content = EntityV3RepositorySpec { + component_of, + dependency_of, + depends_on, + lifecycle, + tier, + type_, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(EntityV3RepositorySpecVisitor) + } +}