Register an OAuth2 client

// Register an OAuth2 client returns "Created" response

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)

func main() {
	body := datadogV2.OAuthClientRegistrationRequest{
		ClientName: "Example MCP Client",
		ClientUri:  datadog.PtrString("https://example.com"),
		GrantTypes: []datadogV2.OAuthClientRegistrationGrantType{
			datadogV2.OAUTHCLIENTREGISTRATIONGRANTTYPE_AUTHORIZATION_CODE,
			datadogV2.OAUTHCLIENTREGISTRATIONGRANTTYPE_REFRESH_TOKEN,
		},
		JwksUri:   datadog.PtrString("https://example.com/.well-known/jwks.json"),
		LogoUri:   datadog.PtrString("https://example.com/logo.png"),
		PolicyUri: datadog.PtrString("https://example.com/privacy"),
		RedirectUris: []string{
			"https://example.com/oauth/callback",
		},
		ResponseTypes: []datadogV2.OAuthClientRegistrationResponseType{
			datadogV2.OAUTHCLIENTREGISTRATIONRESPONSETYPE_CODE,
		},
		Scope:                   datadog.PtrString("openid profile"),
		TokenEndpointAuthMethod: datadog.PtrString("none"),
		TosUri:                  datadog.PtrString("https://example.com/tos"),
	}
	ctx := datadog.NewDefaultContext(context.Background())
	configuration := datadog.NewConfiguration()
	configuration.SetUnstableOperationEnabled("v2.RegisterOAuthClient", true)
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewOAuth2ClientPublicApi(apiClient)
	resp, r, err := api.RegisterOAuthClient(ctx, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `OAuth2ClientPublicApi.RegisterOAuthClient`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `OAuth2ClientPublicApi.RegisterOAuthClient`:\n%s\n", responseContent)
}

// Register an OAuth2 client returns "Created" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.OAuth2ClientPublicApi;
import com.datadog.api.client.v2.model.OAuthClientRegistrationGrantType;
import com.datadog.api.client.v2.model.OAuthClientRegistrationRequest;
import com.datadog.api.client.v2.model.OAuthClientRegistrationResponse;
import com.datadog.api.client.v2.model.OAuthClientRegistrationResponseType;
import java.util.Arrays;
import java.util.Collections;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    defaultClient.setUnstableOperationEnabled("v2.registerOAuthClient", true);
    OAuth2ClientPublicApi apiInstance = new OAuth2ClientPublicApi(defaultClient);

    OAuthClientRegistrationRequest body =
        new OAuthClientRegistrationRequest()
            .clientName("Example MCP Client")
            .clientUri("https://example.com")
            .grantTypes(
                Arrays.asList(
                    OAuthClientRegistrationGrantType.AUTHORIZATION_CODE,
                    OAuthClientRegistrationGrantType.REFRESH_TOKEN))
            .jwksUri("https://example.com/.well-known/jwks.json")
            .logoUri("https://example.com/logo.png")
            .policyUri("https://example.com/privacy")
            .redirectUris(Collections.singletonList("https://example.com/oauth/callback"))
            .responseTypes(Collections.singletonList(OAuthClientRegistrationResponseType.CODE))
            .scope("openid profile")
            .tokenEndpointAuthMethod("none")
            .tosUri("https://example.com/tos");

    try {
      OAuthClientRegistrationResponse result = apiInstance.registerOAuthClient(body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling OAuth2ClientPublicApi#registerOAuthClient");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

"""
Register an OAuth2 client returns "Created" response
"""

from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.o_auth2_client_public_api import OAuth2ClientPublicApi
from datadog_api_client.v2.model.o_auth_client_registration_grant_type import OAuthClientRegistrationGrantType
from datadog_api_client.v2.model.o_auth_client_registration_request import OAuthClientRegistrationRequest
from datadog_api_client.v2.model.o_auth_client_registration_response_type import OAuthClientRegistrationResponseType

body = OAuthClientRegistrationRequest(
    client_name="Example MCP Client",
    client_uri="https://example.com",
    grant_types=[
        OAuthClientRegistrationGrantType.AUTHORIZATION_CODE,
        OAuthClientRegistrationGrantType.REFRESH_TOKEN,
    ],
    jwks_uri="https://example.com/.well-known/jwks.json",
    logo_uri="https://example.com/logo.png",
    policy_uri="https://example.com/privacy",
    redirect_uris=[
        "https://example.com/oauth/callback",
    ],
    response_types=[
        OAuthClientRegistrationResponseType.CODE,
    ],
    scope="openid profile",
    token_endpoint_auth_method="none",
    tos_uri="https://example.com/tos",
)

configuration = Configuration()
configuration.unstable_operations["register_o_auth_client"] = True
with ApiClient(configuration) as api_client:
    api_instance = OAuth2ClientPublicApi(api_client)
    response = api_instance.register_o_auth_client(body=body)

    print(response)

# Register an OAuth2 client returns "Created" response

require "datadog_api_client"
DatadogAPIClient.configure do |config|
  config.unstable_operations["v2.register_o_auth_client".to_sym] = true
end
api_instance = DatadogAPIClient::V2::OAuth2ClientPublicAPI.new

body = DatadogAPIClient::V2::OAuthClientRegistrationRequest.new({
  client_name: "Example MCP Client",
  client_uri: "https://example.com",
  grant_types: [
    DatadogAPIClient::V2::OAuthClientRegistrationGrantType::AUTHORIZATION_CODE,
    DatadogAPIClient::V2::OAuthClientRegistrationGrantType::REFRESH_TOKEN,
  ],
  jwks_uri: "https://example.com/.well-known/jwks.json",
  logo_uri: "https://example.com/logo.png",
  policy_uri: "https://example.com/privacy",
  redirect_uris: [
    "https://example.com/oauth/callback",
  ],
  response_types: [
    DatadogAPIClient::V2::OAuthClientRegistrationResponseType::CODE,
  ],
  scope: "openid profile",
  token_endpoint_auth_method: "none",
  tos_uri: "https://example.com/tos",
})
p api_instance.register_o_auth_client(body)

// Register an OAuth2 client returns "Created" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_o_auth2_client_public::OAuth2ClientPublicAPI;
use datadog_api_client::datadogV2::model::OAuthClientRegistrationGrantType;
use datadog_api_client::datadogV2::model::OAuthClientRegistrationRequest;
use datadog_api_client::datadogV2::model::OAuthClientRegistrationResponseType;

#[tokio::main]
async fn main() {
    let body = OAuthClientRegistrationRequest::new(
        "Example MCP Client".to_string(),
        vec!["https://example.com/oauth/callback".to_string()],
    )
    .client_uri("https://example.com".to_string())
    .grant_types(vec![
        OAuthClientRegistrationGrantType::AUTHORIZATION_CODE,
        OAuthClientRegistrationGrantType::REFRESH_TOKEN,
    ])
    .jwks_uri("https://example.com/.well-known/jwks.json".to_string())
    .logo_uri("https://example.com/logo.png".to_string())
    .policy_uri("https://example.com/privacy".to_string())
    .response_types(vec![OAuthClientRegistrationResponseType::CODE])
    .scope("openid profile".to_string())
    .token_endpoint_auth_method("none".to_string())
    .tos_uri("https://example.com/tos".to_string());
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.register_o_auth_client", true);
    let api = OAuth2ClientPublicAPI::with_config(configuration);
    let resp = api.register_o_auth_client(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

/**
 * Register an OAuth2 client returns "Created" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration();
configuration.unstableOperations["v2.registerOAuthClient"] = true;
const apiInstance = new v2.OAuth2ClientPublicApi(configuration);

const params: v2.OAuth2ClientPublicApiRegisterOAuthClientRequest = {
  body: {
    clientName: "Example MCP Client",
    clientUri: "https://example.com",
    grantTypes: ["authorization_code", "refresh_token"],
    jwksUri: "https://example.com/.well-known/jwks.json",
    logoUri: "https://example.com/logo.png",
    policyUri: "https://example.com/privacy",
    redirectUris: ["https://example.com/oauth/callback"],
    responseTypes: ["code"],
    scope: "openid profile",
    tokenEndpointAuthMethod: "none",
    tosUri: "https://example.com/tos",
  },
};

apiInstance
  .registerOAuthClient(params)
  .then((data: v2.OAuthClientRegistrationResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));