From 96a108e87392d92bb075da8bc34dcb1abdd49470 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Mon, 16 Nov 2026 20:21:11 +0000 Subject: [PATCH] Regenerate client from commit 1bea643 of spec repo --- .generator/schemas/v2/openapi.yaml | 563 ++++++++++++ ..._CreateCoreWeaveCloudIntegrationAccount.rs | 55 ++ ..._DeleteCoreWeaveCloudIntegrationAccount.rs | 19 + ...ion_GetCoreWeaveCloudIntegrationAccount.rs | 19 + ...n_ListCoreWeaveCloudIntegrationAccounts.rs | 17 + ..._UpdateCoreWeaveCloudIntegrationAccount.rs | 61 ++ src/datadog/configuration.rs | 20 + .../api/api_core_weave_integration.rs | 817 ++++++++++++++++++ src/datadogV2/api/mod.rs | 1 + src/datadogV2/mod.rs | 1 + src/datadogV2/model/mod.rs | 56 +- ...egration_account_api_token_auth_request.rs | 99 +++ ...gration_account_api_token_auth_response.rs | 104 +++ ...integration_account_api_token_auth_type.rs | 48 + ...tegration_account_api_token_auth_update.rs | 105 +++ ...egration_account_authentication_request.rs | 38 + ...gration_account_authentication_response.rs | 38 + ...tegration_account_authentication_update.rs | 38 + ...d_integration_account_create_attributes.rs | 153 ++++ ...e_cloud_integration_account_create_data.rs | 115 +++ ...loud_integration_account_create_request.rs | 96 ++ ...eave_cloud_integration_account_response.rs | 96 ++ ...integration_account_response_attributes.rs | 161 ++++ ...cloud_integration_account_response_data.rs | 126 +++ ...ud_integration_account_settings_request.rs | 108 +++ ...d_integration_account_settings_response.rs | 124 +++ ...oud_integration_account_settings_update.rs | 108 +++ ...d_integration_account_update_attributes.rs | 181 ++++ ...e_cloud_integration_account_update_data.rs | 126 +++ ...loud_integration_account_update_request.rs | 96 ++ ...ave_cloud_integration_accounts_response.rs | 96 ++ ...ave_cloud_integration_dataflows_request.rs | 120 +++ ...ve_cloud_integration_dataflows_response.rs | 136 +++ ...cloud_logs_integration_dataflow_request.rs | 86 ++ ...loud_logs_integration_dataflow_response.rs | 105 +++ ...ud_metrics_integration_dataflow_request.rs | 87 ++ ...d_metrics_integration_dataflow_response.rs | 105 +++ .../features/v2/coreweave_integration.feature | 148 ++++ tests/scenarios/features/v2/undo.json | 37 + tests/scenarios/function_mappings.rs | 176 ++++ 40 files changed, 4683 insertions(+), 2 deletions(-) create mode 100644 examples/v2_coreweave-integration_CreateCoreWeaveCloudIntegrationAccount.rs create mode 100644 examples/v2_coreweave-integration_DeleteCoreWeaveCloudIntegrationAccount.rs create mode 100644 examples/v2_coreweave-integration_GetCoreWeaveCloudIntegrationAccount.rs create mode 100644 examples/v2_coreweave-integration_ListCoreWeaveCloudIntegrationAccounts.rs create mode 100644 examples/v2_coreweave-integration_UpdateCoreWeaveCloudIntegrationAccount.rs create mode 100644 src/datadogV2/api/api_core_weave_integration.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_request.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_response.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_type.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_api_token_auth_update.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_authentication_request.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_authentication_response.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_authentication_update.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_create_attributes.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_create_data.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_create_request.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_response.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_response_attributes.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_response_data.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_settings_request.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_settings_response.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_settings_update.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_update_attributes.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_update_data.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_account_update_request.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_accounts_response.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_dataflows_request.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_integration_dataflows_response.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_logs_integration_dataflow_request.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_logs_integration_dataflow_response.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_metrics_integration_dataflow_request.rs create mode 100644 src/datadogV2/model/model_core_weave_cloud_metrics_integration_dataflow_response.rs create mode 100644 tests/scenarios/features/v2/coreweave_integration.feature 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,