Add Entity kind Repository

.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.

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;

src/datadogV2/model/model_entity_v3.rs

@@ -13,6 +13,7 @@ pub enum EntityV3 {
     EntityV3Queue(Box<crate::datadogV2::model::EntityV3Queue>),
     EntityV3System(Box<crate::datadogV2::model::EntityV3System>),
     EntityV3API(Box<crate::datadogV2::model::EntityV3API>),
+    EntityV3Repository(Box<crate::datadogV2::model::EntityV3Repository>),
     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::<Box<crate::datadogV2::model::EntityV3Repository>>(
+            value.clone(),
+        ) {
+            if !_v._unparsed {
+                return Ok(EntityV3::EntityV3Repository(_v));
+            }
+        }
 
         return Ok(EntityV3::UnparsedObject(crate::datadog::UnparsedObject {
             value,

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<crate::datadogV2::model::EntityV3RepositoryDatadog>,
+    /// 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<std::collections::BTreeMap<String, serde_json::Value>>,
+    /// A base schema for defining third-party integrations.
+    #[serde(rename = "integrations")]
+    pub integrations: Option<crate::datadogV2::model::EntityV3Integrations>,
+    /// 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<crate::datadogV2::model::EntityV3RepositorySpec>,
+    #[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<String, serde_json::Value>,
+    ) -> 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<D>(deserializer: D) -> Result<Self, D::Error>
+    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<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+            where
+                M: MapAccess<'a>,
+            {
+                let mut api_version: Option<crate::datadogV2::model::EntityV3APIVersion> = None;
+                let mut datadog: Option<crate::datadogV2::model::EntityV3RepositoryDatadog> = None;
+                let mut extensions: Option<std::collections::BTreeMap<String, serde_json::Value>> =
+                    None;
+                let mut integrations: Option<crate::datadogV2::model::EntityV3Integrations> = None;
+                let mut kind: Option<crate::datadogV2::model::EntityV3RepositoryKind> = None;
+                let mut metadata: Option<crate::datadogV2::model::EntityV3Metadata> = None;
+                let mut spec: Option<crate::datadogV2::model::EntityV3RepositorySpec> = None;
+                let mut _unparsed = false;
+
+                while let Some((k, v)) = map.next_entry::<String, serde_json::Value>()? {
+                    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)
+    }
+}