diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 681999b60bb7..7fe7873e65ec 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -92648,6 +92648,558 @@ components: type: string x-enum-varnames: - NDK + NebiusCloudCostCollectionIntegrationDataflowRequest: + additionalProperties: false + description: >- + Cloud cost data read from a Nebius Object Storage bucket export and used by [Cloud Cost Management](https://docs.datadoghq.com/cloud_cost_management/). Enabling it requires a bucket holding your cost export and a Nebius access key pair that can read it; a request that enables this dataflow without them is rejected with a `422` response. + properties: + enabled: + description: Whether Datadog collects this data. Defaults to `false`; set to `true` to start collection. + example: true + type: boolean + settings: + $ref: "#/components/schemas/NebiusCloudCostCollectionIntegrationDataflowSettingsRequest" + type: object + NebiusCloudCostCollectionIntegrationDataflowResponse: + description: >- + Cloud cost data read from a Nebius Object Storage bucket export and used by [Cloud Cost Management](https://docs.datadoghq.com/cloud_cost_management/). Requires a bucket holding your cost export and a Nebius access key pair that can read it; without both this dataflow collects no data. + properties: + enabled: + description: Whether Datadog collects this data. Absent when the dataflow has never been configured. + example: true + type: boolean + settings: + $ref: "#/components/schemas/NebiusCloudCostCollectionIntegrationDataflowSettingsResponse" + type: object + NebiusCloudCostCollectionIntegrationDataflowSettingsRequest: + additionalProperties: false + description: Settings of the Cloud Cost Management dataflow. Only the fields provided are changed. + properties: + access_key_id: + description: >- + ID of the Nebius Object Storage (S3-compatible) access key used to read the cost export bucket. Required when this dataflow is enabled. + example: AKID0123456789ABCDEF + type: string + access_key_secret: + description: >- + Secret access key for the access key ID. Required when this dataflow is enabled. Omit it on update to keep the stored one; an empty string is rejected with a `422` response. + example: wJalrXUtnFEMIstaticaccesskey + type: string + writeOnly: true + bucket_name: + description: >- + Name of the Nebius Object Storage bucket holding your cost export. Required when this dataflow is enabled; a request that enables it without the bucket fields and access keys is rejected with a `422` response. + example: nebius-cost-exports + type: string + bucket_prefix_path: + description: >- + Prefix path within the bucket that locates the cost export, combining the export name and path prefix. + example: cost-export/2026/ + type: string + bucket_region: + description: >- + Region of the Nebius Object Storage bucket, such as `eu-north1`. Required when this dataflow is enabled. + example: eu-north1 + type: string + type: object + NebiusCloudCostCollectionIntegrationDataflowSettingsResponse: + description: Settings of the Cloud Cost Management dataflow. + properties: + access_key_id: + description: ID of the Nebius Object Storage access key used to read the cost export bucket. + example: AKID0123456789ABCDEF + type: string + bucket_name: + description: Name of the Nebius Object Storage bucket holding the cost export. + example: nebius-cost-exports + type: string + bucket_prefix_path: + description: Prefix path within the bucket that locates the cost export. + example: cost-export/2026/ + type: string + bucket_region: + description: Region of the Nebius Object Storage bucket, such as `eu-north1`. + example: eu-north1 + type: string + type: object + NebiusCloudIntegrationAccountAuthenticationRequest: + description: Authentication for creating the Nebius Cloud integration account. Exactly one method is set. + oneOf: + - $ref: "#/components/schemas/NebiusCloudIntegrationAccountServiceAccountAuthRequest" + NebiusCloudIntegrationAccountAuthenticationResponse: + description: Authentication configured on the Nebius Cloud integration account. + oneOf: + - $ref: "#/components/schemas/NebiusCloudIntegrationAccountServiceAccountAuthResponse" + NebiusCloudIntegrationAccountAuthenticationUpdate: + description: Authentication for updating the Nebius Cloud integration account. Exactly one method is set. + oneOf: + - $ref: "#/components/schemas/NebiusCloudIntegrationAccountServiceAccountAuthUpdate" + NebiusCloudIntegrationAccountCreateAttributes: + description: Writable attributes used to create a Nebius Cloud integration account. + properties: + authentication: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountAuthenticationRequest" + dataflows: + $ref: "#/components/schemas/NebiusCloudIntegrationDataflowsRequest" + name: + description: Human-readable name of the Nebius Cloud integration account. + example: nebius-prod + maxLength: 255 + type: string + settings: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountSettingsRequest" + required: + - name + - authentication + - settings + type: object + NebiusCloudIntegrationAccountCreateData: + description: Data envelope for creating a Nebius Cloud integration account. + properties: + attributes: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountCreateAttributes" + type: + $ref: "#/components/schemas/IntegrationAccountType" + required: + - type + - attributes + type: object + NebiusCloudIntegrationAccountCreateRequest: + description: Request payload to create a Nebius Cloud integration account. + properties: + data: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountCreateData" + required: + - data + type: object + NebiusCloudIntegrationAccountMetricsConfigRequest: + additionalProperties: false + description: Configuration for metric collection from this Nebius Cloud account. + properties: + cluster_filters: + description: >- + Tag-filter rules limiting metric collection to matching Kubernetes 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 + NebiusCloudIntegrationAccountMetricsConfigResponse: + description: >- + Metric collection settings configured on the Nebius Cloud integration account. Absent when no filters are configured. + properties: + cluster_filters: + description: >- + Tag-filter rules limiting metric collection to matching Kubernetes clusters. + example: + - cluster:prod-* + - "!cluster:dev" + items: + type: string + type: array + type: object + NebiusCloudIntegrationAccountMetricsConfigUpdate: + additionalProperties: false + description: Configuration for metric collection. Only the fields provided are changed. + properties: + cluster_filters: + description: >- + Tag-filter rules limiting metric collection to matching Kubernetes clusters. Sending metrics_config replaces the stored object's cluster_filters list; omit it to keep the stored value. 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 + NebiusCloudIntegrationAccountResponse: + description: Response payload for a single Nebius Cloud integration account. + properties: + data: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountResponseData" + required: + - data + type: object + NebiusCloudIntegrationAccountResponseAttributes: + description: Attributes of a Nebius Cloud integration account returned in responses. + properties: + authentication: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountAuthenticationResponse" + dataflows: + $ref: "#/components/schemas/NebiusCloudIntegrationDataflowsResponse" + name: + description: Human-readable name of the Nebius Cloud integration account. + example: nebius-prod + type: string + settings: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountSettingsResponse" + required: + - name + - settings + type: object + NebiusCloudIntegrationAccountResponseData: + description: Data envelope of a Nebius Cloud integration account, including server-assigned identity. + properties: + attributes: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountResponseAttributes" + id: + description: Server-generated unique identifier of the Nebius Cloud integration account. + example: e5f6a7b8-c9d0-4e1f-8a2b-3c4d5e6f7081 + readOnly: true + type: string + type: + $ref: "#/components/schemas/IntegrationAccountType" + required: + - id + - attributes + - type + type: object + NebiusCloudIntegrationAccountServiceAccountAuthRequest: + additionalProperties: false + description: >- + Service-account key pair authentication, the only method Nebius Cloud integration accounts support. Create a service account in the Nebius console, add it to the admin group, upload an authorized key pair to it, and issue a static API key with the OBSERVABILITY scope through the Nebius CLI. + properties: + auth_type: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountServiceAccountAuthType" + private_key: + description: >- + The private key of the authorized key pair, in PEM format. Required when log, resource, or service-quota collection is enabled; a request that enables one of them without it is rejected with a `422` response. + example: "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----" + type: string + writeOnly: true + public_key_id: + description: >- + ID of the public key half of the authorized key pair, such as `publickey-xxxxxxxx`. Required when log, resource, or service-quota collection is enabled; a request that enables one of them without it is rejected with a `422` response. + example: publickey-yyyyyyyy + type: string + service_account_id: + description: Non-secret ID of the Nebius service account the account authenticates as. + example: serviceaccount-xxxxxxxx + type: string + static_api_key: + description: >- + Nebius static API key with the OBSERVABILITY scope, used to query logs. Required when log, resource, or service-quota collection is enabled; a request that enables one of them without it is rejected with a `422` response. + example: eyJhbGciOi...static-api-key + type: string + writeOnly: true + required: + - auth_type + - service_account_id + type: object + NebiusCloudIntegrationAccountServiceAccountAuthResponse: + description: The service-account key pair authentication method configured on the account. + properties: + auth_type: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountServiceAccountAuthType" + public_key_id: + description: ID of the public key half of the authorized key pair. Omitted when unset. + example: publickey-yyyyyyyy + type: string + service_account_id: + description: ID of the Nebius service account the account authenticates as. + example: serviceaccount-xxxxxxxx + type: string + required: + - auth_type + - service_account_id + type: object + NebiusCloudIntegrationAccountServiceAccountAuthType: + default: nebius_service_account + description: The authentication method type. + enum: + - nebius_service_account + example: nebius_service_account + type: string + x-enum-varnames: + - NEBIUS_SERVICE_ACCOUNT + NebiusCloudIntegrationAccountServiceAccountAuthUpdate: + additionalProperties: false + description: >- + Service-account key pair authentication, the only method Nebius Cloud integration accounts support. Only the fields provided are changed; omit `private_key` and `static_api_key` to keep the stored ones. + properties: + auth_type: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountServiceAccountAuthType" + private_key: + description: >- + The private key of the authorized key pair, in PEM format. Omit it to keep the stored one; an empty string is rejected with a `422` response. + example: "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----" + type: string + writeOnly: true + public_key_id: + description: >- + ID of the public key half of the authorized key pair. Omit it to keep the stored public key ID, send `null` or an empty string to remove it, or send a value to replace it. Removing it is rejected with a `422` response while log, resource, or service-quota collection is enabled. + example: publickey-yyyyyyyy + nullable: true + type: string + service_account_id: + description: >- + Non-secret ID of the Nebius service account the account authenticates as. It cannot be cleared; sending `null` or an empty string is rejected with a `422` response. + example: serviceaccount-xxxxxxxx + type: string + static_api_key: + description: >- + Nebius static API key with the OBSERVABILITY scope. Omit it to keep the stored one; an empty string is rejected with a `422` response. + example: eyJhbGciOi...static-api-key + type: string + writeOnly: true + required: + - auth_type + type: object + NebiusCloudIntegrationAccountSettingsRequest: + additionalProperties: false + description: Settings for creating the Nebius Cloud integration account. + properties: + account_tags: + description: >- + Tags applied to all metrics, logs, and resources collected from this Nebius Cloud account. Defaults to no tags. + example: + - env:prod + - team:ai + items: + maxLength: 200 + type: string + type: array + metrics_config: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountMetricsConfigRequest" + tenant_id: + description: >- + ID of the Nebius tenant to monitor, the organizational workspace identifier. Found in the Nebius console under Administration > Organization. + example: tenant-12345678 + type: string + required: + - tenant_id + type: object + NebiusCloudIntegrationAccountSettingsResponse: + description: Settings configured on the Nebius Cloud integration account. + properties: + account_tags: + description: Tags applied to all data collected from this Nebius Cloud account. + example: + - env:prod + - team:ai + items: + type: string + type: array + metrics_config: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountMetricsConfigResponse" + tenant_id: + description: ID of the Nebius tenant being monitored. + example: tenant-12345678 + type: string + required: + - tenant_id + type: object + NebiusCloudIntegrationAccountSettingsUpdate: + additionalProperties: false + description: Settings for updating the Nebius Cloud integration account. Only the fields provided are changed. + properties: + account_tags: + description: >- + Tags applied to all metrics, logs, and resources collected from this Nebius Cloud 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:ai + items: + maxLength: 200 + type: string + type: array + metrics_config: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountMetricsConfigUpdate" + tenant_id: + description: >- + ID of the Nebius tenant to monitor. An empty value is ignored and the stored tenant ID is kept. + example: tenant-12345678 + type: string + type: object + NebiusCloudIntegrationAccountUpdateAttributes: + description: >- + Writable attributes used to update a Nebius Cloud 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, as do the settings of an included dataflow that provides only `enabled`. + properties: + authentication: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountAuthenticationUpdate" + dataflows: + $ref: "#/components/schemas/NebiusCloudIntegrationDataflowsRequest" + name: + description: Human-readable name of the Nebius Cloud integration account. + example: nebius-prod + maxLength: 255 + type: string + settings: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountSettingsUpdate" + type: object + NebiusCloudIntegrationAccountUpdateData: + description: Data envelope for updating a Nebius Cloud integration account. + properties: + attributes: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountUpdateAttributes" + id: + description: Unique identifier of the Nebius Cloud integration account to update. + example: e5f6a7b8-c9d0-4e1f-8a2b-3c4d5e6f7081 + type: string + type: + $ref: "#/components/schemas/IntegrationAccountType" + required: + - id + - type + - attributes + type: object + NebiusCloudIntegrationAccountUpdateRequest: + description: Request payload to update a Nebius Cloud integration account. + properties: + data: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountUpdateData" + required: + - data + type: object + NebiusCloudIntegrationAccountsResponse: + description: Response payload for a list of Nebius Cloud integration accounts. + properties: + data: + description: List of Nebius Cloud integration accounts. + items: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountResponseData" + type: array + required: + - data + type: object + NebiusCloudIntegrationDataflowsRequest: + additionalProperties: false + description: >- + Data Datadog collects from Nebius Cloud, keyed by dataflow id. Each dataflow turns on a distinct kind of collection: set `enabled` to stop or start it, and use `settings` to configure what it collects. Defaults listed on each dataflow apply when the account is created; on update, omitted fields keep their current values. Every dataflow except `nebius-cloud-cost-collection` runs as the service account in `authentication`, using its authorized key pair and the static API key; enabling one of them without those keys is rejected with a `422` response, and one enabled with keys that later expire is stored but collects no data. + properties: + nebius-cloud-cost-collection: + $ref: "#/components/schemas/NebiusCloudCostCollectionIntegrationDataflowRequest" + nebius-cloud-logs: + $ref: "#/components/schemas/NebiusCloudLogsIntegrationDataflowRequest" + nebius-cloud-resources: + $ref: "#/components/schemas/NebiusCloudResourcesIntegrationDataflowRequest" + nebius-cloud-service-quota-collection: + $ref: "#/components/schemas/NebiusCloudServiceQuotaCollectionIntegrationDataflowRequest" + type: object + NebiusCloudIntegrationDataflowsResponse: + description: Data Datadog collects from Nebius Cloud, keyed by dataflow id. + properties: + nebius-cloud-cost-collection: + $ref: "#/components/schemas/NebiusCloudCostCollectionIntegrationDataflowResponse" + nebius-cloud-logs: + $ref: "#/components/schemas/NebiusCloudLogsIntegrationDataflowResponse" + nebius-cloud-resources: + $ref: "#/components/schemas/NebiusCloudResourcesIntegrationDataflowResponse" + nebius-cloud-service-quota-collection: + $ref: "#/components/schemas/NebiusCloudServiceQuotaCollectionIntegrationDataflowResponse" + type: object + NebiusCloudLogsIntegrationDataflowRequest: + additionalProperties: false + description: >- + Logs from your Nebius tenant: Kubernetes control plane and audit logs, tenant-level audit events, compute serial console logs, cloud apps and AI inference logs, PostgreSQL logs, and MLflow logs, collected from the services named in `settings.enabled_services`. `enabled_services` is the sole source of truth for what is collected; `enabled` set to `false` stops log collection, while `true` on its own changes nothing. Defaults to no services. + properties: + enabled: + description: >- + Whether Datadog collects logs. Defaults to `false`. Set to `false` to stop log collection; sending `true` on its own changes nothing, because `settings.enabled_services` is the sole source of truth. + example: true + type: boolean + settings: + $ref: "#/components/schemas/NebiusCloudLogsIntegrationDataflowSettingsRequest" + type: object + NebiusCloudLogsIntegrationDataflowResponse: + description: >- + Logs from your Nebius tenant: Kubernetes control plane and audit logs, tenant-level audit events, compute serial console logs, cloud apps and AI inference logs, PostgreSQL logs, and MLflow logs, collected from the services named in `settings.enabled_services`. + properties: + enabled: + description: >- + Whether Datadog collects logs. Absent when no service is enabled. + example: true + type: boolean + settings: + $ref: "#/components/schemas/NebiusCloudLogsIntegrationDataflowSettingsResponse" + type: object + NebiusCloudLogsIntegrationDataflowSettingsRequest: + additionalProperties: false + description: Settings of the logs dataflow. Only the fields provided are changed. + properties: + enabled_services: + description: >- + Nebius log integrations to collect. One of `nebius-cloud-compute`, `nebius-cloud-kubernetes`, `nebius-cloud-mlflow`, `nebius-cloud-postgresql`, `nebius-cloud-applications`, or `default` for the streams shared by every service. A non-empty list is the sole source of truth and replaces the stored list: those services are collected and any others stop. An empty list stops log collection entirely. Omit it to keep the stored list. + example: + - nebius-cloud-compute + - nebius-cloud-kubernetes + - default + items: + $ref: "#/components/schemas/NebiusCloudLogsIntegrationServiceName" + type: array + type: object + NebiusCloudLogsIntegrationDataflowSettingsResponse: + description: Settings of the logs dataflow. + properties: + enabled_services: + description: >- + Nebius log integrations collected, such as `nebius-cloud-compute` and `default`. Absent when no service is enabled. + example: + - nebius-cloud-compute + - nebius-cloud-kubernetes + - default + items: + type: string + type: array + type: object + NebiusCloudLogsIntegrationServiceName: + description: Nebius log integration whose streams are collected. + enum: + - nebius-cloud-compute + - nebius-cloud-kubernetes + - nebius-cloud-mlflow + - nebius-cloud-postgresql + - nebius-cloud-applications + - default + example: nebius-cloud-compute + type: string + x-enum-varnames: + - NEBIUS_CLOUD_COMPUTE + - NEBIUS_CLOUD_KUBERNETES + - NEBIUS_CLOUD_MLFLOW + - NEBIUS_CLOUD_POSTGRESQL + - NEBIUS_CLOUD_APPLICATIONS + - DEFAULT + NebiusCloudResourcesIntegrationDataflowRequest: + additionalProperties: false + description: >- + Metadata about resources in your Nebius tenant, such as compute instances and Kubernetes clusters. + properties: + enabled: + description: Whether Datadog collects this data. Defaults to `false`; set to `true` to start collection. + example: true + type: boolean + type: object + NebiusCloudResourcesIntegrationDataflowResponse: + description: >- + Metadata about resources in your Nebius tenant, such as compute instances and Kubernetes clusters. + properties: + enabled: + description: Whether Datadog collects this data. Absent when the dataflow has never been configured. + example: true + type: boolean + type: object + NebiusCloudServiceQuotaCollectionIntegrationDataflowRequest: + additionalProperties: false + description: >- + Usage metrics tracked against your Nebius service quotas, such as `nebius_cloud.servicequota.percentage_used` and `nebius_cloud.servicequota.limit`. + properties: + enabled: + description: Whether Datadog collects this data. Defaults to `false`; set to `true` to start collection. + example: true + type: boolean + type: object + NebiusCloudServiceQuotaCollectionIntegrationDataflowResponse: + description: >- + Usage metrics tracked against your Nebius service quotas, such as `nebius_cloud.servicequota.percentage_used` and `nebius_cloud.servicequota.limit`. + properties: + enabled: + description: Whether Datadog collects this data. Absent when the dataflow has never been configured. + example: true + type: boolean + type: object NodeType: additionalProperties: {} description: A tree-sitter node type definition for a given language, describing the node's structure, subtypes, and fields. @@ -201196,6 +201748,372 @@ 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/nebius-cloud/accounts: + get: + description: List Nebius Cloud integration accounts. + operationId: ListNebiusCloudIntegrationAccounts + responses: + "200": + content: + application/json: + examples: + default: + value: + data: + - attributes: + authentication: + auth_type: nebius_service_account + public_key_id: publickey-yyyyyyyy + service_account_id: serviceaccount-xxxxxxxx + dataflows: + nebius-cloud-cost-collection: + enabled: true + settings: + access_key_id: AKID0123456789ABCDEF + bucket_name: nebius-cost-exports + bucket_prefix_path: cost-export/2026/ + bucket_region: eu-north1 + nebius-cloud-logs: + enabled: true + settings: + enabled_services: + - nebius-cloud-compute + - nebius-cloud-kubernetes + - default + nebius-cloud-resources: + enabled: true + nebius-cloud-service-quota-collection: + enabled: true + name: nebius-prod + settings: + account_tags: + - env:prod + - team:ai + tenant_id: tenant-12345678 + id: e5f6a7b8-c9d0-4e1f-8a2b-3c4d5e6f7081 + type: integration-account + schema: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountsResponse" + description: OK + "400": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Bad Request + "403": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Forbidden + "404": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Not Found + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + summary: List Nebius Cloud integration accounts + tags: + - Nebius Cloud 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 Nebius Cloud integration account. + operationId: CreateNebiusCloudIntegrationAccount + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountCreateRequest" + required: true + responses: + "201": + content: + application/json: + examples: + default: + value: + data: + attributes: + authentication: + auth_type: nebius_service_account + public_key_id: publickey-yyyyyyyy + service_account_id: serviceaccount-xxxxxxxx + dataflows: + nebius-cloud-cost-collection: + enabled: true + settings: + access_key_id: AKID0123456789ABCDEF + bucket_name: nebius-cost-exports + bucket_prefix_path: cost-export/2026/ + bucket_region: eu-north1 + nebius-cloud-logs: + enabled: true + settings: + enabled_services: + - nebius-cloud-compute + - nebius-cloud-kubernetes + - default + nebius-cloud-resources: + enabled: true + nebius-cloud-service-quota-collection: + enabled: true + name: nebius-prod + settings: + account_tags: + - env:prod + - team:ai + tenant_id: tenant-12345678 + id: e5f6a7b8-c9d0-4e1f-8a2b-3c4d5e6f7081 + type: integration-account + schema: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountResponse" + description: Created + "400": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Bad Request + "403": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Forbidden + "404": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Not Found + "422": + $ref: "#/components/responses/UnprocessableEntityResponse" + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + summary: Create a Nebius Cloud integration account + tags: + - Nebius Cloud 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/nebius-cloud/accounts/{account_id}: + delete: + description: Delete a Nebius Cloud integration account. + operationId: DeleteNebiusCloudIntegrationAccount + parameters: + - $ref: "#/components/parameters/IntegrationAccountIdParameter" + responses: + "200": + description: OK + "400": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Bad Request + "403": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Forbidden + "404": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Not Found + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + summary: Delete a Nebius Cloud integration account + tags: + - Nebius Cloud 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 Nebius Cloud integration account. + operationId: GetNebiusCloudIntegrationAccount + parameters: + - $ref: "#/components/parameters/IntegrationAccountIdParameter" + responses: + "200": + content: + application/json: + examples: + default: + value: + data: + attributes: + authentication: + auth_type: nebius_service_account + public_key_id: publickey-yyyyyyyy + service_account_id: serviceaccount-xxxxxxxx + dataflows: + nebius-cloud-cost-collection: + enabled: true + settings: + access_key_id: AKID0123456789ABCDEF + bucket_name: nebius-cost-exports + bucket_prefix_path: cost-export/2026/ + bucket_region: eu-north1 + nebius-cloud-logs: + enabled: true + settings: + enabled_services: + - nebius-cloud-compute + - nebius-cloud-kubernetes + - default + nebius-cloud-resources: + enabled: true + nebius-cloud-service-quota-collection: + enabled: true + name: nebius-prod + settings: + account_tags: + - env:prod + - team:ai + tenant_id: tenant-12345678 + id: e5f6a7b8-c9d0-4e1f-8a2b-3c4d5e6f7081 + type: integration-account + schema: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountResponse" + description: OK + "400": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Bad Request + "403": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Forbidden + "404": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Not Found + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + summary: Get a Nebius Cloud integration account + tags: + - Nebius Cloud 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 Nebius Cloud integration account. Only the fields provided are changed. + operationId: UpdateNebiusCloudIntegrationAccount + parameters: + - $ref: "#/components/parameters/IntegrationAccountIdParameter" + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountUpdateRequest" + required: true + responses: + "200": + content: + application/json: + examples: + default: + value: + data: + attributes: + authentication: + auth_type: nebius_service_account + public_key_id: publickey-yyyyyyyy + service_account_id: serviceaccount-xxxxxxxx + dataflows: + nebius-cloud-cost-collection: + enabled: true + settings: + access_key_id: AKID0123456789ABCDEF + bucket_name: nebius-cost-exports + bucket_prefix_path: cost-export/2026/ + bucket_region: eu-north1 + nebius-cloud-logs: + enabled: true + settings: + enabled_services: + - nebius-cloud-compute + - nebius-cloud-kubernetes + - default + nebius-cloud-resources: + enabled: true + nebius-cloud-service-quota-collection: + enabled: true + name: nebius-prod + settings: + account_tags: + - env:prod + - team:ai + tenant_id: tenant-12345678 + id: e5f6a7b8-c9d0-4e1f-8a2b-3c4d5e6f7081 + type: integration-account + schema: + $ref: "#/components/schemas/NebiusCloudIntegrationAccountResponse" + description: OK + "400": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Bad Request + "403": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Forbidden + "404": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Not Found + "422": + $ref: "#/components/responses/UnprocessableEntityResponse" + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + summary: Update a Nebius Cloud integration account + tags: + - Nebius Cloud 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/snowflake/accounts: get: description: List Snowflake integration accounts. @@ -276192,6 +277110,15 @@ tags: description: Find out more at url: https://docs.datadoghq.com/monitors/create/types/ name: Monitors + - description: |- + Manage your Datadog Nebius Cloud integration accounts and account resources + directly through the Datadog API. See the + [Nebius Cloud integration page](https://docs.datadoghq.com/integrations/nebius_cloud/) for + more information. + externalDocs: + description: Nebius Cloud integration. + url: https://docs.datadoghq.com/integrations/nebius_cloud/ + name: Nebius Cloud Integration - description: |- The Network Device Monitoring API allows you to fetch devices and interfaces and their attributes. See the [Network Device Monitoring page](https://docs.datadoghq.com/network_monitoring/) for more information. name: Network Device Monitoring diff --git a/examples/v2/nebius-cloud-integration/CreateNebiusCloudIntegrationAccount.rb b/examples/v2/nebius-cloud-integration/CreateNebiusCloudIntegrationAccount.rb new file mode 100644 index 000000000000..69238e98ce51 --- /dev/null +++ b/examples/v2/nebius-cloud-integration/CreateNebiusCloudIntegrationAccount.rb @@ -0,0 +1,66 @@ +# Create a Nebius Cloud integration account returns "Created" response + +require "datadog_api_client" +DatadogAPIClient.configure do |config| + config.access_token = ENV["DD_BEARER_TOKEN"] + config.unstable_operations["v2.create_nebius_cloud_integration_account".to_sym] = true +end +api_instance = DatadogAPIClient::V2::NebiusCloudIntegrationAPI.new + +body = DatadogAPIClient::V2::NebiusCloudIntegrationAccountCreateRequest.new({ + data: DatadogAPIClient::V2::NebiusCloudIntegrationAccountCreateData.new({ + attributes: DatadogAPIClient::V2::NebiusCloudIntegrationAccountCreateAttributes.new({ + authentication: DatadogAPIClient::V2::NebiusCloudIntegrationAccountServiceAccountAuthRequest.new({ + auth_type: DatadogAPIClient::V2::NebiusCloudIntegrationAccountServiceAccountAuthType::NEBIUS_SERVICE_ACCOUNT, + private_key: '-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----', + public_key_id: "publickey-yyyyyyyy", + service_account_id: "serviceaccount-xxxxxxxx", + static_api_key: "eyJhbGciOi...static-api-key", + }), + dataflows: DatadogAPIClient::V2::NebiusCloudIntegrationDataflowsRequest.new({ + nebius_cloud_cost_collection: DatadogAPIClient::V2::NebiusCloudCostCollectionIntegrationDataflowRequest.new({ + enabled: true, + settings: DatadogAPIClient::V2::NebiusCloudCostCollectionIntegrationDataflowSettingsRequest.new({ + access_key_id: "AKID0123456789ABCDEF", + access_key_secret: "wJalrXUtnFEMIstaticaccesskey", + bucket_name: "nebius-cost-exports", + bucket_prefix_path: "cost-export/2026/", + bucket_region: "eu-north1", + }), + }), + nebius_cloud_logs: DatadogAPIClient::V2::NebiusCloudLogsIntegrationDataflowRequest.new({ + enabled: true, + settings: DatadogAPIClient::V2::NebiusCloudLogsIntegrationDataflowSettingsRequest.new({ + enabled_services: [ + DatadogAPIClient::V2::NebiusCloudLogsIntegrationServiceName::NEBIUS_CLOUD_COMPUTE, + DatadogAPIClient::V2::NebiusCloudLogsIntegrationServiceName::NEBIUS_CLOUD_KUBERNETES, + DatadogAPIClient::V2::NebiusCloudLogsIntegrationServiceName::DEFAULT, + ], + }), + }), + nebius_cloud_resources: DatadogAPIClient::V2::NebiusCloudResourcesIntegrationDataflowRequest.new({ + enabled: true, + }), + nebius_cloud_service_quota_collection: DatadogAPIClient::V2::NebiusCloudServiceQuotaCollectionIntegrationDataflowRequest.new({ + enabled: true, + }), + }), + name: "nebius-prod", + settings: DatadogAPIClient::V2::NebiusCloudIntegrationAccountSettingsRequest.new({ + account_tags: [ + "env:prod", + "team:ai", + ], + metrics_config: DatadogAPIClient::V2::NebiusCloudIntegrationAccountMetricsConfigRequest.new({ + cluster_filters: [ + "cluster:prod-*", + "!cluster:dev", + ], + }), + tenant_id: "tenant-12345678", + }), + }), + type: DatadogAPIClient::V2::IntegrationAccountType::INTEGRATION_ACCOUNT, + }), +}) +p api_instance.create_nebius_cloud_integration_account(body) diff --git a/examples/v2/nebius-cloud-integration/DeleteNebiusCloudIntegrationAccount.rb b/examples/v2/nebius-cloud-integration/DeleteNebiusCloudIntegrationAccount.rb new file mode 100644 index 000000000000..5ffcbb83c97b --- /dev/null +++ b/examples/v2/nebius-cloud-integration/DeleteNebiusCloudIntegrationAccount.rb @@ -0,0 +1,9 @@ +# Delete a Nebius Cloud integration account returns "OK" response + +require "datadog_api_client" +DatadogAPIClient.configure do |config| + config.access_token = ENV["DD_BEARER_TOKEN"] + config.unstable_operations["v2.delete_nebius_cloud_integration_account".to_sym] = true +end +api_instance = DatadogAPIClient::V2::NebiusCloudIntegrationAPI.new +p api_instance.delete_nebius_cloud_integration_account("account_id") diff --git a/examples/v2/nebius-cloud-integration/GetNebiusCloudIntegrationAccount.rb b/examples/v2/nebius-cloud-integration/GetNebiusCloudIntegrationAccount.rb new file mode 100644 index 000000000000..eccedc818682 --- /dev/null +++ b/examples/v2/nebius-cloud-integration/GetNebiusCloudIntegrationAccount.rb @@ -0,0 +1,9 @@ +# Get a Nebius Cloud integration account returns "OK" response + +require "datadog_api_client" +DatadogAPIClient.configure do |config| + config.access_token = ENV["DD_BEARER_TOKEN"] + config.unstable_operations["v2.get_nebius_cloud_integration_account".to_sym] = true +end +api_instance = DatadogAPIClient::V2::NebiusCloudIntegrationAPI.new +p api_instance.get_nebius_cloud_integration_account("account_id") diff --git a/examples/v2/nebius-cloud-integration/ListNebiusCloudIntegrationAccounts.rb b/examples/v2/nebius-cloud-integration/ListNebiusCloudIntegrationAccounts.rb new file mode 100644 index 000000000000..c4cd100f0ed6 --- /dev/null +++ b/examples/v2/nebius-cloud-integration/ListNebiusCloudIntegrationAccounts.rb @@ -0,0 +1,9 @@ +# List Nebius Cloud integration accounts returns "OK" response + +require "datadog_api_client" +DatadogAPIClient.configure do |config| + config.access_token = ENV["DD_BEARER_TOKEN"] + config.unstable_operations["v2.list_nebius_cloud_integration_accounts".to_sym] = true +end +api_instance = DatadogAPIClient::V2::NebiusCloudIntegrationAPI.new +p api_instance.list_nebius_cloud_integration_accounts() diff --git a/examples/v2/nebius-cloud-integration/UpdateNebiusCloudIntegrationAccount.rb b/examples/v2/nebius-cloud-integration/UpdateNebiusCloudIntegrationAccount.rb new file mode 100644 index 000000000000..3c16abe2aace --- /dev/null +++ b/examples/v2/nebius-cloud-integration/UpdateNebiusCloudIntegrationAccount.rb @@ -0,0 +1,67 @@ +# Update a Nebius Cloud integration account returns "OK" response + +require "datadog_api_client" +DatadogAPIClient.configure do |config| + config.access_token = ENV["DD_BEARER_TOKEN"] + config.unstable_operations["v2.update_nebius_cloud_integration_account".to_sym] = true +end +api_instance = DatadogAPIClient::V2::NebiusCloudIntegrationAPI.new + +body = DatadogAPIClient::V2::NebiusCloudIntegrationAccountUpdateRequest.new({ + data: DatadogAPIClient::V2::NebiusCloudIntegrationAccountUpdateData.new({ + attributes: DatadogAPIClient::V2::NebiusCloudIntegrationAccountUpdateAttributes.new({ + authentication: DatadogAPIClient::V2::NebiusCloudIntegrationAccountServiceAccountAuthUpdate.new({ + auth_type: DatadogAPIClient::V2::NebiusCloudIntegrationAccountServiceAccountAuthType::NEBIUS_SERVICE_ACCOUNT, + private_key: '-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----', + public_key_id: "publickey-yyyyyyyy", + service_account_id: "serviceaccount-xxxxxxxx", + static_api_key: "eyJhbGciOi...static-api-key", + }), + dataflows: DatadogAPIClient::V2::NebiusCloudIntegrationDataflowsRequest.new({ + nebius_cloud_cost_collection: DatadogAPIClient::V2::NebiusCloudCostCollectionIntegrationDataflowRequest.new({ + enabled: true, + settings: DatadogAPIClient::V2::NebiusCloudCostCollectionIntegrationDataflowSettingsRequest.new({ + access_key_id: "AKID0123456789ABCDEF", + access_key_secret: "wJalrXUtnFEMIstaticaccesskey", + bucket_name: "nebius-cost-exports", + bucket_prefix_path: "cost-export/2026/", + bucket_region: "eu-north1", + }), + }), + nebius_cloud_logs: DatadogAPIClient::V2::NebiusCloudLogsIntegrationDataflowRequest.new({ + enabled: true, + settings: DatadogAPIClient::V2::NebiusCloudLogsIntegrationDataflowSettingsRequest.new({ + enabled_services: [ + DatadogAPIClient::V2::NebiusCloudLogsIntegrationServiceName::NEBIUS_CLOUD_COMPUTE, + DatadogAPIClient::V2::NebiusCloudLogsIntegrationServiceName::NEBIUS_CLOUD_KUBERNETES, + DatadogAPIClient::V2::NebiusCloudLogsIntegrationServiceName::DEFAULT, + ], + }), + }), + nebius_cloud_resources: DatadogAPIClient::V2::NebiusCloudResourcesIntegrationDataflowRequest.new({ + enabled: true, + }), + nebius_cloud_service_quota_collection: DatadogAPIClient::V2::NebiusCloudServiceQuotaCollectionIntegrationDataflowRequest.new({ + enabled: true, + }), + }), + name: "nebius-prod", + settings: DatadogAPIClient::V2::NebiusCloudIntegrationAccountSettingsUpdate.new({ + account_tags: [ + "env:prod", + "team:ai", + ], + metrics_config: DatadogAPIClient::V2::NebiusCloudIntegrationAccountMetricsConfigUpdate.new({ + cluster_filters: [ + "cluster:prod-*", + "!cluster:dev", + ], + }), + tenant_id: "tenant-12345678", + }), + }), + id: "e5f6a7b8-c9d0-4e1f-8a2b-3c4d5e6f7081", + type: DatadogAPIClient::V2::IntegrationAccountType::INTEGRATION_ACCOUNT, + }), +}) +p api_instance.update_nebius_cloud_integration_account("account_id", body) diff --git a/features/scenarios_model_mapping.rb b/features/scenarios_model_mapping.rb index 07274057c608..e83f8c73528d 100644 --- a/features/scenarios_model_mapping.rb +++ b/features/scenarios_model_mapping.rb @@ -4746,6 +4746,19 @@ "account_id" => "String", "body" => "ElasticCloudIntegrationAccountUpdateRequest", }, + "v2.CreateNebiusCloudIntegrationAccount" => { + "body" => "NebiusCloudIntegrationAccountCreateRequest", + }, + "v2.DeleteNebiusCloudIntegrationAccount" => { + "account_id" => "String", + }, + "v2.GetNebiusCloudIntegrationAccount" => { + "account_id" => "String", + }, + "v2.UpdateNebiusCloudIntegrationAccount" => { + "account_id" => "String", + "body" => "NebiusCloudIntegrationAccountUpdateRequest", + }, "v2.CreateSnowflakeIntegrationAccount" => { "body" => "SnowflakeIntegrationAccountCreateRequest", }, diff --git a/features/v2/given.json b/features/v2/given.json index b33de98f6e78..c7f6385fa86c 100644 --- a/features/v2/given.json +++ b/features/v2/given.json @@ -910,6 +910,18 @@ "tag": "Incidents", "operationId": "CreateIncidentTodo" }, + { + "parameters": [ + { + "name": "body", + "value": "{\"data\": {\"type\": \"integration-account\", \"attributes\": {\"name\": \"nebius-{{ unique }}\", \"authentication\": {\"auth_type\": \"nebius_service_account\", \"service_account_id\": \"serviceaccount-xxxxxxxx\"}, \"settings\": {\"tenant_id\": \"tenant-12345678\"}}}}" + } + ], + "step": "there is a valid \"nebius_cloud_integration_account\" in the system", + "key": "nebius_cloud_integration_account", + "tag": "Nebius Cloud Integration", + "operationId": "CreateNebiusCloudIntegrationAccount" + }, { "step": "there is an integrated AWS test account for WIF", "key": "aws_wif_account_v2", diff --git a/features/v2/nebius_cloud_integration.feature b/features/v2/nebius_cloud_integration.feature new file mode 100644 index 000000000000..aaad053a71a4 --- /dev/null +++ b/features/v2/nebius_cloud_integration.feature @@ -0,0 +1,148 @@ +@endpoint(nebius-cloud-integration) @endpoint(nebius-cloud-integration-v2) +Feature: Nebius Cloud Integration + Manage your Datadog Nebius Cloud integration accounts and account + resources directly through the Datadog API. See the [Nebius Cloud + integration page](https://docs.datadoghq.com/integrations/nebius_cloud/) + for more information. + + Background: + Given a valid "apiKeyAuth" key in the system + And a valid "appKeyAuth" key in the system + And an instance of "NebiusCloudIntegration" API + + @generated @skip @team:ddoghq/emerging-cloud-integrations + Scenario: Create a Nebius Cloud integration account returns "Bad Request" response + Given operation "CreateNebiusCloudIntegrationAccount" enabled + And new "CreateNebiusCloudIntegrationAccount" request + And body with value {"data": {"attributes": {"authentication": {"auth_type": "nebius_service_account", "private_key": "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----", "public_key_id": "publickey-yyyyyyyy", "service_account_id": "serviceaccount-xxxxxxxx", "static_api_key": "eyJhbGciOi...static-api-key"}, "dataflows": {"nebius-cloud-cost-collection": {"enabled": true, "settings": {"access_key_id": "AKID0123456789ABCDEF", "access_key_secret": "wJalrXUtnFEMIstaticaccesskey", "bucket_name": "nebius-cost-exports", "bucket_prefix_path": "cost-export/2026/", "bucket_region": "eu-north1"}}, "nebius-cloud-logs": {"enabled": true, "settings": {"enabled_services": ["nebius-cloud-compute", "nebius-cloud-kubernetes", "default"]}}, "nebius-cloud-resources": {"enabled": true}, "nebius-cloud-service-quota-collection": {"enabled": true}}, "name": "nebius-prod", "settings": {"account_tags": ["env:prod", "team:ai"], "metrics_config": {"cluster_filters": ["cluster:prod-*", "!cluster:dev"]}, "tenant_id": "tenant-12345678"}}, "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 Nebius Cloud integration account returns "Created" response + Given operation "CreateNebiusCloudIntegrationAccount" enabled + And new "CreateNebiusCloudIntegrationAccount" request + And body with value {"data": {"attributes": {"authentication": {"auth_type": "nebius_service_account", "private_key": "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----", "public_key_id": "publickey-yyyyyyyy", "service_account_id": "serviceaccount-xxxxxxxx", "static_api_key": "eyJhbGciOi...static-api-key"}, "dataflows": {"nebius-cloud-cost-collection": {"enabled": true, "settings": {"access_key_id": "AKID0123456789ABCDEF", "access_key_secret": "wJalrXUtnFEMIstaticaccesskey", "bucket_name": "nebius-cost-exports", "bucket_prefix_path": "cost-export/2026/", "bucket_region": "eu-north1"}}, "nebius-cloud-logs": {"enabled": true, "settings": {"enabled_services": ["nebius-cloud-compute", "nebius-cloud-kubernetes", "default"]}}, "nebius-cloud-resources": {"enabled": true}, "nebius-cloud-service-quota-collection": {"enabled": true}}, "name": "nebius-prod", "settings": {"account_tags": ["env:prod", "team:ai"], "metrics_config": {"cluster_filters": ["cluster:prod-*", "!cluster:dev"]}, "tenant_id": "tenant-12345678"}}, "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 Nebius Cloud integration account returns "Not Found" response + Given operation "CreateNebiusCloudIntegrationAccount" enabled + And new "CreateNebiusCloudIntegrationAccount" request + And body with value {"data": {"attributes": {"authentication": {"auth_type": "nebius_service_account", "private_key": "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----", "public_key_id": "publickey-yyyyyyyy", "service_account_id": "serviceaccount-xxxxxxxx", "static_api_key": "eyJhbGciOi...static-api-key"}, "dataflows": {"nebius-cloud-cost-collection": {"enabled": true, "settings": {"access_key_id": "AKID0123456789ABCDEF", "access_key_secret": "wJalrXUtnFEMIstaticaccesskey", "bucket_name": "nebius-cost-exports", "bucket_prefix_path": "cost-export/2026/", "bucket_region": "eu-north1"}}, "nebius-cloud-logs": {"enabled": true, "settings": {"enabled_services": ["nebius-cloud-compute", "nebius-cloud-kubernetes", "default"]}}, "nebius-cloud-resources": {"enabled": true}, "nebius-cloud-service-quota-collection": {"enabled": true}}, "name": "nebius-prod", "settings": {"account_tags": ["env:prod", "team:ai"], "metrics_config": {"cluster_filters": ["cluster:prod-*", "!cluster:dev"]}, "tenant_id": "tenant-12345678"}}, "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 Nebius Cloud integration account returns "The server cannot process the request because it contains invalid data." response + Given operation "CreateNebiusCloudIntegrationAccount" enabled + And new "CreateNebiusCloudIntegrationAccount" request + And body with value {"data": {"attributes": {"authentication": {"auth_type": "nebius_service_account", "private_key": "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----", "public_key_id": "publickey-yyyyyyyy", "service_account_id": "serviceaccount-xxxxxxxx", "static_api_key": "eyJhbGciOi...static-api-key"}, "dataflows": {"nebius-cloud-cost-collection": {"enabled": true, "settings": {"access_key_id": "AKID0123456789ABCDEF", "access_key_secret": "wJalrXUtnFEMIstaticaccesskey", "bucket_name": "nebius-cost-exports", "bucket_prefix_path": "cost-export/2026/", "bucket_region": "eu-north1"}}, "nebius-cloud-logs": {"enabled": true, "settings": {"enabled_services": ["nebius-cloud-compute", "nebius-cloud-kubernetes", "default"]}}, "nebius-cloud-resources": {"enabled": true}, "nebius-cloud-service-quota-collection": {"enabled": true}}, "name": "nebius-prod", "settings": {"account_tags": ["env:prod", "team:ai"], "metrics_config": {"cluster_filters": ["cluster:prod-*", "!cluster:dev"]}, "tenant_id": "tenant-12345678"}}, "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 Nebius Cloud integration account returns "Bad Request" response + Given operation "DeleteNebiusCloudIntegrationAccount" enabled + And new "DeleteNebiusCloudIntegrationAccount" 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 Nebius Cloud integration account returns "Not Found" response + Given operation "DeleteNebiusCloudIntegrationAccount" enabled + And new "DeleteNebiusCloudIntegrationAccount" 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 Nebius Cloud integration account returns "OK" response + Given operation "DeleteNebiusCloudIntegrationAccount" enabled + And new "DeleteNebiusCloudIntegrationAccount" 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 Nebius Cloud integration account returns "Bad Request" response + Given operation "GetNebiusCloudIntegrationAccount" enabled + And new "GetNebiusCloudIntegrationAccount" 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 Nebius Cloud integration account returns "Not Found" response + Given operation "GetNebiusCloudIntegrationAccount" enabled + And new "GetNebiusCloudIntegrationAccount" 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 Nebius Cloud integration account returns "OK" response + Given operation "GetNebiusCloudIntegrationAccount" enabled + And new "GetNebiusCloudIntegrationAccount" 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 Nebius Cloud integration accounts returns "Bad Request" response + Given operation "ListNebiusCloudIntegrationAccounts" enabled + And new "ListNebiusCloudIntegrationAccounts" request + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:ddoghq/emerging-cloud-integrations + Scenario: List Nebius Cloud integration accounts returns "Not Found" response + Given operation "ListNebiusCloudIntegrationAccounts" enabled + And new "ListNebiusCloudIntegrationAccounts" request + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:ddoghq/emerging-cloud-integrations + Scenario: List Nebius Cloud integration accounts returns "OK" response + Given operation "ListNebiusCloudIntegrationAccounts" enabled + And new "ListNebiusCloudIntegrationAccounts" request + When the request is sent + Then the response status is 200 OK + + @generated @skip @team:ddoghq/emerging-cloud-integrations + Scenario: Update a Nebius Cloud integration account returns "Bad Request" response + Given operation "UpdateNebiusCloudIntegrationAccount" enabled + And new "UpdateNebiusCloudIntegrationAccount" request + And request contains "account_id" parameter from "REPLACE.ME" + And body with value {"data": {"attributes": {"authentication": {"auth_type": "nebius_service_account", "private_key": "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----", "public_key_id": "publickey-yyyyyyyy", "service_account_id": "serviceaccount-xxxxxxxx", "static_api_key": "eyJhbGciOi...static-api-key"}, "dataflows": {"nebius-cloud-cost-collection": {"enabled": true, "settings": {"access_key_id": "AKID0123456789ABCDEF", "access_key_secret": "wJalrXUtnFEMIstaticaccesskey", "bucket_name": "nebius-cost-exports", "bucket_prefix_path": "cost-export/2026/", "bucket_region": "eu-north1"}}, "nebius-cloud-logs": {"enabled": true, "settings": {"enabled_services": ["nebius-cloud-compute", "nebius-cloud-kubernetes", "default"]}}, "nebius-cloud-resources": {"enabled": true}, "nebius-cloud-service-quota-collection": {"enabled": true}}, "name": "nebius-prod", "settings": {"account_tags": ["env:prod", "team:ai"], "metrics_config": {"cluster_filters": ["cluster:prod-*", "!cluster:dev"]}, "tenant_id": "tenant-12345678"}}, "id": "e5f6a7b8-c9d0-4e1f-8a2b-3c4d5e6f7081", "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 Nebius Cloud integration account returns "Not Found" response + Given operation "UpdateNebiusCloudIntegrationAccount" enabled + And new "UpdateNebiusCloudIntegrationAccount" request + And request contains "account_id" parameter from "REPLACE.ME" + And body with value {"data": {"attributes": {"authentication": {"auth_type": "nebius_service_account", "private_key": "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----", "public_key_id": "publickey-yyyyyyyy", "service_account_id": "serviceaccount-xxxxxxxx", "static_api_key": "eyJhbGciOi...static-api-key"}, "dataflows": {"nebius-cloud-cost-collection": {"enabled": true, "settings": {"access_key_id": "AKID0123456789ABCDEF", "access_key_secret": "wJalrXUtnFEMIstaticaccesskey", "bucket_name": "nebius-cost-exports", "bucket_prefix_path": "cost-export/2026/", "bucket_region": "eu-north1"}}, "nebius-cloud-logs": {"enabled": true, "settings": {"enabled_services": ["nebius-cloud-compute", "nebius-cloud-kubernetes", "default"]}}, "nebius-cloud-resources": {"enabled": true}, "nebius-cloud-service-quota-collection": {"enabled": true}}, "name": "nebius-prod", "settings": {"account_tags": ["env:prod", "team:ai"], "metrics_config": {"cluster_filters": ["cluster:prod-*", "!cluster:dev"]}, "tenant_id": "tenant-12345678"}}, "id": "e5f6a7b8-c9d0-4e1f-8a2b-3c4d5e6f7081", "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 Nebius Cloud integration account returns "OK" response + Given operation "UpdateNebiusCloudIntegrationAccount" enabled + And new "UpdateNebiusCloudIntegrationAccount" request + And request contains "account_id" parameter from "REPLACE.ME" + And body with value {"data": {"attributes": {"authentication": {"auth_type": "nebius_service_account", "private_key": "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----", "public_key_id": "publickey-yyyyyyyy", "service_account_id": "serviceaccount-xxxxxxxx", "static_api_key": "eyJhbGciOi...static-api-key"}, "dataflows": {"nebius-cloud-cost-collection": {"enabled": true, "settings": {"access_key_id": "AKID0123456789ABCDEF", "access_key_secret": "wJalrXUtnFEMIstaticaccesskey", "bucket_name": "nebius-cost-exports", "bucket_prefix_path": "cost-export/2026/", "bucket_region": "eu-north1"}}, "nebius-cloud-logs": {"enabled": true, "settings": {"enabled_services": ["nebius-cloud-compute", "nebius-cloud-kubernetes", "default"]}}, "nebius-cloud-resources": {"enabled": true}, "nebius-cloud-service-quota-collection": {"enabled": true}}, "name": "nebius-prod", "settings": {"account_tags": ["env:prod", "team:ai"], "metrics_config": {"cluster_filters": ["cluster:prod-*", "!cluster:dev"]}, "tenant_id": "tenant-12345678"}}, "id": "e5f6a7b8-c9d0-4e1f-8a2b-3c4d5e6f7081", "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 Nebius Cloud integration account returns "The server cannot process the request because it contains invalid data." response + Given operation "UpdateNebiusCloudIntegrationAccount" enabled + And new "UpdateNebiusCloudIntegrationAccount" request + And request contains "account_id" parameter from "REPLACE.ME" + And body with value {"data": {"attributes": {"authentication": {"auth_type": "nebius_service_account", "private_key": "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----", "public_key_id": "publickey-yyyyyyyy", "service_account_id": "serviceaccount-xxxxxxxx", "static_api_key": "eyJhbGciOi...static-api-key"}, "dataflows": {"nebius-cloud-cost-collection": {"enabled": true, "settings": {"access_key_id": "AKID0123456789ABCDEF", "access_key_secret": "wJalrXUtnFEMIstaticaccesskey", "bucket_name": "nebius-cost-exports", "bucket_prefix_path": "cost-export/2026/", "bucket_region": "eu-north1"}}, "nebius-cloud-logs": {"enabled": true, "settings": {"enabled_services": ["nebius-cloud-compute", "nebius-cloud-kubernetes", "default"]}}, "nebius-cloud-resources": {"enabled": true}, "nebius-cloud-service-quota-collection": {"enabled": true}}, "name": "nebius-prod", "settings": {"account_tags": ["env:prod", "team:ai"], "metrics_config": {"cluster_filters": ["cluster:prod-*", "!cluster:dev"]}, "tenant_id": "tenant-12345678"}}, "id": "e5f6a7b8-c9d0-4e1f-8a2b-3c4d5e6f7081", "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/features/v2/undo.json b/features/v2/undo.json index 0d9b33aa46f6..4fb92fbf0ca5 100644 --- a/features/v2/undo.json +++ b/features/v2/undo.json @@ -4381,6 +4381,43 @@ "type": "idempotent" } }, + "ListNebiusCloudIntegrationAccounts": { + "tag": "Nebius Cloud Integration", + "undo": { + "type": "safe" + } + }, + "CreateNebiusCloudIntegrationAccount": { + "tag": "Nebius Cloud Integration", + "undo": { + "operationId": "DeleteNebiusCloudIntegrationAccount", + "parameters": [ + { + "name": "account_id", + "source": "data.id" + } + ], + "type": "unsafe" + } + }, + "DeleteNebiusCloudIntegrationAccount": { + "tag": "Nebius Cloud Integration", + "undo": { + "type": "idempotent" + } + }, + "GetNebiusCloudIntegrationAccount": { + "tag": "Nebius Cloud Integration", + "undo": { + "type": "safe" + } + }, + "UpdateNebiusCloudIntegrationAccount": { + "tag": "Nebius Cloud Integration", + "undo": { + "type": "idempotent" + } + }, "ListSnowflakeIntegrationAccounts": { "tag": "Snowflake Integration", "undo": { diff --git a/lib/datadog_api_client/configuration.rb b/lib/datadog_api_client/configuration.rb index f3c25b0e12e0..8c2bb5ecce90 100644 --- a/lib/datadog_api_client/configuration.rb +++ b/lib/datadog_api_client/configuration.rb @@ -684,6 +684,11 @@ def initialize "v2.get_elastic_cloud_integration_account": false, "v2.list_elastic_cloud_integration_accounts": false, "v2.update_elastic_cloud_integration_account": false, + "v2.create_nebius_cloud_integration_account": false, + "v2.delete_nebius_cloud_integration_account": false, + "v2.get_nebius_cloud_integration_account": false, + "v2.list_nebius_cloud_integration_accounts": false, + "v2.update_nebius_cloud_integration_account": false, "v2.create_snowflake_integration_account": false, "v2.delete_snowflake_integration_account": false, "v2.get_snowflake_integration_account": false, diff --git a/lib/datadog_api_client/inflector.rb b/lib/datadog_api_client/inflector.rb index f34fac60dd1c..a33c35abb815 100644 --- a/lib/datadog_api_client/inflector.rb +++ b/lib/datadog_api_client/inflector.rb @@ -6440,6 +6440,44 @@ def overrides "v2.ndk_sourcemap_attributes" => "NDKSourcemapAttributes", "v2.ndk_sourcemap_data" => "NDKSourcemapData", "v2.ndk_sourcemap_map_kind" => "NDKSourcemapMapKind", + "v2.nebius_cloud_cost_collection_integration_dataflow_request" => "NebiusCloudCostCollectionIntegrationDataflowRequest", + "v2.nebius_cloud_cost_collection_integration_dataflow_response" => "NebiusCloudCostCollectionIntegrationDataflowResponse", + "v2.nebius_cloud_cost_collection_integration_dataflow_settings_request" => "NebiusCloudCostCollectionIntegrationDataflowSettingsRequest", + "v2.nebius_cloud_cost_collection_integration_dataflow_settings_response" => "NebiusCloudCostCollectionIntegrationDataflowSettingsResponse", + "v2.nebius_cloud_integration_account_authentication_request" => "NebiusCloudIntegrationAccountAuthenticationRequest", + "v2.nebius_cloud_integration_account_authentication_response" => "NebiusCloudIntegrationAccountAuthenticationResponse", + "v2.nebius_cloud_integration_account_authentication_update" => "NebiusCloudIntegrationAccountAuthenticationUpdate", + "v2.nebius_cloud_integration_account_create_attributes" => "NebiusCloudIntegrationAccountCreateAttributes", + "v2.nebius_cloud_integration_account_create_data" => "NebiusCloudIntegrationAccountCreateData", + "v2.nebius_cloud_integration_account_create_request" => "NebiusCloudIntegrationAccountCreateRequest", + "v2.nebius_cloud_integration_account_metrics_config_request" => "NebiusCloudIntegrationAccountMetricsConfigRequest", + "v2.nebius_cloud_integration_account_metrics_config_response" => "NebiusCloudIntegrationAccountMetricsConfigResponse", + "v2.nebius_cloud_integration_account_metrics_config_update" => "NebiusCloudIntegrationAccountMetricsConfigUpdate", + "v2.nebius_cloud_integration_account_response" => "NebiusCloudIntegrationAccountResponse", + "v2.nebius_cloud_integration_account_response_attributes" => "NebiusCloudIntegrationAccountResponseAttributes", + "v2.nebius_cloud_integration_account_response_data" => "NebiusCloudIntegrationAccountResponseData", + "v2.nebius_cloud_integration_account_service_account_auth_request" => "NebiusCloudIntegrationAccountServiceAccountAuthRequest", + "v2.nebius_cloud_integration_account_service_account_auth_response" => "NebiusCloudIntegrationAccountServiceAccountAuthResponse", + "v2.nebius_cloud_integration_account_service_account_auth_type" => "NebiusCloudIntegrationAccountServiceAccountAuthType", + "v2.nebius_cloud_integration_account_service_account_auth_update" => "NebiusCloudIntegrationAccountServiceAccountAuthUpdate", + "v2.nebius_cloud_integration_account_settings_request" => "NebiusCloudIntegrationAccountSettingsRequest", + "v2.nebius_cloud_integration_account_settings_response" => "NebiusCloudIntegrationAccountSettingsResponse", + "v2.nebius_cloud_integration_account_settings_update" => "NebiusCloudIntegrationAccountSettingsUpdate", + "v2.nebius_cloud_integration_accounts_response" => "NebiusCloudIntegrationAccountsResponse", + "v2.nebius_cloud_integration_account_update_attributes" => "NebiusCloudIntegrationAccountUpdateAttributes", + "v2.nebius_cloud_integration_account_update_data" => "NebiusCloudIntegrationAccountUpdateData", + "v2.nebius_cloud_integration_account_update_request" => "NebiusCloudIntegrationAccountUpdateRequest", + "v2.nebius_cloud_integration_dataflows_request" => "NebiusCloudIntegrationDataflowsRequest", + "v2.nebius_cloud_integration_dataflows_response" => "NebiusCloudIntegrationDataflowsResponse", + "v2.nebius_cloud_logs_integration_dataflow_request" => "NebiusCloudLogsIntegrationDataflowRequest", + "v2.nebius_cloud_logs_integration_dataflow_response" => "NebiusCloudLogsIntegrationDataflowResponse", + "v2.nebius_cloud_logs_integration_dataflow_settings_request" => "NebiusCloudLogsIntegrationDataflowSettingsRequest", + "v2.nebius_cloud_logs_integration_dataflow_settings_response" => "NebiusCloudLogsIntegrationDataflowSettingsResponse", + "v2.nebius_cloud_logs_integration_service_name" => "NebiusCloudLogsIntegrationServiceName", + "v2.nebius_cloud_resources_integration_dataflow_request" => "NebiusCloudResourcesIntegrationDataflowRequest", + "v2.nebius_cloud_resources_integration_dataflow_response" => "NebiusCloudResourcesIntegrationDataflowResponse", + "v2.nebius_cloud_service_quota_collection_integration_dataflow_request" => "NebiusCloudServiceQuotaCollectionIntegrationDataflowRequest", + "v2.nebius_cloud_service_quota_collection_integration_dataflow_response" => "NebiusCloudServiceQuotaCollectionIntegrationDataflowResponse", "v2.node_types_response" => "NodeTypesResponse", "v2.node_types_response_data" => "NodeTypesResponseData", "v2.node_types_response_data_attributes" => "NodeTypesResponseDataAttributes", @@ -10643,6 +10681,7 @@ def overrides "v2.microsoft_teams_integration_api" => "MicrosoftTeamsIntegrationAPI", "v2.model_lab_api_api" => "ModelLabAPIAPI", "v2.monitors_api" => "MonitorsAPI", + "v2.nebius_cloud_integration_api" => "NebiusCloudIntegrationAPI", "v2.network_device_monitoring_api" => "NetworkDeviceMonitoringAPI", "v2.o_auth2_client_public_api" => "OAuth2ClientPublicAPI", "v2.observability_pipelines_api" => "ObservabilityPipelinesAPI", diff --git a/lib/datadog_api_client/v2/api/nebius_cloud_integration_api.rb b/lib/datadog_api_client/v2/api/nebius_cloud_integration_api.rb new file mode 100644 index 000000000000..134745d6ef8c --- /dev/null +++ b/lib/datadog_api_client/v2/api/nebius_cloud_integration_api.rb @@ -0,0 +1,385 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'cgi' + +module DatadogAPIClient::V2 + class NebiusCloudIntegrationAPI + attr_accessor :api_client + + def initialize(api_client = DatadogAPIClient::APIClient.default) + @api_client = api_client + end + + # Create a Nebius Cloud integration account. + # + # @see #create_nebius_cloud_integration_account_with_http_info + def create_nebius_cloud_integration_account(body, opts = {}) + data, _status_code, _headers = create_nebius_cloud_integration_account_with_http_info(body, opts) + data + end + + # Create a Nebius Cloud integration account. + # + # Create a Nebius Cloud integration account. + # + # @param body [NebiusCloudIntegrationAccountCreateRequest] + # @param opts [Hash] the optional parameters + # @return [Array<(NebiusCloudIntegrationAccountResponse, Integer, Hash)>] NebiusCloudIntegrationAccountResponse data, response status code and response headers + def create_nebius_cloud_integration_account_with_http_info(body, opts = {}) + unstable_enabled = @api_client.config.unstable_operations["v2.create_nebius_cloud_integration_account".to_sym] + if unstable_enabled + @api_client.config.logger.warn format("Using unstable operation '%s'", "v2.create_nebius_cloud_integration_account") + else + raise DatadogAPIClient::APIError.new(message: format("Unstable operation '%s' is disabled", "v2.create_nebius_cloud_integration_account")) + end + + if @api_client.config.debugging + @api_client.config.logger.debug 'Calling API: NebiusCloudIntegrationAPI.create_nebius_cloud_integration_account ...' + end + # verify the required parameter 'body' is set + if @api_client.config.client_side_validation && body.nil? + fail ArgumentError, "Missing the required parameter 'body' when calling NebiusCloudIntegrationAPI.create_nebius_cloud_integration_account" + end + # resource path + local_var_path = '/api/v2/integration-interfaces/nebius-cloud/accounts' + + # query parameters + query_params = opts[:query_params] || {} + + # header parameters + header_params = opts[:header_params] || {} + # HTTP header 'Accept' (if needed) + header_params['Accept'] = @api_client.select_header_accept(['application/json']) + # HTTP header 'Content-Type' + header_params['Content-Type'] = @api_client.select_header_content_type(['application/json']) + + # form parameters + form_params = opts[:form_params] || {} + + # http body (model) + post_body = opts[:debug_body] || @api_client.object_to_http_body(body) + + # return_type + return_type = opts[:debug_return_type] || 'NebiusCloudIntegrationAccountResponse' + + # auth_names + auth_names = opts[:debug_auth_names] || [:apiKeyAuth, :appKeyAuth, :AuthZ] + + new_options = opts.merge( + :operation => :create_nebius_cloud_integration_account, + :header_params => header_params, + :query_params => query_params, + :form_params => form_params, + :body => post_body, + :auth_names => auth_names, + :return_type => return_type, + :api_version => "V2" + ) + + data, status_code, headers = @api_client.call_api(Net::HTTP::Post, local_var_path, new_options) + if @api_client.config.debugging + @api_client.config.logger.debug "API called: NebiusCloudIntegrationAPI#create_nebius_cloud_integration_account\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}" + end + return data, status_code, headers + end + + # Delete a Nebius Cloud integration account. + # + # @see #delete_nebius_cloud_integration_account_with_http_info + def delete_nebius_cloud_integration_account(account_id, opts = {}) + delete_nebius_cloud_integration_account_with_http_info(account_id, opts) + nil + end + + # Delete a Nebius Cloud integration account. + # + # Delete a Nebius Cloud integration account. + # + # @param account_id [String] Unique identifier of the integration account. + # @param opts [Hash] the optional parameters + # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers + def delete_nebius_cloud_integration_account_with_http_info(account_id, opts = {}) + unstable_enabled = @api_client.config.unstable_operations["v2.delete_nebius_cloud_integration_account".to_sym] + if unstable_enabled + @api_client.config.logger.warn format("Using unstable operation '%s'", "v2.delete_nebius_cloud_integration_account") + else + raise DatadogAPIClient::APIError.new(message: format("Unstable operation '%s' is disabled", "v2.delete_nebius_cloud_integration_account")) + end + + if @api_client.config.debugging + @api_client.config.logger.debug 'Calling API: NebiusCloudIntegrationAPI.delete_nebius_cloud_integration_account ...' + end + # verify the required parameter 'account_id' is set + if @api_client.config.client_side_validation && account_id.nil? + fail ArgumentError, "Missing the required parameter 'account_id' when calling NebiusCloudIntegrationAPI.delete_nebius_cloud_integration_account" + end + # resource path + local_var_path = '/api/v2/integration-interfaces/nebius-cloud/accounts/{account_id}'.sub('{account_id}', CGI.escape(account_id.to_s).gsub('%2F', '/')) + + # query parameters + query_params = opts[:query_params] || {} + + # header parameters + header_params = opts[:header_params] || {} + # HTTP header 'Accept' (if needed) + header_params['Accept'] = @api_client.select_header_accept(['*/*']) + + # form parameters + form_params = opts[:form_params] || {} + + # http body (model) + post_body = opts[:debug_body] + + # return_type + return_type = opts[:debug_return_type] + + # auth_names + auth_names = opts[:debug_auth_names] || [:apiKeyAuth, :appKeyAuth, :AuthZ] + + new_options = opts.merge( + :operation => :delete_nebius_cloud_integration_account, + :header_params => header_params, + :query_params => query_params, + :form_params => form_params, + :body => post_body, + :auth_names => auth_names, + :return_type => return_type, + :api_version => "V2" + ) + + data, status_code, headers = @api_client.call_api(Net::HTTP::Delete, local_var_path, new_options) + if @api_client.config.debugging + @api_client.config.logger.debug "API called: NebiusCloudIntegrationAPI#delete_nebius_cloud_integration_account\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}" + end + return data, status_code, headers + end + + # Get a Nebius Cloud integration account. + # + # @see #get_nebius_cloud_integration_account_with_http_info + def get_nebius_cloud_integration_account(account_id, opts = {}) + data, _status_code, _headers = get_nebius_cloud_integration_account_with_http_info(account_id, opts) + data + end + + # Get a Nebius Cloud integration account. + # + # Get a Nebius Cloud integration account. + # + # @param account_id [String] Unique identifier of the integration account. + # @param opts [Hash] the optional parameters + # @return [Array<(NebiusCloudIntegrationAccountResponse, Integer, Hash)>] NebiusCloudIntegrationAccountResponse data, response status code and response headers + def get_nebius_cloud_integration_account_with_http_info(account_id, opts = {}) + unstable_enabled = @api_client.config.unstable_operations["v2.get_nebius_cloud_integration_account".to_sym] + if unstable_enabled + @api_client.config.logger.warn format("Using unstable operation '%s'", "v2.get_nebius_cloud_integration_account") + else + raise DatadogAPIClient::APIError.new(message: format("Unstable operation '%s' is disabled", "v2.get_nebius_cloud_integration_account")) + end + + if @api_client.config.debugging + @api_client.config.logger.debug 'Calling API: NebiusCloudIntegrationAPI.get_nebius_cloud_integration_account ...' + end + # verify the required parameter 'account_id' is set + if @api_client.config.client_side_validation && account_id.nil? + fail ArgumentError, "Missing the required parameter 'account_id' when calling NebiusCloudIntegrationAPI.get_nebius_cloud_integration_account" + end + # resource path + local_var_path = '/api/v2/integration-interfaces/nebius-cloud/accounts/{account_id}'.sub('{account_id}', CGI.escape(account_id.to_s).gsub('%2F', '/')) + + # query parameters + query_params = opts[:query_params] || {} + + # header parameters + header_params = opts[:header_params] || {} + # HTTP header 'Accept' (if needed) + header_params['Accept'] = @api_client.select_header_accept(['application/json']) + + # form parameters + form_params = opts[:form_params] || {} + + # http body (model) + post_body = opts[:debug_body] + + # return_type + return_type = opts[:debug_return_type] || 'NebiusCloudIntegrationAccountResponse' + + # auth_names + auth_names = opts[:debug_auth_names] || [:apiKeyAuth, :appKeyAuth, :AuthZ] + + new_options = opts.merge( + :operation => :get_nebius_cloud_integration_account, + :header_params => header_params, + :query_params => query_params, + :form_params => form_params, + :body => post_body, + :auth_names => auth_names, + :return_type => return_type, + :api_version => "V2" + ) + + data, status_code, headers = @api_client.call_api(Net::HTTP::Get, local_var_path, new_options) + if @api_client.config.debugging + @api_client.config.logger.debug "API called: NebiusCloudIntegrationAPI#get_nebius_cloud_integration_account\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}" + end + return data, status_code, headers + end + + # List Nebius Cloud integration accounts. + # + # @see #list_nebius_cloud_integration_accounts_with_http_info + def list_nebius_cloud_integration_accounts(opts = {}) + data, _status_code, _headers = list_nebius_cloud_integration_accounts_with_http_info(opts) + data + end + + # List Nebius Cloud integration accounts. + # + # List Nebius Cloud integration accounts. + # + # @param opts [Hash] the optional parameters + # @return [Array<(NebiusCloudIntegrationAccountsResponse, Integer, Hash)>] NebiusCloudIntegrationAccountsResponse data, response status code and response headers + def list_nebius_cloud_integration_accounts_with_http_info(opts = {}) + unstable_enabled = @api_client.config.unstable_operations["v2.list_nebius_cloud_integration_accounts".to_sym] + if unstable_enabled + @api_client.config.logger.warn format("Using unstable operation '%s'", "v2.list_nebius_cloud_integration_accounts") + else + raise DatadogAPIClient::APIError.new(message: format("Unstable operation '%s' is disabled", "v2.list_nebius_cloud_integration_accounts")) + end + + if @api_client.config.debugging + @api_client.config.logger.debug 'Calling API: NebiusCloudIntegrationAPI.list_nebius_cloud_integration_accounts ...' + end + # resource path + local_var_path = '/api/v2/integration-interfaces/nebius-cloud/accounts' + + # query parameters + query_params = opts[:query_params] || {} + + # header parameters + header_params = opts[:header_params] || {} + # HTTP header 'Accept' (if needed) + header_params['Accept'] = @api_client.select_header_accept(['application/json']) + + # form parameters + form_params = opts[:form_params] || {} + + # http body (model) + post_body = opts[:debug_body] + + # return_type + return_type = opts[:debug_return_type] || 'NebiusCloudIntegrationAccountsResponse' + + # auth_names + auth_names = opts[:debug_auth_names] || [:apiKeyAuth, :appKeyAuth, :AuthZ] + + new_options = opts.merge( + :operation => :list_nebius_cloud_integration_accounts, + :header_params => header_params, + :query_params => query_params, + :form_params => form_params, + :body => post_body, + :auth_names => auth_names, + :return_type => return_type, + :api_version => "V2" + ) + + data, status_code, headers = @api_client.call_api(Net::HTTP::Get, local_var_path, new_options) + if @api_client.config.debugging + @api_client.config.logger.debug "API called: NebiusCloudIntegrationAPI#list_nebius_cloud_integration_accounts\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}" + end + return data, status_code, headers + end + + # Update a Nebius Cloud integration account. + # + # @see #update_nebius_cloud_integration_account_with_http_info + def update_nebius_cloud_integration_account(account_id, body, opts = {}) + data, _status_code, _headers = update_nebius_cloud_integration_account_with_http_info(account_id, body, opts) + data + end + + # Update a Nebius Cloud integration account. + # + # Update a Nebius Cloud integration account. Only the fields provided are changed. + # + # @param account_id [String] Unique identifier of the integration account. + # @param body [NebiusCloudIntegrationAccountUpdateRequest] + # @param opts [Hash] the optional parameters + # @return [Array<(NebiusCloudIntegrationAccountResponse, Integer, Hash)>] NebiusCloudIntegrationAccountResponse data, response status code and response headers + def update_nebius_cloud_integration_account_with_http_info(account_id, body, opts = {}) + unstable_enabled = @api_client.config.unstable_operations["v2.update_nebius_cloud_integration_account".to_sym] + if unstable_enabled + @api_client.config.logger.warn format("Using unstable operation '%s'", "v2.update_nebius_cloud_integration_account") + else + raise DatadogAPIClient::APIError.new(message: format("Unstable operation '%s' is disabled", "v2.update_nebius_cloud_integration_account")) + end + + if @api_client.config.debugging + @api_client.config.logger.debug 'Calling API: NebiusCloudIntegrationAPI.update_nebius_cloud_integration_account ...' + end + # verify the required parameter 'account_id' is set + if @api_client.config.client_side_validation && account_id.nil? + fail ArgumentError, "Missing the required parameter 'account_id' when calling NebiusCloudIntegrationAPI.update_nebius_cloud_integration_account" + end + # verify the required parameter 'body' is set + if @api_client.config.client_side_validation && body.nil? + fail ArgumentError, "Missing the required parameter 'body' when calling NebiusCloudIntegrationAPI.update_nebius_cloud_integration_account" + end + # resource path + local_var_path = '/api/v2/integration-interfaces/nebius-cloud/accounts/{account_id}'.sub('{account_id}', CGI.escape(account_id.to_s).gsub('%2F', '/')) + + # query parameters + query_params = opts[:query_params] || {} + + # header parameters + header_params = opts[:header_params] || {} + # HTTP header 'Accept' (if needed) + header_params['Accept'] = @api_client.select_header_accept(['application/json']) + # HTTP header 'Content-Type' + header_params['Content-Type'] = @api_client.select_header_content_type(['application/json']) + + # form parameters + form_params = opts[:form_params] || {} + + # http body (model) + post_body = opts[:debug_body] || @api_client.object_to_http_body(body) + + # return_type + return_type = opts[:debug_return_type] || 'NebiusCloudIntegrationAccountResponse' + + # auth_names + auth_names = opts[:debug_auth_names] || [:apiKeyAuth, :appKeyAuth, :AuthZ] + + new_options = opts.merge( + :operation => :update_nebius_cloud_integration_account, + :header_params => header_params, + :query_params => query_params, + :form_params => form_params, + :body => post_body, + :auth_names => auth_names, + :return_type => return_type, + :api_version => "V2" + ) + + data, status_code, headers = @api_client.call_api(Net::HTTP::Patch, local_var_path, new_options) + if @api_client.config.debugging + @api_client.config.logger.debug "API called: NebiusCloudIntegrationAPI#update_nebius_cloud_integration_account\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}" + end + return data, status_code, headers + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_cost_collection_integration_dataflow_request.rb b/lib/datadog_api_client/v2/models/nebius_cloud_cost_collection_integration_dataflow_request.rb new file mode 100644 index 000000000000..949aded26c88 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_cost_collection_integration_dataflow_request.rb @@ -0,0 +1,90 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Cloud cost data read from a Nebius Object Storage bucket export and used by [Cloud Cost Management](https://docs.datadoghq.com/cloud_cost_management/). Enabling it requires a bucket holding your cost export and a Nebius access key pair that can read it; a request that enables this dataflow without them is rejected with a `422` response. + class NebiusCloudCostCollectionIntegrationDataflowRequest + include BaseGenericModel + + # Whether Datadog collects this data. Defaults to `false`; set to `true` to start collection. + attr_accessor :enabled + + # Settings of the Cloud Cost Management dataflow. Only the fields provided are changed. + attr_accessor :settings + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'enabled' => :'enabled', + :'settings' => :'settings' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'enabled' => :'Boolean', + :'settings' => :'NebiusCloudCostCollectionIntegrationDataflowSettingsRequest' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudCostCollectionIntegrationDataflowRequest` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `DatadogAPIClient::V2::NebiusCloudCostCollectionIntegrationDataflowRequest`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'enabled') + self.enabled = attributes[:'enabled'] + end + + if attributes.key?(:'settings') + self.settings = attributes[:'settings'] + end + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + enabled == o.enabled && + settings == o.settings + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [enabled, settings].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_cost_collection_integration_dataflow_response.rb b/lib/datadog_api_client/v2/models/nebius_cloud_cost_collection_integration_dataflow_response.rb new file mode 100644 index 000000000000..aba911eab69b --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_cost_collection_integration_dataflow_response.rb @@ -0,0 +1,115 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Cloud cost data read from a Nebius Object Storage bucket export and used by [Cloud Cost Management](https://docs.datadoghq.com/cloud_cost_management/). Requires a bucket holding your cost export and a Nebius access key pair that can read it; without both this dataflow collects no data. + class NebiusCloudCostCollectionIntegrationDataflowResponse + include BaseGenericModel + + # Whether Datadog collects this data. Absent when the dataflow has never been configured. + attr_accessor :enabled + + # Settings of the Cloud Cost Management dataflow. + attr_accessor :settings + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'enabled' => :'enabled', + :'settings' => :'settings' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'enabled' => :'Boolean', + :'settings' => :'NebiusCloudCostCollectionIntegrationDataflowSettingsResponse' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudCostCollectionIntegrationDataflowResponse` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'enabled') + self.enabled = attributes[:'enabled'] + end + + if attributes.key?(:'settings') + self.settings = attributes[:'settings'] + end + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + enabled == o.enabled && + settings == o.settings && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [enabled, settings, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_cost_collection_integration_dataflow_settings_request.rb b/lib/datadog_api_client/v2/models/nebius_cloud_cost_collection_integration_dataflow_settings_request.rb new file mode 100644 index 000000000000..a33a5c4182b4 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_cost_collection_integration_dataflow_settings_request.rb @@ -0,0 +1,120 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Settings of the Cloud Cost Management dataflow. Only the fields provided are changed. + class NebiusCloudCostCollectionIntegrationDataflowSettingsRequest + include BaseGenericModel + + # ID of the Nebius Object Storage (S3-compatible) access key used to read the cost export bucket. Required when this dataflow is enabled. + attr_accessor :access_key_id + + # Secret access key for the access key ID. Required when this dataflow is enabled. Omit it on update to keep the stored one; an empty string is rejected with a `422` response. + attr_accessor :access_key_secret + + # Name of the Nebius Object Storage bucket holding your cost export. Required when this dataflow is enabled; a request that enables it without the bucket fields and access keys is rejected with a `422` response. + attr_accessor :bucket_name + + # Prefix path within the bucket that locates the cost export, combining the export name and path prefix. + attr_accessor :bucket_prefix_path + + # Region of the Nebius Object Storage bucket, such as `eu-north1`. Required when this dataflow is enabled. + attr_accessor :bucket_region + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'access_key_id' => :'access_key_id', + :'access_key_secret' => :'access_key_secret', + :'bucket_name' => :'bucket_name', + :'bucket_prefix_path' => :'bucket_prefix_path', + :'bucket_region' => :'bucket_region' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'access_key_id' => :'String', + :'access_key_secret' => :'String', + :'bucket_name' => :'String', + :'bucket_prefix_path' => :'String', + :'bucket_region' => :'String' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudCostCollectionIntegrationDataflowSettingsRequest` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `DatadogAPIClient::V2::NebiusCloudCostCollectionIntegrationDataflowSettingsRequest`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'access_key_id') + self.access_key_id = attributes[:'access_key_id'] + end + + if attributes.key?(:'access_key_secret') + self.access_key_secret = attributes[:'access_key_secret'] + end + + if attributes.key?(:'bucket_name') + self.bucket_name = attributes[:'bucket_name'] + end + + if attributes.key?(:'bucket_prefix_path') + self.bucket_prefix_path = attributes[:'bucket_prefix_path'] + end + + if attributes.key?(:'bucket_region') + self.bucket_region = attributes[:'bucket_region'] + end + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + access_key_id == o.access_key_id && + access_key_secret == o.access_key_secret && + bucket_name == o.bucket_name && + bucket_prefix_path == o.bucket_prefix_path && + bucket_region == o.bucket_region + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [access_key_id, access_key_secret, bucket_name, bucket_prefix_path, bucket_region].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_cost_collection_integration_dataflow_settings_response.rb b/lib/datadog_api_client/v2/models/nebius_cloud_cost_collection_integration_dataflow_settings_response.rb new file mode 100644 index 000000000000..2af6c783c723 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_cost_collection_integration_dataflow_settings_response.rb @@ -0,0 +1,135 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Settings of the Cloud Cost Management dataflow. + class NebiusCloudCostCollectionIntegrationDataflowSettingsResponse + include BaseGenericModel + + # ID of the Nebius Object Storage access key used to read the cost export bucket. + attr_accessor :access_key_id + + # Name of the Nebius Object Storage bucket holding the cost export. + attr_accessor :bucket_name + + # Prefix path within the bucket that locates the cost export. + attr_accessor :bucket_prefix_path + + # Region of the Nebius Object Storage bucket, such as `eu-north1`. + attr_accessor :bucket_region + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'access_key_id' => :'access_key_id', + :'bucket_name' => :'bucket_name', + :'bucket_prefix_path' => :'bucket_prefix_path', + :'bucket_region' => :'bucket_region' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'access_key_id' => :'String', + :'bucket_name' => :'String', + :'bucket_prefix_path' => :'String', + :'bucket_region' => :'String' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudCostCollectionIntegrationDataflowSettingsResponse` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'access_key_id') + self.access_key_id = attributes[:'access_key_id'] + end + + if attributes.key?(:'bucket_name') + self.bucket_name = attributes[:'bucket_name'] + end + + if attributes.key?(:'bucket_prefix_path') + self.bucket_prefix_path = attributes[:'bucket_prefix_path'] + end + + if attributes.key?(:'bucket_region') + self.bucket_region = attributes[:'bucket_region'] + end + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + access_key_id == o.access_key_id && + bucket_name == o.bucket_name && + bucket_prefix_path == o.bucket_prefix_path && + bucket_region == o.bucket_region && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [access_key_id, bucket_name, bucket_prefix_path, bucket_region, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_authentication_request.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_authentication_request.rb new file mode 100644 index 000000000000..a8971602a8a1 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_authentication_request.rb @@ -0,0 +1,62 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Authentication for creating the Nebius Cloud integration account. Exactly one method is set. + module NebiusCloudIntegrationAccountAuthenticationRequest + class << self + include BaseOneOfModel + include BaseOneOfModelNoDiscriminator + + # List of class defined in oneOf (OpenAPI v3) + def openapi_one_of + [ + :'NebiusCloudIntegrationAccountServiceAccountAuthRequest' + ] + end + # Builds the object + # @param data [Mixed] Data to be matched against the list of oneOf items + # @return [Object] Returns the model or the data itself + def build(data) + # Go through the list of oneOf items and attempt to identify the appropriate one. + # Note: + # - We do not attempt to check whether exactly one item matches. + # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 }) + # due to the way the deserialization is made in the base_object template (it just casts without verifying). + # - TODO: scalar values are de facto behaving as if they were nullable. + # - TODO: logging when debugging is set. + openapi_one_of.each do |klass| + begin + next if klass == :AnyType # "nullable: true" + typed_data = find_and_cast_into_type(klass, data) + next if typed_data.respond_to?(:_unparsed) && typed_data._unparsed + return typed_data if typed_data + rescue # rescue all errors so we keep iterating even if the current item lookup raises + end + end + + if openapi_one_of.include?(:AnyType) + data + else + self._unparsed = true + DatadogAPIClient::UnparsedObject.new(data) + end + end + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_authentication_response.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_authentication_response.rb new file mode 100644 index 000000000000..1c319b7a0564 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_authentication_response.rb @@ -0,0 +1,62 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Authentication configured on the Nebius Cloud integration account. + module NebiusCloudIntegrationAccountAuthenticationResponse + class << self + include BaseOneOfModel + include BaseOneOfModelNoDiscriminator + + # List of class defined in oneOf (OpenAPI v3) + def openapi_one_of + [ + :'NebiusCloudIntegrationAccountServiceAccountAuthResponse' + ] + end + # Builds the object + # @param data [Mixed] Data to be matched against the list of oneOf items + # @return [Object] Returns the model or the data itself + def build(data) + # Go through the list of oneOf items and attempt to identify the appropriate one. + # Note: + # - We do not attempt to check whether exactly one item matches. + # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 }) + # due to the way the deserialization is made in the base_object template (it just casts without verifying). + # - TODO: scalar values are de facto behaving as if they were nullable. + # - TODO: logging when debugging is set. + openapi_one_of.each do |klass| + begin + next if klass == :AnyType # "nullable: true" + typed_data = find_and_cast_into_type(klass, data) + next if typed_data.respond_to?(:_unparsed) && typed_data._unparsed + return typed_data if typed_data + rescue # rescue all errors so we keep iterating even if the current item lookup raises + end + end + + if openapi_one_of.include?(:AnyType) + data + else + self._unparsed = true + DatadogAPIClient::UnparsedObject.new(data) + end + end + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_authentication_update.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_authentication_update.rb new file mode 100644 index 000000000000..7be8b5c612e5 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_authentication_update.rb @@ -0,0 +1,62 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Authentication for updating the Nebius Cloud integration account. Exactly one method is set. + module NebiusCloudIntegrationAccountAuthenticationUpdate + class << self + include BaseOneOfModel + include BaseOneOfModelNoDiscriminator + + # List of class defined in oneOf (OpenAPI v3) + def openapi_one_of + [ + :'NebiusCloudIntegrationAccountServiceAccountAuthUpdate' + ] + end + # Builds the object + # @param data [Mixed] Data to be matched against the list of oneOf items + # @return [Object] Returns the model or the data itself + def build(data) + # Go through the list of oneOf items and attempt to identify the appropriate one. + # Note: + # - We do not attempt to check whether exactly one item matches. + # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 }) + # due to the way the deserialization is made in the base_object template (it just casts without verifying). + # - TODO: scalar values are de facto behaving as if they were nullable. + # - TODO: logging when debugging is set. + openapi_one_of.each do |klass| + begin + next if klass == :AnyType # "nullable: true" + typed_data = find_and_cast_into_type(klass, data) + next if typed_data.respond_to?(:_unparsed) && typed_data._unparsed + return typed_data if typed_data + rescue # rescue all errors so we keep iterating even if the current item lookup raises + end + end + + if openapi_one_of.include?(:AnyType) + data + else + self._unparsed = true + DatadogAPIClient::UnparsedObject.new(data) + end + end + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_create_attributes.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_create_attributes.rb new file mode 100644 index 000000000000..b6c2990cfdec --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_create_attributes.rb @@ -0,0 +1,179 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Writable attributes used to create a Nebius Cloud integration account. + class NebiusCloudIntegrationAccountCreateAttributes + include BaseGenericModel + + # Authentication for creating the Nebius Cloud integration account. Exactly one method is set. + attr_reader :authentication + + # Data Datadog collects from Nebius Cloud, keyed by dataflow id. Each dataflow turns on a distinct kind of collection: set `enabled` to stop or start it, and use `settings` to configure what it collects. Defaults listed on each dataflow apply when the account is created; on update, omitted fields keep their current values. Every dataflow except `nebius-cloud-cost-collection` runs as the service account in `authentication`, using its authorized key pair and the static API key; enabling one of them without those keys is rejected with a `422` response, and one enabled with keys that later expire is stored but collects no data. + attr_accessor :dataflows + + # Human-readable name of the Nebius Cloud integration account. + attr_reader :name + + # Settings for creating the Nebius Cloud integration account. + attr_reader :settings + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'authentication' => :'authentication', + :'dataflows' => :'dataflows', + :'name' => :'name', + :'settings' => :'settings' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'authentication' => :'NebiusCloudIntegrationAccountAuthenticationRequest', + :'dataflows' => :'NebiusCloudIntegrationDataflowsRequest', + :'name' => :'String', + :'settings' => :'NebiusCloudIntegrationAccountSettingsRequest' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountCreateAttributes` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'authentication') + self.authentication = attributes[:'authentication'] + end + + if attributes.key?(:'dataflows') + self.dataflows = attributes[:'dataflows'] + end + + if attributes.key?(:'name') + self.name = attributes[:'name'] + end + + if attributes.key?(:'settings') + self.settings = attributes[:'settings'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @authentication.nil? + return false if @name.nil? + return false if @name.to_s.length > 255 + return false if @settings.nil? + true + end + + # Custom attribute writer method with validation + # @param authentication [Object] Object to be assigned + # @!visibility private + def authentication=(authentication) + if authentication.nil? + fail ArgumentError, 'invalid value for "authentication", authentication cannot be nil.' + end + @authentication = authentication + end + + # Custom attribute writer method with validation + # @param name [Object] Object to be assigned + # @!visibility private + def name=(name) + if name.nil? + fail ArgumentError, 'invalid value for "name", name cannot be nil.' + end + if name.to_s.length > 255 + fail ArgumentError, 'invalid value for "name", the character length must be smaller than or equal to 255.' + end + @name = name + end + + # Custom attribute writer method with validation + # @param settings [Object] Object to be assigned + # @!visibility private + def settings=(settings) + if settings.nil? + fail ArgumentError, 'invalid value for "settings", settings cannot be nil.' + end + @settings = settings + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + authentication == o.authentication && + dataflows == o.dataflows && + name == o.name && + settings == o.settings && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [authentication, dataflows, name, settings, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_create_data.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_create_data.rb new file mode 100644 index 000000000000..19e2e6443136 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_create_data.rb @@ -0,0 +1,144 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Data envelope for creating a Nebius Cloud integration account. + class NebiusCloudIntegrationAccountCreateData + include BaseGenericModel + + # Writable attributes used to create a Nebius Cloud integration account. + attr_reader :attributes + + # The type of the integration account resource. Always `integration-account`. + attr_reader :type + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'attributes' => :'attributes', + :'type' => :'type' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'attributes' => :'NebiusCloudIntegrationAccountCreateAttributes', + :'type' => :'IntegrationAccountType' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountCreateData` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'attributes') + self.attributes = attributes[:'attributes'] + end + + if attributes.key?(:'type') + self.type = attributes[:'type'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @attributes.nil? + return false if @type.nil? + true + end + + # Custom attribute writer method with validation + # @param attributes [Object] Object to be assigned + # @!visibility private + def attributes=(attributes) + if attributes.nil? + fail ArgumentError, 'invalid value for "attributes", attributes cannot be nil.' + end + @attributes = attributes + end + + # Custom attribute writer method with validation + # @param type [Object] Object to be assigned + # @!visibility private + def type=(type) + if type.nil? + fail ArgumentError, 'invalid value for "type", type cannot be nil.' + end + @type = type + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + attributes == o.attributes && + type == o.type && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [attributes, type, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_create_request.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_create_request.rb new file mode 100644 index 000000000000..71758bc8c46f --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_create_request.rb @@ -0,0 +1,123 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Request payload to create a Nebius Cloud integration account. + class NebiusCloudIntegrationAccountCreateRequest + include BaseGenericModel + + # Data envelope for creating a Nebius Cloud integration account. + attr_reader :data + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'data' => :'data' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'data' => :'NebiusCloudIntegrationAccountCreateData' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountCreateRequest` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'data') + self.data = attributes[:'data'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @data.nil? + true + end + + # Custom attribute writer method with validation + # @param data [Object] Object to be assigned + # @!visibility private + def data=(data) + if data.nil? + fail ArgumentError, 'invalid value for "data", data cannot be nil.' + end + @data = data + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + data == o.data && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [data, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_metrics_config_request.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_metrics_config_request.rb new file mode 100644 index 000000000000..8ceb191e0376 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_metrics_config_request.rb @@ -0,0 +1,82 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Configuration for metric collection from this Nebius Cloud account. + class NebiusCloudIntegrationAccountMetricsConfigRequest + include BaseGenericModel + + # Tag-filter rules limiting metric collection to matching Kubernetes 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. + attr_accessor :cluster_filters + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'cluster_filters' => :'cluster_filters' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'cluster_filters' => :'Array' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountMetricsConfigRequest` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountMetricsConfigRequest`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'cluster_filters') + if (value = attributes[:'cluster_filters']).is_a?(Array) + self.cluster_filters = value + end + end + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + cluster_filters == o.cluster_filters + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [cluster_filters].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_metrics_config_response.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_metrics_config_response.rb new file mode 100644 index 000000000000..8c4e53323cf7 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_metrics_config_response.rb @@ -0,0 +1,107 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Metric collection settings configured on the Nebius Cloud integration account. Absent when no filters are configured. + class NebiusCloudIntegrationAccountMetricsConfigResponse + include BaseGenericModel + + # Tag-filter rules limiting metric collection to matching Kubernetes clusters. + attr_accessor :cluster_filters + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'cluster_filters' => :'cluster_filters' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'cluster_filters' => :'Array' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountMetricsConfigResponse` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'cluster_filters') + if (value = attributes[:'cluster_filters']).is_a?(Array) + self.cluster_filters = value + end + end + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + cluster_filters == o.cluster_filters && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [cluster_filters, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_metrics_config_update.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_metrics_config_update.rb new file mode 100644 index 000000000000..6124c025e9c5 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_metrics_config_update.rb @@ -0,0 +1,82 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Configuration for metric collection. Only the fields provided are changed. + class NebiusCloudIntegrationAccountMetricsConfigUpdate + include BaseGenericModel + + # Tag-filter rules limiting metric collection to matching Kubernetes clusters. Sending metrics_config replaces the stored object's cluster_filters list; omit it to keep the stored value. Include rules (`key:value`) are combined with OR, exclusion rules (`!key:value`) are then applied with AND, and `?` and `*` are wildcards. + attr_accessor :cluster_filters + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'cluster_filters' => :'cluster_filters' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'cluster_filters' => :'Array' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountMetricsConfigUpdate` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountMetricsConfigUpdate`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'cluster_filters') + if (value = attributes[:'cluster_filters']).is_a?(Array) + self.cluster_filters = value + end + end + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + cluster_filters == o.cluster_filters + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [cluster_filters].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_response.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_response.rb new file mode 100644 index 000000000000..ccf9ca0eefa1 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_response.rb @@ -0,0 +1,123 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Response payload for a single Nebius Cloud integration account. + class NebiusCloudIntegrationAccountResponse + include BaseGenericModel + + # Data envelope of a Nebius Cloud integration account, including server-assigned identity. + attr_reader :data + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'data' => :'data' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'data' => :'NebiusCloudIntegrationAccountResponseData' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountResponse` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'data') + self.data = attributes[:'data'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @data.nil? + true + end + + # Custom attribute writer method with validation + # @param data [Object] Object to be assigned + # @!visibility private + def data=(data) + if data.nil? + fail ArgumentError, 'invalid value for "data", data cannot be nil.' + end + @data = data + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + data == o.data && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [data, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_response_attributes.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_response_attributes.rb new file mode 100644 index 000000000000..352e21278194 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_response_attributes.rb @@ -0,0 +1,164 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Attributes of a Nebius Cloud integration account returned in responses. + class NebiusCloudIntegrationAccountResponseAttributes + include BaseGenericModel + + # Authentication configured on the Nebius Cloud integration account. + attr_accessor :authentication + + # Data Datadog collects from Nebius Cloud, keyed by dataflow id. + attr_accessor :dataflows + + # Human-readable name of the Nebius Cloud integration account. + attr_reader :name + + # Settings configured on the Nebius Cloud integration account. + attr_reader :settings + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'authentication' => :'authentication', + :'dataflows' => :'dataflows', + :'name' => :'name', + :'settings' => :'settings' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'authentication' => :'NebiusCloudIntegrationAccountAuthenticationResponse', + :'dataflows' => :'NebiusCloudIntegrationDataflowsResponse', + :'name' => :'String', + :'settings' => :'NebiusCloudIntegrationAccountSettingsResponse' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountResponseAttributes` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'authentication') + self.authentication = attributes[:'authentication'] + end + + if attributes.key?(:'dataflows') + self.dataflows = attributes[:'dataflows'] + end + + if attributes.key?(:'name') + self.name = attributes[:'name'] + end + + if attributes.key?(:'settings') + self.settings = attributes[:'settings'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @name.nil? + return false if @settings.nil? + true + end + + # Custom attribute writer method with validation + # @param name [Object] Object to be assigned + # @!visibility private + def name=(name) + if name.nil? + fail ArgumentError, 'invalid value for "name", name cannot be nil.' + end + @name = name + end + + # Custom attribute writer method with validation + # @param settings [Object] Object to be assigned + # @!visibility private + def settings=(settings) + if settings.nil? + fail ArgumentError, 'invalid value for "settings", settings cannot be nil.' + end + @settings = settings + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + authentication == o.authentication && + dataflows == o.dataflows && + name == o.name && + settings == o.settings && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [authentication, dataflows, name, settings, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_response_data.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_response_data.rb new file mode 100644 index 000000000000..596e49631a7a --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_response_data.rb @@ -0,0 +1,165 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Data envelope of a Nebius Cloud integration account, including server-assigned identity. + class NebiusCloudIntegrationAccountResponseData + include BaseGenericModel + + # Attributes of a Nebius Cloud integration account returned in responses. + attr_reader :attributes + + # Server-generated unique identifier of the Nebius Cloud integration account. + attr_reader :id + + # The type of the integration account resource. Always `integration-account`. + attr_reader :type + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'attributes' => :'attributes', + :'id' => :'id', + :'type' => :'type' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'attributes' => :'NebiusCloudIntegrationAccountResponseAttributes', + :'id' => :'String', + :'type' => :'IntegrationAccountType' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountResponseData` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'attributes') + self.attributes = attributes[:'attributes'] + end + + if attributes.key?(:'id') + self.id = attributes[:'id'] + end + + if attributes.key?(:'type') + self.type = attributes[:'type'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @attributes.nil? + return false if @id.nil? + return false if @type.nil? + true + end + + # Custom attribute writer method with validation + # @param attributes [Object] Object to be assigned + # @!visibility private + def attributes=(attributes) + if attributes.nil? + fail ArgumentError, 'invalid value for "attributes", attributes cannot be nil.' + end + @attributes = attributes + end + + # Custom attribute writer method with validation + # @param id [Object] Object to be assigned + # @!visibility private + def id=(id) + if id.nil? + fail ArgumentError, 'invalid value for "id", id cannot be nil.' + end + @id = id + end + + # Custom attribute writer method with validation + # @param type [Object] Object to be assigned + # @!visibility private + def type=(type) + if type.nil? + fail ArgumentError, 'invalid value for "type", type cannot be nil.' + end + @type = type + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + attributes == o.attributes && + id == o.id && + type == o.type && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [attributes, id, type, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_service_account_auth_request.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_service_account_auth_request.rb new file mode 100644 index 000000000000..422f0a8aa42e --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_service_account_auth_request.rb @@ -0,0 +1,149 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Service-account key pair authentication, the only method Nebius Cloud integration accounts support. Create a service account in the Nebius console, add it to the admin group, upload an authorized key pair to it, and issue a static API key with the OBSERVABILITY scope through the Nebius CLI. + class NebiusCloudIntegrationAccountServiceAccountAuthRequest + include BaseGenericModel + + # The authentication method type. + attr_reader :auth_type + + # The private key of the authorized key pair, in PEM format. Required when log, resource, or service-quota collection is enabled; a request that enables one of them without it is rejected with a `422` response. + attr_accessor :private_key + + # ID of the public key half of the authorized key pair, such as `publickey-xxxxxxxx`. Required when log, resource, or service-quota collection is enabled; a request that enables one of them without it is rejected with a `422` response. + attr_accessor :public_key_id + + # Non-secret ID of the Nebius service account the account authenticates as. + attr_reader :service_account_id + + # Nebius static API key with the OBSERVABILITY scope, used to query logs. Required when log, resource, or service-quota collection is enabled; a request that enables one of them without it is rejected with a `422` response. + attr_accessor :static_api_key + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'auth_type' => :'auth_type', + :'private_key' => :'private_key', + :'public_key_id' => :'public_key_id', + :'service_account_id' => :'service_account_id', + :'static_api_key' => :'static_api_key' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'auth_type' => :'NebiusCloudIntegrationAccountServiceAccountAuthType', + :'private_key' => :'String', + :'public_key_id' => :'String', + :'service_account_id' => :'String', + :'static_api_key' => :'String' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountServiceAccountAuthRequest` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountServiceAccountAuthRequest`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'auth_type') + self.auth_type = attributes[:'auth_type'] + end + + if attributes.key?(:'private_key') + self.private_key = attributes[:'private_key'] + end + + if attributes.key?(:'public_key_id') + self.public_key_id = attributes[:'public_key_id'] + end + + if attributes.key?(:'service_account_id') + self.service_account_id = attributes[:'service_account_id'] + end + + if attributes.key?(:'static_api_key') + self.static_api_key = attributes[:'static_api_key'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @auth_type.nil? + return false if @service_account_id.nil? + true + end + + # Custom attribute writer method with validation + # @param auth_type [Object] Object to be assigned + # @!visibility private + def auth_type=(auth_type) + if auth_type.nil? + fail ArgumentError, 'invalid value for "auth_type", auth_type cannot be nil.' + end + @auth_type = auth_type + end + + # Custom attribute writer method with validation + # @param service_account_id [Object] Object to be assigned + # @!visibility private + def service_account_id=(service_account_id) + if service_account_id.nil? + fail ArgumentError, 'invalid value for "service_account_id", service_account_id cannot be nil.' + end + @service_account_id = service_account_id + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + auth_type == o.auth_type && + private_key == o.private_key && + public_key_id == o.public_key_id && + service_account_id == o.service_account_id && + static_api_key == o.static_api_key + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [auth_type, private_key, public_key_id, service_account_id, static_api_key].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_service_account_auth_response.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_service_account_auth_response.rb new file mode 100644 index 000000000000..06601f396845 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_service_account_auth_response.rb @@ -0,0 +1,154 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # The service-account key pair authentication method configured on the account. + class NebiusCloudIntegrationAccountServiceAccountAuthResponse + include BaseGenericModel + + # The authentication method type. + attr_reader :auth_type + + # ID of the public key half of the authorized key pair. Omitted when unset. + attr_accessor :public_key_id + + # ID of the Nebius service account the account authenticates as. + attr_reader :service_account_id + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'auth_type' => :'auth_type', + :'public_key_id' => :'public_key_id', + :'service_account_id' => :'service_account_id' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'auth_type' => :'NebiusCloudIntegrationAccountServiceAccountAuthType', + :'public_key_id' => :'String', + :'service_account_id' => :'String' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountServiceAccountAuthResponse` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'auth_type') + self.auth_type = attributes[:'auth_type'] + end + + if attributes.key?(:'public_key_id') + self.public_key_id = attributes[:'public_key_id'] + end + + if attributes.key?(:'service_account_id') + self.service_account_id = attributes[:'service_account_id'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @auth_type.nil? + return false if @service_account_id.nil? + true + end + + # Custom attribute writer method with validation + # @param auth_type [Object] Object to be assigned + # @!visibility private + def auth_type=(auth_type) + if auth_type.nil? + fail ArgumentError, 'invalid value for "auth_type", auth_type cannot be nil.' + end + @auth_type = auth_type + end + + # Custom attribute writer method with validation + # @param service_account_id [Object] Object to be assigned + # @!visibility private + def service_account_id=(service_account_id) + if service_account_id.nil? + fail ArgumentError, 'invalid value for "service_account_id", service_account_id cannot be nil.' + end + @service_account_id = service_account_id + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + auth_type == o.auth_type && + public_key_id == o.public_key_id && + service_account_id == o.service_account_id && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [auth_type, public_key_id, service_account_id, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_service_account_auth_type.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_service_account_auth_type.rb new file mode 100644 index 000000000000..b3e7a8462b11 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_service_account_auth_type.rb @@ -0,0 +1,26 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # The authentication method type. + class NebiusCloudIntegrationAccountServiceAccountAuthType + include BaseEnumModel + + NEBIUS_SERVICE_ACCOUNT = "nebius_service_account".freeze + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_service_account_auth_update.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_service_account_auth_update.rb new file mode 100644 index 000000000000..c93228e2a269 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_service_account_auth_update.rb @@ -0,0 +1,146 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Service-account key pair authentication, the only method Nebius Cloud integration accounts support. Only the fields provided are changed; omit `private_key` and `static_api_key` to keep the stored ones. + class NebiusCloudIntegrationAccountServiceAccountAuthUpdate + include BaseGenericModel + + # The authentication method type. + attr_reader :auth_type + + # The private key of the authorized key pair, in PEM format. Omit it to keep the stored one; an empty string is rejected with a `422` response. + attr_accessor :private_key + + # ID of the public key half of the authorized key pair. Omit it to keep the stored public key ID, send `null` or an empty string to remove it, or send a value to replace it. Removing it is rejected with a `422` response while log, resource, or service-quota collection is enabled. + attr_accessor :public_key_id + + # Non-secret ID of the Nebius service account the account authenticates as. It cannot be cleared; sending `null` or an empty string is rejected with a `422` response. + attr_accessor :service_account_id + + # Nebius static API key with the OBSERVABILITY scope. Omit it to keep the stored one; an empty string is rejected with a `422` response. + attr_accessor :static_api_key + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'auth_type' => :'auth_type', + :'private_key' => :'private_key', + :'public_key_id' => :'public_key_id', + :'service_account_id' => :'service_account_id', + :'static_api_key' => :'static_api_key' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'auth_type' => :'NebiusCloudIntegrationAccountServiceAccountAuthType', + :'private_key' => :'String', + :'public_key_id' => :'String', + :'service_account_id' => :'String', + :'static_api_key' => :'String' + } + end + + # List of attributes with nullable: true + # @!visibility private + def self.openapi_nullable + Set.new([ + :'public_key_id', + ]) + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountServiceAccountAuthUpdate` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountServiceAccountAuthUpdate`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'auth_type') + self.auth_type = attributes[:'auth_type'] + end + + if attributes.key?(:'private_key') + self.private_key = attributes[:'private_key'] + end + + if attributes.key?(:'public_key_id') + self.public_key_id = attributes[:'public_key_id'] + end + + if attributes.key?(:'service_account_id') + self.service_account_id = attributes[:'service_account_id'] + end + + if attributes.key?(:'static_api_key') + self.static_api_key = attributes[:'static_api_key'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @auth_type.nil? + true + end + + # Custom attribute writer method with validation + # @param auth_type [Object] Object to be assigned + # @!visibility private + def auth_type=(auth_type) + if auth_type.nil? + fail ArgumentError, 'invalid value for "auth_type", auth_type cannot be nil.' + end + @auth_type = auth_type + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + auth_type == o.auth_type && + private_key == o.private_key && + public_key_id == o.public_key_id && + service_account_id == o.service_account_id && + static_api_key == o.static_api_key + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [auth_type, private_key, public_key_id, service_account_id, static_api_key].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_settings_request.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_settings_request.rb new file mode 100644 index 000000000000..d65d03ac9784 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_settings_request.rb @@ -0,0 +1,120 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Settings for creating the Nebius Cloud integration account. + class NebiusCloudIntegrationAccountSettingsRequest + include BaseGenericModel + + # Tags applied to all metrics, logs, and resources collected from this Nebius Cloud account. Defaults to no tags. + attr_accessor :account_tags + + # Configuration for metric collection from this Nebius Cloud account. + attr_accessor :metrics_config + + # ID of the Nebius tenant to monitor, the organizational workspace identifier. Found in the Nebius console under Administration > Organization. + attr_reader :tenant_id + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'account_tags' => :'account_tags', + :'metrics_config' => :'metrics_config', + :'tenant_id' => :'tenant_id' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'account_tags' => :'Array', + :'metrics_config' => :'NebiusCloudIntegrationAccountMetricsConfigRequest', + :'tenant_id' => :'String' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountSettingsRequest` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountSettingsRequest`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'account_tags') + if (value = attributes[:'account_tags']).is_a?(Array) + self.account_tags = value + end + end + + if attributes.key?(:'metrics_config') + self.metrics_config = attributes[:'metrics_config'] + end + + if attributes.key?(:'tenant_id') + self.tenant_id = attributes[:'tenant_id'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @tenant_id.nil? + true + end + + # Custom attribute writer method with validation + # @param tenant_id [Object] Object to be assigned + # @!visibility private + def tenant_id=(tenant_id) + if tenant_id.nil? + fail ArgumentError, 'invalid value for "tenant_id", tenant_id cannot be nil.' + end + @tenant_id = tenant_id + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + account_tags == o.account_tags && + metrics_config == o.metrics_config && + tenant_id == o.tenant_id + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [account_tags, metrics_config, tenant_id].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_settings_response.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_settings_response.rb new file mode 100644 index 000000000000..7fe33b1db6d7 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_settings_response.rb @@ -0,0 +1,145 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Settings configured on the Nebius Cloud integration account. + class NebiusCloudIntegrationAccountSettingsResponse + include BaseGenericModel + + # Tags applied to all data collected from this Nebius Cloud account. + attr_accessor :account_tags + + # Metric collection settings configured on the Nebius Cloud integration account. Absent when no filters are configured. + attr_accessor :metrics_config + + # ID of the Nebius tenant being monitored. + attr_reader :tenant_id + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'account_tags' => :'account_tags', + :'metrics_config' => :'metrics_config', + :'tenant_id' => :'tenant_id' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'account_tags' => :'Array', + :'metrics_config' => :'NebiusCloudIntegrationAccountMetricsConfigResponse', + :'tenant_id' => :'String' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountSettingsResponse` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'account_tags') + if (value = attributes[:'account_tags']).is_a?(Array) + self.account_tags = value + end + end + + if attributes.key?(:'metrics_config') + self.metrics_config = attributes[:'metrics_config'] + end + + if attributes.key?(:'tenant_id') + self.tenant_id = attributes[:'tenant_id'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @tenant_id.nil? + true + end + + # Custom attribute writer method with validation + # @param tenant_id [Object] Object to be assigned + # @!visibility private + def tenant_id=(tenant_id) + if tenant_id.nil? + fail ArgumentError, 'invalid value for "tenant_id", tenant_id cannot be nil.' + end + @tenant_id = tenant_id + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + account_tags == o.account_tags && + metrics_config == o.metrics_config && + tenant_id == o.tenant_id && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [account_tags, metrics_config, tenant_id, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_settings_update.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_settings_update.rb new file mode 100644 index 000000000000..2757dd79aefb --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_settings_update.rb @@ -0,0 +1,102 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Settings for updating the Nebius Cloud integration account. Only the fields provided are changed. + class NebiusCloudIntegrationAccountSettingsUpdate + include BaseGenericModel + + # Tags applied to all metrics, logs, and resources collected from this Nebius Cloud account. Sending it replaces the whole list; send an empty array to remove all tags, or omit it to keep the stored list. + attr_accessor :account_tags + + # Configuration for metric collection. Only the fields provided are changed. + attr_accessor :metrics_config + + # ID of the Nebius tenant to monitor. An empty value is ignored and the stored tenant ID is kept. + attr_accessor :tenant_id + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'account_tags' => :'account_tags', + :'metrics_config' => :'metrics_config', + :'tenant_id' => :'tenant_id' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'account_tags' => :'Array', + :'metrics_config' => :'NebiusCloudIntegrationAccountMetricsConfigUpdate', + :'tenant_id' => :'String' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountSettingsUpdate` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountSettingsUpdate`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'account_tags') + if (value = attributes[:'account_tags']).is_a?(Array) + self.account_tags = value + end + end + + if attributes.key?(:'metrics_config') + self.metrics_config = attributes[:'metrics_config'] + end + + if attributes.key?(:'tenant_id') + self.tenant_id = attributes[:'tenant_id'] + end + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + account_tags == o.account_tags && + metrics_config == o.metrics_config && + tenant_id == o.tenant_id + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [account_tags, metrics_config, tenant_id].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_update_attributes.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_update_attributes.rb new file mode 100644 index 000000000000..26b6dadcdcc8 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_update_attributes.rb @@ -0,0 +1,153 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Writable attributes used to update a Nebius Cloud 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, as do the settings of an included dataflow that provides only `enabled`. + class NebiusCloudIntegrationAccountUpdateAttributes + include BaseGenericModel + + # Authentication for updating the Nebius Cloud integration account. Exactly one method is set. + attr_accessor :authentication + + # Data Datadog collects from Nebius Cloud, keyed by dataflow id. Each dataflow turns on a distinct kind of collection: set `enabled` to stop or start it, and use `settings` to configure what it collects. Defaults listed on each dataflow apply when the account is created; on update, omitted fields keep their current values. Every dataflow except `nebius-cloud-cost-collection` runs as the service account in `authentication`, using its authorized key pair and the static API key; enabling one of them without those keys is rejected with a `422` response, and one enabled with keys that later expire is stored but collects no data. + attr_accessor :dataflows + + # Human-readable name of the Nebius Cloud integration account. + attr_reader :name + + # Settings for updating the Nebius Cloud integration account. Only the fields provided are changed. + attr_accessor :settings + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'authentication' => :'authentication', + :'dataflows' => :'dataflows', + :'name' => :'name', + :'settings' => :'settings' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'authentication' => :'NebiusCloudIntegrationAccountAuthenticationUpdate', + :'dataflows' => :'NebiusCloudIntegrationDataflowsRequest', + :'name' => :'String', + :'settings' => :'NebiusCloudIntegrationAccountSettingsUpdate' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountUpdateAttributes` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'authentication') + self.authentication = attributes[:'authentication'] + end + + if attributes.key?(:'dataflows') + self.dataflows = attributes[:'dataflows'] + end + + if attributes.key?(:'name') + self.name = attributes[:'name'] + end + + if attributes.key?(:'settings') + self.settings = attributes[:'settings'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if !@name.nil? && @name.to_s.length > 255 + true + end + + # Custom attribute writer method with validation + # @param name [Object] Object to be assigned + # @!visibility private + def name=(name) + if !name.nil? && name.to_s.length > 255 + fail ArgumentError, 'invalid value for "name", the character length must be smaller than or equal to 255.' + end + @name = name + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + authentication == o.authentication && + dataflows == o.dataflows && + name == o.name && + settings == o.settings && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [authentication, dataflows, name, settings, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_update_data.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_update_data.rb new file mode 100644 index 000000000000..59b3403fa72f --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_update_data.rb @@ -0,0 +1,165 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Data envelope for updating a Nebius Cloud integration account. + class NebiusCloudIntegrationAccountUpdateData + include BaseGenericModel + + # Writable attributes used to update a Nebius Cloud 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, as do the settings of an included dataflow that provides only `enabled`. + attr_reader :attributes + + # Unique identifier of the Nebius Cloud integration account to update. + attr_reader :id + + # The type of the integration account resource. Always `integration-account`. + attr_reader :type + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'attributes' => :'attributes', + :'id' => :'id', + :'type' => :'type' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'attributes' => :'NebiusCloudIntegrationAccountUpdateAttributes', + :'id' => :'String', + :'type' => :'IntegrationAccountType' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountUpdateData` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'attributes') + self.attributes = attributes[:'attributes'] + end + + if attributes.key?(:'id') + self.id = attributes[:'id'] + end + + if attributes.key?(:'type') + self.type = attributes[:'type'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @attributes.nil? + return false if @id.nil? + return false if @type.nil? + true + end + + # Custom attribute writer method with validation + # @param attributes [Object] Object to be assigned + # @!visibility private + def attributes=(attributes) + if attributes.nil? + fail ArgumentError, 'invalid value for "attributes", attributes cannot be nil.' + end + @attributes = attributes + end + + # Custom attribute writer method with validation + # @param id [Object] Object to be assigned + # @!visibility private + def id=(id) + if id.nil? + fail ArgumentError, 'invalid value for "id", id cannot be nil.' + end + @id = id + end + + # Custom attribute writer method with validation + # @param type [Object] Object to be assigned + # @!visibility private + def type=(type) + if type.nil? + fail ArgumentError, 'invalid value for "type", type cannot be nil.' + end + @type = type + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + attributes == o.attributes && + id == o.id && + type == o.type && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [attributes, id, type, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_update_request.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_update_request.rb new file mode 100644 index 000000000000..64c3aae51441 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_account_update_request.rb @@ -0,0 +1,123 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Request payload to update a Nebius Cloud integration account. + class NebiusCloudIntegrationAccountUpdateRequest + include BaseGenericModel + + # Data envelope for updating a Nebius Cloud integration account. + attr_reader :data + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'data' => :'data' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'data' => :'NebiusCloudIntegrationAccountUpdateData' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountUpdateRequest` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'data') + self.data = attributes[:'data'] + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @data.nil? + true + end + + # Custom attribute writer method with validation + # @param data [Object] Object to be assigned + # @!visibility private + def data=(data) + if data.nil? + fail ArgumentError, 'invalid value for "data", data cannot be nil.' + end + @data = data + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + data == o.data && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [data, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_accounts_response.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_accounts_response.rb new file mode 100644 index 000000000000..50d94ab14431 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_accounts_response.rb @@ -0,0 +1,125 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Response payload for a list of Nebius Cloud integration accounts. + class NebiusCloudIntegrationAccountsResponse + include BaseGenericModel + + # List of Nebius Cloud integration accounts. + attr_reader :data + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'data' => :'data' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'data' => :'Array' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationAccountsResponse` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'data') + if (value = attributes[:'data']).is_a?(Array) + self.data = value + end + end + end + + # Check to see if the all the properties in the model are valid + # @return true if the model is valid + # @!visibility private + def valid? + return false if @data.nil? + true + end + + # Custom attribute writer method with validation + # @param data [Object] Object to be assigned + # @!visibility private + def data=(data) + if data.nil? + fail ArgumentError, 'invalid value for "data", data cannot be nil.' + end + @data = data + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + data == o.data && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [data, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_dataflows_request.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_dataflows_request.rb new file mode 100644 index 000000000000..0436bf2e3ef4 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_dataflows_request.rb @@ -0,0 +1,110 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Data Datadog collects from Nebius Cloud, keyed by dataflow id. Each dataflow turns on a distinct kind of collection: set `enabled` to stop or start it, and use `settings` to configure what it collects. Defaults listed on each dataflow apply when the account is created; on update, omitted fields keep their current values. Every dataflow except `nebius-cloud-cost-collection` runs as the service account in `authentication`, using its authorized key pair and the static API key; enabling one of them without those keys is rejected with a `422` response, and one enabled with keys that later expire is stored but collects no data. + class NebiusCloudIntegrationDataflowsRequest + include BaseGenericModel + + # Cloud cost data read from a Nebius Object Storage bucket export and used by [Cloud Cost Management](https://docs.datadoghq.com/cloud_cost_management/). Enabling it requires a bucket holding your cost export and a Nebius access key pair that can read it; a request that enables this dataflow without them is rejected with a `422` response. + attr_accessor :nebius_cloud_cost_collection + + # Logs from your Nebius tenant: Kubernetes control plane and audit logs, tenant-level audit events, compute serial console logs, cloud apps and AI inference logs, PostgreSQL logs, and MLflow logs, collected from the services named in `settings.enabled_services`. `enabled_services` is the sole source of truth for what is collected; `enabled` set to `false` stops log collection, while `true` on its own changes nothing. Defaults to no services. + attr_accessor :nebius_cloud_logs + + # Metadata about resources in your Nebius tenant, such as compute instances and Kubernetes clusters. + attr_accessor :nebius_cloud_resources + + # Usage metrics tracked against your Nebius service quotas, such as `nebius_cloud.servicequota.percentage_used` and `nebius_cloud.servicequota.limit`. + attr_accessor :nebius_cloud_service_quota_collection + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'nebius_cloud_cost_collection' => :'nebius-cloud-cost-collection', + :'nebius_cloud_logs' => :'nebius-cloud-logs', + :'nebius_cloud_resources' => :'nebius-cloud-resources', + :'nebius_cloud_service_quota_collection' => :'nebius-cloud-service-quota-collection' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'nebius_cloud_cost_collection' => :'NebiusCloudCostCollectionIntegrationDataflowRequest', + :'nebius_cloud_logs' => :'NebiusCloudLogsIntegrationDataflowRequest', + :'nebius_cloud_resources' => :'NebiusCloudResourcesIntegrationDataflowRequest', + :'nebius_cloud_service_quota_collection' => :'NebiusCloudServiceQuotaCollectionIntegrationDataflowRequest' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationDataflowsRequest` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `DatadogAPIClient::V2::NebiusCloudIntegrationDataflowsRequest`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'nebius_cloud_cost_collection') + self.nebius_cloud_cost_collection = attributes[:'nebius_cloud_cost_collection'] + end + + if attributes.key?(:'nebius_cloud_logs') + self.nebius_cloud_logs = attributes[:'nebius_cloud_logs'] + end + + if attributes.key?(:'nebius_cloud_resources') + self.nebius_cloud_resources = attributes[:'nebius_cloud_resources'] + end + + if attributes.key?(:'nebius_cloud_service_quota_collection') + self.nebius_cloud_service_quota_collection = attributes[:'nebius_cloud_service_quota_collection'] + end + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + nebius_cloud_cost_collection == o.nebius_cloud_cost_collection && + nebius_cloud_logs == o.nebius_cloud_logs && + nebius_cloud_resources == o.nebius_cloud_resources && + nebius_cloud_service_quota_collection == o.nebius_cloud_service_quota_collection + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [nebius_cloud_cost_collection, nebius_cloud_logs, nebius_cloud_resources, nebius_cloud_service_quota_collection].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_integration_dataflows_response.rb b/lib/datadog_api_client/v2/models/nebius_cloud_integration_dataflows_response.rb new file mode 100644 index 000000000000..0efb6e3273f3 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_integration_dataflows_response.rb @@ -0,0 +1,135 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Data Datadog collects from Nebius Cloud, keyed by dataflow id. + class NebiusCloudIntegrationDataflowsResponse + include BaseGenericModel + + # Cloud cost data read from a Nebius Object Storage bucket export and used by [Cloud Cost Management](https://docs.datadoghq.com/cloud_cost_management/). Requires a bucket holding your cost export and a Nebius access key pair that can read it; without both this dataflow collects no data. + attr_accessor :nebius_cloud_cost_collection + + # Logs from your Nebius tenant: Kubernetes control plane and audit logs, tenant-level audit events, compute serial console logs, cloud apps and AI inference logs, PostgreSQL logs, and MLflow logs, collected from the services named in `settings.enabled_services`. + attr_accessor :nebius_cloud_logs + + # Metadata about resources in your Nebius tenant, such as compute instances and Kubernetes clusters. + attr_accessor :nebius_cloud_resources + + # Usage metrics tracked against your Nebius service quotas, such as `nebius_cloud.servicequota.percentage_used` and `nebius_cloud.servicequota.limit`. + attr_accessor :nebius_cloud_service_quota_collection + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'nebius_cloud_cost_collection' => :'nebius-cloud-cost-collection', + :'nebius_cloud_logs' => :'nebius-cloud-logs', + :'nebius_cloud_resources' => :'nebius-cloud-resources', + :'nebius_cloud_service_quota_collection' => :'nebius-cloud-service-quota-collection' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'nebius_cloud_cost_collection' => :'NebiusCloudCostCollectionIntegrationDataflowResponse', + :'nebius_cloud_logs' => :'NebiusCloudLogsIntegrationDataflowResponse', + :'nebius_cloud_resources' => :'NebiusCloudResourcesIntegrationDataflowResponse', + :'nebius_cloud_service_quota_collection' => :'NebiusCloudServiceQuotaCollectionIntegrationDataflowResponse' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudIntegrationDataflowsResponse` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'nebius_cloud_cost_collection') + self.nebius_cloud_cost_collection = attributes[:'nebius_cloud_cost_collection'] + end + + if attributes.key?(:'nebius_cloud_logs') + self.nebius_cloud_logs = attributes[:'nebius_cloud_logs'] + end + + if attributes.key?(:'nebius_cloud_resources') + self.nebius_cloud_resources = attributes[:'nebius_cloud_resources'] + end + + if attributes.key?(:'nebius_cloud_service_quota_collection') + self.nebius_cloud_service_quota_collection = attributes[:'nebius_cloud_service_quota_collection'] + end + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + nebius_cloud_cost_collection == o.nebius_cloud_cost_collection && + nebius_cloud_logs == o.nebius_cloud_logs && + nebius_cloud_resources == o.nebius_cloud_resources && + nebius_cloud_service_quota_collection == o.nebius_cloud_service_quota_collection && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [nebius_cloud_cost_collection, nebius_cloud_logs, nebius_cloud_resources, nebius_cloud_service_quota_collection, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_dataflow_request.rb b/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_dataflow_request.rb new file mode 100644 index 000000000000..f8646b00d7b7 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_dataflow_request.rb @@ -0,0 +1,90 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Logs from your Nebius tenant: Kubernetes control plane and audit logs, tenant-level audit events, compute serial console logs, cloud apps and AI inference logs, PostgreSQL logs, and MLflow logs, collected from the services named in `settings.enabled_services`. `enabled_services` is the sole source of truth for what is collected; `enabled` set to `false` stops log collection, while `true` on its own changes nothing. Defaults to no services. + class NebiusCloudLogsIntegrationDataflowRequest + include BaseGenericModel + + # Whether Datadog collects logs. Defaults to `false`. Set to `false` to stop log collection; sending `true` on its own changes nothing, because `settings.enabled_services` is the sole source of truth. + attr_accessor :enabled + + # Settings of the logs dataflow. Only the fields provided are changed. + attr_accessor :settings + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'enabled' => :'enabled', + :'settings' => :'settings' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'enabled' => :'Boolean', + :'settings' => :'NebiusCloudLogsIntegrationDataflowSettingsRequest' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudLogsIntegrationDataflowRequest` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `DatadogAPIClient::V2::NebiusCloudLogsIntegrationDataflowRequest`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'enabled') + self.enabled = attributes[:'enabled'] + end + + if attributes.key?(:'settings') + self.settings = attributes[:'settings'] + end + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + enabled == o.enabled && + settings == o.settings + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [enabled, settings].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_dataflow_response.rb b/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_dataflow_response.rb new file mode 100644 index 000000000000..2e9d54c15602 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_dataflow_response.rb @@ -0,0 +1,115 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Logs from your Nebius tenant: Kubernetes control plane and audit logs, tenant-level audit events, compute serial console logs, cloud apps and AI inference logs, PostgreSQL logs, and MLflow logs, collected from the services named in `settings.enabled_services`. + class NebiusCloudLogsIntegrationDataflowResponse + include BaseGenericModel + + # Whether Datadog collects logs. Absent when no service is enabled. + attr_accessor :enabled + + # Settings of the logs dataflow. + attr_accessor :settings + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'enabled' => :'enabled', + :'settings' => :'settings' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'enabled' => :'Boolean', + :'settings' => :'NebiusCloudLogsIntegrationDataflowSettingsResponse' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudLogsIntegrationDataflowResponse` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'enabled') + self.enabled = attributes[:'enabled'] + end + + if attributes.key?(:'settings') + self.settings = attributes[:'settings'] + end + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + enabled == o.enabled && + settings == o.settings && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [enabled, settings, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_dataflow_settings_request.rb b/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_dataflow_settings_request.rb new file mode 100644 index 000000000000..70f0ae47f2ca --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_dataflow_settings_request.rb @@ -0,0 +1,82 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Settings of the logs dataflow. Only the fields provided are changed. + class NebiusCloudLogsIntegrationDataflowSettingsRequest + include BaseGenericModel + + # Nebius log integrations to collect. One of `nebius-cloud-compute`, `nebius-cloud-kubernetes`, `nebius-cloud-mlflow`, `nebius-cloud-postgresql`, `nebius-cloud-applications`, or `default` for the streams shared by every service. A non-empty list is the sole source of truth and replaces the stored list: those services are collected and any others stop. An empty list stops log collection entirely. Omit it to keep the stored list. + attr_accessor :enabled_services + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'enabled_services' => :'enabled_services' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'enabled_services' => :'Array' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudLogsIntegrationDataflowSettingsRequest` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `DatadogAPIClient::V2::NebiusCloudLogsIntegrationDataflowSettingsRequest`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'enabled_services') + if (value = attributes[:'enabled_services']).is_a?(Array) + self.enabled_services = value + end + end + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + enabled_services == o.enabled_services + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [enabled_services].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_dataflow_settings_response.rb b/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_dataflow_settings_response.rb new file mode 100644 index 000000000000..2ecd2ec1119f --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_dataflow_settings_response.rb @@ -0,0 +1,107 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Settings of the logs dataflow. + class NebiusCloudLogsIntegrationDataflowSettingsResponse + include BaseGenericModel + + # Nebius log integrations collected, such as `nebius-cloud-compute` and `default`. Absent when no service is enabled. + attr_accessor :enabled_services + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'enabled_services' => :'enabled_services' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'enabled_services' => :'Array' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudLogsIntegrationDataflowSettingsResponse` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'enabled_services') + if (value = attributes[:'enabled_services']).is_a?(Array) + self.enabled_services = value + end + end + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + enabled_services == o.enabled_services && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [enabled_services, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_service_name.rb b/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_service_name.rb new file mode 100644 index 000000000000..3da54f163586 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_logs_integration_service_name.rb @@ -0,0 +1,31 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Nebius log integration whose streams are collected. + class NebiusCloudLogsIntegrationServiceName + include BaseEnumModel + + NEBIUS_CLOUD_COMPUTE = "nebius-cloud-compute".freeze + NEBIUS_CLOUD_KUBERNETES = "nebius-cloud-kubernetes".freeze + NEBIUS_CLOUD_MLFLOW = "nebius-cloud-mlflow".freeze + NEBIUS_CLOUD_POSTGRESQL = "nebius-cloud-postgresql".freeze + NEBIUS_CLOUD_APPLICATIONS = "nebius-cloud-applications".freeze + DEFAULT = "default".freeze + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_resources_integration_dataflow_request.rb b/lib/datadog_api_client/v2/models/nebius_cloud_resources_integration_dataflow_request.rb new file mode 100644 index 000000000000..e7effe6f8a70 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_resources_integration_dataflow_request.rb @@ -0,0 +1,80 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Metadata about resources in your Nebius tenant, such as compute instances and Kubernetes clusters. + class NebiusCloudResourcesIntegrationDataflowRequest + include BaseGenericModel + + # Whether Datadog collects this data. Defaults to `false`; set to `true` to start collection. + attr_accessor :enabled + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'enabled' => :'enabled' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'enabled' => :'Boolean' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudResourcesIntegrationDataflowRequest` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `DatadogAPIClient::V2::NebiusCloudResourcesIntegrationDataflowRequest`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'enabled') + self.enabled = attributes[:'enabled'] + end + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + enabled == o.enabled + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [enabled].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_resources_integration_dataflow_response.rb b/lib/datadog_api_client/v2/models/nebius_cloud_resources_integration_dataflow_response.rb new file mode 100644 index 000000000000..7c433bd24093 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_resources_integration_dataflow_response.rb @@ -0,0 +1,105 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Metadata about resources in your Nebius tenant, such as compute instances and Kubernetes clusters. + class NebiusCloudResourcesIntegrationDataflowResponse + include BaseGenericModel + + # Whether Datadog collects this data. Absent when the dataflow has never been configured. + attr_accessor :enabled + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'enabled' => :'enabled' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'enabled' => :'Boolean' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudResourcesIntegrationDataflowResponse` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'enabled') + self.enabled = attributes[:'enabled'] + end + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + enabled == o.enabled && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [enabled, additional_properties].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_service_quota_collection_integration_dataflow_request.rb b/lib/datadog_api_client/v2/models/nebius_cloud_service_quota_collection_integration_dataflow_request.rb new file mode 100644 index 000000000000..92c7a6c491f4 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_service_quota_collection_integration_dataflow_request.rb @@ -0,0 +1,80 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Usage metrics tracked against your Nebius service quotas, such as `nebius_cloud.servicequota.percentage_used` and `nebius_cloud.servicequota.limit`. + class NebiusCloudServiceQuotaCollectionIntegrationDataflowRequest + include BaseGenericModel + + # Whether Datadog collects this data. Defaults to `false`; set to `true` to start collection. + attr_accessor :enabled + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'enabled' => :'enabled' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'enabled' => :'Boolean' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudServiceQuotaCollectionIntegrationDataflowRequest` initialize method" + end + + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + fail ArgumentError, "`#{k}` is not a valid attribute in `DatadogAPIClient::V2::NebiusCloudServiceQuotaCollectionIntegrationDataflowRequest`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect + end + h[k.to_sym] = v + } + + if attributes.key?(:'enabled') + self.enabled = attributes[:'enabled'] + end + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + enabled == o.enabled + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [enabled].hash + end + end +end diff --git a/lib/datadog_api_client/v2/models/nebius_cloud_service_quota_collection_integration_dataflow_response.rb b/lib/datadog_api_client/v2/models/nebius_cloud_service_quota_collection_integration_dataflow_response.rb new file mode 100644 index 000000000000..5dd93ba25a53 --- /dev/null +++ b/lib/datadog_api_client/v2/models/nebius_cloud_service_quota_collection_integration_dataflow_response.rb @@ -0,0 +1,105 @@ +=begin +#Datadog API V2 Collection + +#Collection of all Datadog Public endpoints. + +The version of the OpenAPI document: 1.0 +Contact: support@datadoghq.com +Generated by: https://github.com/DataDog/datadog-api-client-ruby/tree/master/.generator + + 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 2020-Present Datadog, Inc. + +=end + +require 'date' +require 'time' + +module DatadogAPIClient::V2 + # Usage metrics tracked against your Nebius service quotas, such as `nebius_cloud.servicequota.percentage_used` and `nebius_cloud.servicequota.limit`. + class NebiusCloudServiceQuotaCollectionIntegrationDataflowResponse + include BaseGenericModel + + # Whether Datadog collects this data. Absent when the dataflow has never been configured. + attr_accessor :enabled + + attr_accessor :additional_properties + + # Attribute mapping from ruby-style variable name to JSON key. + # @!visibility private + def self.attribute_map + { + :'enabled' => :'enabled' + } + end + + # Attribute type mapping. + # @!visibility private + def self.openapi_types + { + :'enabled' => :'Boolean' + } + end + + # Initializes the object + # @param attributes [Hash] Model attributes in the form of hash + # @!visibility private + def initialize(attributes = {}) + if (!attributes.is_a?(Hash)) + fail ArgumentError, "The input argument (attributes) must be a hash in `DatadogAPIClient::V2::NebiusCloudServiceQuotaCollectionIntegrationDataflowResponse` initialize method" + end + + self.additional_properties = {} + # check to see if the attribute exists and convert string to symbol for hash key + attributes = attributes.each_with_object({}) { |(k, v), h| + if (!self.class.attribute_map.key?(k.to_sym)) + self.additional_properties[k.to_sym] = v + else + h[k.to_sym] = v + end + } + + if attributes.key?(:'enabled') + self.enabled = attributes[:'enabled'] + end + end + + # Returns the object in the form of hash, with additionalProperties support. + # @return [Hash] Returns the object in the form of hash + # @!visibility private + def to_hash + hash = {} + self.class.attribute_map.each_pair do |attr, param| + value = self.send(attr) + if value.nil? + is_nullable = self.class.openapi_nullable.include?(attr) + next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}")) + end + + hash[param] = _to_hash(value) + end + self.additional_properties.each_pair do |attr, value| + hash[attr] = value + end + hash + end + + # Checks equality by comparing each attribute. + # @param o [Object] Object to be compared + # @!visibility private + def ==(o) + return true if self.equal?(o) + self.class == o.class && + enabled == o.enabled && + additional_properties == o.additional_properties + end + + # Calculates hash code according to all attributes. + # @return [Integer] Hash code + # @!visibility private + def hash + [enabled, additional_properties].hash + end + end +end