Add support for Entity kind API

.apigentools-info

@@ -4,13 +4,13 @@
     "spec_versions": {
         "v1": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-01-31 15:03:07.218117",
-            "spec_repo_commit": "b01f90f4"
+            "regenerated": "2025-02-03 15:47:55.976108",
+            "spec_repo_commit": "d6014add"
         },
         "v2": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-01-31 15:03:07.236273",
-            "spec_repo_commit": "b01f90f4"
+            "regenerated": "2025-02-03 15:47:55.991637",
+            "spec_repo_commit": "d6014add"
         }
     }
 }

.generator/schemas/v2/openapi.yaml

@@ -10524,6 +10524,99 @@ components:
       - $ref: '#/components/schemas/EntityV3Datastore'
       - $ref: '#/components/schemas/EntityV3Queue'
       - $ref: '#/components/schemas/EntityV3System'
+      - $ref: '#/components/schemas/EntityV3API'
+    EntityV3API:
+      additionalProperties: false
+      description: Schema for API entities.
+      properties:
+        apiVersion:
+          $ref: '#/components/schemas/EntityV3APIVersion'
+        datadog:
+          $ref: '#/components/schemas/EntityV3APIDatadog'
+        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/EntityV3APIKind'
+        metadata:
+          $ref: '#/components/schemas/EntityV3Metadata'
+        spec:
+          $ref: '#/components/schemas/EntityV3APISpec'
+      required:
+      - apiVersion
+      - kind
+      - metadata
+      type: object
+    EntityV3APIDatadog:
+      additionalProperties: false
+      description: Datadog product integrations for the API 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
+    EntityV3APIKind:
+      description: The definition of Entity V3 API Kind object.
+      enum:
+      - api
+      example: api
+      type: string
+      x-enum-varnames:
+      - API
+    EntityV3APISpec:
+      additionalProperties: false
+      description: The definition of Entity V3 API Spec object.
+      properties:
+        implementedBy:
+          description: Services which implemented the API.
+          items:
+            type: string
+          type: array
+        interface:
+          $ref: '#/components/schemas/EntityV3APISpecInterface'
+        lifecycle:
+          description: The lifecycle state of the component.
+          minLength: 1
+          type: string
+        tier:
+          description: The importance of the component.
+          minLength: 1
+          type: string
+        type:
+          description: The type of API.
+          type: string
+      type: object
+    EntityV3APISpecInterface:
+      additionalProperties: false
+      description: The API definition.
+      oneOf:
+      - $ref: '#/components/schemas/EntityV3APISpecInterfaceFileRef'
+      - $ref: '#/components/schemas/EntityV3APISpecInterfaceDefinition'
+    EntityV3APISpecInterfaceDefinition:
+      additionalProperties: false
+      description: The definition of `EntityV3APISpecInterfaceDefinition` object.
+      properties:
+        definition:
+          description: The API definition.
+          type: object
+    EntityV3APISpecInterfaceFileRef:
+      additionalProperties: false
+      description: The definition of `EntityV3APISpecInterfaceFileRef` object.
+      properties:
+        fileRef:
+          description: The reference to the API definition file.
+          type: string
     EntityV3APIVersion:
       description: The schema version of entity type. The field is known as schema-version
         in the previous version.

src/datadogV2/model/mod.rs

@@ -706,6 +706,20 @@ pub mod model_entity_v3_system_kind;
 pub use self::model_entity_v3_system_kind::EntityV3SystemKind;
 pub mod model_entity_v3_system_spec;
 pub use self::model_entity_v3_system_spec::EntityV3SystemSpec;
+pub mod model_entity_v3_api;
+pub use self::model_entity_v3_api::EntityV3API;
+pub mod model_entity_v3_api_datadog;
+pub use self::model_entity_v3_api_datadog::EntityV3APIDatadog;
+pub mod model_entity_v3_api_kind;
+pub use self::model_entity_v3_api_kind::EntityV3APIKind;
+pub mod model_entity_v3_api_spec;
+pub use self::model_entity_v3_api_spec::EntityV3APISpec;
+pub mod model_entity_v3_api_spec_interface_file_ref;
+pub use self::model_entity_v3_api_spec_interface_file_ref::EntityV3APISpecInterfaceFileRef;
+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;
 pub use self::model_entity_v3::EntityV3;
 pub mod model_entity_response_included_raw_schema;

src/datadogV2/model/model_entity_v3.rs

@@ -12,6 +12,7 @@ pub enum EntityV3 {
     EntityV3Datastore(Box<crate::datadogV2::model::EntityV3Datastore>),
     EntityV3Queue(Box<crate::datadogV2::model::EntityV3Queue>),
     EntityV3System(Box<crate::datadogV2::model::EntityV3System>),
+    EntityV3API(Box<crate::datadogV2::model::EntityV3API>),
     UnparsedObject(crate::datadog::UnparsedObject),
 }
 
@@ -49,6 +50,13 @@ impl<'de> Deserialize<'de> for EntityV3 {
                 return Ok(EntityV3::EntityV3System(_v));
             }
         }
+        if let Ok(_v) =
+            serde_json::from_value::<Box<crate::datadogV2::model::EntityV3API>>(value.clone())
+        {
+            if !_v._unparsed {
+                return Ok(EntityV3::EntityV3API(_v));
+            }
+        }
 
         return Ok(EntityV3::UnparsedObject(crate::datadog::UnparsedObject {
             value,

src/datadogV2/model/model_entity_v3_api.rs

@@ -0,0 +1,195 @@
+// 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 API entities.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct EntityV3API {
+    /// The schema version of entity type. 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 API entity.
+    #[serde(rename = "datadog")]
+    pub datadog: Option<crate::datadogV2::model::EntityV3APIDatadog>,
+    /// 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 API Kind object.
+    #[serde(rename = "kind")]
+    pub kind: crate::datadogV2::model::EntityV3APIKind,
+    /// The definition of Entity V3 Metadata object.
+    #[serde(rename = "metadata")]
+    pub metadata: crate::datadogV2::model::EntityV3Metadata,
+    /// The definition of Entity V3 API Spec object.
+    #[serde(rename = "spec")]
+    pub spec: Option<crate::datadogV2::model::EntityV3APISpec>,
+    #[serde(skip)]
+    #[serde(default)]
+    pub(crate) _unparsed: bool,
+}
+
+impl EntityV3API {
+    pub fn new(
+        api_version: crate::datadogV2::model::EntityV3APIVersion,
+        kind: crate::datadogV2::model::EntityV3APIKind,
+        metadata: crate::datadogV2::model::EntityV3Metadata,
+    ) -> EntityV3API {
+        EntityV3API {
+            api_version,
+            datadog: None,
+            extensions: None,
+            integrations: None,
+            kind,
+            metadata,
+            spec: None,
+            _unparsed: false,
+        }
+    }
+
+    pub fn datadog(mut self, value: crate::datadogV2::model::EntityV3APIDatadog) -> 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::EntityV3APISpec) -> Self {
+        self.spec = Some(value);
+        self
+    }
+}
+
+impl<'de> Deserialize<'de> for EntityV3API {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct EntityV3APIVisitor;
+        impl<'a> Visitor<'a> for EntityV3APIVisitor {
+            type Value = EntityV3API;
+
+            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::EntityV3APIDatadog> = 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::EntityV3APIKind> = None;
+                let mut metadata: Option<crate::datadogV2::model::EntityV3Metadata> = None;
+                let mut spec: Option<crate::datadogV2::model::EntityV3APISpec> = 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::EntityV3APIKind::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 = EntityV3API {
+                    api_version,
+                    datadog,
+                    extensions,
+                    integrations,
+                    kind,
+                    metadata,
+                    spec,
+                    _unparsed,
+                };
+
+                Ok(content)
+            }
+        }
+
+        deserializer.deserialize_any(EntityV3APIVisitor)
+    }
+}