diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml
index c0368d657d..baae26319a 100644
--- a/.generator/schemas/v2/openapi.yaml
+++ b/.generator/schemas/v2/openapi.yaml
@@ -29989,6 +29989,322 @@ components:
data:
$ref: "#/components/schemas/ConvertJobResultsToSignalsData"
type: object
+ CoreWeaveCloudIntegrationAccountAPITokenAuthRequest:
+ additionalProperties: false
+ description: >-
+ API token authentication, the only method CoreWeave integration accounts support. Create the token in the CoreWeave Cloud console under Access Tokens; it starts with `CW-SECRET-`. The user who owns the token must have the Observability Viewer role, because tokens inherit their user's permissions.
+ properties:
+ api_token:
+ description: >-
+ Secret CoreWeave API access token used to authenticate with CoreWeave. Values that do not start with `CW-SECRET-` are rejected with a `422` response.
+ example: CW-SECRET-xxxxxxxxxxxxxxxxxxxx
+ pattern: "^CW-SECRET-.+"
+ type: string
+ writeOnly: true
+ auth_type:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountAPITokenAuthType"
+ required:
+ - auth_type
+ - api_token
+ type: object
+ CoreWeaveCloudIntegrationAccountAPITokenAuthResponse:
+ description: The API token authentication method configured on the account.
+ properties:
+ auth_type:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountAPITokenAuthType"
+ required:
+ - auth_type
+ type: object
+ CoreWeaveCloudIntegrationAccountAPITokenAuthType:
+ default: coreweave_api_token
+ description: The authentication method type.
+ enum:
+ - coreweave_api_token
+ example: coreweave_api_token
+ type: string
+ x-enum-varnames:
+ - COREWEAVE_API_TOKEN
+ CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate:
+ additionalProperties: false
+ description: >-
+ API token authentication, the only method CoreWeave integration accounts support. Only the fields provided are changed; omit `api_token` to keep the stored one.
+ properties:
+ api_token:
+ description: >-
+ Secret CoreWeave API access token used to authenticate with CoreWeave. It cannot be cleared; sending `null` or an empty string is rejected with a `422` response.
+ example: CW-SECRET-xxxxxxxxxxxxxxxxxxxx
+ pattern: "^CW-SECRET-.+"
+ type: string
+ writeOnly: true
+ auth_type:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountAPITokenAuthType"
+ required:
+ - auth_type
+ type: object
+ CoreWeaveCloudIntegrationAccountAuthenticationRequest:
+ description: Authentication for creating the CoreWeave integration account. Exactly one method is set.
+ oneOf:
+ - $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountAPITokenAuthRequest"
+ CoreWeaveCloudIntegrationAccountAuthenticationResponse:
+ description: Authentication configured on the CoreWeave integration account.
+ oneOf:
+ - $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountAPITokenAuthResponse"
+ CoreWeaveCloudIntegrationAccountAuthenticationUpdate:
+ description: Authentication for updating the CoreWeave integration account. Exactly one method is set.
+ oneOf:
+ - $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate"
+ CoreWeaveCloudIntegrationAccountCreateAttributes:
+ description: Writable attributes used to create a CoreWeave integration account.
+ properties:
+ authentication:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountAuthenticationRequest"
+ dataflows:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationDataflowsRequest"
+ name:
+ description: Human-readable name of the CoreWeave integration account.
+ example: coreweave-prod
+ type: string
+ settings:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountSettingsRequest"
+ required:
+ - name
+ - authentication
+ - settings
+ type: object
+ CoreWeaveCloudIntegrationAccountCreateData:
+ description: Data envelope for creating a CoreWeave integration account.
+ properties:
+ attributes:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountCreateAttributes"
+ type:
+ $ref: "#/components/schemas/IntegrationAccountType"
+ required:
+ - type
+ - attributes
+ type: object
+ CoreWeaveCloudIntegrationAccountCreateRequest:
+ description: Request payload to create a CoreWeave integration account.
+ properties:
+ data:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountCreateData"
+ required:
+ - data
+ type: object
+ CoreWeaveCloudIntegrationAccountResponse:
+ description: Response payload for a single CoreWeave integration account.
+ properties:
+ data:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountResponseData"
+ required:
+ - data
+ type: object
+ CoreWeaveCloudIntegrationAccountResponseAttributes:
+ description: Attributes of a CoreWeave integration account returned in responses.
+ properties:
+ authentication:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountAuthenticationResponse"
+ dataflows:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationDataflowsResponse"
+ name:
+ description: Human-readable name of the CoreWeave integration account.
+ example: coreweave-prod
+ type: string
+ settings:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountSettingsResponse"
+ required:
+ - name
+ - settings
+ type: object
+ CoreWeaveCloudIntegrationAccountResponseData:
+ description: Data envelope of a CoreWeave integration account, including server-assigned identity.
+ properties:
+ attributes:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountResponseAttributes"
+ id:
+ description: Server-generated unique identifier of the CoreWeave integration account.
+ example: f7a8b9c0-d1e2-4f3a-9b4c-5d6e7f8091a2
+ readOnly: true
+ type: string
+ type:
+ $ref: "#/components/schemas/IntegrationAccountType"
+ required:
+ - id
+ - attributes
+ - type
+ type: object
+ CoreWeaveCloudIntegrationAccountSettingsRequest:
+ additionalProperties: false
+ description: Settings for creating the CoreWeave integration account.
+ properties:
+ account_tags:
+ description: >-
+ Tags added to all metrics and logs collected from this CoreWeave account. Defaults to no tags.
+ example:
+ - env:prod
+ - team:gpu
+ items:
+ type: string
+ type: array
+ cluster_filters:
+ description: >-
+ Tag-filter rules limiting metric collection to matching clusters, for cost savings. Include rules (`key:value`) are combined with OR, exclusion rules (`!key:value`) are then applied with AND, and `?` and `*` are wildcards; for example `cluster:prod-*` collects only matching clusters and `!cluster:dev` excludes a cluster. Defaults to no filters: every cluster is collected. Only cluster-scoped metrics are filtered; billing and object storage metrics are always collected.
+ example:
+ - cluster:prod-*
+ - "!cluster:dev"
+ items:
+ type: string
+ type: array
+ type: object
+ CoreWeaveCloudIntegrationAccountSettingsResponse:
+ description: Settings configured on the CoreWeave integration account.
+ properties:
+ account_tags:
+ description: Tags added to all data collected from this CoreWeave account.
+ example:
+ - env:prod
+ - team:gpu
+ items:
+ type: string
+ type: array
+ cluster_filters:
+ description: >-
+ Tag-filter rules limiting metric collection to matching clusters. Absent when no filters are configured.
+ example:
+ - cluster:prod-*
+ - "!cluster:dev"
+ items:
+ type: string
+ type: array
+ type: object
+ CoreWeaveCloudIntegrationAccountSettingsUpdate:
+ additionalProperties: false
+ description: Settings for updating the CoreWeave integration account. Only the fields provided are changed.
+ properties:
+ account_tags:
+ description: >-
+ Tags added to all metrics and logs collected from this CoreWeave account. Sending it replaces the whole list; send an empty array to remove all tags, or omit it to keep the stored list.
+ example:
+ - env:prod
+ - team:gpu
+ items:
+ type: string
+ type: array
+ cluster_filters:
+ description: >-
+ Tag-filter rules limiting metric collection to matching clusters. Sending it replaces the whole list; send an empty array to remove all filters and collect every cluster, or omit it to keep the stored list. Include rules (`key:value`) are combined with OR, exclusion rules (`!key:value`) are then applied with AND, and `?` and `*` are wildcards.
+ example:
+ - cluster:prod-*
+ - "!cluster:dev"
+ items:
+ type: string
+ type: array
+ type: object
+ CoreWeaveCloudIntegrationAccountUpdateAttributes:
+ description: >-
+ Writable attributes used to update a CoreWeave integration account. Every field is optional; only the fields provided are changed. When `dataflows` is provided, only the dataflow ids included in the request are modified; dataflows omitted from the map keep their current configuration.
+ properties:
+ authentication:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountAuthenticationUpdate"
+ dataflows:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationDataflowsRequest"
+ name:
+ description: Human-readable name of the CoreWeave integration account.
+ example: coreweave-prod
+ type: string
+ settings:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountSettingsUpdate"
+ type: object
+ CoreWeaveCloudIntegrationAccountUpdateData:
+ description: Data envelope for updating a CoreWeave integration account.
+ properties:
+ attributes:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountUpdateAttributes"
+ id:
+ description: Unique identifier of the CoreWeave integration account to update.
+ example: f7a8b9c0-d1e2-4f3a-9b4c-5d6e7f8091a2
+ type: string
+ type:
+ $ref: "#/components/schemas/IntegrationAccountType"
+ required:
+ - id
+ - type
+ - attributes
+ type: object
+ CoreWeaveCloudIntegrationAccountUpdateRequest:
+ description: Request payload to update a CoreWeave integration account.
+ properties:
+ data:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountUpdateData"
+ required:
+ - data
+ type: object
+ CoreWeaveCloudIntegrationAccountsResponse:
+ description: Response payload for a list of CoreWeave integration accounts.
+ properties:
+ data:
+ description: List of CoreWeave integration accounts.
+ items:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountResponseData"
+ type: array
+ required:
+ - data
+ type: object
+ CoreWeaveCloudIntegrationDataflowsRequest:
+ additionalProperties: false
+ description: >-
+ Data Datadog collects from CoreWeave, keyed by dataflow id. Each dataflow turns on a distinct kind of collection: set `enabled` to start or stop it. Defaults listed on each dataflow apply when the account is created; on update, omitted dataflow ids keep their current values. Collection runs with the API access token in `authentication`, whose user must have the Observability Viewer role; a dataflow enabled without that role is stored but collects no data.
+ properties:
+ coreweave-cloud-logs:
+ $ref: "#/components/schemas/CoreWeaveCloudLogsIntegrationDataflowRequest"
+ coreweave-cloud-metrics:
+ $ref: "#/components/schemas/CoreWeaveCloudMetricsIntegrationDataflowRequest"
+ type: object
+ CoreWeaveCloudIntegrationDataflowsResponse:
+ description: Data Datadog collects from CoreWeave, keyed by dataflow id.
+ properties:
+ coreweave-cloud-logs:
+ $ref: "#/components/schemas/CoreWeaveCloudLogsIntegrationDataflowResponse"
+ coreweave-cloud-metrics:
+ $ref: "#/components/schemas/CoreWeaveCloudMetricsIntegrationDataflowResponse"
+ type: object
+ CoreWeaveCloudLogsIntegrationDataflowRequest:
+ additionalProperties: false
+ description: >-
+ Service logs for CoreWeave-managed components in each CoreWeave region: the CKS control plane (such as `kube-apiserver` and `etcd`), CoreWeave add-on services in the `cw-*` and `kube-system` namespaces, SUNK, and node system logs such as `kubelet` and `containerd`. Logs from your own workloads and Kubernetes audit logs are not collected. Logs are sent with `source:coreweave`, with CoreWeave log labels such as `namespace`, `app`, and `systemd_unit` added as tags.
+ properties:
+ enabled:
+ description: Whether Datadog collects this data. Defaults to `false`; set to `true` to start collection.
+ example: true
+ type: boolean
+ type: object
+ CoreWeaveCloudLogsIntegrationDataflowResponse:
+ description: >-
+ Service logs for CoreWeave-managed components in each CoreWeave region: the CKS control plane (such as `kube-apiserver` and `etcd`), CoreWeave add-on services in the `cw-*` and `kube-system` namespaces, SUNK, and node system logs such as `kubelet` and `containerd`. Logs from your own workloads and Kubernetes audit logs are not collected. Logs are sent with `source:coreweave`, with CoreWeave log labels such as `namespace`, `app`, and `systemd_unit` added as tags.
+ properties:
+ enabled:
+ description: Whether Datadog collects this data. Absent when the dataflow has never been configured, in which case the documented default applies.
+ example: true
+ type: boolean
+ type: object
+ CoreWeaveCloudMetricsIntegrationDataflowRequest:
+ additionalProperties: false
+ description: >-
+ Metrics from your CoreWeave organization: CoreWeave service metrics collected through its PromQL-compatible Prometheus endpoint, plus the `coreweave.*` namespaces from CoreWeave products such as Kubernetes, Database, Distributed File Storage, Inference, and Object Storage. Compute metrics (`coreweave.bare_metal`, `coreweave.gpu`, `coreweave.nccl`, and `coreweave.node`) are in Preview. Container metrics are not collected; install the Datadog Agent on your clusters for those.
+ properties:
+ enabled:
+ description: Whether Datadog collects this data. Defaults to `true`; set to `false` to stop collection.
+ example: true
+ type: boolean
+ type: object
+ CoreWeaveCloudMetricsIntegrationDataflowResponse:
+ description: >-
+ Metrics from your CoreWeave organization: CoreWeave service metrics collected through its PromQL-compatible Prometheus endpoint, plus the `coreweave.*` namespaces from CoreWeave products such as Kubernetes, Database, Distributed File Storage, Inference, and Object Storage. Compute metrics (`coreweave.bare_metal`, `coreweave.gpu`, `coreweave.nccl`, and `coreweave.node`) are in Preview. Container metrics are not collected; install the Datadog Agent on your clusters for those.
+ properties:
+ enabled:
+ description: Whether Datadog collects this data. Absent when the dataflow has never been configured, in which case the documented default applies.
+ example: true
+ type: boolean
+ type: object
CostAggregationType:
description: "Controls how costs are aggregated when using `start_date`. The `cumulative` option returns month-to-date running totals."
enum:
@@ -200610,6 +200926,244 @@ paths:
x-unstable: |-
**Note**: This endpoint is in preview and is subject to change.
If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/).
+ /api/v2/integration-interfaces/coreweave-cloud/accounts:
+ get:
+ description: List CoreWeave integration accounts.
+ operationId: ListCoreWeaveCloudIntegrationAccounts
+ responses:
+ "200":
+ content:
+ application/json:
+ examples:
+ default:
+ value:
+ data:
+ - attributes:
+ authentication:
+ auth_type: coreweave_api_token
+ dataflows:
+ coreweave-cloud-logs:
+ enabled: true
+ coreweave-cloud-metrics:
+ enabled: true
+ name: coreweave-prod
+ settings:
+ account_tags:
+ - env:prod
+ - team:gpu
+ id: f7a8b9c0-d1e2-4f3a-9b4c-5d6e7f8091a2
+ type: integration-account
+ schema:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountsResponse"
+ description: OK
+ "400":
+ $ref: "#/components/responses/BadRequestResponse"
+ "403":
+ $ref: "#/components/responses/ForbiddenResponse"
+ "404":
+ $ref: "#/components/responses/NotFoundResponse"
+ "429":
+ $ref: "#/components/responses/TooManyRequestsResponse"
+ summary: List CoreWeave integration accounts
+ tags:
+ - CoreWeave Integration
+ "x-permission":
+ operator: OR
+ permissions:
+ - integrations_read
+ x-unstable: |-
+ **Note**: This endpoint is in preview and is subject to change.
+ If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/).
+ post:
+ description: Create a CoreWeave integration account.
+ operationId: CreateCoreWeaveCloudIntegrationAccount
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountCreateRequest"
+ required: true
+ responses:
+ "201":
+ content:
+ application/json:
+ examples:
+ default:
+ value:
+ data:
+ attributes:
+ authentication:
+ auth_type: coreweave_api_token
+ dataflows:
+ coreweave-cloud-logs:
+ enabled: true
+ coreweave-cloud-metrics:
+ enabled: true
+ name: coreweave-prod
+ settings:
+ account_tags:
+ - env:prod
+ - team:gpu
+ id: f7a8b9c0-d1e2-4f3a-9b4c-5d6e7f8091a2
+ type: integration-account
+ schema:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountResponse"
+ description: Created
+ "400":
+ $ref: "#/components/responses/BadRequestResponse"
+ "403":
+ $ref: "#/components/responses/ForbiddenResponse"
+ "404":
+ $ref: "#/components/responses/NotFoundResponse"
+ "422":
+ $ref: "#/components/responses/UnprocessableEntityResponse"
+ "429":
+ $ref: "#/components/responses/TooManyRequestsResponse"
+ summary: Create a CoreWeave integration account
+ tags:
+ - CoreWeave Integration
+ x-codegen-request-body-name: body
+ "x-permission":
+ operator: OR
+ permissions:
+ - manage_integrations
+ x-unstable: |-
+ **Note**: This endpoint is in preview and is subject to change.
+ If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/).
+ /api/v2/integration-interfaces/coreweave-cloud/accounts/{account_id}:
+ delete:
+ description: Delete a CoreWeave integration account.
+ operationId: DeleteCoreWeaveCloudIntegrationAccount
+ parameters:
+ - $ref: "#/components/parameters/IntegrationAccountIdParameter"
+ responses:
+ "200":
+ description: OK
+ "400":
+ $ref: "#/components/responses/BadRequestResponse"
+ "403":
+ $ref: "#/components/responses/ForbiddenResponse"
+ "404":
+ $ref: "#/components/responses/NotFoundResponse"
+ "429":
+ $ref: "#/components/responses/TooManyRequestsResponse"
+ summary: Delete a CoreWeave integration account
+ tags:
+ - CoreWeave Integration
+ "x-permission":
+ operator: OR
+ permissions:
+ - manage_integrations
+ x-unstable: |-
+ **Note**: This endpoint is in preview and is subject to change.
+ If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/).
+ get:
+ description: Get a CoreWeave integration account.
+ operationId: GetCoreWeaveCloudIntegrationAccount
+ parameters:
+ - $ref: "#/components/parameters/IntegrationAccountIdParameter"
+ responses:
+ "200":
+ content:
+ application/json:
+ examples:
+ default:
+ value:
+ data:
+ attributes:
+ authentication:
+ auth_type: coreweave_api_token
+ dataflows:
+ coreweave-cloud-logs:
+ enabled: true
+ coreweave-cloud-metrics:
+ enabled: true
+ name: coreweave-prod
+ settings:
+ account_tags:
+ - env:prod
+ - team:gpu
+ id: f7a8b9c0-d1e2-4f3a-9b4c-5d6e7f8091a2
+ type: integration-account
+ schema:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountResponse"
+ description: OK
+ "400":
+ $ref: "#/components/responses/BadRequestResponse"
+ "403":
+ $ref: "#/components/responses/ForbiddenResponse"
+ "404":
+ $ref: "#/components/responses/NotFoundResponse"
+ "429":
+ $ref: "#/components/responses/TooManyRequestsResponse"
+ summary: Get a CoreWeave integration account
+ tags:
+ - CoreWeave Integration
+ "x-permission":
+ operator: OR
+ permissions:
+ - integrations_read
+ x-unstable: |-
+ **Note**: This endpoint is in preview and is subject to change.
+ If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/).
+ patch:
+ description: Update a CoreWeave integration account. Only the fields provided are changed.
+ operationId: UpdateCoreWeaveCloudIntegrationAccount
+ parameters:
+ - $ref: "#/components/parameters/IntegrationAccountIdParameter"
+ requestBody:
+ content:
+ application/json:
+ schema:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountUpdateRequest"
+ required: true
+ responses:
+ "200":
+ content:
+ application/json:
+ examples:
+ default:
+ value:
+ data:
+ attributes:
+ authentication:
+ auth_type: coreweave_api_token
+ dataflows:
+ coreweave-cloud-logs:
+ enabled: true
+ coreweave-cloud-metrics:
+ enabled: true
+ name: coreweave-prod
+ settings:
+ account_tags:
+ - env:prod
+ - team:gpu
+ id: f7a8b9c0-d1e2-4f3a-9b4c-5d6e7f8091a2
+ type: integration-account
+ schema:
+ $ref: "#/components/schemas/CoreWeaveCloudIntegrationAccountResponse"
+ description: OK
+ "400":
+ $ref: "#/components/responses/BadRequestResponse"
+ "403":
+ $ref: "#/components/responses/ForbiddenResponse"
+ "404":
+ $ref: "#/components/responses/NotFoundResponse"
+ "422":
+ $ref: "#/components/responses/UnprocessableEntityResponse"
+ "429":
+ $ref: "#/components/responses/TooManyRequestsResponse"
+ summary: Update a CoreWeave integration account
+ tags:
+ - CoreWeave Integration
+ x-codegen-request-body-name: body
+ "x-permission":
+ operator: OR
+ permissions:
+ - manage_integrations
+ x-unstable: |-
+ **Note**: This endpoint is in preview and is subject to change.
+ If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/).
/api/v2/integration-interfaces/databricks/accounts:
get:
description: List Databricks integration accounts.
@@ -275851,6 +276405,15 @@ tags:
The Containers API allows you to query container data for your organization.
See the [Container Monitoring page](https://docs.datadoghq.com/containers/) for more information.
name: Containers
+ - description: |-
+ Manage your Datadog CoreWeave integration accounts and account resources
+ directly through the Datadog API. See the
+ [CoreWeave integration page](https://docs.datadoghq.com/integrations/coreweave/) for
+ more information.
+ externalDocs:
+ description: CoreWeave integration.
+ url: https://docs.datadoghq.com/integrations/coreweave/
+ name: CoreWeave Integration
- description: |-
Programmatic management of a customer's Datadog organization. Use this API to perform
self-service organization lifecycle actions such as disabling the authenticated org.
diff --git a/examples/v2_coreweave-integration_CreateCoreWeaveCloudIntegrationAccount.rs b/examples/v2_coreweave-integration_CreateCoreWeaveCloudIntegrationAccount.rs
new file mode 100644
index 0000000000..2a744ab28e
--- /dev/null
+++ b/examples/v2_coreweave-integration_CreateCoreWeaveCloudIntegrationAccount.rs
@@ -0,0 +1,55 @@
+// Create a CoreWeave integration account returns "Created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_core_weave_integration::CoreWeaveIntegrationAPI;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthRequest;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountAuthenticationRequest;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountCreateAttributes;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountCreateData;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountCreateRequest;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountSettingsRequest;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationDataflowsRequest;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudLogsIntegrationDataflowRequest;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudMetricsIntegrationDataflowRequest;
+use datadog_api_client::datadogV2::model::IntegrationAccountType;
+
+#[tokio::main]
+async fn main() {
+ let body =
+ CoreWeaveCloudIntegrationAccountCreateRequest::new(
+ CoreWeaveCloudIntegrationAccountCreateData::new(
+ CoreWeaveCloudIntegrationAccountCreateAttributes::new(
+ CoreWeaveCloudIntegrationAccountAuthenticationRequest
+ ::CoreWeaveCloudIntegrationAccountAPITokenAuthRequest(
+ Box::new(
+ CoreWeaveCloudIntegrationAccountAPITokenAuthRequest::new(
+ "CW-SECRET-xxxxxxxxxxxxxxxxxxxx".to_string(),
+ CoreWeaveCloudIntegrationAccountAPITokenAuthType::COREWEAVE_API_TOKEN,
+ ),
+ ),
+ ),
+ "coreweave-prod".to_string(),
+ CoreWeaveCloudIntegrationAccountSettingsRequest::new()
+ .account_tags(vec!["env:prod".to_string(), "team:gpu".to_string()])
+ .cluster_filters(vec!["cluster:prod-*".to_string(), "!cluster:dev".to_string()]),
+ ).dataflows(
+ CoreWeaveCloudIntegrationDataflowsRequest::new()
+ .coreweave_cloud_logs(CoreWeaveCloudLogsIntegrationDataflowRequest::new().enabled(true))
+ .coreweave_cloud_metrics(
+ CoreWeaveCloudMetricsIntegrationDataflowRequest::new().enabled(true),
+ ),
+ ),
+ IntegrationAccountType::INTEGRATION_ACCOUNT,
+ ),
+ );
+ let mut configuration = datadog::Configuration::new();
+ configuration
+ .set_unstable_operation_enabled("v2.create_core_weave_cloud_integration_account", true);
+ let api = CoreWeaveIntegrationAPI::with_config(configuration);
+ let resp = api.create_core_weave_cloud_integration_account(body).await;
+ if let Ok(value) = resp {
+ println!("{:#?}", value);
+ } else {
+ println!("{:#?}", resp.unwrap_err());
+ }
+}
diff --git a/examples/v2_coreweave-integration_DeleteCoreWeaveCloudIntegrationAccount.rs b/examples/v2_coreweave-integration_DeleteCoreWeaveCloudIntegrationAccount.rs
new file mode 100644
index 0000000000..b10235a81b
--- /dev/null
+++ b/examples/v2_coreweave-integration_DeleteCoreWeaveCloudIntegrationAccount.rs
@@ -0,0 +1,19 @@
+// Delete a CoreWeave integration account returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_core_weave_integration::CoreWeaveIntegrationAPI;
+
+#[tokio::main]
+async fn main() {
+ let mut configuration = datadog::Configuration::new();
+ configuration
+ .set_unstable_operation_enabled("v2.delete_core_weave_cloud_integration_account", true);
+ let api = CoreWeaveIntegrationAPI::with_config(configuration);
+ let resp = api
+ .delete_core_weave_cloud_integration_account("account_id".to_string())
+ .await;
+ if let Ok(value) = resp {
+ println!("{:#?}", value);
+ } else {
+ println!("{:#?}", resp.unwrap_err());
+ }
+}
diff --git a/examples/v2_coreweave-integration_GetCoreWeaveCloudIntegrationAccount.rs b/examples/v2_coreweave-integration_GetCoreWeaveCloudIntegrationAccount.rs
new file mode 100644
index 0000000000..b6a42782ac
--- /dev/null
+++ b/examples/v2_coreweave-integration_GetCoreWeaveCloudIntegrationAccount.rs
@@ -0,0 +1,19 @@
+// Get a CoreWeave integration account returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_core_weave_integration::CoreWeaveIntegrationAPI;
+
+#[tokio::main]
+async fn main() {
+ let mut configuration = datadog::Configuration::new();
+ configuration
+ .set_unstable_operation_enabled("v2.get_core_weave_cloud_integration_account", true);
+ let api = CoreWeaveIntegrationAPI::with_config(configuration);
+ let resp = api
+ .get_core_weave_cloud_integration_account("account_id".to_string())
+ .await;
+ if let Ok(value) = resp {
+ println!("{:#?}", value);
+ } else {
+ println!("{:#?}", resp.unwrap_err());
+ }
+}
diff --git a/examples/v2_coreweave-integration_ListCoreWeaveCloudIntegrationAccounts.rs b/examples/v2_coreweave-integration_ListCoreWeaveCloudIntegrationAccounts.rs
new file mode 100644
index 0000000000..6eb9ab112d
--- /dev/null
+++ b/examples/v2_coreweave-integration_ListCoreWeaveCloudIntegrationAccounts.rs
@@ -0,0 +1,17 @@
+// List CoreWeave integration accounts returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_core_weave_integration::CoreWeaveIntegrationAPI;
+
+#[tokio::main]
+async fn main() {
+ let mut configuration = datadog::Configuration::new();
+ configuration
+ .set_unstable_operation_enabled("v2.list_core_weave_cloud_integration_accounts", true);
+ let api = CoreWeaveIntegrationAPI::with_config(configuration);
+ let resp = api.list_core_weave_cloud_integration_accounts().await;
+ if let Ok(value) = resp {
+ println!("{:#?}", value);
+ } else {
+ println!("{:#?}", resp.unwrap_err());
+ }
+}
diff --git a/examples/v2_coreweave-integration_UpdateCoreWeaveCloudIntegrationAccount.rs b/examples/v2_coreweave-integration_UpdateCoreWeaveCloudIntegrationAccount.rs
new file mode 100644
index 0000000000..2f8f973911
--- /dev/null
+++ b/examples/v2_coreweave-integration_UpdateCoreWeaveCloudIntegrationAccount.rs
@@ -0,0 +1,61 @@
+// Update a CoreWeave integration account returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_core_weave_integration::CoreWeaveIntegrationAPI;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountAuthenticationUpdate;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountSettingsUpdate;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountUpdateAttributes;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountUpdateData;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationAccountUpdateRequest;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudIntegrationDataflowsRequest;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudLogsIntegrationDataflowRequest;
+use datadog_api_client::datadogV2::model::CoreWeaveCloudMetricsIntegrationDataflowRequest;
+use datadog_api_client::datadogV2::model::IntegrationAccountType;
+
+#[tokio::main]
+async fn main() {
+ let body =
+ CoreWeaveCloudIntegrationAccountUpdateRequest::new(
+ CoreWeaveCloudIntegrationAccountUpdateData::new(
+ CoreWeaveCloudIntegrationAccountUpdateAttributes::new()
+ .authentication(
+ CoreWeaveCloudIntegrationAccountAuthenticationUpdate
+ ::CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate(
+ Box::new(
+ CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate::new(
+ CoreWeaveCloudIntegrationAccountAPITokenAuthType::COREWEAVE_API_TOKEN,
+ ).api_token("CW-SECRET-xxxxxxxxxxxxxxxxxxxx".to_string()),
+ ),
+ ),
+ )
+ .dataflows(
+ CoreWeaveCloudIntegrationDataflowsRequest::new()
+ .coreweave_cloud_logs(CoreWeaveCloudLogsIntegrationDataflowRequest::new().enabled(true))
+ .coreweave_cloud_metrics(
+ CoreWeaveCloudMetricsIntegrationDataflowRequest::new().enabled(true),
+ ),
+ )
+ .name("coreweave-prod".to_string())
+ .settings(
+ CoreWeaveCloudIntegrationAccountSettingsUpdate::new()
+ .account_tags(vec!["env:prod".to_string(), "team:gpu".to_string()])
+ .cluster_filters(vec!["cluster:prod-*".to_string(), "!cluster:dev".to_string()]),
+ ),
+ "f7a8b9c0-d1e2-4f3a-9b4c-5d6e7f8091a2".to_string(),
+ IntegrationAccountType::INTEGRATION_ACCOUNT,
+ ),
+ );
+ let mut configuration = datadog::Configuration::new();
+ configuration
+ .set_unstable_operation_enabled("v2.update_core_weave_cloud_integration_account", true);
+ let api = CoreWeaveIntegrationAPI::with_config(configuration);
+ let resp = api
+ .update_core_weave_cloud_integration_account("account_id".to_string(), body)
+ .await;
+ if let Ok(value) = resp {
+ println!("{:#?}", value);
+ } else {
+ println!("{:#?}", resp.unwrap_err());
+ }
+}
diff --git a/src/datadog/configuration.rs b/src/datadog/configuration.rs
index 7d018169b6..617ea2c985 100644
--- a/src/datadog/configuration.rs
+++ b/src/datadog/configuration.rs
@@ -899,6 +899,26 @@ impl Default for Configuration {
("v2.update_incident_user_defined_field".to_owned(), false),
("v2.update_incident_user_defined_role".to_owned(), false),
("v2.update_timestamp_override".to_owned(), false),
+ (
+ "v2.create_core_weave_cloud_integration_account".to_owned(),
+ false,
+ ),
+ (
+ "v2.delete_core_weave_cloud_integration_account".to_owned(),
+ false,
+ ),
+ (
+ "v2.get_core_weave_cloud_integration_account".to_owned(),
+ false,
+ ),
+ (
+ "v2.list_core_weave_cloud_integration_accounts".to_owned(),
+ false,
+ ),
+ (
+ "v2.update_core_weave_cloud_integration_account".to_owned(),
+ false,
+ ),
("v2.create_databricks_integration_account".to_owned(), false),
("v2.delete_databricks_integration_account".to_owned(), false),
("v2.get_databricks_integration_account".to_owned(), false),
diff --git a/src/datadogV2/api/api_core_weave_integration.rs b/src/datadogV2/api/api_core_weave_integration.rs
new file mode 100644
index 0000000000..8df890bc58
--- /dev/null
+++ b/src/datadogV2/api/api_core_weave_integration.rs
@@ -0,0 +1,817 @@
+// 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 crate::datadog;
+use flate2::{
+ write::{GzEncoder, ZlibEncoder},
+ Compression,
+};
+use log::warn;
+use reqwest::header::{HeaderMap, HeaderValue};
+use serde::{Deserialize, Serialize};
+use std::io::Write;
+
+/// CreateCoreWeaveCloudIntegrationAccountError is a struct for typed errors of method [`CoreWeaveIntegrationAPI::create_core_weave_cloud_integration_account`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum CreateCoreWeaveCloudIntegrationAccountError {
+ APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
+ JSONAPIErrorResponse(crate::datadogV2::model::JSONAPIErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+/// DeleteCoreWeaveCloudIntegrationAccountError is a struct for typed errors of method [`CoreWeaveIntegrationAPI::delete_core_weave_cloud_integration_account`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum DeleteCoreWeaveCloudIntegrationAccountError {
+ APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+/// GetCoreWeaveCloudIntegrationAccountError is a struct for typed errors of method [`CoreWeaveIntegrationAPI::get_core_weave_cloud_integration_account`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum GetCoreWeaveCloudIntegrationAccountError {
+ APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+/// ListCoreWeaveCloudIntegrationAccountsError is a struct for typed errors of method [`CoreWeaveIntegrationAPI::list_core_weave_cloud_integration_accounts`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum ListCoreWeaveCloudIntegrationAccountsError {
+ APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+/// UpdateCoreWeaveCloudIntegrationAccountError is a struct for typed errors of method [`CoreWeaveIntegrationAPI::update_core_weave_cloud_integration_account`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum UpdateCoreWeaveCloudIntegrationAccountError {
+ APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
+ JSONAPIErrorResponse(crate::datadogV2::model::JSONAPIErrorResponse),
+ UnknownValue(serde_json::Value),
+}
+
+/// Manage your Datadog CoreWeave integration accounts and account resources
+/// directly through the Datadog API. See the
+/// [CoreWeave integration page]() for
+/// more information.
+#[derive(Debug, Clone)]
+pub struct CoreWeaveIntegrationAPI {
+ config: datadog::Configuration,
+ client: reqwest_middleware::ClientWithMiddleware,
+}
+
+impl Default for CoreWeaveIntegrationAPI {
+ fn default() -> Self {
+ Self::with_config(datadog::Configuration::default())
+ }
+}
+
+impl CoreWeaveIntegrationAPI {
+ pub fn new() -> Self {
+ Self::default()
+ }
+ pub fn with_config(config: datadog::Configuration) -> Self {
+ let reqwest_client_builder = {
+ let builder = config.apply_headers(reqwest::Client::builder());
+ #[cfg(not(target_arch = "wasm32"))]
+ let builder = if let Some(proxy_url) = &config.proxy_url {
+ builder.proxy(reqwest::Proxy::all(proxy_url).expect("Failed to parse proxy URL"))
+ } else {
+ builder
+ };
+ builder
+ };
+
+ let middleware_client_builder = {
+ let builder =
+ reqwest_middleware::ClientBuilder::new(reqwest_client_builder.build().unwrap());
+ #[cfg(feature = "retry")]
+ let builder = if config.enable_retry {
+ struct RetryableStatus;
+ impl reqwest_retry::RetryableStrategy for RetryableStatus {
+ fn handle(
+ &self,
+ res: &Result,
+ ) -> Option {
+ match res {
+ Ok(success) => reqwest_retry::default_on_request_success(success),
+ Err(_) => None,
+ }
+ }
+ }
+ let backoff_policy = reqwest_retry::policies::ExponentialBackoff::builder()
+ .build_with_max_retries(config.max_retries);
+
+ let retry_middleware =
+ reqwest_retry::RetryTransientMiddleware::new_with_policy_and_strategy(
+ backoff_policy,
+ RetryableStatus,
+ );
+
+ builder.with(retry_middleware)
+ } else {
+ builder
+ };
+ builder
+ };
+
+ let client = middleware_client_builder.build();
+
+ Self { config, client }
+ }
+
+ pub fn with_client_and_config(
+ config: datadog::Configuration,
+ client: reqwest_middleware::ClientWithMiddleware,
+ ) -> Self {
+ Self { config, client }
+ }
+
+ /// Create a CoreWeave integration account.
+ pub async fn create_core_weave_cloud_integration_account(
+ &self,
+ body: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountCreateRequest,
+ ) -> Result<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountResponse,
+ datadog::Error,
+ > {
+ match self
+ .create_core_weave_cloud_integration_account_with_http_info(body)
+ .await
+ {
+ Ok(response_content) => {
+ if let Some(e) = response_content.entity {
+ Ok(e)
+ } else {
+ Err(datadog::Error::Serde(serde::de::Error::custom(
+ "response content was None",
+ )))
+ }
+ }
+ Err(err) => Err(err),
+ }
+ }
+
+ /// Create a CoreWeave integration account.
+ pub async fn create_core_weave_cloud_integration_account_with_http_info(
+ &self,
+ body: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountCreateRequest,
+ ) -> Result<
+ datadog::ResponseContent,
+ datadog::Error,
+ > {
+ let local_configuration = &self.config;
+ let local_operation_id = "v2.create_core_weave_cloud_integration_account";
+ if local_configuration.is_unstable_operation_enabled(local_operation_id) {
+ warn!("Using unstable operation {local_operation_id}");
+ } else {
+ let local_error = datadog::UnstableOperationDisabledError {
+ msg: "Operation 'v2.create_core_weave_cloud_integration_account' is not enabled"
+ .to_string(),
+ };
+ return Err(datadog::Error::UnstableOperationDisabledError(local_error));
+ }
+
+ let local_client = &self.client;
+
+ let local_uri_str = format!(
+ "{}/api/v2/integration-interfaces/coreweave-cloud/accounts",
+ local_configuration.get_operation_host(local_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("application/json"));
+
+ // 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)),
+ }
+ }
+ #[cfg(feature = "zstd")]
+ "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() {
+ match serde_json::from_str::<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountResponse,
+ >(&local_content)
+ {
+ Ok(e) => {
+ return Ok(datadog::ResponseContent {
+ status: local_status,
+ content: local_content,
+ entity: Some(e),
+ })
+ }
+ Err(e) => return Err(datadog::Error::Serde(e)),
+ };
+ } else {
+ let local_entity: Option =
+ 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))
+ }
+ }
+
+ /// Delete a CoreWeave integration account.
+ pub async fn delete_core_weave_cloud_integration_account(
+ &self,
+ account_id: String,
+ ) -> Result<(), datadog::Error> {
+ match self
+ .delete_core_weave_cloud_integration_account_with_http_info(account_id)
+ .await
+ {
+ Ok(_) => Ok(()),
+ Err(err) => Err(err),
+ }
+ }
+
+ /// Delete a CoreWeave integration account.
+ pub async fn delete_core_weave_cloud_integration_account_with_http_info(
+ &self,
+ account_id: String,
+ ) -> Result<
+ datadog::ResponseContent<()>,
+ datadog::Error,
+ > {
+ let local_configuration = &self.config;
+ let local_operation_id = "v2.delete_core_weave_cloud_integration_account";
+ if local_configuration.is_unstable_operation_enabled(local_operation_id) {
+ warn!("Using unstable operation {local_operation_id}");
+ } else {
+ let local_error = datadog::UnstableOperationDisabledError {
+ msg: "Operation 'v2.delete_core_weave_cloud_integration_account' is not enabled"
+ .to_string(),
+ };
+ return Err(datadog::Error::UnstableOperationDisabledError(local_error));
+ }
+
+ let local_client = &self.client;
+
+ let local_uri_str = format!(
+ "{}/api/v2/integration-interfaces/coreweave-cloud/accounts/{account_id}",
+ local_configuration.get_operation_host(local_operation_id),
+ account_id = datadog::urlencode(account_id)
+ );
+ let mut local_req_builder =
+ local_client.request(reqwest::Method::DELETE, local_uri_str.as_str());
+
+ // build headers
+ let mut headers = HeaderMap::new();
+ 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"),
+ );
+ };
+
+ 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 =
+ 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))
+ }
+ }
+
+ /// Get a CoreWeave integration account.
+ pub async fn get_core_weave_cloud_integration_account(
+ &self,
+ account_id: String,
+ ) -> Result<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountResponse,
+ datadog::Error,
+ > {
+ match self
+ .get_core_weave_cloud_integration_account_with_http_info(account_id)
+ .await
+ {
+ Ok(response_content) => {
+ if let Some(e) = response_content.entity {
+ Ok(e)
+ } else {
+ Err(datadog::Error::Serde(serde::de::Error::custom(
+ "response content was None",
+ )))
+ }
+ }
+ Err(err) => Err(err),
+ }
+ }
+
+ /// Get a CoreWeave integration account.
+ pub async fn get_core_weave_cloud_integration_account_with_http_info(
+ &self,
+ account_id: String,
+ ) -> Result<
+ datadog::ResponseContent,
+ datadog::Error,
+ > {
+ let local_configuration = &self.config;
+ let local_operation_id = "v2.get_core_weave_cloud_integration_account";
+ if local_configuration.is_unstable_operation_enabled(local_operation_id) {
+ warn!("Using unstable operation {local_operation_id}");
+ } else {
+ let local_error = datadog::UnstableOperationDisabledError {
+ msg: "Operation 'v2.get_core_weave_cloud_integration_account' is not enabled"
+ .to_string(),
+ };
+ return Err(datadog::Error::UnstableOperationDisabledError(local_error));
+ }
+
+ let local_client = &self.client;
+
+ let local_uri_str = format!(
+ "{}/api/v2/integration-interfaces/coreweave-cloud/accounts/{account_id}",
+ local_configuration.get_operation_host(local_operation_id),
+ account_id = datadog::urlencode(account_id)
+ );
+ let mut local_req_builder =
+ local_client.request(reqwest::Method::GET, local_uri_str.as_str());
+
+ // build headers
+ let mut headers = HeaderMap::new();
+ headers.insert("Accept", HeaderValue::from_static("application/json"));
+
+ // 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"),
+ );
+ };
+
+ 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() {
+ match serde_json::from_str::<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountResponse,
+ >(&local_content)
+ {
+ Ok(e) => {
+ return Ok(datadog::ResponseContent {
+ status: local_status,
+ content: local_content,
+ entity: Some(e),
+ })
+ }
+ Err(e) => return Err(datadog::Error::Serde(e)),
+ };
+ } else {
+ let local_entity: Option =
+ 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))
+ }
+ }
+
+ /// List CoreWeave integration accounts.
+ pub async fn list_core_weave_cloud_integration_accounts(
+ &self,
+ ) -> Result<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountsResponse,
+ datadog::Error,
+ > {
+ match self
+ .list_core_weave_cloud_integration_accounts_with_http_info()
+ .await
+ {
+ Ok(response_content) => {
+ if let Some(e) = response_content.entity {
+ Ok(e)
+ } else {
+ Err(datadog::Error::Serde(serde::de::Error::custom(
+ "response content was None",
+ )))
+ }
+ }
+ Err(err) => Err(err),
+ }
+ }
+
+ /// List CoreWeave integration accounts.
+ pub async fn list_core_weave_cloud_integration_accounts_with_http_info(
+ &self,
+ ) -> Result<
+ datadog::ResponseContent<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountsResponse,
+ >,
+ datadog::Error,
+ > {
+ let local_configuration = &self.config;
+ let local_operation_id = "v2.list_core_weave_cloud_integration_accounts";
+ if local_configuration.is_unstable_operation_enabled(local_operation_id) {
+ warn!("Using unstable operation {local_operation_id}");
+ } else {
+ let local_error = datadog::UnstableOperationDisabledError {
+ msg: "Operation 'v2.list_core_weave_cloud_integration_accounts' is not enabled"
+ .to_string(),
+ };
+ return Err(datadog::Error::UnstableOperationDisabledError(local_error));
+ }
+
+ let local_client = &self.client;
+
+ let local_uri_str = format!(
+ "{}/api/v2/integration-interfaces/coreweave-cloud/accounts",
+ local_configuration.get_operation_host(local_operation_id)
+ );
+ let mut local_req_builder =
+ local_client.request(reqwest::Method::GET, local_uri_str.as_str());
+
+ // build headers
+ let mut headers = HeaderMap::new();
+ headers.insert("Accept", HeaderValue::from_static("application/json"));
+
+ // 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"),
+ );
+ };
+
+ 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() {
+ match serde_json::from_str::<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountsResponse,
+ >(&local_content)
+ {
+ Ok(e) => {
+ return Ok(datadog::ResponseContent {
+ status: local_status,
+ content: local_content,
+ entity: Some(e),
+ })
+ }
+ Err(e) => return Err(datadog::Error::Serde(e)),
+ };
+ } else {
+ let local_entity: Option =
+ 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 CoreWeave integration account. Only the fields provided are changed.
+ pub async fn update_core_weave_cloud_integration_account(
+ &self,
+ account_id: String,
+ body: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountUpdateRequest,
+ ) -> Result<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountResponse,
+ datadog::Error,
+ > {
+ match self
+ .update_core_weave_cloud_integration_account_with_http_info(account_id, body)
+ .await
+ {
+ Ok(response_content) => {
+ if let Some(e) = response_content.entity {
+ Ok(e)
+ } else {
+ Err(datadog::Error::Serde(serde::de::Error::custom(
+ "response content was None",
+ )))
+ }
+ }
+ Err(err) => Err(err),
+ }
+ }
+
+ /// Update a CoreWeave integration account. Only the fields provided are changed.
+ pub async fn update_core_weave_cloud_integration_account_with_http_info(
+ &self,
+ account_id: String,
+ body: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountUpdateRequest,
+ ) -> Result<
+ datadog::ResponseContent,
+ datadog::Error,
+ > {
+ let local_configuration = &self.config;
+ let local_operation_id = "v2.update_core_weave_cloud_integration_account";
+ if local_configuration.is_unstable_operation_enabled(local_operation_id) {
+ warn!("Using unstable operation {local_operation_id}");
+ } else {
+ let local_error = datadog::UnstableOperationDisabledError {
+ msg: "Operation 'v2.update_core_weave_cloud_integration_account' is not enabled"
+ .to_string(),
+ };
+ return Err(datadog::Error::UnstableOperationDisabledError(local_error));
+ }
+
+ let local_client = &self.client;
+
+ let local_uri_str = format!(
+ "{}/api/v2/integration-interfaces/coreweave-cloud/accounts/{account_id}",
+ local_configuration.get_operation_host(local_operation_id),
+ account_id = datadog::urlencode(account_id)
+ );
+ let mut local_req_builder =
+ local_client.request(reqwest::Method::PATCH, 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("application/json"));
+
+ // 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)),
+ }
+ }
+ #[cfg(feature = "zstd")]
+ "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() {
+ match serde_json::from_str::<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountResponse,
+ >(&local_content)
+ {
+ Ok(e) => {
+ return Ok(datadog::ResponseContent {
+ status: local_status,
+ content: local_content,
+ entity: Some(e),
+ })
+ }
+ Err(e) => return Err(datadog::Error::Serde(e)),
+ };
+ } else {
+ let local_entity: Option =
+ 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))
+ }
+ }
+}
diff --git a/src/datadogV2/api/mod.rs b/src/datadogV2/api/mod.rs
index 74eb5b6a40..e52f7e3aa2 100644
--- a/src/datadogV2/api/mod.rs
+++ b/src/datadogV2/api/mod.rs
@@ -39,6 +39,7 @@ pub mod api_compliance;
pub mod api_confluent_cloud;
pub mod api_container_images;
pub mod api_containers;
+pub mod api_core_weave_integration;
pub mod api_csm_agents;
pub mod api_csm_coverage_analysis;
pub mod api_csm_ownership;
diff --git a/src/datadogV2/mod.rs b/src/datadogV2/mod.rs
index 92d99d8435..db6122920e 100644
--- a/src/datadogV2/mod.rs
+++ b/src/datadogV2/mod.rs
@@ -40,6 +40,7 @@ pub use self::api::api_compliance;
pub use self::api::api_confluent_cloud;
pub use self::api::api_container_images;
pub use self::api::api_containers;
+pub use self::api::api_core_weave_integration;
pub use self::api::api_csm_agents;
pub use self::api::api_csm_coverage_analysis;
pub use self::api::api_csm_ownership;
diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs
index d4bad7d203..452293bc7e 100644
--- a/src/datadogV2/model/mod.rs
+++ b/src/datadogV2/model/mod.rs
@@ -6880,6 +6880,60 @@ pub mod model_incident_timestamp_override_patch_data_request;
pub use self::model_incident_timestamp_override_patch_data_request::IncidentTimestampOverridePatchDataRequest;
pub mod model_incident_timestamp_override_patch_data_attributes_request;
pub use self::model_incident_timestamp_override_patch_data_attributes_request::IncidentTimestampOverridePatchDataAttributesRequest;
+pub mod model_core_weave_cloud_integration_accounts_response;
+pub use self::model_core_weave_cloud_integration_accounts_response::CoreWeaveCloudIntegrationAccountsResponse;
+pub mod model_core_weave_cloud_integration_account_response_data;
+pub use self::model_core_weave_cloud_integration_account_response_data::CoreWeaveCloudIntegrationAccountResponseData;
+pub mod model_core_weave_cloud_integration_account_response_attributes;
+pub use self::model_core_weave_cloud_integration_account_response_attributes::CoreWeaveCloudIntegrationAccountResponseAttributes;
+pub mod model_core_weave_cloud_integration_account_api_token_auth_response;
+pub use self::model_core_weave_cloud_integration_account_api_token_auth_response::CoreWeaveCloudIntegrationAccountAPITokenAuthResponse;
+pub mod model_core_weave_cloud_integration_account_api_token_auth_type;
+pub use self::model_core_weave_cloud_integration_account_api_token_auth_type::CoreWeaveCloudIntegrationAccountAPITokenAuthType;
+pub mod model_core_weave_cloud_integration_account_authentication_response;
+pub use self::model_core_weave_cloud_integration_account_authentication_response::CoreWeaveCloudIntegrationAccountAuthenticationResponse;
+pub mod model_core_weave_cloud_integration_dataflows_response;
+pub use self::model_core_weave_cloud_integration_dataflows_response::CoreWeaveCloudIntegrationDataflowsResponse;
+pub mod model_core_weave_cloud_logs_integration_dataflow_response;
+pub use self::model_core_weave_cloud_logs_integration_dataflow_response::CoreWeaveCloudLogsIntegrationDataflowResponse;
+pub mod model_core_weave_cloud_metrics_integration_dataflow_response;
+pub use self::model_core_weave_cloud_metrics_integration_dataflow_response::CoreWeaveCloudMetricsIntegrationDataflowResponse;
+pub mod model_core_weave_cloud_integration_account_settings_response;
+pub use self::model_core_weave_cloud_integration_account_settings_response::CoreWeaveCloudIntegrationAccountSettingsResponse;
+pub mod model_integration_account_type;
+pub use self::model_integration_account_type::IntegrationAccountType;
+pub mod model_core_weave_cloud_integration_account_create_request;
+pub use self::model_core_weave_cloud_integration_account_create_request::CoreWeaveCloudIntegrationAccountCreateRequest;
+pub mod model_core_weave_cloud_integration_account_create_data;
+pub use self::model_core_weave_cloud_integration_account_create_data::CoreWeaveCloudIntegrationAccountCreateData;
+pub mod model_core_weave_cloud_integration_account_create_attributes;
+pub use self::model_core_weave_cloud_integration_account_create_attributes::CoreWeaveCloudIntegrationAccountCreateAttributes;
+pub mod model_core_weave_cloud_integration_account_api_token_auth_request;
+pub use self::model_core_weave_cloud_integration_account_api_token_auth_request::CoreWeaveCloudIntegrationAccountAPITokenAuthRequest;
+pub mod model_core_weave_cloud_integration_account_authentication_request;
+pub use self::model_core_weave_cloud_integration_account_authentication_request::CoreWeaveCloudIntegrationAccountAuthenticationRequest;
+pub mod model_core_weave_cloud_integration_dataflows_request;
+pub use self::model_core_weave_cloud_integration_dataflows_request::CoreWeaveCloudIntegrationDataflowsRequest;
+pub mod model_core_weave_cloud_logs_integration_dataflow_request;
+pub use self::model_core_weave_cloud_logs_integration_dataflow_request::CoreWeaveCloudLogsIntegrationDataflowRequest;
+pub mod model_core_weave_cloud_metrics_integration_dataflow_request;
+pub use self::model_core_weave_cloud_metrics_integration_dataflow_request::CoreWeaveCloudMetricsIntegrationDataflowRequest;
+pub mod model_core_weave_cloud_integration_account_settings_request;
+pub use self::model_core_weave_cloud_integration_account_settings_request::CoreWeaveCloudIntegrationAccountSettingsRequest;
+pub mod model_core_weave_cloud_integration_account_response;
+pub use self::model_core_weave_cloud_integration_account_response::CoreWeaveCloudIntegrationAccountResponse;
+pub mod model_core_weave_cloud_integration_account_update_request;
+pub use self::model_core_weave_cloud_integration_account_update_request::CoreWeaveCloudIntegrationAccountUpdateRequest;
+pub mod model_core_weave_cloud_integration_account_update_data;
+pub use self::model_core_weave_cloud_integration_account_update_data::CoreWeaveCloudIntegrationAccountUpdateData;
+pub mod model_core_weave_cloud_integration_account_update_attributes;
+pub use self::model_core_weave_cloud_integration_account_update_attributes::CoreWeaveCloudIntegrationAccountUpdateAttributes;
+pub mod model_core_weave_cloud_integration_account_api_token_auth_update;
+pub use self::model_core_weave_cloud_integration_account_api_token_auth_update::CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate;
+pub mod model_core_weave_cloud_integration_account_authentication_update;
+pub use self::model_core_weave_cloud_integration_account_authentication_update::CoreWeaveCloudIntegrationAccountAuthenticationUpdate;
+pub mod model_core_weave_cloud_integration_account_settings_update;
+pub use self::model_core_weave_cloud_integration_account_settings_update::CoreWeaveCloudIntegrationAccountSettingsUpdate;
pub mod model_databricks_integration_accounts_response;
pub use self::model_databricks_integration_accounts_response::DatabricksIntegrationAccountsResponse;
pub mod model_databricks_integration_account_response_data;
@@ -6918,8 +6972,6 @@ pub mod model_databricks_model_serving_metrics_integration_dataflow_response;
pub use self::model_databricks_model_serving_metrics_integration_dataflow_response::DatabricksModelServingMetricsIntegrationDataflowResponse;
pub mod model_databricks_integration_account_settings_response;
pub use self::model_databricks_integration_account_settings_response::DatabricksIntegrationAccountSettingsResponse;
-pub mod model_integration_account_type;
-pub use self::model_integration_account_type::IntegrationAccountType;
pub mod model_databricks_integration_account_create_request;
pub use self::model_databricks_integration_account_create_request::DatabricksIntegrationAccountCreateRequest;
pub mod model_databricks_integration_account_create_data;
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_request.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_request.rs
new file mode 100644
index 0000000000..cca77a27e8
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_request.rs
@@ -0,0 +1,99 @@
+// 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};
+
+/// API token authentication, the only method CoreWeave integration accounts support. Create the token in the CoreWeave Cloud console under Access Tokens; it starts with `CW-SECRET-`. The user who owns the token must have the Observability Viewer role, because tokens inherit their user's permissions.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountAPITokenAuthRequest {
+ /// Secret CoreWeave API access token used to authenticate with CoreWeave. Values that do not start with `CW-SECRET-` are rejected with a `422` response.
+ #[serde(rename = "api_token")]
+ pub api_token: String,
+ /// The authentication method type.
+ #[serde(rename = "auth_type")]
+ pub auth_type: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountAPITokenAuthRequest {
+ pub fn new(
+ api_token: String,
+ auth_type: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType,
+ ) -> CoreWeaveCloudIntegrationAccountAPITokenAuthRequest {
+ CoreWeaveCloudIntegrationAccountAPITokenAuthRequest {
+ api_token,
+ auth_type,
+ _unparsed: false,
+ }
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountAPITokenAuthRequest {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountAPITokenAuthRequestVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountAPITokenAuthRequestVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountAPITokenAuthRequest;
+
+ 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_token: Option = None;
+ let mut auth_type: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType,
+ > = None;
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "api_token" => {
+ api_token = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "auth_type" => {
+ auth_type = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ if let Some(ref _auth_type) = auth_type {
+ match _auth_type {
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType::UnparsedObject(_auth_type) => {
+ _unparsed = true;
+ },
+ _ => {}
+ }
+ }
+ }
+ &_ => {
+ return Err(serde::de::Error::custom(
+ "Additional properties not allowed",
+ ));
+ }
+ }
+ }
+ let api_token = api_token.ok_or_else(|| M::Error::missing_field("api_token"))?;
+ let auth_type = auth_type.ok_or_else(|| M::Error::missing_field("auth_type"))?;
+
+ let content = CoreWeaveCloudIntegrationAccountAPITokenAuthRequest {
+ api_token,
+ auth_type,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountAPITokenAuthRequestVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_response.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_response.rs
new file mode 100644
index 0000000000..e3f19d8a96
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_response.rs
@@ -0,0 +1,104 @@
+// 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 API token authentication method configured on the account.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountAPITokenAuthResponse {
+ /// The authentication method type.
+ #[serde(rename = "auth_type")]
+ pub auth_type: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountAPITokenAuthResponse {
+ pub fn new(
+ auth_type: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType,
+ ) -> CoreWeaveCloudIntegrationAccountAPITokenAuthResponse {
+ CoreWeaveCloudIntegrationAccountAPITokenAuthResponse {
+ auth_type,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountAPITokenAuthResponse {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountAPITokenAuthResponseVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountAPITokenAuthResponseVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountAPITokenAuthResponse;
+
+ 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 auth_type: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType,
+ > = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "auth_type" => {
+ auth_type = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ if let Some(ref _auth_type) = auth_type {
+ match _auth_type {
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType::UnparsedObject(_auth_type) => {
+ _unparsed = true;
+ },
+ _ => {}
+ }
+ }
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+ let auth_type = auth_type.ok_or_else(|| M::Error::missing_field("auth_type"))?;
+
+ let content = CoreWeaveCloudIntegrationAccountAPITokenAuthResponse {
+ auth_type,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountAPITokenAuthResponseVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_type.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_type.rs
new file mode 100644
index 0000000000..09f52886a1
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_type.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 CoreWeaveCloudIntegrationAccountAPITokenAuthType {
+ COREWEAVE_API_TOKEN,
+ UnparsedObject(crate::datadog::UnparsedObject),
+}
+
+impl ToString for CoreWeaveCloudIntegrationAccountAPITokenAuthType {
+ fn to_string(&self) -> String {
+ match self {
+ Self::COREWEAVE_API_TOKEN => String::from("coreweave_api_token"),
+ Self::UnparsedObject(v) => v.value.to_string(),
+ }
+ }
+}
+
+impl Serialize for CoreWeaveCloudIntegrationAccountAPITokenAuthType {
+ 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 CoreWeaveCloudIntegrationAccountAPITokenAuthType {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ let s: String = String::deserialize(deserializer)?;
+ Ok(match s.as_str() {
+ "coreweave_api_token" => Self::COREWEAVE_API_TOKEN,
+ _ => Self::UnparsedObject(crate::datadog::UnparsedObject {
+ value: serde_json::Value::String(s.into()),
+ }),
+ })
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_update.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_update.rs
new file mode 100644
index 0000000000..00e43a5e6c
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_update.rs
@@ -0,0 +1,105 @@
+// 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};
+
+/// API token authentication, the only method CoreWeave integration accounts support. Only the fields provided are changed; omit `api_token` to keep the stored one.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate {
+ /// Secret CoreWeave API access token used to authenticate with CoreWeave. It cannot be cleared; sending `null` or an empty string is rejected with a `422` response.
+ #[serde(rename = "api_token")]
+ pub api_token: Option,
+ /// The authentication method type.
+ #[serde(rename = "auth_type")]
+ pub auth_type: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate {
+ pub fn new(
+ auth_type: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType,
+ ) -> CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate {
+ CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate {
+ api_token: None,
+ auth_type,
+ _unparsed: false,
+ }
+ }
+
+ pub fn api_token(mut self, value: String) -> Self {
+ self.api_token = Some(value);
+ self
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountAPITokenAuthUpdateVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountAPITokenAuthUpdateVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate;
+
+ 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_token: Option = None;
+ let mut auth_type: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType,
+ > = None;
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "api_token" => {
+ if v.is_null() {
+ continue;
+ }
+ api_token = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "auth_type" => {
+ auth_type = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ if let Some(ref _auth_type) = auth_type {
+ match _auth_type {
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAPITokenAuthType::UnparsedObject(_auth_type) => {
+ _unparsed = true;
+ },
+ _ => {}
+ }
+ }
+ }
+ &_ => {
+ return Err(serde::de::Error::custom(
+ "Additional properties not allowed",
+ ));
+ }
+ }
+ }
+ let auth_type = auth_type.ok_or_else(|| M::Error::missing_field("auth_type"))?;
+
+ let content = CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate {
+ api_token,
+ auth_type,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountAPITokenAuthUpdateVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_authentication_request.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_authentication_request.rs
new file mode 100644
index 0000000000..68de21781f
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_authentication_request.rs
@@ -0,0 +1,38 @@
+// 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};
+
+/// Authentication for creating the CoreWeave integration account. Exactly one method is set.
+#[non_exhaustive]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(untagged)]
+pub enum CoreWeaveCloudIntegrationAccountAuthenticationRequest {
+ CoreWeaveCloudIntegrationAccountAPITokenAuthRequest(
+ Box,
+ ),
+ UnparsedObject(crate::datadog::UnparsedObject),
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountAuthenticationRequest {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ let value: serde_json::Value = Deserialize::deserialize(deserializer)?;
+ if let Ok(_v) = serde_json::from_value::<
+ Box,
+ >(value.clone())
+ {
+ if !_v._unparsed {
+ return Ok(CoreWeaveCloudIntegrationAccountAuthenticationRequest::CoreWeaveCloudIntegrationAccountAPITokenAuthRequest(_v));
+ }
+ }
+
+ return Ok(
+ CoreWeaveCloudIntegrationAccountAuthenticationRequest::UnparsedObject(
+ crate::datadog::UnparsedObject { value },
+ ),
+ );
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_authentication_response.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_authentication_response.rs
new file mode 100644
index 0000000000..d76a3be4f7
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_authentication_response.rs
@@ -0,0 +1,38 @@
+// 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};
+
+/// Authentication configured on the CoreWeave integration account.
+#[non_exhaustive]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(untagged)]
+pub enum CoreWeaveCloudIntegrationAccountAuthenticationResponse {
+ CoreWeaveCloudIntegrationAccountAPITokenAuthResponse(
+ Box,
+ ),
+ UnparsedObject(crate::datadog::UnparsedObject),
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountAuthenticationResponse {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ let value: serde_json::Value = Deserialize::deserialize(deserializer)?;
+ if let Ok(_v) = serde_json::from_value::<
+ Box,
+ >(value.clone())
+ {
+ if !_v._unparsed {
+ return Ok(CoreWeaveCloudIntegrationAccountAuthenticationResponse::CoreWeaveCloudIntegrationAccountAPITokenAuthResponse(_v));
+ }
+ }
+
+ return Ok(
+ CoreWeaveCloudIntegrationAccountAuthenticationResponse::UnparsedObject(
+ crate::datadog::UnparsedObject { value },
+ ),
+ );
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_authentication_update.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_authentication_update.rs
new file mode 100644
index 0000000000..09d1fd298a
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_authentication_update.rs
@@ -0,0 +1,38 @@
+// 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};
+
+/// Authentication for updating the CoreWeave integration account. Exactly one method is set.
+#[non_exhaustive]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(untagged)]
+pub enum CoreWeaveCloudIntegrationAccountAuthenticationUpdate {
+ CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate(
+ Box,
+ ),
+ UnparsedObject(crate::datadog::UnparsedObject),
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountAuthenticationUpdate {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ let value: serde_json::Value = Deserialize::deserialize(deserializer)?;
+ if let Ok(_v) = serde_json::from_value::<
+ Box,
+ >(value.clone())
+ {
+ if !_v._unparsed {
+ return Ok(CoreWeaveCloudIntegrationAccountAuthenticationUpdate::CoreWeaveCloudIntegrationAccountAPITokenAuthUpdate(_v));
+ }
+ }
+
+ return Ok(
+ CoreWeaveCloudIntegrationAccountAuthenticationUpdate::UnparsedObject(
+ crate::datadog::UnparsedObject { value },
+ ),
+ );
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_create_attributes.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_create_attributes.rs
new file mode 100644
index 0000000000..d2291ca05c
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_create_attributes.rs
@@ -0,0 +1,153 @@
+// 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};
+
+/// Writable attributes used to create a CoreWeave integration account.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountCreateAttributes {
+ /// Authentication for creating the CoreWeave integration account. Exactly one method is set.
+ #[serde(rename = "authentication")]
+ pub authentication:
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAuthenticationRequest,
+ /// Data Datadog collects from CoreWeave, keyed by dataflow id. Each dataflow turns on a distinct kind of collection: set `enabled` to start or stop it. Defaults listed on each dataflow apply when the account is created; on update, omitted dataflow ids keep their current values. Collection runs with the API access token in `authentication`, whose user must have the Observability Viewer role; a dataflow enabled without that role is stored but collects no data.
+ #[serde(rename = "dataflows")]
+ pub dataflows: Option,
+ /// Human-readable name of the CoreWeave integration account.
+ #[serde(rename = "name")]
+ pub name: String,
+ /// Settings for creating the CoreWeave integration account.
+ #[serde(rename = "settings")]
+ pub settings: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountSettingsRequest,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountCreateAttributes {
+ pub fn new(
+ authentication: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAuthenticationRequest,
+ name: String,
+ settings: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountSettingsRequest,
+ ) -> CoreWeaveCloudIntegrationAccountCreateAttributes {
+ CoreWeaveCloudIntegrationAccountCreateAttributes {
+ authentication,
+ dataflows: None,
+ name,
+ settings,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn dataflows(
+ mut self,
+ value: crate::datadogV2::model::CoreWeaveCloudIntegrationDataflowsRequest,
+ ) -> Self {
+ self.dataflows = Some(value);
+ self
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountCreateAttributes {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountCreateAttributesVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountCreateAttributesVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountCreateAttributes;
+
+ 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 authentication: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAuthenticationRequest,
+ > = None;
+ let mut dataflows: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationDataflowsRequest,
+ > = None;
+ let mut name: Option = None;
+ let mut settings: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountSettingsRequest,
+ > = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "authentication" => {
+ authentication =
+ Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ if let Some(ref _authentication) = authentication {
+ match _authentication {
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAuthenticationRequest::UnparsedObject(_authentication) => {
+ _unparsed = true;
+ },
+ _ => {}
+ }
+ }
+ }
+ "dataflows" => {
+ if v.is_null() {
+ continue;
+ }
+ dataflows = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "name" => {
+ name = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "settings" => {
+ settings = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+ let authentication =
+ authentication.ok_or_else(|| M::Error::missing_field("authentication"))?;
+ let name = name.ok_or_else(|| M::Error::missing_field("name"))?;
+ let settings = settings.ok_or_else(|| M::Error::missing_field("settings"))?;
+
+ let content = CoreWeaveCloudIntegrationAccountCreateAttributes {
+ authentication,
+ dataflows,
+ name,
+ settings,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountCreateAttributesVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_create_data.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_create_data.rs
new file mode 100644
index 0000000000..4f059ee79b
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_create_data.rs
@@ -0,0 +1,115 @@
+// 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};
+
+/// Data envelope for creating a CoreWeave integration account.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountCreateData {
+ /// Writable attributes used to create a CoreWeave integration account.
+ #[serde(rename = "attributes")]
+ pub attributes: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountCreateAttributes,
+ /// The type of the integration account resource. Always `integration-account`.
+ #[serde(rename = "type")]
+ pub type_: crate::datadogV2::model::IntegrationAccountType,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountCreateData {
+ pub fn new(
+ attributes: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountCreateAttributes,
+ type_: crate::datadogV2::model::IntegrationAccountType,
+ ) -> CoreWeaveCloudIntegrationAccountCreateData {
+ CoreWeaveCloudIntegrationAccountCreateData {
+ attributes,
+ type_,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountCreateData {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountCreateDataVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountCreateDataVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountCreateData;
+
+ 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 attributes: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountCreateAttributes,
+ > = None;
+ let mut type_: Option = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "attributes" => {
+ attributes = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "type" => {
+ type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ if let Some(ref _type_) = type_ {
+ match _type_ {
+ crate::datadogV2::model::IntegrationAccountType::UnparsedObject(_type_) => {
+ _unparsed = true;
+ },
+ _ => {}
+ }
+ }
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+ let attributes = attributes.ok_or_else(|| M::Error::missing_field("attributes"))?;
+ let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?;
+
+ let content = CoreWeaveCloudIntegrationAccountCreateData {
+ attributes,
+ type_,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountCreateDataVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_create_request.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_create_request.rs
new file mode 100644
index 0000000000..3ea49631ed
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_create_request.rs
@@ -0,0 +1,96 @@
+// 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};
+
+/// Request payload to create a CoreWeave integration account.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountCreateRequest {
+ /// Data envelope for creating a CoreWeave integration account.
+ #[serde(rename = "data")]
+ pub data: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountCreateData,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountCreateRequest {
+ pub fn new(
+ data: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountCreateData,
+ ) -> CoreWeaveCloudIntegrationAccountCreateRequest {
+ CoreWeaveCloudIntegrationAccountCreateRequest {
+ data,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountCreateRequest {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountCreateRequestVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountCreateRequestVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountCreateRequest;
+
+ 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 data: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountCreateData,
+ > = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "data" => {
+ data = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+ let data = data.ok_or_else(|| M::Error::missing_field("data"))?;
+
+ let content = CoreWeaveCloudIntegrationAccountCreateRequest {
+ data,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountCreateRequestVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_response.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_response.rs
new file mode 100644
index 0000000000..f61900341a
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_response.rs
@@ -0,0 +1,96 @@
+// 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};
+
+/// Response payload for a single CoreWeave integration account.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountResponse {
+ /// Data envelope of a CoreWeave integration account, including server-assigned identity.
+ #[serde(rename = "data")]
+ pub data: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountResponseData,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountResponse {
+ pub fn new(
+ data: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountResponseData,
+ ) -> CoreWeaveCloudIntegrationAccountResponse {
+ CoreWeaveCloudIntegrationAccountResponse {
+ data,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountResponse {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountResponseVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountResponseVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountResponse;
+
+ 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 data: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountResponseData,
+ > = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "data" => {
+ data = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+ let data = data.ok_or_else(|| M::Error::missing_field("data"))?;
+
+ let content = CoreWeaveCloudIntegrationAccountResponse {
+ data,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountResponseVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_response_attributes.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_response_attributes.rs
new file mode 100644
index 0000000000..b015f47413
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_response_attributes.rs
@@ -0,0 +1,161 @@
+// 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};
+
+/// Attributes of a CoreWeave integration account returned in responses.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountResponseAttributes {
+ /// Authentication configured on the CoreWeave integration account.
+ #[serde(rename = "authentication")]
+ pub authentication:
+ Option,
+ /// Data Datadog collects from CoreWeave, keyed by dataflow id.
+ #[serde(rename = "dataflows")]
+ pub dataflows: Option,
+ /// Human-readable name of the CoreWeave integration account.
+ #[serde(rename = "name")]
+ pub name: String,
+ /// Settings configured on the CoreWeave integration account.
+ #[serde(rename = "settings")]
+ pub settings: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountSettingsResponse,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountResponseAttributes {
+ pub fn new(
+ name: String,
+ settings: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountSettingsResponse,
+ ) -> CoreWeaveCloudIntegrationAccountResponseAttributes {
+ CoreWeaveCloudIntegrationAccountResponseAttributes {
+ authentication: None,
+ dataflows: None,
+ name,
+ settings,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn authentication(
+ mut self,
+ value: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAuthenticationResponse,
+ ) -> Self {
+ self.authentication = Some(value);
+ self
+ }
+
+ pub fn dataflows(
+ mut self,
+ value: crate::datadogV2::model::CoreWeaveCloudIntegrationDataflowsResponse,
+ ) -> Self {
+ self.dataflows = Some(value);
+ self
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountResponseAttributes {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountResponseAttributesVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountResponseAttributesVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountResponseAttributes;
+
+ 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 authentication: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAuthenticationResponse,
+ > = None;
+ let mut dataflows: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationDataflowsResponse,
+ > = None;
+ let mut name: Option = None;
+ let mut settings: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountSettingsResponse,
+ > = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "authentication" => {
+ if v.is_null() {
+ continue;
+ }
+ authentication =
+ Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ if let Some(ref _authentication) = authentication {
+ match _authentication {
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAuthenticationResponse::UnparsedObject(_authentication) => {
+ _unparsed = true;
+ },
+ _ => {}
+ }
+ }
+ }
+ "dataflows" => {
+ if v.is_null() {
+ continue;
+ }
+ dataflows = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "name" => {
+ name = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "settings" => {
+ settings = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+ let name = name.ok_or_else(|| M::Error::missing_field("name"))?;
+ let settings = settings.ok_or_else(|| M::Error::missing_field("settings"))?;
+
+ let content = CoreWeaveCloudIntegrationAccountResponseAttributes {
+ authentication,
+ dataflows,
+ name,
+ settings,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountResponseAttributesVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_response_data.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_response_data.rs
new file mode 100644
index 0000000000..431ac42554
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_response_data.rs
@@ -0,0 +1,126 @@
+// 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};
+
+/// Data envelope of a CoreWeave integration account, including server-assigned identity.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountResponseData {
+ /// Attributes of a CoreWeave integration account returned in responses.
+ #[serde(rename = "attributes")]
+ pub attributes: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountResponseAttributes,
+ /// Server-generated unique identifier of the CoreWeave integration account.
+ #[serde(rename = "id")]
+ pub id: String,
+ /// The type of the integration account resource. Always `integration-account`.
+ #[serde(rename = "type")]
+ pub type_: crate::datadogV2::model::IntegrationAccountType,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountResponseData {
+ pub fn new(
+ attributes: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountResponseAttributes,
+ id: String,
+ type_: crate::datadogV2::model::IntegrationAccountType,
+ ) -> CoreWeaveCloudIntegrationAccountResponseData {
+ CoreWeaveCloudIntegrationAccountResponseData {
+ attributes,
+ id,
+ type_,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountResponseData {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountResponseDataVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountResponseDataVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountResponseData;
+
+ 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 attributes: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountResponseAttributes,
+ > = None;
+ let mut id: Option = None;
+ let mut type_: Option = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "attributes" => {
+ attributes = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "id" => {
+ id = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "type" => {
+ type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ if let Some(ref _type_) = type_ {
+ match _type_ {
+ crate::datadogV2::model::IntegrationAccountType::UnparsedObject(_type_) => {
+ _unparsed = true;
+ },
+ _ => {}
+ }
+ }
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+ let attributes = attributes.ok_or_else(|| M::Error::missing_field("attributes"))?;
+ let id = id.ok_or_else(|| M::Error::missing_field("id"))?;
+ let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?;
+
+ let content = CoreWeaveCloudIntegrationAccountResponseData {
+ attributes,
+ id,
+ type_,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountResponseDataVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_settings_request.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_settings_request.rs
new file mode 100644
index 0000000000..1671973c67
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_settings_request.rs
@@ -0,0 +1,108 @@
+// 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};
+
+/// Settings for creating the CoreWeave integration account.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountSettingsRequest {
+ /// Tags added to all metrics and logs collected from this CoreWeave account. Defaults to no tags.
+ #[serde(rename = "account_tags")]
+ pub account_tags: Option>,
+ /// Tag-filter rules limiting metric collection to matching clusters, for cost savings. Include rules (`key:value`) are combined with OR, exclusion rules (`!key:value`) are then applied with AND, and `?` and `*` are wildcards; for example `cluster:prod-*` collects only matching clusters and `!cluster:dev` excludes a cluster. Defaults to no filters: every cluster is collected. Only cluster-scoped metrics are filtered; billing and object storage metrics are always collected.
+ #[serde(rename = "cluster_filters")]
+ pub cluster_filters: Option>,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountSettingsRequest {
+ pub fn new() -> CoreWeaveCloudIntegrationAccountSettingsRequest {
+ CoreWeaveCloudIntegrationAccountSettingsRequest {
+ account_tags: None,
+ cluster_filters: None,
+ _unparsed: false,
+ }
+ }
+
+ pub fn account_tags(mut self, value: Vec) -> Self {
+ self.account_tags = Some(value);
+ self
+ }
+
+ pub fn cluster_filters(mut self, value: Vec) -> Self {
+ self.cluster_filters = Some(value);
+ self
+ }
+}
+
+impl Default for CoreWeaveCloudIntegrationAccountSettingsRequest {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountSettingsRequest {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountSettingsRequestVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountSettingsRequestVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountSettingsRequest;
+
+ 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 account_tags: Option> = None;
+ let mut cluster_filters: Option> = None;
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "account_tags" => {
+ if v.is_null() {
+ continue;
+ }
+ account_tags =
+ Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "cluster_filters" => {
+ if v.is_null() {
+ continue;
+ }
+ cluster_filters =
+ Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ return Err(serde::de::Error::custom(
+ "Additional properties not allowed",
+ ));
+ }
+ }
+ }
+
+ let content = CoreWeaveCloudIntegrationAccountSettingsRequest {
+ account_tags,
+ cluster_filters,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountSettingsRequestVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_settings_response.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_settings_response.rs
new file mode 100644
index 0000000000..a2b2a04bcb
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_settings_response.rs
@@ -0,0 +1,124 @@
+// 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};
+
+/// Settings configured on the CoreWeave integration account.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountSettingsResponse {
+ /// Tags added to all data collected from this CoreWeave account.
+ #[serde(rename = "account_tags")]
+ pub account_tags: Option>,
+ /// Tag-filter rules limiting metric collection to matching clusters. Absent when no filters are configured.
+ #[serde(rename = "cluster_filters")]
+ pub cluster_filters: Option>,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountSettingsResponse {
+ pub fn new() -> CoreWeaveCloudIntegrationAccountSettingsResponse {
+ CoreWeaveCloudIntegrationAccountSettingsResponse {
+ account_tags: None,
+ cluster_filters: None,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn account_tags(mut self, value: Vec) -> Self {
+ self.account_tags = Some(value);
+ self
+ }
+
+ pub fn cluster_filters(mut self, value: Vec) -> Self {
+ self.cluster_filters = Some(value);
+ self
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl Default for CoreWeaveCloudIntegrationAccountSettingsResponse {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountSettingsResponse {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountSettingsResponseVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountSettingsResponseVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountSettingsResponse;
+
+ 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 account_tags: Option> = None;
+ let mut cluster_filters: Option> = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "account_tags" => {
+ if v.is_null() {
+ continue;
+ }
+ account_tags =
+ Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "cluster_filters" => {
+ if v.is_null() {
+ continue;
+ }
+ cluster_filters =
+ Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+
+ let content = CoreWeaveCloudIntegrationAccountSettingsResponse {
+ account_tags,
+ cluster_filters,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountSettingsResponseVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_settings_update.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_settings_update.rs
new file mode 100644
index 0000000000..16951bfd27
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_settings_update.rs
@@ -0,0 +1,108 @@
+// 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};
+
+/// Settings for updating the CoreWeave integration account. Only the fields provided are changed.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountSettingsUpdate {
+ /// Tags added to all metrics and logs collected from this CoreWeave account. Sending it replaces the whole list; send an empty array to remove all tags, or omit it to keep the stored list.
+ #[serde(rename = "account_tags")]
+ pub account_tags: Option>,
+ /// Tag-filter rules limiting metric collection to matching clusters. Sending it replaces the whole list; send an empty array to remove all filters and collect every cluster, or omit it to keep the stored list. Include rules (`key:value`) are combined with OR, exclusion rules (`!key:value`) are then applied with AND, and `?` and `*` are wildcards.
+ #[serde(rename = "cluster_filters")]
+ pub cluster_filters: Option>,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountSettingsUpdate {
+ pub fn new() -> CoreWeaveCloudIntegrationAccountSettingsUpdate {
+ CoreWeaveCloudIntegrationAccountSettingsUpdate {
+ account_tags: None,
+ cluster_filters: None,
+ _unparsed: false,
+ }
+ }
+
+ pub fn account_tags(mut self, value: Vec) -> Self {
+ self.account_tags = Some(value);
+ self
+ }
+
+ pub fn cluster_filters(mut self, value: Vec) -> Self {
+ self.cluster_filters = Some(value);
+ self
+ }
+}
+
+impl Default for CoreWeaveCloudIntegrationAccountSettingsUpdate {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountSettingsUpdate {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountSettingsUpdateVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountSettingsUpdateVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountSettingsUpdate;
+
+ 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 account_tags: Option> = None;
+ let mut cluster_filters: Option> = None;
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "account_tags" => {
+ if v.is_null() {
+ continue;
+ }
+ account_tags =
+ Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "cluster_filters" => {
+ if v.is_null() {
+ continue;
+ }
+ cluster_filters =
+ Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ return Err(serde::de::Error::custom(
+ "Additional properties not allowed",
+ ));
+ }
+ }
+ }
+
+ let content = CoreWeaveCloudIntegrationAccountSettingsUpdate {
+ account_tags,
+ cluster_filters,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountSettingsUpdateVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_update_attributes.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_update_attributes.rs
new file mode 100644
index 0000000000..1b3e69fd64
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_update_attributes.rs
@@ -0,0 +1,181 @@
+// 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};
+
+/// Writable attributes used to update a CoreWeave integration account. Every field is optional; only the fields provided are changed. When `dataflows` is provided, only the dataflow ids included in the request are modified; dataflows omitted from the map keep their current configuration.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountUpdateAttributes {
+ /// Authentication for updating the CoreWeave integration account. Exactly one method is set.
+ #[serde(rename = "authentication")]
+ pub authentication:
+ Option,
+ /// Data Datadog collects from CoreWeave, keyed by dataflow id. Each dataflow turns on a distinct kind of collection: set `enabled` to start or stop it. Defaults listed on each dataflow apply when the account is created; on update, omitted dataflow ids keep their current values. Collection runs with the API access token in `authentication`, whose user must have the Observability Viewer role; a dataflow enabled without that role is stored but collects no data.
+ #[serde(rename = "dataflows")]
+ pub dataflows: Option,
+ /// Human-readable name of the CoreWeave integration account.
+ #[serde(rename = "name")]
+ pub name: Option,
+ /// Settings for updating the CoreWeave integration account. Only the fields provided are changed.
+ #[serde(rename = "settings")]
+ pub settings: Option,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountUpdateAttributes {
+ pub fn new() -> CoreWeaveCloudIntegrationAccountUpdateAttributes {
+ CoreWeaveCloudIntegrationAccountUpdateAttributes {
+ authentication: None,
+ dataflows: None,
+ name: None,
+ settings: None,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn authentication(
+ mut self,
+ value: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAuthenticationUpdate,
+ ) -> Self {
+ self.authentication = Some(value);
+ self
+ }
+
+ pub fn dataflows(
+ mut self,
+ value: crate::datadogV2::model::CoreWeaveCloudIntegrationDataflowsRequest,
+ ) -> Self {
+ self.dataflows = Some(value);
+ self
+ }
+
+ pub fn name(mut self, value: String) -> Self {
+ self.name = Some(value);
+ self
+ }
+
+ pub fn settings(
+ mut self,
+ value: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountSettingsUpdate,
+ ) -> Self {
+ self.settings = Some(value);
+ self
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl Default for CoreWeaveCloudIntegrationAccountUpdateAttributes {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountUpdateAttributes {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountUpdateAttributesVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountUpdateAttributesVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountUpdateAttributes;
+
+ 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 authentication: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAuthenticationUpdate,
+ > = None;
+ let mut dataflows: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationDataflowsRequest,
+ > = None;
+ let mut name: Option = None;
+ let mut settings: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountSettingsUpdate,
+ > = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "authentication" => {
+ if v.is_null() {
+ continue;
+ }
+ authentication =
+ Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ if let Some(ref _authentication) = authentication {
+ match _authentication {
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountAuthenticationUpdate::UnparsedObject(_authentication) => {
+ _unparsed = true;
+ },
+ _ => {}
+ }
+ }
+ }
+ "dataflows" => {
+ if v.is_null() {
+ continue;
+ }
+ dataflows = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "name" => {
+ if v.is_null() {
+ continue;
+ }
+ name = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "settings" => {
+ if v.is_null() {
+ continue;
+ }
+ settings = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+
+ let content = CoreWeaveCloudIntegrationAccountUpdateAttributes {
+ authentication,
+ dataflows,
+ name,
+ settings,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountUpdateAttributesVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_update_data.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_update_data.rs
new file mode 100644
index 0000000000..2056504588
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_update_data.rs
@@ -0,0 +1,126 @@
+// 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};
+
+/// Data envelope for updating a CoreWeave integration account.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountUpdateData {
+ /// Writable attributes used to update a CoreWeave integration account. Every field is optional; only the fields provided are changed. When `dataflows` is provided, only the dataflow ids included in the request are modified; dataflows omitted from the map keep their current configuration.
+ #[serde(rename = "attributes")]
+ pub attributes: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountUpdateAttributes,
+ /// Unique identifier of the CoreWeave integration account to update.
+ #[serde(rename = "id")]
+ pub id: String,
+ /// The type of the integration account resource. Always `integration-account`.
+ #[serde(rename = "type")]
+ pub type_: crate::datadogV2::model::IntegrationAccountType,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountUpdateData {
+ pub fn new(
+ attributes: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountUpdateAttributes,
+ id: String,
+ type_: crate::datadogV2::model::IntegrationAccountType,
+ ) -> CoreWeaveCloudIntegrationAccountUpdateData {
+ CoreWeaveCloudIntegrationAccountUpdateData {
+ attributes,
+ id,
+ type_,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountUpdateData {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountUpdateDataVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountUpdateDataVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountUpdateData;
+
+ 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 attributes: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountUpdateAttributes,
+ > = None;
+ let mut id: Option = None;
+ let mut type_: Option = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "attributes" => {
+ attributes = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "id" => {
+ id = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "type" => {
+ type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ if let Some(ref _type_) = type_ {
+ match _type_ {
+ crate::datadogV2::model::IntegrationAccountType::UnparsedObject(_type_) => {
+ _unparsed = true;
+ },
+ _ => {}
+ }
+ }
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+ let attributes = attributes.ok_or_else(|| M::Error::missing_field("attributes"))?;
+ let id = id.ok_or_else(|| M::Error::missing_field("id"))?;
+ let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?;
+
+ let content = CoreWeaveCloudIntegrationAccountUpdateData {
+ attributes,
+ id,
+ type_,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountUpdateDataVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_account_update_request.rs b/src/datadogV2/model/model_core_weave_cloud_integration_account_update_request.rs
new file mode 100644
index 0000000000..139c2ba896
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_account_update_request.rs
@@ -0,0 +1,96 @@
+// 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};
+
+/// Request payload to update a CoreWeave integration account.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountUpdateRequest {
+ /// Data envelope for updating a CoreWeave integration account.
+ #[serde(rename = "data")]
+ pub data: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountUpdateData,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountUpdateRequest {
+ pub fn new(
+ data: crate::datadogV2::model::CoreWeaveCloudIntegrationAccountUpdateData,
+ ) -> CoreWeaveCloudIntegrationAccountUpdateRequest {
+ CoreWeaveCloudIntegrationAccountUpdateRequest {
+ data,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountUpdateRequest {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountUpdateRequestVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountUpdateRequestVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountUpdateRequest;
+
+ 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 data: Option<
+ crate::datadogV2::model::CoreWeaveCloudIntegrationAccountUpdateData,
+ > = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "data" => {
+ data = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+ let data = data.ok_or_else(|| M::Error::missing_field("data"))?;
+
+ let content = CoreWeaveCloudIntegrationAccountUpdateRequest {
+ data,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountUpdateRequestVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_accounts_response.rs b/src/datadogV2/model/model_core_weave_cloud_integration_accounts_response.rs
new file mode 100644
index 0000000000..ac06cb277f
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_accounts_response.rs
@@ -0,0 +1,96 @@
+// 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};
+
+/// Response payload for a list of CoreWeave integration accounts.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationAccountsResponse {
+ /// List of CoreWeave integration accounts.
+ #[serde(rename = "data")]
+ pub data: Vec,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationAccountsResponse {
+ pub fn new(
+ data: Vec,
+ ) -> CoreWeaveCloudIntegrationAccountsResponse {
+ CoreWeaveCloudIntegrationAccountsResponse {
+ data,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationAccountsResponse {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationAccountsResponseVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationAccountsResponseVisitor {
+ type Value = CoreWeaveCloudIntegrationAccountsResponse;
+
+ 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 data: Option<
+ Vec,
+ > = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "data" => {
+ data = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+ let data = data.ok_or_else(|| M::Error::missing_field("data"))?;
+
+ let content = CoreWeaveCloudIntegrationAccountsResponse {
+ data,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationAccountsResponseVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_dataflows_request.rs b/src/datadogV2/model/model_core_weave_cloud_integration_dataflows_request.rs
new file mode 100644
index 0000000000..b3a37999ff
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_dataflows_request.rs
@@ -0,0 +1,120 @@
+// 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};
+
+/// Data Datadog collects from CoreWeave, keyed by dataflow id. Each dataflow turns on a distinct kind of collection: set `enabled` to start or stop it. Defaults listed on each dataflow apply when the account is created; on update, omitted dataflow ids keep their current values. Collection runs with the API access token in `authentication`, whose user must have the Observability Viewer role; a dataflow enabled without that role is stored but collects no data.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationDataflowsRequest {
+ /// Service logs for CoreWeave-managed components in each CoreWeave region: the CKS control plane (such as `kube-apiserver` and `etcd`), CoreWeave add-on services in the `cw-*` and `kube-system` namespaces, SUNK, and node system logs such as `kubelet` and `containerd`. Logs from your own workloads and Kubernetes audit logs are not collected. Logs are sent with `source:coreweave`, with CoreWeave log labels such as `namespace`, `app`, and `systemd_unit` added as tags.
+ #[serde(rename = "coreweave-cloud-logs")]
+ pub coreweave_cloud_logs:
+ Option,
+ /// Metrics from your CoreWeave organization: CoreWeave service metrics collected through its PromQL-compatible Prometheus endpoint, plus the `coreweave.*` namespaces from CoreWeave products such as Kubernetes, Database, Distributed File Storage, Inference, and Object Storage. Compute metrics (`coreweave.bare_metal`, `coreweave.gpu`, `coreweave.nccl`, and `coreweave.node`) are in Preview. Container metrics are not collected; install the Datadog Agent on your clusters for those.
+ #[serde(rename = "coreweave-cloud-metrics")]
+ pub coreweave_cloud_metrics:
+ Option,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationDataflowsRequest {
+ pub fn new() -> CoreWeaveCloudIntegrationDataflowsRequest {
+ CoreWeaveCloudIntegrationDataflowsRequest {
+ coreweave_cloud_logs: None,
+ coreweave_cloud_metrics: None,
+ _unparsed: false,
+ }
+ }
+
+ pub fn coreweave_cloud_logs(
+ mut self,
+ value: crate::datadogV2::model::CoreWeaveCloudLogsIntegrationDataflowRequest,
+ ) -> Self {
+ self.coreweave_cloud_logs = Some(value);
+ self
+ }
+
+ pub fn coreweave_cloud_metrics(
+ mut self,
+ value: crate::datadogV2::model::CoreWeaveCloudMetricsIntegrationDataflowRequest,
+ ) -> Self {
+ self.coreweave_cloud_metrics = Some(value);
+ self
+ }
+}
+
+impl Default for CoreWeaveCloudIntegrationDataflowsRequest {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationDataflowsRequest {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationDataflowsRequestVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationDataflowsRequestVisitor {
+ type Value = CoreWeaveCloudIntegrationDataflowsRequest;
+
+ 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 coreweave_cloud_logs: Option<
+ crate::datadogV2::model::CoreWeaveCloudLogsIntegrationDataflowRequest,
+ > = None;
+ let mut coreweave_cloud_metrics: Option<
+ crate::datadogV2::model::CoreWeaveCloudMetricsIntegrationDataflowRequest,
+ > = None;
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "coreweave-cloud-logs" => {
+ if v.is_null() {
+ continue;
+ }
+ coreweave_cloud_logs =
+ Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "coreweave-cloud-metrics" => {
+ if v.is_null() {
+ continue;
+ }
+ coreweave_cloud_metrics =
+ Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ return Err(serde::de::Error::custom(
+ "Additional properties not allowed",
+ ));
+ }
+ }
+ }
+
+ let content = CoreWeaveCloudIntegrationDataflowsRequest {
+ coreweave_cloud_logs,
+ coreweave_cloud_metrics,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationDataflowsRequestVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_integration_dataflows_response.rs b/src/datadogV2/model/model_core_weave_cloud_integration_dataflows_response.rs
new file mode 100644
index 0000000000..3bab58f244
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_integration_dataflows_response.rs
@@ -0,0 +1,136 @@
+// 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};
+
+/// Data Datadog collects from CoreWeave, keyed by dataflow id.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudIntegrationDataflowsResponse {
+ /// Service logs for CoreWeave-managed components in each CoreWeave region: the CKS control plane (such as `kube-apiserver` and `etcd`), CoreWeave add-on services in the `cw-*` and `kube-system` namespaces, SUNK, and node system logs such as `kubelet` and `containerd`. Logs from your own workloads and Kubernetes audit logs are not collected. Logs are sent with `source:coreweave`, with CoreWeave log labels such as `namespace`, `app`, and `systemd_unit` added as tags.
+ #[serde(rename = "coreweave-cloud-logs")]
+ pub coreweave_cloud_logs:
+ Option,
+ /// Metrics from your CoreWeave organization: CoreWeave service metrics collected through its PromQL-compatible Prometheus endpoint, plus the `coreweave.*` namespaces from CoreWeave products such as Kubernetes, Database, Distributed File Storage, Inference, and Object Storage. Compute metrics (`coreweave.bare_metal`, `coreweave.gpu`, `coreweave.nccl`, and `coreweave.node`) are in Preview. Container metrics are not collected; install the Datadog Agent on your clusters for those.
+ #[serde(rename = "coreweave-cloud-metrics")]
+ pub coreweave_cloud_metrics:
+ Option,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudIntegrationDataflowsResponse {
+ pub fn new() -> CoreWeaveCloudIntegrationDataflowsResponse {
+ CoreWeaveCloudIntegrationDataflowsResponse {
+ coreweave_cloud_logs: None,
+ coreweave_cloud_metrics: None,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn coreweave_cloud_logs(
+ mut self,
+ value: crate::datadogV2::model::CoreWeaveCloudLogsIntegrationDataflowResponse,
+ ) -> Self {
+ self.coreweave_cloud_logs = Some(value);
+ self
+ }
+
+ pub fn coreweave_cloud_metrics(
+ mut self,
+ value: crate::datadogV2::model::CoreWeaveCloudMetricsIntegrationDataflowResponse,
+ ) -> Self {
+ self.coreweave_cloud_metrics = Some(value);
+ self
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl Default for CoreWeaveCloudIntegrationDataflowsResponse {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudIntegrationDataflowsResponse {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudIntegrationDataflowsResponseVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudIntegrationDataflowsResponseVisitor {
+ type Value = CoreWeaveCloudIntegrationDataflowsResponse;
+
+ 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 coreweave_cloud_logs: Option<
+ crate::datadogV2::model::CoreWeaveCloudLogsIntegrationDataflowResponse,
+ > = None;
+ let mut coreweave_cloud_metrics: Option<
+ crate::datadogV2::model::CoreWeaveCloudMetricsIntegrationDataflowResponse,
+ > = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "coreweave-cloud-logs" => {
+ if v.is_null() {
+ continue;
+ }
+ coreweave_cloud_logs =
+ Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ "coreweave-cloud-metrics" => {
+ if v.is_null() {
+ continue;
+ }
+ coreweave_cloud_metrics =
+ Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+
+ let content = CoreWeaveCloudIntegrationDataflowsResponse {
+ coreweave_cloud_logs,
+ coreweave_cloud_metrics,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudIntegrationDataflowsResponseVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_logs_integration_dataflow_request.rs b/src/datadogV2/model/model_core_weave_cloud_logs_integration_dataflow_request.rs
new file mode 100644
index 0000000000..51ed37b3ff
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_logs_integration_dataflow_request.rs
@@ -0,0 +1,86 @@
+// 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};
+
+/// Service logs for CoreWeave-managed components in each CoreWeave region: the CKS control plane (such as `kube-apiserver` and `etcd`), CoreWeave add-on services in the `cw-*` and `kube-system` namespaces, SUNK, and node system logs such as `kubelet` and `containerd`. Logs from your own workloads and Kubernetes audit logs are not collected. Logs are sent with `source:coreweave`, with CoreWeave log labels such as `namespace`, `app`, and `systemd_unit` added as tags.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudLogsIntegrationDataflowRequest {
+ /// Whether Datadog collects this data. Defaults to `false`; set to `true` to start collection.
+ #[serde(rename = "enabled")]
+ pub enabled: Option,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudLogsIntegrationDataflowRequest {
+ pub fn new() -> CoreWeaveCloudLogsIntegrationDataflowRequest {
+ CoreWeaveCloudLogsIntegrationDataflowRequest {
+ enabled: None,
+ _unparsed: false,
+ }
+ }
+
+ pub fn enabled(mut self, value: bool) -> Self {
+ self.enabled = Some(value);
+ self
+ }
+}
+
+impl Default for CoreWeaveCloudLogsIntegrationDataflowRequest {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudLogsIntegrationDataflowRequest {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudLogsIntegrationDataflowRequestVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudLogsIntegrationDataflowRequestVisitor {
+ type Value = CoreWeaveCloudLogsIntegrationDataflowRequest;
+
+ 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 enabled: Option = None;
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "enabled" => {
+ if v.is_null() {
+ continue;
+ }
+ enabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ return Err(serde::de::Error::custom(
+ "Additional properties not allowed",
+ ));
+ }
+ }
+ }
+
+ let content = CoreWeaveCloudLogsIntegrationDataflowRequest { enabled, _unparsed };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudLogsIntegrationDataflowRequestVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_logs_integration_dataflow_response.rs b/src/datadogV2/model/model_core_weave_cloud_logs_integration_dataflow_response.rs
new file mode 100644
index 0000000000..2739794ac3
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_logs_integration_dataflow_response.rs
@@ -0,0 +1,105 @@
+// 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};
+
+/// Service logs for CoreWeave-managed components in each CoreWeave region: the CKS control plane (such as `kube-apiserver` and `etcd`), CoreWeave add-on services in the `cw-*` and `kube-system` namespaces, SUNK, and node system logs such as `kubelet` and `containerd`. Logs from your own workloads and Kubernetes audit logs are not collected. Logs are sent with `source:coreweave`, with CoreWeave log labels such as `namespace`, `app`, and `systemd_unit` added as tags.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudLogsIntegrationDataflowResponse {
+ /// Whether Datadog collects this data. Absent when the dataflow has never been configured, in which case the documented default applies.
+ #[serde(rename = "enabled")]
+ pub enabled: Option,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudLogsIntegrationDataflowResponse {
+ pub fn new() -> CoreWeaveCloudLogsIntegrationDataflowResponse {
+ CoreWeaveCloudLogsIntegrationDataflowResponse {
+ enabled: None,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn enabled(mut self, value: bool) -> Self {
+ self.enabled = Some(value);
+ self
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl Default for CoreWeaveCloudLogsIntegrationDataflowResponse {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudLogsIntegrationDataflowResponse {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudLogsIntegrationDataflowResponseVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudLogsIntegrationDataflowResponseVisitor {
+ type Value = CoreWeaveCloudLogsIntegrationDataflowResponse;
+
+ 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 enabled: Option = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "enabled" => {
+ if v.is_null() {
+ continue;
+ }
+ enabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+
+ let content = CoreWeaveCloudLogsIntegrationDataflowResponse {
+ enabled,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudLogsIntegrationDataflowResponseVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_metrics_integration_dataflow_request.rs b/src/datadogV2/model/model_core_weave_cloud_metrics_integration_dataflow_request.rs
new file mode 100644
index 0000000000..53b8753db2
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_metrics_integration_dataflow_request.rs
@@ -0,0 +1,87 @@
+// 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};
+
+/// Metrics from your CoreWeave organization: CoreWeave service metrics collected through its PromQL-compatible Prometheus endpoint, plus the `coreweave.*` namespaces from CoreWeave products such as Kubernetes, Database, Distributed File Storage, Inference, and Object Storage. Compute metrics (`coreweave.bare_metal`, `coreweave.gpu`, `coreweave.nccl`, and `coreweave.node`) are in Preview. Container metrics are not collected; install the Datadog Agent on your clusters for those.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudMetricsIntegrationDataflowRequest {
+ /// Whether Datadog collects this data. Defaults to `true`; set to `false` to stop collection.
+ #[serde(rename = "enabled")]
+ pub enabled: Option,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudMetricsIntegrationDataflowRequest {
+ pub fn new() -> CoreWeaveCloudMetricsIntegrationDataflowRequest {
+ CoreWeaveCloudMetricsIntegrationDataflowRequest {
+ enabled: None,
+ _unparsed: false,
+ }
+ }
+
+ pub fn enabled(mut self, value: bool) -> Self {
+ self.enabled = Some(value);
+ self
+ }
+}
+
+impl Default for CoreWeaveCloudMetricsIntegrationDataflowRequest {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudMetricsIntegrationDataflowRequest {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudMetricsIntegrationDataflowRequestVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudMetricsIntegrationDataflowRequestVisitor {
+ type Value = CoreWeaveCloudMetricsIntegrationDataflowRequest;
+
+ 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 enabled: Option = None;
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "enabled" => {
+ if v.is_null() {
+ continue;
+ }
+ enabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ return Err(serde::de::Error::custom(
+ "Additional properties not allowed",
+ ));
+ }
+ }
+ }
+
+ let content =
+ CoreWeaveCloudMetricsIntegrationDataflowRequest { enabled, _unparsed };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudMetricsIntegrationDataflowRequestVisitor)
+ }
+}
diff --git a/src/datadogV2/model/model_core_weave_cloud_metrics_integration_dataflow_response.rs b/src/datadogV2/model/model_core_weave_cloud_metrics_integration_dataflow_response.rs
new file mode 100644
index 0000000000..f69956816d
--- /dev/null
+++ b/src/datadogV2/model/model_core_weave_cloud_metrics_integration_dataflow_response.rs
@@ -0,0 +1,105 @@
+// 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};
+
+/// Metrics from your CoreWeave organization: CoreWeave service metrics collected through its PromQL-compatible Prometheus endpoint, plus the `coreweave.*` namespaces from CoreWeave products such as Kubernetes, Database, Distributed File Storage, Inference, and Object Storage. Compute metrics (`coreweave.bare_metal`, `coreweave.gpu`, `coreweave.nccl`, and `coreweave.node`) are in Preview. Container metrics are not collected; install the Datadog Agent on your clusters for those.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CoreWeaveCloudMetricsIntegrationDataflowResponse {
+ /// Whether Datadog collects this data. Absent when the dataflow has never been configured, in which case the documented default applies.
+ #[serde(rename = "enabled")]
+ pub enabled: Option,
+ #[serde(flatten)]
+ pub additional_properties: std::collections::BTreeMap,
+ #[serde(skip)]
+ #[serde(default)]
+ pub(crate) _unparsed: bool,
+}
+
+impl CoreWeaveCloudMetricsIntegrationDataflowResponse {
+ pub fn new() -> CoreWeaveCloudMetricsIntegrationDataflowResponse {
+ CoreWeaveCloudMetricsIntegrationDataflowResponse {
+ enabled: None,
+ additional_properties: std::collections::BTreeMap::new(),
+ _unparsed: false,
+ }
+ }
+
+ pub fn enabled(mut self, value: bool) -> Self {
+ self.enabled = Some(value);
+ self
+ }
+
+ pub fn additional_properties(
+ mut self,
+ value: std::collections::BTreeMap,
+ ) -> Self {
+ self.additional_properties = value;
+ self
+ }
+}
+
+impl Default for CoreWeaveCloudMetricsIntegrationDataflowResponse {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl<'de> Deserialize<'de> for CoreWeaveCloudMetricsIntegrationDataflowResponse {
+ fn deserialize(deserializer: D) -> Result
+ where
+ D: Deserializer<'de>,
+ {
+ struct CoreWeaveCloudMetricsIntegrationDataflowResponseVisitor;
+ impl<'a> Visitor<'a> for CoreWeaveCloudMetricsIntegrationDataflowResponseVisitor {
+ type Value = CoreWeaveCloudMetricsIntegrationDataflowResponse;
+
+ 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 enabled: Option = None;
+ let mut additional_properties: std::collections::BTreeMap<
+ String,
+ serde_json::Value,
+ > = std::collections::BTreeMap::new();
+ let mut _unparsed = false;
+
+ while let Some((k, v)) = map.next_entry::()? {
+ match k.as_str() {
+ "enabled" => {
+ if v.is_null() {
+ continue;
+ }
+ enabled = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+ }
+ &_ => {
+ if let Ok(value) = serde_json::from_value(v.clone()) {
+ additional_properties.insert(k, value);
+ }
+ }
+ }
+ }
+
+ let content = CoreWeaveCloudMetricsIntegrationDataflowResponse {
+ enabled,
+ additional_properties,
+ _unparsed,
+ };
+
+ Ok(content)
+ }
+ }
+
+ deserializer.deserialize_any(CoreWeaveCloudMetricsIntegrationDataflowResponseVisitor)
+ }
+}
diff --git a/tests/scenarios/features/v2/coreweave_integration.feature b/tests/scenarios/features/v2/coreweave_integration.feature
new file mode 100644
index 0000000000..3861d784e1
--- /dev/null
+++ b/tests/scenarios/features/v2/coreweave_integration.feature
@@ -0,0 +1,148 @@
+@endpoint(coreweave-integration) @endpoint(coreweave-integration-v2)
+Feature: CoreWeave Integration
+ Manage your Datadog CoreWeave integration accounts and account resources
+ directly through the Datadog API. See the [CoreWeave integration
+ page](https://docs.datadoghq.com/integrations/coreweave/) for more
+ information.
+
+ Background:
+ Given a valid "apiKeyAuth" key in the system
+ And a valid "appKeyAuth" key in the system
+ And an instance of "CoreWeaveIntegration" API
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Create a CoreWeave integration account returns "Bad Request" response
+ Given operation "CreateCoreWeaveCloudIntegrationAccount" enabled
+ And new "CreateCoreWeaveCloudIntegrationAccount" request
+ And body with value {"data": {"attributes": {"authentication": {"api_token": "CW-SECRET-xxxxxxxxxxxxxxxxxxxx", "auth_type": "coreweave_api_token"}, "dataflows": {"coreweave-cloud-logs": {"enabled": true}, "coreweave-cloud-metrics": {"enabled": true}}, "name": "coreweave-prod", "settings": {"account_tags": ["env:prod", "team:gpu"], "cluster_filters": ["cluster:prod-*", "!cluster:dev"]}}, "type": "integration-account"}}
+ When the request is sent
+ Then the response status is 400 Bad Request
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Create a CoreWeave integration account returns "Created" response
+ Given operation "CreateCoreWeaveCloudIntegrationAccount" enabled
+ And new "CreateCoreWeaveCloudIntegrationAccount" request
+ And body with value {"data": {"attributes": {"authentication": {"api_token": "CW-SECRET-xxxxxxxxxxxxxxxxxxxx", "auth_type": "coreweave_api_token"}, "dataflows": {"coreweave-cloud-logs": {"enabled": true}, "coreweave-cloud-metrics": {"enabled": true}}, "name": "coreweave-prod", "settings": {"account_tags": ["env:prod", "team:gpu"], "cluster_filters": ["cluster:prod-*", "!cluster:dev"]}}, "type": "integration-account"}}
+ When the request is sent
+ Then the response status is 201 Created
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Create a CoreWeave integration account returns "Not Found" response
+ Given operation "CreateCoreWeaveCloudIntegrationAccount" enabled
+ And new "CreateCoreWeaveCloudIntegrationAccount" request
+ And body with value {"data": {"attributes": {"authentication": {"api_token": "CW-SECRET-xxxxxxxxxxxxxxxxxxxx", "auth_type": "coreweave_api_token"}, "dataflows": {"coreweave-cloud-logs": {"enabled": true}, "coreweave-cloud-metrics": {"enabled": true}}, "name": "coreweave-prod", "settings": {"account_tags": ["env:prod", "team:gpu"], "cluster_filters": ["cluster:prod-*", "!cluster:dev"]}}, "type": "integration-account"}}
+ When the request is sent
+ Then the response status is 404 Not Found
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Create a CoreWeave integration account returns "The server cannot process the request because it contains invalid data." response
+ Given operation "CreateCoreWeaveCloudIntegrationAccount" enabled
+ And new "CreateCoreWeaveCloudIntegrationAccount" request
+ And body with value {"data": {"attributes": {"authentication": {"api_token": "CW-SECRET-xxxxxxxxxxxxxxxxxxxx", "auth_type": "coreweave_api_token"}, "dataflows": {"coreweave-cloud-logs": {"enabled": true}, "coreweave-cloud-metrics": {"enabled": true}}, "name": "coreweave-prod", "settings": {"account_tags": ["env:prod", "team:gpu"], "cluster_filters": ["cluster:prod-*", "!cluster:dev"]}}, "type": "integration-account"}}
+ When the request is sent
+ Then the response status is 422 The server cannot process the request because it contains invalid data.
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Delete a CoreWeave integration account returns "Bad Request" response
+ Given operation "DeleteCoreWeaveCloudIntegrationAccount" enabled
+ And new "DeleteCoreWeaveCloudIntegrationAccount" request
+ And request contains "account_id" parameter from "REPLACE.ME"
+ When the request is sent
+ Then the response status is 400 Bad Request
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Delete a CoreWeave integration account returns "Not Found" response
+ Given operation "DeleteCoreWeaveCloudIntegrationAccount" enabled
+ And new "DeleteCoreWeaveCloudIntegrationAccount" request
+ And request contains "account_id" parameter from "REPLACE.ME"
+ When the request is sent
+ Then the response status is 404 Not Found
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Delete a CoreWeave integration account returns "OK" response
+ Given operation "DeleteCoreWeaveCloudIntegrationAccount" enabled
+ And new "DeleteCoreWeaveCloudIntegrationAccount" request
+ And request contains "account_id" parameter from "REPLACE.ME"
+ When the request is sent
+ Then the response status is 200 OK
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Get a CoreWeave integration account returns "Bad Request" response
+ Given operation "GetCoreWeaveCloudIntegrationAccount" enabled
+ And new "GetCoreWeaveCloudIntegrationAccount" request
+ And request contains "account_id" parameter from "REPLACE.ME"
+ When the request is sent
+ Then the response status is 400 Bad Request
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Get a CoreWeave integration account returns "Not Found" response
+ Given operation "GetCoreWeaveCloudIntegrationAccount" enabled
+ And new "GetCoreWeaveCloudIntegrationAccount" request
+ And request contains "account_id" parameter from "REPLACE.ME"
+ When the request is sent
+ Then the response status is 404 Not Found
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Get a CoreWeave integration account returns "OK" response
+ Given operation "GetCoreWeaveCloudIntegrationAccount" enabled
+ And new "GetCoreWeaveCloudIntegrationAccount" request
+ And request contains "account_id" parameter from "REPLACE.ME"
+ When the request is sent
+ Then the response status is 200 OK
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: List CoreWeave integration accounts returns "Bad Request" response
+ Given operation "ListCoreWeaveCloudIntegrationAccounts" enabled
+ And new "ListCoreWeaveCloudIntegrationAccounts" request
+ When the request is sent
+ Then the response status is 400 Bad Request
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: List CoreWeave integration accounts returns "Not Found" response
+ Given operation "ListCoreWeaveCloudIntegrationAccounts" enabled
+ And new "ListCoreWeaveCloudIntegrationAccounts" request
+ When the request is sent
+ Then the response status is 404 Not Found
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: List CoreWeave integration accounts returns "OK" response
+ Given operation "ListCoreWeaveCloudIntegrationAccounts" enabled
+ And new "ListCoreWeaveCloudIntegrationAccounts" request
+ When the request is sent
+ Then the response status is 200 OK
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Update a CoreWeave integration account returns "Bad Request" response
+ Given operation "UpdateCoreWeaveCloudIntegrationAccount" enabled
+ And new "UpdateCoreWeaveCloudIntegrationAccount" request
+ And request contains "account_id" parameter from "REPLACE.ME"
+ And body with value {"data": {"attributes": {"authentication": {"api_token": "CW-SECRET-xxxxxxxxxxxxxxxxxxxx", "auth_type": "coreweave_api_token"}, "dataflows": {"coreweave-cloud-logs": {"enabled": true}, "coreweave-cloud-metrics": {"enabled": true}}, "name": "coreweave-prod", "settings": {"account_tags": ["env:prod", "team:gpu"], "cluster_filters": ["cluster:prod-*", "!cluster:dev"]}}, "id": "f7a8b9c0-d1e2-4f3a-9b4c-5d6e7f8091a2", "type": "integration-account"}}
+ When the request is sent
+ Then the response status is 400 Bad Request
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Update a CoreWeave integration account returns "Not Found" response
+ Given operation "UpdateCoreWeaveCloudIntegrationAccount" enabled
+ And new "UpdateCoreWeaveCloudIntegrationAccount" request
+ And request contains "account_id" parameter from "REPLACE.ME"
+ And body with value {"data": {"attributes": {"authentication": {"api_token": "CW-SECRET-xxxxxxxxxxxxxxxxxxxx", "auth_type": "coreweave_api_token"}, "dataflows": {"coreweave-cloud-logs": {"enabled": true}, "coreweave-cloud-metrics": {"enabled": true}}, "name": "coreweave-prod", "settings": {"account_tags": ["env:prod", "team:gpu"], "cluster_filters": ["cluster:prod-*", "!cluster:dev"]}}, "id": "f7a8b9c0-d1e2-4f3a-9b4c-5d6e7f8091a2", "type": "integration-account"}}
+ When the request is sent
+ Then the response status is 404 Not Found
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Update a CoreWeave integration account returns "OK" response
+ Given operation "UpdateCoreWeaveCloudIntegrationAccount" enabled
+ And new "UpdateCoreWeaveCloudIntegrationAccount" request
+ And request contains "account_id" parameter from "REPLACE.ME"
+ And body with value {"data": {"attributes": {"authentication": {"api_token": "CW-SECRET-xxxxxxxxxxxxxxxxxxxx", "auth_type": "coreweave_api_token"}, "dataflows": {"coreweave-cloud-logs": {"enabled": true}, "coreweave-cloud-metrics": {"enabled": true}}, "name": "coreweave-prod", "settings": {"account_tags": ["env:prod", "team:gpu"], "cluster_filters": ["cluster:prod-*", "!cluster:dev"]}}, "id": "f7a8b9c0-d1e2-4f3a-9b4c-5d6e7f8091a2", "type": "integration-account"}}
+ When the request is sent
+ Then the response status is 200 OK
+
+ @generated @skip @team:ddoghq/emerging-cloud-integrations
+ Scenario: Update a CoreWeave integration account returns "The server cannot process the request because it contains invalid data." response
+ Given operation "UpdateCoreWeaveCloudIntegrationAccount" enabled
+ And new "UpdateCoreWeaveCloudIntegrationAccount" request
+ And request contains "account_id" parameter from "REPLACE.ME"
+ And body with value {"data": {"attributes": {"authentication": {"api_token": "CW-SECRET-xxxxxxxxxxxxxxxxxxxx", "auth_type": "coreweave_api_token"}, "dataflows": {"coreweave-cloud-logs": {"enabled": true}, "coreweave-cloud-metrics": {"enabled": true}}, "name": "coreweave-prod", "settings": {"account_tags": ["env:prod", "team:gpu"], "cluster_filters": ["cluster:prod-*", "!cluster:dev"]}}, "id": "f7a8b9c0-d1e2-4f3a-9b4c-5d6e7f8091a2", "type": "integration-account"}}
+ When the request is sent
+ Then the response status is 422 The server cannot process the request because it contains invalid data.
diff --git a/tests/scenarios/features/v2/undo.json b/tests/scenarios/features/v2/undo.json
index 0d9b33aa46..d20a297e00 100644
--- a/tests/scenarios/features/v2/undo.json
+++ b/tests/scenarios/features/v2/undo.json
@@ -4307,6 +4307,43 @@
"type": "safe"
}
},
+ "ListCoreWeaveCloudIntegrationAccounts": {
+ "tag": "CoreWeave Integration",
+ "undo": {
+ "type": "safe"
+ }
+ },
+ "CreateCoreWeaveCloudIntegrationAccount": {
+ "tag": "CoreWeave Integration",
+ "undo": {
+ "operationId": "DeleteCoreWeaveCloudIntegrationAccount",
+ "parameters": [
+ {
+ "name": "account_id",
+ "source": "data.id"
+ }
+ ],
+ "type": "unsafe"
+ }
+ },
+ "DeleteCoreWeaveCloudIntegrationAccount": {
+ "tag": "CoreWeave Integration",
+ "undo": {
+ "type": "idempotent"
+ }
+ },
+ "GetCoreWeaveCloudIntegrationAccount": {
+ "tag": "CoreWeave Integration",
+ "undo": {
+ "type": "safe"
+ }
+ },
+ "UpdateCoreWeaveCloudIntegrationAccount": {
+ "tag": "CoreWeave Integration",
+ "undo": {
+ "type": "idempotent"
+ }
+ },
"ListDatabricksIntegrationAccounts": {
"tag": "Databricks Integration",
"undo": {
diff --git a/tests/scenarios/function_mappings.rs b/tests/scenarios/function_mappings.rs
index 50bcd48960..820ef8f167 100644
--- a/tests/scenarios/function_mappings.rs
+++ b/tests/scenarios/function_mappings.rs
@@ -110,6 +110,7 @@ pub struct ApiInstances {
pub v2_api_identity_providers: Option,
pub v2_api_entity_integration_configs: Option,
pub v2_api_incidents: Option,
+ pub v2_api_core_weave_integration: Option,
pub v2_api_databricks_integration: Option,
pub v2_api_elastic_cloud_integration: Option,
pub v2_api_snowflake_integration: Option,
@@ -994,6 +995,12 @@ pub fn initialize_api_instance(world: &mut DatadogWorld, api: String) {
),
);
}
+ "CoreWeaveIntegration" => {
+ world.api_instances.v2_api_core_weave_integration = Some(datadogV2::api_core_weave_integration::CoreWeaveIntegrationAPI::with_client_and_config(
+ world.config.clone(),
+ world.http_client.as_ref().unwrap().clone()
+ ));
+ }
"DatabricksIntegration" => {
world.api_instances.v2_api_databricks_integration = Some(datadogV2::api_databricks_integration::DatabricksIntegrationAPI::with_client_and_config(
world.config.clone(),
@@ -6334,6 +6341,26 @@ pub fn collect_function_calls(world: &mut DatadogWorld) {
"v2.UpdateTimestampOverride".into(),
test_v2_update_timestamp_override,
);
+ world.function_mappings.insert(
+ "v2.ListCoreWeaveCloudIntegrationAccounts".into(),
+ test_v2_list_core_weave_cloud_integration_accounts,
+ );
+ world.function_mappings.insert(
+ "v2.CreateCoreWeaveCloudIntegrationAccount".into(),
+ test_v2_create_core_weave_cloud_integration_account,
+ );
+ world.function_mappings.insert(
+ "v2.DeleteCoreWeaveCloudIntegrationAccount".into(),
+ test_v2_delete_core_weave_cloud_integration_account,
+ );
+ world.function_mappings.insert(
+ "v2.GetCoreWeaveCloudIntegrationAccount".into(),
+ test_v2_get_core_weave_cloud_integration_account,
+ );
+ world.function_mappings.insert(
+ "v2.UpdateCoreWeaveCloudIntegrationAccount".into(),
+ test_v2_update_core_weave_cloud_integration_account,
+ );
world.function_mappings.insert(
"v2.ListDatabricksIntegrationAccounts".into(),
test_v2_list_databricks_integration_accounts,
@@ -50537,6 +50564,155 @@ fn test_v2_update_timestamp_override(
world.response.code = response.status.as_u16();
}
+fn test_v2_list_core_weave_cloud_integration_accounts(
+ world: &mut DatadogWorld,
+ _parameters: &HashMap,
+) {
+ let api = world
+ .api_instances
+ .v2_api_core_weave_integration
+ .as_ref()
+ .expect("api instance not found");
+ let response = match block_on(api.list_core_weave_cloud_integration_accounts_with_http_info()) {
+ Ok(response) => response,
+ Err(error) => {
+ return match error {
+ Error::ResponseError(e) => {
+ world.response.code = e.status.as_u16();
+ if let Some(entity) = e.entity {
+ world.response.object = serde_json::to_value(entity).unwrap();
+ }
+ }
+ _ => panic!("error parsing response: {error}"),
+ };
+ }
+ };
+ world.response.object = serde_json::to_value(response.entity).unwrap();
+ world.response.code = response.status.as_u16();
+}
+
+fn test_v2_create_core_weave_cloud_integration_account(
+ world: &mut DatadogWorld,
+ _parameters: &HashMap,
+) {
+ let api = world
+ .api_instances
+ .v2_api_core_weave_integration
+ .as_ref()
+ .expect("api instance not found");
+ let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap();
+ let response =
+ match block_on(api.create_core_weave_cloud_integration_account_with_http_info(body)) {
+ Ok(response) => response,
+ Err(error) => {
+ return match error {
+ Error::ResponseError(e) => {
+ world.response.code = e.status.as_u16();
+ if let Some(entity) = e.entity {
+ world.response.object = serde_json::to_value(entity).unwrap();
+ }
+ }
+ _ => panic!("error parsing response: {error}"),
+ };
+ }
+ };
+ world.response.object = serde_json::to_value(response.entity).unwrap();
+ world.response.code = response.status.as_u16();
+}
+
+fn test_v2_delete_core_weave_cloud_integration_account(
+ world: &mut DatadogWorld,
+ _parameters: &HashMap,
+) {
+ let api = world
+ .api_instances
+ .v2_api_core_weave_integration
+ .as_ref()
+ .expect("api instance not found");
+ let account_id =
+ serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap();
+ let response = match block_on(
+ api.delete_core_weave_cloud_integration_account_with_http_info(account_id),
+ ) {
+ Ok(response) => response,
+ Err(error) => {
+ return match error {
+ Error::ResponseError(e) => {
+ world.response.code = e.status.as_u16();
+ if let Some(entity) = e.entity {
+ world.response.object = serde_json::to_value(entity).unwrap();
+ }
+ }
+ _ => panic!("error parsing response: {error}"),
+ };
+ }
+ };
+ world.response.object = serde_json::to_value(response.entity).unwrap();
+ world.response.code = response.status.as_u16();
+}
+
+fn test_v2_get_core_weave_cloud_integration_account(
+ world: &mut DatadogWorld,
+ _parameters: &HashMap,
+) {
+ let api = world
+ .api_instances
+ .v2_api_core_weave_integration
+ .as_ref()
+ .expect("api instance not found");
+ let account_id =
+ serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap();
+ let response =
+ match block_on(api.get_core_weave_cloud_integration_account_with_http_info(account_id)) {
+ Ok(response) => response,
+ Err(error) => {
+ return match error {
+ Error::ResponseError(e) => {
+ world.response.code = e.status.as_u16();
+ if let Some(entity) = e.entity {
+ world.response.object = serde_json::to_value(entity).unwrap();
+ }
+ }
+ _ => panic!("error parsing response: {error}"),
+ };
+ }
+ };
+ world.response.object = serde_json::to_value(response.entity).unwrap();
+ world.response.code = response.status.as_u16();
+}
+
+fn test_v2_update_core_weave_cloud_integration_account(
+ world: &mut DatadogWorld,
+ _parameters: &HashMap,
+) {
+ let api = world
+ .api_instances
+ .v2_api_core_weave_integration
+ .as_ref()
+ .expect("api instance not found");
+ let account_id =
+ serde_json::from_value(_parameters.get("account_id").unwrap().clone()).unwrap();
+ let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap();
+ let response = match block_on(
+ api.update_core_weave_cloud_integration_account_with_http_info(account_id, body),
+ ) {
+ Ok(response) => response,
+ Err(error) => {
+ return match error {
+ Error::ResponseError(e) => {
+ world.response.code = e.status.as_u16();
+ if let Some(entity) = e.entity {
+ world.response.object = serde_json::to_value(entity).unwrap();
+ }
+ }
+ _ => panic!("error parsing response: {error}"),
+ };
+ }
+ };
+ world.response.object = serde_json::to_value(response.entity).unwrap();
+ world.response.code = response.status.as_u16();
+}
+
fn test_v2_list_databricks_integration_accounts(
world: &mut DatadogWorld,
_parameters: &HashMap,