Add documentation for /api/v2/team/sync (#829)

Co-authored-by: ci.datadog-api-spec <[email protected]>

Author: api-clients-generation-pipeline[bot]

.generated-info

@@ -1,4 +1,4 @@
 {
-  "spec_repo_commit": "b434599",
-  "generated": "2025-08-13 22:20:40.351"
+  "spec_repo_commit": "c38287b",
+  "generated": "2025-08-15 18:58:44.539"
 }

.generator/schemas/v2/openapi.yaml

@@ -42824,6 +42824,68 @@ components:
         urgency:
           $ref: '#/components/schemas/Urgency'
       type: object
+    TeamSyncAttributes:
+      description: Team sync attributes.
+      properties:
+        source:
+          $ref: '#/components/schemas/TeamSyncAttributesSource'
+        type:
+          $ref: '#/components/schemas/TeamSyncAttributesType'
+      required:
+      - source
+      - type
+      type: object
+    TeamSyncAttributesSource:
+      description: The external source platform for team synchronization. Only "github"
+        is supported.
+      enum:
+      - github
+      example: github
+      type: string
+      x-enum-varnames:
+      - GITHUB
+    TeamSyncAttributesType:
+      description: The type of synchronization operation. Only "link" is supported,
+        which links existing teams by matching names.
+      enum:
+      - link
+      example: link
+      type: string
+      x-enum-varnames:
+      - LINK
+    TeamSyncBulkType:
+      description: Team sync bulk type.
+      enum:
+      - team_sync_bulk
+      example: team_sync_bulk
+      type: string
+      x-enum-varnames:
+      - TEAM_SYNC_BULK
+    TeamSyncData:
+      description: Team sync data.
+      properties:
+        attributes:
+          $ref: '#/components/schemas/TeamSyncAttributes'
+        type:
+          $ref: '#/components/schemas/TeamSyncBulkType'
+      required:
+      - attributes
+      - type
+      type: object
+    TeamSyncRequest:
+      description: Team sync request.
+      example:
+        data:
+          attributes:
+            source: github
+            type: link
+          type: team_sync_bulk
+      properties:
+        data:
+          $ref: '#/components/schemas/TeamSyncData'
+      required:
+      - data
+      type: object
     TeamTarget:
       description: Represents a team target for an escalation policy step, including
         the team's ID and resource type.
@@ -65913,6 +65975,71 @@ paths:
         permissions:
         - teams_read
         - teams_manage
+  /api/v2/team/sync:
+    post:
+      description: 'This endpoint attempts to link your existing Datadog teams with
+        GitHub teams by matching their names.
+
+        It evaluates all current Datadog teams and compares them against teams in
+        the GitHub organization
+
+        connected to your Datadog account, based on Datadog Team handle and GitHub
+        Team slug
+
+        (lowercased and kebab-cased).
+
+
+        This operation is read-only on the GitHub side, no teams will be modified
+        or created.
+
+
+        [A GitHub organization must be connected to your Datadog account](https://docs.datadoghq.com/integrations/github/),
+
+        and the GitHub App integrated with Datadog must have the `Members Read` permission.
+        Matching is performed by comparing the Datadog team handle to the GitHub team
+        slug
+
+        using a normalized exact match; case is ignored and spaces are removed. No
+        modifications are made
+
+        to teams in GitHub. This will not create new Teams in Datadog.'
+      operationId: SyncTeams
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/TeamSyncRequest'
+        required: true
+      responses:
+        '200':
+          description: OK
+        '403':
+          $ref: '#/components/responses/ForbiddenResponse'
+        '429':
+          $ref: '#/components/responses/TooManyRequestsResponse'
+        '500':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/APIErrorResponse'
+          description: Internal Server Error - Unexpected error during linking.
+      security:
+      - apiKeyAuth: []
+        appKeyAuth: []
+      - AuthZ:
+        - teams_manage
+      summary: Link Teams with GitHub Teams
+      tags:
+      - Teams
+      x-codegen-request-body-name: body
+      x-permission:
+        operator: AND
+        permissions:
+        - teams_manage
+      x-unstable: '**Note**: This endpoint is in Preview. To request access, fill
+        out this [form](https://www.datadoghq.com/product-preview/github-integration-for-teams/).
+
+        If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/).'
   /api/v2/team/{super_team_id}/member_teams:
     get:
       description: Get all member teams.

examples/v2_teams_SyncTeams.rs

@@ -0,0 +1,29 @@
+// Link Teams with GitHub Teams returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_teams::TeamsAPI;
+use datadog_api_client::datadogV2::model::TeamSyncAttributes;
+use datadog_api_client::datadogV2::model::TeamSyncAttributesSource;
+use datadog_api_client::datadogV2::model::TeamSyncAttributesType;
+use datadog_api_client::datadogV2::model::TeamSyncBulkType;
+use datadog_api_client::datadogV2::model::TeamSyncData;
+use datadog_api_client::datadogV2::model::TeamSyncRequest;
+
+#[tokio::main]
+async fn main() {
+    let body = TeamSyncRequest::new(TeamSyncData::new(
+        TeamSyncAttributes::new(
+            TeamSyncAttributesSource::GITHUB,
+            TeamSyncAttributesType::LINK,
+        ),
+        TeamSyncBulkType::TEAM_SYNC_BULK,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.SyncTeams", true);
+    let api = TeamsAPI::with_config(configuration);
+    let resp = api.sync_teams(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_teams_SyncTeams_3215592344.rs

@@ -0,0 +1,29 @@
+// Sync teams returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_teams::TeamsAPI;
+use datadog_api_client::datadogV2::model::TeamSyncAttributes;
+use datadog_api_client::datadogV2::model::TeamSyncAttributesSource;
+use datadog_api_client::datadogV2::model::TeamSyncAttributesType;
+use datadog_api_client::datadogV2::model::TeamSyncBulkType;
+use datadog_api_client::datadogV2::model::TeamSyncData;
+use datadog_api_client::datadogV2::model::TeamSyncRequest;
+
+#[tokio::main]
+async fn main() {
+    let body = TeamSyncRequest::new(TeamSyncData::new(
+        TeamSyncAttributes::new(
+            TeamSyncAttributesSource::GITHUB,
+            TeamSyncAttributesType::LINK,
+        ),
+        TeamSyncBulkType::TEAM_SYNC_BULK,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.SyncTeams", true);
+    let api = TeamsAPI::with_config(configuration);
+    let resp = api.sync_teams(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

src/datadog/configuration.rs

@@ -213,6 +213,7 @@ impl Default for Configuration {
             ("v2.add_member_team".to_owned(), false),
             ("v2.list_member_teams".to_owned(), false),
             ("v2.remove_member_team".to_owned(), false),
+            ("v2.sync_teams".to_owned(), false),
             ("v2.create_incident_team".to_owned(), false),
             ("v2.delete_incident_team".to_owned(), false),
             ("v2.get_incident_team".to_owned(), false),

src/datadogV2/api/api_teams.rs

@@ -266,6 +266,14 @@ pub enum RemoveMemberTeamError {
     UnknownValue(serde_json::Value),
 }
 
+/// SyncTeamsError is a struct for typed errors of method [`TeamsAPI::sync_teams`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum SyncTeamsError {
+    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
+    UnknownValue(serde_json::Value),
+}
+
 /// UpdateTeamError is a struct for typed errors of method [`TeamsAPI::update_team`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(untagged)]
@@ -2408,6 +2416,166 @@ impl TeamsAPI {
         }
     }
 
+    /// This endpoint attempts to link your existing Datadog teams with GitHub teams by matching their names.
+    /// It evaluates all current Datadog teams and compares them against teams in the GitHub organization
+    /// connected to your Datadog account, based on Datadog Team handle and GitHub Team slug
+    /// (lowercased and kebab-cased).
+    ///
+    /// This operation is read-only on the GitHub side, no teams will be modified or created.
+    ///
+    /// [A GitHub organization must be connected to your Datadog account](<https://docs.datadoghq.com/integrations/github/>),
+    /// and the GitHub App integrated with Datadog must have the `Members Read` permission. Matching is performed by comparing the Datadog team handle to the GitHub team slug
+    /// using a normalized exact match; case is ignored and spaces are removed. No modifications are made
+    /// to teams in GitHub. This will not create new Teams in Datadog.
+    pub async fn sync_teams(
+        &self,
+        body: crate::datadogV2::model::TeamSyncRequest,
+    ) -> Result<(), datadog::Error<SyncTeamsError>> {
+        match self.sync_teams_with_http_info(body).await {
+            Ok(_) => Ok(()),
+            Err(err) => Err(err),
+        }
+    }
+
+    /// This endpoint attempts to link your existing Datadog teams with GitHub teams by matching their names.
+    /// It evaluates all current Datadog teams and compares them against teams in the GitHub organization
+    /// connected to your Datadog account, based on Datadog Team handle and GitHub Team slug
+    /// (lowercased and kebab-cased).
+    ///
+    /// This operation is read-only on the GitHub side, no teams will be modified or created.
+    ///
+    /// [A GitHub organization must be connected to your Datadog account](<https://docs.datadoghq.com/integrations/github/>),
+    /// and the GitHub App integrated with Datadog must have the `Members Read` permission. Matching is performed by comparing the Datadog team handle to the GitHub team slug
+    /// using a normalized exact match; case is ignored and spaces are removed. No modifications are made
+    /// to teams in GitHub. This will not create new Teams in Datadog.
+    pub async fn sync_teams_with_http_info(
+        &self,
+        body: crate::datadogV2::model::TeamSyncRequest,
+    ) -> Result<datadog::ResponseContent<()>, datadog::Error<SyncTeamsError>> {
+        let local_configuration = &self.config;
+        let operation_id = "v2.sync_teams";
+        if local_configuration.is_unstable_operation_enabled(operation_id) {
+            warn!("Using unstable operation {operation_id}");
+        } else {
+            let local_error = datadog::UnstableOperationDisabledError {
+                msg: "Operation 'v2.sync_teams' is not enabled".to_string(),
+            };
+            return Err(datadog::Error::UnstableOperationDisabledError(local_error));
+        }
+
+        let local_client = &self.client;
+
+        let local_uri_str = format!(
+            "{}/api/v2/team/sync",
+            local_configuration.get_operation_host(operation_id)
+        );
+        let mut local_req_builder =
+            local_client.request(reqwest::Method::POST, local_uri_str.as_str());
+
+        // build headers
+        let mut headers = HeaderMap::new();
+        headers.insert("Content-Type", HeaderValue::from_static("application/json"));
+        headers.insert("Accept", HeaderValue::from_static("*/*"));
+
+        // build user agent
+        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
+            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
+            Err(e) => {
+                log::warn!("Failed to parse user agent header: {e}, falling back to default");
+                headers.insert(
+                    reqwest::header::USER_AGENT,
+                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
+                )
+            }
+        };
+
+        // build auth
+        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
+            headers.insert(
+                "DD-API-KEY",
+                HeaderValue::from_str(local_key.key.as_str())
+                    .expect("failed to parse DD-API-KEY header"),
+            );
+        };
+        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
+            headers.insert(
+                "DD-APPLICATION-KEY",
+                HeaderValue::from_str(local_key.key.as_str())
+                    .expect("failed to parse DD-APPLICATION-KEY header"),
+            );
+        };
+
+        // build body parameters
+        let output = Vec::new();
+        let mut ser = serde_json::Serializer::with_formatter(output, datadog::DDFormatter);
+        if body.serialize(&mut ser).is_ok() {
+            if let Some(content_encoding) = headers.get("Content-Encoding") {
+                match content_encoding.to_str().unwrap_or_default() {
+                    "gzip" => {
+                        let mut enc = GzEncoder::new(Vec::new(), Compression::default());
+                        let _ = enc.write_all(ser.into_inner().as_slice());
+                        match enc.finish() {
+                            Ok(buf) => {
+                                local_req_builder = local_req_builder.body(buf);
+                            }
+                            Err(e) => return Err(datadog::Error::Io(e)),
+                        }
+                    }
+                    "deflate" => {
+                        let mut enc = ZlibEncoder::new(Vec::new(), Compression::default());
+                        let _ = enc.write_all(ser.into_inner().as_slice());
+                        match enc.finish() {
+                            Ok(buf) => {
+                                local_req_builder = local_req_builder.body(buf);
+                            }
+                            Err(e) => return Err(datadog::Error::Io(e)),
+                        }
+                    }
+                    "zstd1" => {
+                        let mut enc = zstd::stream::Encoder::new(Vec::new(), 0).unwrap();
+                        let _ = enc.write_all(ser.into_inner().as_slice());
+                        match enc.finish() {
+                            Ok(buf) => {
+                                local_req_builder = local_req_builder.body(buf);
+                            }
+                            Err(e) => return Err(datadog::Error::Io(e)),
+                        }
+                    }
+                    _ => {
+                        local_req_builder = local_req_builder.body(ser.into_inner());
+                    }
+                }
+            } else {
+                local_req_builder = local_req_builder.body(ser.into_inner());
+            }
+        }
+
+        local_req_builder = local_req_builder.headers(headers);
+        let local_req = local_req_builder.build()?;
+        log::debug!("request content: {:?}", local_req.body());
+        let local_resp = local_client.execute(local_req).await?;
+
+        let local_status = local_resp.status();
+        let local_content = local_resp.text().await?;
+        log::debug!("response content: {}", local_content);
+
+        if !local_status.is_client_error() && !local_status.is_server_error() {
+            Ok(datadog::ResponseContent {
+                status: local_status,
+                content: local_content,
+                entity: None,
+            })
+        } else {
+            let local_entity: Option<SyncTeamsError> = serde_json::from_str(&local_content).ok();
+            let local_error = datadog::ResponseContent {
+                status: local_status,
+                content: local_content,
+                entity: local_entity,
+            };
+            Err(datadog::Error::ResponseError(local_error))
+        }
+    }
+
     /// Update a team using the team's `id`.
     /// If the `team_links` relationship is present, the associated links are updated to be in the order they appear in the array, and any existing team links not present are removed.
     pub async fn update_team(