diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index b17c8433bd55..a07ab7db9ff9 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -1932,6 +1932,15 @@ components: required: false schema: $ref: "#/components/schemas/WebhooksAuthMethodProtocol" + WifConfigUUID: + description: The UUID of the WIF configuration to operate on. + example: c5c758c6-18c2-4484-ae3f-46b84128404a + in: path + name: config_uuid + required: true + schema: + format: uuid + type: string WorkflowId: description: The ID of the workflow. in: path @@ -12146,6 +12155,181 @@ components: required: - data type: object + AwsWifIntakeMappingAttributes: + description: Attributes of an AWS WIF intake mapping. + properties: + arn_pattern: + description: |- + The AWS IAM ARN pattern identifying the role or user permitted to obtain an intake API key. + Supports wildcards (`*`) to match multiple principals within an account. + example: "arn:aws:iam::123456789012:role/my-agent-role" + type: string + required: + - arn_pattern + type: object + AwsWifIntakeMappingCreateData: + description: Data for creating an AWS WIF intake mapping. + properties: + attributes: + $ref: "#/components/schemas/AwsWifIntakeMappingAttributes" + type: + $ref: "#/components/schemas/AwsWifIntakeMappingType" + required: + - type + - attributes + type: object + AwsWifIntakeMappingCreateRequest: + description: Request body for creating an AWS WIF intake mapping. + properties: + data: + $ref: "#/components/schemas/AwsWifIntakeMappingCreateData" + required: + - data + type: object + AwsWifIntakeMappingData: + description: An AWS WIF intake mapping resource. + properties: + attributes: + $ref: "#/components/schemas/AwsWifIntakeMappingAttributes" + id: + description: The UUID of the intake mapping. + example: "a1b2c3d4-e5f6-7890-abcd-ef1234567890" + format: uuid + type: string + type: + $ref: "#/components/schemas/AwsWifIntakeMappingType" + required: + - id + - type + - attributes + type: object + AwsWifIntakeMappingResponse: + description: Response containing a single AWS WIF intake mapping. + properties: + data: + $ref: "#/components/schemas/AwsWifIntakeMappingData" + required: + - data + type: object + AwsWifIntakeMappingType: + description: Type identifier for an AWS WIF intake mapping. + enum: + - aws_wif_intake_mapping + example: aws_wif_intake_mapping + type: string + x-enum-varnames: + - AWS_WIF_INTAKE_MAPPING + AwsWifIntakeMappingsResponse: + description: Response containing a list of AWS WIF intake mappings. + properties: + data: + items: + $ref: "#/components/schemas/AwsWifIntakeMappingData" + type: array + required: + - data + type: object + AwsWifPersonaMappingAttributes: + description: Attributes of an AWS WIF persona mapping. + properties: + account_identifier: + description: The Datadog user handle (email address) to map the AWS principal to. + example: "user@example.com" + type: string + account_uuid: + description: The Datadog user UUID corresponding to `account_identifier`. Read-only — set by the server. + example: "12bbdc5c-5966-47e0-8733-285f9e44bcf4" + format: uuid + type: string + arn_pattern: + description: |- + The AWS IAM ARN pattern identifying the role or user that will be mapped. + Supports wildcards (`*`) to match multiple principals within an account. + example: "arn:aws:iam::123456789012:role/my-workload-role" + type: string + required: + - arn_pattern + - account_identifier + type: object + AwsWifPersonaMappingCreateAttributes: + description: Attributes for creating an AWS WIF persona mapping. + properties: + account_identifier: + description: The Datadog user handle (email address) to map the AWS principal to. + example: "user@example.com" + type: string + arn_pattern: + description: |- + The AWS IAM ARN pattern identifying the role or user that will be mapped. + Supports wildcards (`*`) to match multiple principals within an account. + example: "arn:aws:iam::123456789012:role/my-workload-role" + type: string + required: + - arn_pattern + - account_identifier + type: object + AwsWifPersonaMappingCreateData: + description: Data for creating an AWS WIF persona mapping. + properties: + attributes: + $ref: "#/components/schemas/AwsWifPersonaMappingCreateAttributes" + type: + $ref: "#/components/schemas/AwsWifPersonaMappingType" + required: + - type + - attributes + type: object + AwsWifPersonaMappingCreateRequest: + description: Request body for creating an AWS WIF persona mapping. + properties: + data: + $ref: "#/components/schemas/AwsWifPersonaMappingCreateData" + required: + - data + type: object + AwsWifPersonaMappingData: + description: An AWS WIF persona mapping resource. + properties: + attributes: + $ref: "#/components/schemas/AwsWifPersonaMappingAttributes" + id: + description: The UUID of the persona mapping. + example: "c5c758c6-18c2-4484-ae3f-46b84128404a" + format: uuid + type: string + type: + $ref: "#/components/schemas/AwsWifPersonaMappingType" + required: + - id + - type + - attributes + type: object + AwsWifPersonaMappingResponse: + description: Response containing a single AWS WIF persona mapping. + properties: + data: + $ref: "#/components/schemas/AwsWifPersonaMappingData" + required: + - data + type: object + AwsWifPersonaMappingType: + description: Type identifier for an AWS WIF persona mapping. + enum: + - aws_wif_config + example: aws_wif_config + type: string + x-enum-varnames: + - AWS_WIF_CONFIG + AwsWifPersonaMappingsResponse: + description: Response containing a list of AWS WIF persona mappings. + properties: + data: + items: + $ref: "#/components/schemas/AwsWifPersonaMappingData" + type: array + required: + - data + type: object AzureCredentials: description: The definition of the `AzureCredentials` object. oneOf: @@ -29812,6 +29996,55 @@ components: oneOf: - $ref: "#/components/schemas/StatusPagesUser" - $ref: "#/components/schemas/StatusPageAsIncluded" + DelegatedTokenAttributes: + description: Attributes of a delegated token. + properties: + access_token: + description: A short-lived JWT representing the authenticated Datadog user. Pass this as a bearer token in subsequent API calls. + example: "eyJhbGciOiJQUzI1NiIsInR5cCI6IkpXVCJ9..." + type: string + expires: + description: The expiry time of the token. + example: "2024-01-15T11:30:00Z" + format: date-time + type: string + required: + - access_token + - expires + type: object + DelegatedTokenData: + description: A delegated token resource. + properties: + attributes: + $ref: "#/components/schemas/DelegatedTokenAttributes" + id: + description: A random UUID assigned to this token issuance. + example: "550e8400-e29b-41d4-a716-446655440000" + format: uuid + type: string + type: + $ref: "#/components/schemas/DelegatedTokenType" + required: + - id + - type + - attributes + type: object + DelegatedTokenResponse: + description: Response containing a delegated user token. + properties: + data: + $ref: "#/components/schemas/DelegatedTokenData" + required: + - data + type: object + DelegatedTokenType: + description: The resource type for a delegated token. + enum: + - token + example: token + type: string + x-enum-varnames: + - TOKEN DeleteAppResponse: description: The response object after an app is successfully deleted. properties: @@ -45556,6 +45789,54 @@ components: - ARRAY_NUMBER - ARRAY_BOOLEAN - ARRAY_OBJECT + IntakeAPIKeyAttributes: + description: Attributes of an intake API key returned after successful authentication. + properties: + api_key: + description: The Datadog API key the workload can use to send telemetry. + example: "abc123def456..." + type: string + org_id: + description: The numeric ID of the Datadog organization the API key belongs to. + example: 123456 + format: int64 + type: integer + required: + - api_key + - org_id + type: object + IntakeAPIKeyData: + description: An intake API key resource. + properties: + attributes: + $ref: "#/components/schemas/IntakeAPIKeyAttributes" + id: + description: A stable identifier for the intake key, scoped to the matched organization. + example: "intake-123456" + type: string + type: + $ref: "#/components/schemas/IntakeAPIKeyType" + required: + - id + - type + - attributes + type: object + IntakeAPIKeyResponse: + description: Response containing an intake API key for the authenticated cloud workload. + properties: + data: + $ref: "#/components/schemas/IntakeAPIKeyData" + required: + - data + type: object + IntakeAPIKeyType: + description: The resource type for an intake API key. + enum: + - intake_api_key + example: intake_api_key + type: string + x-enum-varnames: + - INTAKE_API_KEY IntakePayloadAccepted: description: The payload accepted for intake. properties: @@ -120040,6 +120321,7 @@ paths: - test_optimization_read /api/v2/cloud_auth/aws/persona_mapping: get: + deprecated: true description: List all AWS cloud authentication persona mappings. This endpoint retrieves all configured persona mappings that associate AWS IAM principals with Datadog users. operationId: ListAWSCloudAuthPersonaMappings responses: @@ -120076,10 +120358,14 @@ paths: summary: List AWS cloud authentication persona mappings tags: - Cloud Authentication + x-deprecated: |- + **Deprecated**: Use `ListAwsWifPersonaMappings` (`GET /api/v2/wif/aws/persona_mapping`) instead. + x-sunset: "2027-01-01" x-unstable: |- **Note**: This endpoint is in public beta and is subject to change. If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/). post: + deprecated: true description: Create an AWS cloud authentication persona mapping. This endpoint associates an AWS IAM principal with a Datadog user. operationId: CreateAWSCloudAuthPersonaMapping requestBody: @@ -120137,11 +120423,15 @@ paths: tags: - Cloud Authentication x-codegen-request-body-name: body + x-deprecated: |- + **Deprecated**: Use `CreateAwsWifPersonaMapping` (`POST /api/v2/wif/aws/persona_mapping`) instead. + x-sunset: "2027-01-01" x-unstable: |- **Note**: This endpoint is in public beta and is subject to change. If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/). /api/v2/cloud_auth/aws/persona_mapping/{persona_mapping_id}: delete: + deprecated: true description: Delete an AWS cloud authentication persona mapping by ID. This removes the association between an AWS IAM principal and a Datadog user. operationId: DeleteAWSCloudAuthPersonaMapping parameters: @@ -120166,10 +120456,14 @@ paths: summary: Delete an AWS cloud authentication persona mapping tags: - Cloud Authentication + x-deprecated: |- + **Deprecated**: Use `DeleteAwsWifPersonaMapping` (`DELETE /api/v2/wif/aws/persona_mapping/{config_uuid}`) instead. + x-sunset: "2027-01-01" x-unstable: |- **Note**: This endpoint is in public beta and is subject to change. If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/). get: + deprecated: true description: Get a specific AWS cloud authentication persona mapping by ID. This endpoint retrieves a single configured persona mapping that associates an AWS IAM principal with a Datadog user. operationId: GetAWSCloudAuthPersonaMapping parameters: @@ -120208,6 +120502,9 @@ paths: summary: Get an AWS cloud authentication persona mapping tags: - Cloud Authentication + x-deprecated: |- + **Deprecated**: Use `GetAwsWifPersonaMapping` (`GET /api/v2/wif/aws/persona_mapping/{config_uuid}`) instead. + x-sunset: "2027-01-01" x-unstable: |- **Note**: This endpoint is in public beta and is subject to change. If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/). @@ -127393,6 +127690,54 @@ paths: x-unstable: |- **Note: Data Access is in preview. If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/).** + /api/v2/delegated-token: + post: + description: |- + Exchange a Workload Identity Federation (WIF) proof or Datadog credentials for a short-lived access token + scoped to a Datadog user. + + To authenticate with a WIF identity, pass the cloud-provider token in the `Authorization` header using + the `Bearer` or `Delegated` scheme. Datadog resolves the Datadog user from the persona mapping configured + for that cloud identity. + + To obtain a token for the calling user directly, authenticate with standard Datadog API and application keys. + + Use the returned `access_token` as a bearer token in subsequent API calls. + operationId: GetDelegatedToken + responses: + "200": + content: + application/json: + examples: + default: + value: + data: + attributes: + access_token: "eyJhbGciOiJQUzI1NiIsInR5cCI6IkpXVCJ9..." + expires: "2024-01-15T11:30:00Z" + id: "550e8400-e29b-41d4-a716-446655440000" + type: token + schema: + $ref: "#/components/schemas/DelegatedTokenResponse" + description: OK + "401": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Unauthorized — missing or invalid authorization proof. + "403": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Forbidden — the cloud identity is not mapped to any Datadog user, or the authenticated user does not have access. + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + security: [] + summary: Get a delegated token + tags: + - Delegated Token /api/v2/deletion/data/{product}: post: description: Creates a data deletion request by providing a query and a timeframe targeting the proper data. @@ -136004,6 +136349,55 @@ paths: x-unstable: |- **Note**: This endpoint is in public beta. If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/). + /api/v2/intake-key: + post: + description: |- + Exchanges a Workload Identity Federation (WIF) identity proof for a Datadog API key associated with the matching WIF intake mapping. + + Pass a cloud-provider token in the `Authorization` header using the `Bearer` or `Delegated` scheme. + The token is validated against the WIF intake mappings configured for the caller's organization. On success, + a managed-rotation API key is returned that the workload can use to send telemetry to Datadog. + + Unlike the delegated-token endpoint (`POST /api/v2/delegated-token`), this endpoint authenticates + the cloud workload at the organization level rather than mapping it to a specific Datadog user. + + Standard Datadog API and application key authentication is not accepted. Authenticate using a + cloud-provider token in the `Authorization: Bearer` header. + operationId: GetIntakeKey + responses: + "200": + content: + application/json: + examples: + default: + value: + data: + attributes: + api_key: "abc123def456..." + org_id: 123456 + id: "intake-123456" + type: intake_api_key + schema: + $ref: "#/components/schemas/IntakeAPIKeyResponse" + description: OK + "401": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Unauthorized — missing or invalid authorization proof. + "403": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Forbidden — the cloud identity is not matched by any intake mapping for this organization. + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + security: [] + summary: Get an intake API key + tags: + - Intake Key /api/v2/integration/aws/accounts: get: description: Get a list of AWS Account Integration Configs. @@ -189631,6 +190025,373 @@ paths: - generate_log_reports - manage_log_reports - product_analytics_saved_widgets_write + /api/v2/wif/aws/intake_mapping: + get: + description: List every AWS WIF intake mapping configured for the caller's organization. + operationId: ListAwsWifIntakeMappings + responses: + "200": + content: + application/json: + examples: + default: + value: + data: + - attributes: + arn_pattern: "arn:aws:iam::123456789012:role/my-agent-role" + id: "a1b2c3d4-e5f6-7890-abcd-ef1234567890" + type: aws_wif_intake_mapping + schema: + $ref: "#/components/schemas/AwsWifIntakeMappingsResponse" + description: OK + "403": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Forbidden + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - workload_identity_federation_read + summary: List AWS WIF intake mappings + tags: + - AWS WIF + post: + description: Create an AWS WIF intake mapping. The mapping binds an IAM role ARN pattern to a managed-rotation API key, allowing AWS workloads to send telemetry to Datadog without requiring a delegated user token. + operationId: CreateAwsWifIntakeMapping + requestBody: + content: + application/json: + examples: + default: + value: + data: + attributes: + arn_pattern: "arn:aws:iam::123456789012:role/my-agent-role" + type: aws_wif_intake_mapping + schema: + $ref: "#/components/schemas/AwsWifIntakeMappingCreateRequest" + required: true + responses: + "201": + content: + application/json: + examples: + default: + value: + data: + attributes: + arn_pattern: "arn:aws:iam::123456789012:role/my-agent-role" + id: "a1b2c3d4-e5f6-7890-abcd-ef1234567890" + type: aws_wif_intake_mapping + schema: + $ref: "#/components/schemas/AwsWifIntakeMappingResponse" + 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 + "409": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Conflict + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - workload_identity_federation_write + summary: Create an AWS WIF intake mapping + tags: + - AWS WIF + x-codegen-request-body-name: body + /api/v2/wif/aws/intake_mapping/{config_uuid}: + delete: + description: Delete an AWS WIF intake mapping by UUID. The associated managed-rotation API key is left intact, but AWS workloads that previously matched this mapping will lose intake access. + operationId: DeleteAwsWifIntakeMapping + parameters: + - $ref: "#/components/parameters/WifConfigUUID" + responses: + "204": + description: No Content + "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" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - workload_identity_federation_write + summary: Delete an AWS WIF intake mapping + tags: + - AWS WIF + get: + description: Retrieve a single AWS WIF intake mapping by UUID. + operationId: GetAwsWifIntakeMapping + parameters: + - $ref: "#/components/parameters/WifConfigUUID" + responses: + "200": + content: + application/json: + examples: + default: + value: + data: + attributes: + arn_pattern: "arn:aws:iam::123456789012:role/my-agent-role" + id: "a1b2c3d4-e5f6-7890-abcd-ef1234567890" + type: aws_wif_intake_mapping + schema: + $ref: "#/components/schemas/AwsWifIntakeMappingResponse" + 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" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - workload_identity_federation_read + summary: Get an AWS WIF intake mapping + tags: + - AWS WIF + /api/v2/wif/aws/persona_mapping: + get: + description: List every AWS WIF persona mapping configured for the caller's organization. + operationId: ListAwsWifPersonaMappings + responses: + "200": + content: + application/json: + examples: + default: + value: + data: + - attributes: + account_identifier: "user@example.com" + account_uuid: "12bbdc5c-5966-47e0-8733-285f9e44bcf4" + arn_pattern: "arn:aws:iam::123456789012:role/my-workload-role" + id: "c5c758c6-18c2-4484-ae3f-46b84128404a" + type: aws_wif_config + schema: + $ref: "#/components/schemas/AwsWifPersonaMappingsResponse" + description: OK + "403": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Forbidden + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - workload_identity_federation_read + summary: List AWS WIF persona mappings + tags: + - AWS WIF + post: + description: Create an AWS Workload Identity Federation (WIF) persona mapping. The mapping binds an IAM role ARN pattern to a Datadog user handle, which is used to authenticate delegated-token requests from that AWS identity. + operationId: CreateAwsWifPersonaMapping + requestBody: + content: + application/json: + examples: + default: + value: + data: + attributes: + account_identifier: "user@example.com" + arn_pattern: "arn:aws:iam::123456789012:role/my-workload-role" + type: aws_wif_config + schema: + $ref: "#/components/schemas/AwsWifPersonaMappingCreateRequest" + required: true + responses: + "201": + content: + application/json: + examples: + default: + value: + data: + attributes: + account_identifier: "user@example.com" + account_uuid: "12bbdc5c-5966-47e0-8733-285f9e44bcf4" + arn_pattern: "arn:aws:iam::123456789012:role/my-workload-role" + id: "c5c758c6-18c2-4484-ae3f-46b84128404a" + type: aws_wif_config + schema: + $ref: "#/components/schemas/AwsWifPersonaMappingResponse" + 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 + "409": + content: + application/json: + schema: + $ref: "#/components/schemas/JSONAPIErrorResponse" + description: Conflict + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - workload_identity_federation_write + summary: Create an AWS WIF persona mapping + tags: + - AWS WIF + x-codegen-request-body-name: body + /api/v2/wif/aws/persona_mapping/{config_uuid}: + delete: + description: Delete an AWS WIF persona mapping by UUID. Subsequent delegated-token requests from the previously mapped AWS identity will be denied. + operationId: DeleteAwsWifPersonaMapping + parameters: + - $ref: "#/components/parameters/WifConfigUUID" + responses: + "204": + description: No Content + "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" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - workload_identity_federation_write + summary: Delete an AWS WIF persona mapping + tags: + - AWS WIF + get: + description: Retrieve a single AWS WIF persona mapping by UUID. + operationId: GetAwsWifPersonaMapping + parameters: + - $ref: "#/components/parameters/WifConfigUUID" + responses: + "200": + content: + application/json: + examples: + default: + value: + data: + attributes: + account_identifier: "user@example.com" + account_uuid: "12bbdc5c-5966-47e0-8733-285f9e44bcf4" + arn_pattern: "arn:aws:iam::123456789012:role/my-workload-role" + id: "c5c758c6-18c2-4484-ae3f-46b84128404a" + type: aws_wif_config + schema: + $ref: "#/components/schemas/AwsWifPersonaMappingResponse" + 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" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - workload_identity_federation_read + summary: Get an AWS WIF persona mapping + tags: + - AWS WIF /api/v2/workflows: get: description: List all workflows in your organization. This API requires a [registered application key](https://docs.datadoghq.com/api/latest/action-connection/#register-a-new-app-key). Alternatively, you can configure these permissions [in the UI](https://docs.datadoghq.com/account_management/api-app-keys/#actions-api-access). @@ -190292,6 +191053,11 @@ tags: externalDocs: url: https://docs.datadoghq.com/integrations/amazon_web_services/#log-collection name: AWS Logs Integration + - description: |- + Manage AWS Workload Identity Federation (WIF) mappings. + Persona mappings link IAM role ARN patterns to Datadog users for delegated-token authentication. + Intake mappings link IAM role ARN patterns to managed-rotation API keys for agent telemetry ingestion. + name: AWS WIF - description: |- Action connections extend your installed integrations and allow you to take action in your third-party systems (e.g. AWS, GitLab, and Statuspage) with Datadog’s Workflow Automation and App Builder products. @@ -190463,6 +191229,10 @@ tags: access to sensitive data. By defining Restricted Datasets, you can ensure that only specific teams or roles can view certain types of telemetry (for example, logs, traces, metrics, and RUM data). name: Datasets + - description: |- + Exchange a cloud-provider identity proof or Datadog credential for a short-lived delegated-user JWT + via Workload Identity Federation. + name: Delegated Token - description: |- Manage Deployment Gates using this API to reduce the likelihood and impact of incidents caused by deployments. See the [Deployment Gates documentation](https://docs.datadoghq.com/deployment_gates/) for more information. name: Deployment Gates @@ -190547,6 +191317,9 @@ tags: name: IP Allowlist - description: Manage incident response, as well as associated attachments, metadata, and todos. See the [Incident Management page](https://docs.datadoghq.com/service_management/incident_management/) for more information. name: Incidents + - description: |- + Exchange a cloud-provider identity proof for a Datadog API key via Workload Identity Federation intake mappings. + name: Intake Key - description: |- The Integrations API is used to list available integrations and retrieve information about their installation status. diff --git a/examples/v2/aws-wif/CreateAwsWifIntakeMapping.ts b/examples/v2/aws-wif/CreateAwsWifIntakeMapping.ts new file mode 100644 index 000000000000..974ca095b33e --- /dev/null +++ b/examples/v2/aws-wif/CreateAwsWifIntakeMapping.ts @@ -0,0 +1,28 @@ +/** + * Create an AWS WIF intake mapping returns "Created" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +const apiInstance = new v2.AWSWIFApi(configuration); + +const params: v2.AWSWIFApiCreateAwsWifIntakeMappingRequest = { + body: { + data: { + attributes: { + arnPattern: "arn:aws:iam::123456789012:role/my-agent-role", + }, + type: "aws_wif_intake_mapping", + }, + }, +}; + +apiInstance + .createAwsWifIntakeMapping(params) + .then((data: v2.AwsWifIntakeMappingResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/aws-wif/CreateAwsWifPersonaMapping.ts b/examples/v2/aws-wif/CreateAwsWifPersonaMapping.ts new file mode 100644 index 000000000000..f477623a4b6b --- /dev/null +++ b/examples/v2/aws-wif/CreateAwsWifPersonaMapping.ts @@ -0,0 +1,29 @@ +/** + * Create an AWS WIF persona mapping returns "Created" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +const apiInstance = new v2.AWSWIFApi(configuration); + +const params: v2.AWSWIFApiCreateAwsWifPersonaMappingRequest = { + body: { + data: { + attributes: { + accountIdentifier: "user@example.com", + arnPattern: "arn:aws:iam::123456789012:role/my-workload-role", + }, + type: "aws_wif_config", + }, + }, +}; + +apiInstance + .createAwsWifPersonaMapping(params) + .then((data: v2.AwsWifPersonaMappingResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/aws-wif/DeleteAwsWifIntakeMapping.ts b/examples/v2/aws-wif/DeleteAwsWifIntakeMapping.ts new file mode 100644 index 000000000000..8a81a74fbccc --- /dev/null +++ b/examples/v2/aws-wif/DeleteAwsWifIntakeMapping.ts @@ -0,0 +1,21 @@ +/** + * Delete an AWS WIF intake mapping returns "No Content" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +const apiInstance = new v2.AWSWIFApi(configuration); + +const params: v2.AWSWIFApiDeleteAwsWifIntakeMappingRequest = { + configUuid: "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d", +}; + +apiInstance + .deleteAwsWifIntakeMapping(params) + .then((data: any) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/aws-wif/DeleteAwsWifPersonaMapping.ts b/examples/v2/aws-wif/DeleteAwsWifPersonaMapping.ts new file mode 100644 index 000000000000..06a7dbbcab5d --- /dev/null +++ b/examples/v2/aws-wif/DeleteAwsWifPersonaMapping.ts @@ -0,0 +1,21 @@ +/** + * Delete an AWS WIF persona mapping returns "No Content" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +const apiInstance = new v2.AWSWIFApi(configuration); + +const params: v2.AWSWIFApiDeleteAwsWifPersonaMappingRequest = { + configUuid: "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d", +}; + +apiInstance + .deleteAwsWifPersonaMapping(params) + .then((data: any) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/aws-wif/GetAwsWifIntakeMapping.ts b/examples/v2/aws-wif/GetAwsWifIntakeMapping.ts new file mode 100644 index 000000000000..4fcfeb05a2a7 --- /dev/null +++ b/examples/v2/aws-wif/GetAwsWifIntakeMapping.ts @@ -0,0 +1,21 @@ +/** + * Get an AWS WIF intake mapping returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +const apiInstance = new v2.AWSWIFApi(configuration); + +const params: v2.AWSWIFApiGetAwsWifIntakeMappingRequest = { + configUuid: "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d", +}; + +apiInstance + .getAwsWifIntakeMapping(params) + .then((data: v2.AwsWifIntakeMappingResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/aws-wif/GetAwsWifPersonaMapping.ts b/examples/v2/aws-wif/GetAwsWifPersonaMapping.ts new file mode 100644 index 000000000000..e90e30473d7d --- /dev/null +++ b/examples/v2/aws-wif/GetAwsWifPersonaMapping.ts @@ -0,0 +1,21 @@ +/** + * Get an AWS WIF persona mapping returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +const apiInstance = new v2.AWSWIFApi(configuration); + +const params: v2.AWSWIFApiGetAwsWifPersonaMappingRequest = { + configUuid: "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d", +}; + +apiInstance + .getAwsWifPersonaMapping(params) + .then((data: v2.AwsWifPersonaMappingResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/aws-wif/ListAwsWifIntakeMappings.ts b/examples/v2/aws-wif/ListAwsWifIntakeMappings.ts new file mode 100644 index 000000000000..8df5c4b0cf3a --- /dev/null +++ b/examples/v2/aws-wif/ListAwsWifIntakeMappings.ts @@ -0,0 +1,17 @@ +/** + * List AWS WIF intake mappings returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +const apiInstance = new v2.AWSWIFApi(configuration); + +apiInstance + .listAwsWifIntakeMappings() + .then((data: v2.AwsWifIntakeMappingsResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/aws-wif/ListAwsWifPersonaMappings.ts b/examples/v2/aws-wif/ListAwsWifPersonaMappings.ts new file mode 100644 index 000000000000..365b3e474077 --- /dev/null +++ b/examples/v2/aws-wif/ListAwsWifPersonaMappings.ts @@ -0,0 +1,17 @@ +/** + * List AWS WIF persona mappings returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +const apiInstance = new v2.AWSWIFApi(configuration); + +apiInstance + .listAwsWifPersonaMappings() + .then((data: v2.AwsWifPersonaMappingsResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/delegated-token/GetDelegatedToken.ts b/examples/v2/delegated-token/GetDelegatedToken.ts new file mode 100644 index 000000000000..85e252c506dc --- /dev/null +++ b/examples/v2/delegated-token/GetDelegatedToken.ts @@ -0,0 +1,17 @@ +/** + * Get a delegated token returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +const apiInstance = new v2.DelegatedTokenApi(configuration); + +apiInstance + .getDelegatedToken() + .then((data: v2.DelegatedTokenResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/intake-key/GetIntakeKey.ts b/examples/v2/intake-key/GetIntakeKey.ts new file mode 100644 index 000000000000..b7168c7b096a --- /dev/null +++ b/examples/v2/intake-key/GetIntakeKey.ts @@ -0,0 +1,17 @@ +/** + * Get an intake API key returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +const apiInstance = new v2.IntakeKeyApi(configuration); + +apiInstance + .getIntakeKey() + .then((data: v2.IntakeAPIKeyResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/features/support/scenarios_model_mapping.ts b/features/support/scenarios_model_mapping.ts index 67d13077c60a..70c14517b821 100644 --- a/features/support/scenarios_model_mapping.ts +++ b/features/support/scenarios_model_mapping.ts @@ -8589,6 +8589,9 @@ export const ScenariosModelMappings: {[key: string]: {[key: string]: any}} = { }, "operationResponseType": "{}", }, + "v2.GetDelegatedToken": { + "operationResponseType": "DelegatedTokenResponse", + }, "v2.CreateDataDeletionRequest": { "product": { "type": "string", @@ -10005,6 +10008,9 @@ export const ScenariosModelMappings: {[key: string]: {[key: string]: any}} = { }, "operationResponseType": "IncidentTodoResponse", }, + "v2.GetIntakeKey": { + "operationResponseType": "IntakeAPIKeyResponse", + }, "v2.ListAWSAccounts": { "awsAccountId": { "type": "string", @@ -16703,6 +16709,54 @@ export const ScenariosModelMappings: {[key: string]: {[key: string]: any}} = { }, "operationResponseType": "{}", }, + "v2.ListAwsWifIntakeMappings": { + "operationResponseType": "AwsWifIntakeMappingsResponse", + }, + "v2.CreateAwsWifIntakeMapping": { + "body": { + "type": "AwsWifIntakeMappingCreateRequest", + "format": "", + }, + "operationResponseType": "AwsWifIntakeMappingResponse", + }, + "v2.GetAwsWifIntakeMapping": { + "configUuid": { + "type": "string", + "format": "uuid", + }, + "operationResponseType": "AwsWifIntakeMappingResponse", + }, + "v2.DeleteAwsWifIntakeMapping": { + "configUuid": { + "type": "string", + "format": "uuid", + }, + "operationResponseType": "{}", + }, + "v2.ListAwsWifPersonaMappings": { + "operationResponseType": "AwsWifPersonaMappingsResponse", + }, + "v2.CreateAwsWifPersonaMapping": { + "body": { + "type": "AwsWifPersonaMappingCreateRequest", + "format": "", + }, + "operationResponseType": "AwsWifPersonaMappingResponse", + }, + "v2.GetAwsWifPersonaMapping": { + "configUuid": { + "type": "string", + "format": "uuid", + }, + "operationResponseType": "AwsWifPersonaMappingResponse", + }, + "v2.DeleteAwsWifPersonaMapping": { + "configUuid": { + "type": "string", + "format": "uuid", + }, + "operationResponseType": "{}", + }, "v2.ListWorkflows": { "limit": { "type": "number", diff --git a/features/v2/aws_wif.feature b/features/v2/aws_wif.feature new file mode 100644 index 000000000000..922431ffee3d --- /dev/null +++ b/features/v2/aws_wif.feature @@ -0,0 +1,149 @@ +@endpoint(aws-wif) @endpoint(aws-wif-v2) +Feature: AWS WIF + Manage AWS Workload Identity Federation (WIF) mappings. Persona mappings + link IAM role ARN patterns to Datadog users for delegated-token + authentication. Intake mappings link IAM role ARN patterns to managed- + rotation API keys for agent telemetry ingestion. + + Background: + Given a valid "apiKeyAuth" key in the system + And a valid "appKeyAuth" key in the system + And an instance of "AWSWIF" API + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Create an AWS WIF intake mapping returns "Bad Request" response + Given new "CreateAwsWifIntakeMapping" request + And body with value {"data": {"attributes": {"arn_pattern": "arn:aws:iam::123456789012:role/my-agent-role"}, "type": "aws_wif_intake_mapping"}} + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Create an AWS WIF intake mapping returns "Conflict" response + Given new "CreateAwsWifIntakeMapping" request + And body with value {"data": {"attributes": {"arn_pattern": "arn:aws:iam::123456789012:role/my-agent-role"}, "type": "aws_wif_intake_mapping"}} + When the request is sent + Then the response status is 409 Conflict + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Create an AWS WIF intake mapping returns "Created" response + Given new "CreateAwsWifIntakeMapping" request + And body with value {"data": {"attributes": {"arn_pattern": "arn:aws:iam::123456789012:role/my-agent-role"}, "type": "aws_wif_intake_mapping"}} + When the request is sent + Then the response status is 201 Created + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Create an AWS WIF persona mapping returns "Bad Request" response + Given new "CreateAwsWifPersonaMapping" request + And body with value {"data": {"attributes": {"account_identifier": "user@example.com", "arn_pattern": "arn:aws:iam::123456789012:role/my-workload-role"}, "type": "aws_wif_config"}} + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Create an AWS WIF persona mapping returns "Conflict" response + Given new "CreateAwsWifPersonaMapping" request + And body with value {"data": {"attributes": {"account_identifier": "user@example.com", "arn_pattern": "arn:aws:iam::123456789012:role/my-workload-role"}, "type": "aws_wif_config"}} + When the request is sent + Then the response status is 409 Conflict + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Create an AWS WIF persona mapping returns "Created" response + Given new "CreateAwsWifPersonaMapping" request + And body with value {"data": {"attributes": {"account_identifier": "user@example.com", "arn_pattern": "arn:aws:iam::123456789012:role/my-workload-role"}, "type": "aws_wif_config"}} + When the request is sent + Then the response status is 201 Created + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Delete an AWS WIF intake mapping returns "Bad Request" response + Given new "DeleteAwsWifIntakeMapping" request + And request contains "config_uuid" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Delete an AWS WIF intake mapping returns "No Content" response + Given new "DeleteAwsWifIntakeMapping" request + And request contains "config_uuid" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 204 No Content + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Delete an AWS WIF intake mapping returns "Not Found" response + Given new "DeleteAwsWifIntakeMapping" request + And request contains "config_uuid" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Delete an AWS WIF persona mapping returns "Bad Request" response + Given new "DeleteAwsWifPersonaMapping" request + And request contains "config_uuid" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Delete an AWS WIF persona mapping returns "No Content" response + Given new "DeleteAwsWifPersonaMapping" request + And request contains "config_uuid" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 204 No Content + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Delete an AWS WIF persona mapping returns "Not Found" response + Given new "DeleteAwsWifPersonaMapping" request + And request contains "config_uuid" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Get an AWS WIF intake mapping returns "Bad Request" response + Given new "GetAwsWifIntakeMapping" request + And request contains "config_uuid" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Get an AWS WIF intake mapping returns "Not Found" response + Given new "GetAwsWifIntakeMapping" request + And request contains "config_uuid" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Get an AWS WIF intake mapping returns "OK" response + Given new "GetAwsWifIntakeMapping" request + And request contains "config_uuid" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 200 OK + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Get an AWS WIF persona mapping returns "Bad Request" response + Given new "GetAwsWifPersonaMapping" request + And request contains "config_uuid" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Get an AWS WIF persona mapping returns "Not Found" response + Given new "GetAwsWifPersonaMapping" request + And request contains "config_uuid" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Get an AWS WIF persona mapping returns "OK" response + Given new "GetAwsWifPersonaMapping" request + And request contains "config_uuid" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 200 OK + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: List AWS WIF intake mappings returns "OK" response + Given new "ListAwsWifIntakeMappings" request + When the request is sent + Then the response status is 200 OK + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: List AWS WIF persona mappings returns "OK" response + Given new "ListAwsWifPersonaMappings" request + When the request is sent + Then the response status is 200 OK diff --git a/features/v2/cloud_authentication.feature b/features/v2/cloud_authentication.feature index c444f1469c23..03888e59bb81 100644 --- a/features/v2/cloud_authentication.feature +++ b/features/v2/cloud_authentication.feature @@ -8,7 +8,7 @@ Feature: Cloud Authentication And a valid "appKeyAuth" key in the system And an instance of "CloudAuthentication" API - @generated @skip @team:DataDog/team-aaaauthn + @generated @skip @team:DataDog/delegated-auth-login Scenario: Create an AWS cloud authentication persona mapping returns "Bad Request" response Given operation "CreateAWSCloudAuthPersonaMapping" enabled And new "CreateAWSCloudAuthPersonaMapping" request @@ -16,7 +16,7 @@ Feature: Cloud Authentication When the request is sent Then the response status is 400 Bad Request - @generated @skip @team:DataDog/team-aaaauthn + @generated @skip @team:DataDog/delegated-auth-login Scenario: Create an AWS cloud authentication persona mapping returns "Conflict" response Given operation "CreateAWSCloudAuthPersonaMapping" enabled And new "CreateAWSCloudAuthPersonaMapping" request @@ -24,7 +24,7 @@ Feature: Cloud Authentication When the request is sent Then the response status is 409 Conflict - @generated @skip @team:DataDog/team-aaaauthn + @generated @skip @team:DataDog/delegated-auth-login Scenario: Create an AWS cloud authentication persona mapping returns "Created" response Given operation "CreateAWSCloudAuthPersonaMapping" enabled And new "CreateAWSCloudAuthPersonaMapping" request @@ -32,7 +32,7 @@ Feature: Cloud Authentication When the request is sent Then the response status is 201 Created - @generated @skip @team:DataDog/team-aaaauthn + @generated @skip @team:DataDog/delegated-auth-login Scenario: Delete an AWS cloud authentication persona mapping returns "No Content" response Given operation "DeleteAWSCloudAuthPersonaMapping" enabled And new "DeleteAWSCloudAuthPersonaMapping" request @@ -40,7 +40,7 @@ Feature: Cloud Authentication When the request is sent Then the response status is 204 No Content - @generated @skip @team:DataDog/team-aaaauthn + @generated @skip @team:DataDog/delegated-auth-login Scenario: Delete an AWS cloud authentication persona mapping returns "Not Found" response Given operation "DeleteAWSCloudAuthPersonaMapping" enabled And new "DeleteAWSCloudAuthPersonaMapping" request @@ -48,7 +48,7 @@ Feature: Cloud Authentication When the request is sent Then the response status is 404 Not Found - @generated @skip @team:DataDog/team-aaaauthn + @generated @skip @team:DataDog/delegated-auth-login Scenario: Get an AWS cloud authentication persona mapping returns "Not Found" response Given operation "GetAWSCloudAuthPersonaMapping" enabled And new "GetAWSCloudAuthPersonaMapping" request @@ -56,7 +56,7 @@ Feature: Cloud Authentication When the request is sent Then the response status is 404 Not Found - @generated @skip @team:DataDog/team-aaaauthn + @generated @skip @team:DataDog/delegated-auth-login Scenario: Get an AWS cloud authentication persona mapping returns "OK" response Given operation "GetAWSCloudAuthPersonaMapping" enabled And new "GetAWSCloudAuthPersonaMapping" request @@ -64,14 +64,14 @@ Feature: Cloud Authentication When the request is sent Then the response status is 200 OK - @generated @skip @team:DataDog/team-aaaauthn + @generated @skip @team:DataDog/delegated-auth-login Scenario: List AWS cloud authentication persona mappings returns "Bad Request" response Given operation "ListAWSCloudAuthPersonaMappings" enabled And new "ListAWSCloudAuthPersonaMappings" request When the request is sent Then the response status is 400 Bad Request - @generated @skip @team:DataDog/team-aaaauthn + @generated @skip @team:DataDog/delegated-auth-login Scenario: List AWS cloud authentication persona mappings returns "OK" response Given operation "ListAWSCloudAuthPersonaMappings" enabled And new "ListAWSCloudAuthPersonaMappings" request diff --git a/features/v2/delegated_token.feature b/features/v2/delegated_token.feature new file mode 100644 index 000000000000..343463af38d5 --- /dev/null +++ b/features/v2/delegated_token.feature @@ -0,0 +1,13 @@ +@endpoint(delegated-token) @endpoint(delegated-token-v2) +Feature: Delegated Token + Exchange a cloud-provider identity proof or Datadog credential for a + short-lived delegated-user JWT via Workload Identity Federation. + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Get a delegated token returns "OK" response + Given a valid "apiKeyAuth" key in the system + And a valid "appKeyAuth" key in the system + And an instance of "DelegatedToken" API + And new "GetDelegatedToken" request + When the request is sent + Then the response status is 200 OK diff --git a/features/v2/intake_key.feature b/features/v2/intake_key.feature new file mode 100644 index 000000000000..ddcc5a81f129 --- /dev/null +++ b/features/v2/intake_key.feature @@ -0,0 +1,13 @@ +@endpoint(intake-key) @endpoint(intake-key-v2) +Feature: Intake Key + Exchange a cloud-provider identity proof for a Datadog API key via + Workload Identity Federation intake mappings. + + @generated @skip @team:DataDog/credentials-management + Scenario: Get an intake API key returns "OK" response + Given a valid "apiKeyAuth" key in the system + And a valid "appKeyAuth" key in the system + And an instance of "IntakeKey" API + And new "GetIntakeKey" request + When the request is sent + Then the response status is 200 OK diff --git a/features/v2/undo.json b/features/v2/undo.json index 049cc1252219..d96495cf2733 100644 --- a/features/v2/undo.json +++ b/features/v2/undo.json @@ -2255,6 +2255,12 @@ "type": "idempotent" } }, + "GetDelegatedToken": { + "tag": "Delegated Token", + "undo": { + "type": "idempotent" + } + }, "CreateDataDeletionRequest": { "tag": "Data Deletion", "undo": { @@ -3233,6 +3239,12 @@ "type": "idempotent" } }, + "GetIntakeKey": { + "tag": "Intake Key", + "undo": { + "type": "idempotent" + } + }, "ListAWSAccounts": { "tag": "AWS Integration", "undo": { @@ -9246,6 +9258,68 @@ "type": "safe" } }, + "ListAwsWifIntakeMappings": { + "tag": "AWS WIF", + "undo": { + "type": "safe" + } + }, + "CreateAwsWifIntakeMapping": { + "tag": "AWS WIF", + "undo": { + "operationId": "DeleteAwsWifIntakeMapping", + "parameters": [ + { + "name": "config_uuid", + "source": "data.id" + } + ], + "type": "unsafe" + } + }, + "DeleteAwsWifIntakeMapping": { + "tag": "AWS WIF", + "undo": { + "type": "idempotent" + } + }, + "GetAwsWifIntakeMapping": { + "tag": "AWS WIF", + "undo": { + "type": "safe" + } + }, + "ListAwsWifPersonaMappings": { + "tag": "AWS WIF", + "undo": { + "type": "safe" + } + }, + "CreateAwsWifPersonaMapping": { + "tag": "AWS WIF", + "undo": { + "operationId": "DeleteAwsWifPersonaMapping", + "parameters": [ + { + "name": "config_uuid", + "source": "data.id" + } + ], + "type": "unsafe" + } + }, + "DeleteAwsWifPersonaMapping": { + "tag": "AWS WIF", + "undo": { + "type": "idempotent" + } + }, + "GetAwsWifPersonaMapping": { + "tag": "AWS WIF", + "undo": { + "type": "safe" + } + }, "ListWorkflows": { "tag": "Workflow Automation", "undo": { diff --git a/packages/datadog-api-client-v2/apis/AWSWIFApi.ts b/packages/datadog-api-client-v2/apis/AWSWIFApi.ts new file mode 100644 index 000000000000..b9daee51414e --- /dev/null +++ b/packages/datadog-api-client-v2/apis/AWSWIFApi.ts @@ -0,0 +1,1192 @@ +import { + BaseAPIRequestFactory, + RequiredError, +} from "../../datadog-api-client-common/baseapi"; +import { + Configuration, + applySecurityAuthentication, +} from "../../datadog-api-client-common/configuration"; +import { + RequestContext, + HttpMethod, + ResponseContext, +} from "../../datadog-api-client-common/http/http"; + +import { logger } from "../../../logger"; +import { ObjectSerializer } from "../models/ObjectSerializer"; +import { ApiException } from "../../datadog-api-client-common/exception"; + +import { APIErrorResponse } from "../models/APIErrorResponse"; +import { AwsWifIntakeMappingCreateRequest } from "../models/AwsWifIntakeMappingCreateRequest"; +import { AwsWifIntakeMappingResponse } from "../models/AwsWifIntakeMappingResponse"; +import { AwsWifIntakeMappingsResponse } from "../models/AwsWifIntakeMappingsResponse"; +import { AwsWifPersonaMappingCreateRequest } from "../models/AwsWifPersonaMappingCreateRequest"; +import { AwsWifPersonaMappingResponse } from "../models/AwsWifPersonaMappingResponse"; +import { AwsWifPersonaMappingsResponse } from "../models/AwsWifPersonaMappingsResponse"; +import { JSONAPIErrorResponse } from "../models/JSONAPIErrorResponse"; + +export class AWSWIFApiRequestFactory extends BaseAPIRequestFactory { + public async createAwsWifIntakeMapping( + body: AwsWifIntakeMappingCreateRequest, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + // verify required parameter 'body' is not null or undefined + if (body === null || body === undefined) { + throw new RequiredError("body", "createAwsWifIntakeMapping"); + } + + // Path Params + const localVarPath = "/api/v2/wif/aws/intake_mapping"; + + // Make Request Context + const requestContext = _config + .getServer("v2.AWSWIFApi.createAwsWifIntakeMapping") + .makeRequestContext(localVarPath, HttpMethod.POST); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Body Params + const contentType = ObjectSerializer.getPreferredMediaType([ + "application/json", + ]); + requestContext.setHeaderParam("Content-Type", contentType); + const serializedBody = ObjectSerializer.stringify( + ObjectSerializer.serialize(body, "AwsWifIntakeMappingCreateRequest", ""), + contentType + ); + requestContext.setBody(serializedBody); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + + public async createAwsWifPersonaMapping( + body: AwsWifPersonaMappingCreateRequest, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + // verify required parameter 'body' is not null or undefined + if (body === null || body === undefined) { + throw new RequiredError("body", "createAwsWifPersonaMapping"); + } + + // Path Params + const localVarPath = "/api/v2/wif/aws/persona_mapping"; + + // Make Request Context + const requestContext = _config + .getServer("v2.AWSWIFApi.createAwsWifPersonaMapping") + .makeRequestContext(localVarPath, HttpMethod.POST); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Body Params + const contentType = ObjectSerializer.getPreferredMediaType([ + "application/json", + ]); + requestContext.setHeaderParam("Content-Type", contentType); + const serializedBody = ObjectSerializer.stringify( + ObjectSerializer.serialize(body, "AwsWifPersonaMappingCreateRequest", ""), + contentType + ); + requestContext.setBody(serializedBody); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + + public async deleteAwsWifIntakeMapping( + configUuid: string, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + // verify required parameter 'configUuid' is not null or undefined + if (configUuid === null || configUuid === undefined) { + throw new RequiredError("configUuid", "deleteAwsWifIntakeMapping"); + } + + // Path Params + const localVarPath = "/api/v2/wif/aws/intake_mapping/{config_uuid}".replace( + "{config_uuid}", + encodeURIComponent(String(configUuid)) + ); + + // Make Request Context + const requestContext = _config + .getServer("v2.AWSWIFApi.deleteAwsWifIntakeMapping") + .makeRequestContext(localVarPath, HttpMethod.DELETE); + requestContext.setHeaderParam("Accept", "*/*"); + requestContext.setHttpConfig(_config.httpConfig); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + + public async deleteAwsWifPersonaMapping( + configUuid: string, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + // verify required parameter 'configUuid' is not null or undefined + if (configUuid === null || configUuid === undefined) { + throw new RequiredError("configUuid", "deleteAwsWifPersonaMapping"); + } + + // Path Params + const localVarPath = + "/api/v2/wif/aws/persona_mapping/{config_uuid}".replace( + "{config_uuid}", + encodeURIComponent(String(configUuid)) + ); + + // Make Request Context + const requestContext = _config + .getServer("v2.AWSWIFApi.deleteAwsWifPersonaMapping") + .makeRequestContext(localVarPath, HttpMethod.DELETE); + requestContext.setHeaderParam("Accept", "*/*"); + requestContext.setHttpConfig(_config.httpConfig); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + + public async getAwsWifIntakeMapping( + configUuid: string, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + // verify required parameter 'configUuid' is not null or undefined + if (configUuid === null || configUuid === undefined) { + throw new RequiredError("configUuid", "getAwsWifIntakeMapping"); + } + + // Path Params + const localVarPath = "/api/v2/wif/aws/intake_mapping/{config_uuid}".replace( + "{config_uuid}", + encodeURIComponent(String(configUuid)) + ); + + // Make Request Context + const requestContext = _config + .getServer("v2.AWSWIFApi.getAwsWifIntakeMapping") + .makeRequestContext(localVarPath, HttpMethod.GET); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + + public async getAwsWifPersonaMapping( + configUuid: string, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + // verify required parameter 'configUuid' is not null or undefined + if (configUuid === null || configUuid === undefined) { + throw new RequiredError("configUuid", "getAwsWifPersonaMapping"); + } + + // Path Params + const localVarPath = + "/api/v2/wif/aws/persona_mapping/{config_uuid}".replace( + "{config_uuid}", + encodeURIComponent(String(configUuid)) + ); + + // Make Request Context + const requestContext = _config + .getServer("v2.AWSWIFApi.getAwsWifPersonaMapping") + .makeRequestContext(localVarPath, HttpMethod.GET); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + + public async listAwsWifIntakeMappings( + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + // Path Params + const localVarPath = "/api/v2/wif/aws/intake_mapping"; + + // Make Request Context + const requestContext = _config + .getServer("v2.AWSWIFApi.listAwsWifIntakeMappings") + .makeRequestContext(localVarPath, HttpMethod.GET); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } + + public async listAwsWifPersonaMappings( + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + // Path Params + const localVarPath = "/api/v2/wif/aws/persona_mapping"; + + // Make Request Context + const requestContext = _config + .getServer("v2.AWSWIFApi.listAwsWifPersonaMappings") + .makeRequestContext(localVarPath, HttpMethod.GET); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + "AuthZ", + ]); + + return requestContext; + } +} + +export class AWSWIFApiResponseProcessor { + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to createAwsWifIntakeMapping + * @throws ApiException if the response code was not in [200, 299] + */ + public async createAwsWifIntakeMapping( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 201) { + const body: AwsWifIntakeMappingResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "AwsWifIntakeMappingResponse" + ) as AwsWifIntakeMappingResponse; + return body; + } + if ( + response.httpStatusCode === 400 || + response.httpStatusCode === 403 || + response.httpStatusCode === 409 + ) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: JSONAPIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "JSONAPIErrorResponse" + ) as JSONAPIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException( + response.httpStatusCode, + body + ); + } + if (response.httpStatusCode === 429) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + const body: AwsWifIntakeMappingResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "AwsWifIntakeMappingResponse", + "" + ) as AwsWifIntakeMappingResponse; + return body; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } + + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to createAwsWifPersonaMapping + * @throws ApiException if the response code was not in [200, 299] + */ + public async createAwsWifPersonaMapping( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 201) { + const body: AwsWifPersonaMappingResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "AwsWifPersonaMappingResponse" + ) as AwsWifPersonaMappingResponse; + return body; + } + if ( + response.httpStatusCode === 400 || + response.httpStatusCode === 403 || + response.httpStatusCode === 409 + ) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: JSONAPIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "JSONAPIErrorResponse" + ) as JSONAPIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException( + response.httpStatusCode, + body + ); + } + if (response.httpStatusCode === 429) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + const body: AwsWifPersonaMappingResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "AwsWifPersonaMappingResponse", + "" + ) as AwsWifPersonaMappingResponse; + return body; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } + + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to deleteAwsWifIntakeMapping + * @throws ApiException if the response code was not in [200, 299] + */ + public async deleteAwsWifIntakeMapping( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 204) { + return; + } + if ( + response.httpStatusCode === 400 || + response.httpStatusCode === 403 || + response.httpStatusCode === 404 + ) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: JSONAPIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "JSONAPIErrorResponse" + ) as JSONAPIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException( + response.httpStatusCode, + body + ); + } + if (response.httpStatusCode === 429) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + return; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } + + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to deleteAwsWifPersonaMapping + * @throws ApiException if the response code was not in [200, 299] + */ + public async deleteAwsWifPersonaMapping( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 204) { + return; + } + if ( + response.httpStatusCode === 400 || + response.httpStatusCode === 403 || + response.httpStatusCode === 404 + ) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: JSONAPIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "JSONAPIErrorResponse" + ) as JSONAPIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException( + response.httpStatusCode, + body + ); + } + if (response.httpStatusCode === 429) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + return; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } + + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to getAwsWifIntakeMapping + * @throws ApiException if the response code was not in [200, 299] + */ + public async getAwsWifIntakeMapping( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: AwsWifIntakeMappingResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "AwsWifIntakeMappingResponse" + ) as AwsWifIntakeMappingResponse; + return body; + } + if ( + response.httpStatusCode === 400 || + response.httpStatusCode === 403 || + response.httpStatusCode === 404 + ) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: JSONAPIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "JSONAPIErrorResponse" + ) as JSONAPIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException( + response.httpStatusCode, + body + ); + } + if (response.httpStatusCode === 429) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + const body: AwsWifIntakeMappingResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "AwsWifIntakeMappingResponse", + "" + ) as AwsWifIntakeMappingResponse; + return body; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } + + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to getAwsWifPersonaMapping + * @throws ApiException if the response code was not in [200, 299] + */ + public async getAwsWifPersonaMapping( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: AwsWifPersonaMappingResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "AwsWifPersonaMappingResponse" + ) as AwsWifPersonaMappingResponse; + return body; + } + if ( + response.httpStatusCode === 400 || + response.httpStatusCode === 403 || + response.httpStatusCode === 404 + ) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: JSONAPIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "JSONAPIErrorResponse" + ) as JSONAPIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException( + response.httpStatusCode, + body + ); + } + if (response.httpStatusCode === 429) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + const body: AwsWifPersonaMappingResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "AwsWifPersonaMappingResponse", + "" + ) as AwsWifPersonaMappingResponse; + return body; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } + + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to listAwsWifIntakeMappings + * @throws ApiException if the response code was not in [200, 299] + */ + public async listAwsWifIntakeMappings( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: AwsWifIntakeMappingsResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "AwsWifIntakeMappingsResponse" + ) as AwsWifIntakeMappingsResponse; + return body; + } + if (response.httpStatusCode === 403) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: JSONAPIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "JSONAPIErrorResponse" + ) as JSONAPIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException( + response.httpStatusCode, + body + ); + } + if (response.httpStatusCode === 429) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + const body: AwsWifIntakeMappingsResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "AwsWifIntakeMappingsResponse", + "" + ) as AwsWifIntakeMappingsResponse; + return body; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } + + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to listAwsWifPersonaMappings + * @throws ApiException if the response code was not in [200, 299] + */ + public async listAwsWifPersonaMappings( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: AwsWifPersonaMappingsResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "AwsWifPersonaMappingsResponse" + ) as AwsWifPersonaMappingsResponse; + return body; + } + if (response.httpStatusCode === 403) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: JSONAPIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "JSONAPIErrorResponse" + ) as JSONAPIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException( + response.httpStatusCode, + body + ); + } + if (response.httpStatusCode === 429) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + const body: AwsWifPersonaMappingsResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "AwsWifPersonaMappingsResponse", + "" + ) as AwsWifPersonaMappingsResponse; + return body; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } +} + +export interface AWSWIFApiCreateAwsWifIntakeMappingRequest { + /** + * @type AwsWifIntakeMappingCreateRequest + */ + body: AwsWifIntakeMappingCreateRequest; +} + +export interface AWSWIFApiCreateAwsWifPersonaMappingRequest { + /** + * @type AwsWifPersonaMappingCreateRequest + */ + body: AwsWifPersonaMappingCreateRequest; +} + +export interface AWSWIFApiDeleteAwsWifIntakeMappingRequest { + /** + * The UUID of the WIF configuration to operate on. + * @type string + */ + configUuid: string; +} + +export interface AWSWIFApiDeleteAwsWifPersonaMappingRequest { + /** + * The UUID of the WIF configuration to operate on. + * @type string + */ + configUuid: string; +} + +export interface AWSWIFApiGetAwsWifIntakeMappingRequest { + /** + * The UUID of the WIF configuration to operate on. + * @type string + */ + configUuid: string; +} + +export interface AWSWIFApiGetAwsWifPersonaMappingRequest { + /** + * The UUID of the WIF configuration to operate on. + * @type string + */ + configUuid: string; +} + +export class AWSWIFApi { + private requestFactory: AWSWIFApiRequestFactory; + private responseProcessor: AWSWIFApiResponseProcessor; + private configuration: Configuration; + + public constructor( + configuration: Configuration, + requestFactory?: AWSWIFApiRequestFactory, + responseProcessor?: AWSWIFApiResponseProcessor + ) { + this.configuration = configuration; + this.requestFactory = + requestFactory || new AWSWIFApiRequestFactory(configuration); + this.responseProcessor = + responseProcessor || new AWSWIFApiResponseProcessor(); + } + + /** + * Create an AWS WIF intake mapping. The mapping binds an IAM role ARN pattern to a managed-rotation API key, allowing AWS workloads to send telemetry to Datadog without requiring a delegated user token. + * @param param The request object + */ + public createAwsWifIntakeMapping( + param: AWSWIFApiCreateAwsWifIntakeMappingRequest, + options?: Configuration + ): Promise { + const requestContextPromise = this.requestFactory.createAwsWifIntakeMapping( + param.body, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.createAwsWifIntakeMapping( + responseContext + ); + }); + }); + } + + /** + * Create an AWS Workload Identity Federation (WIF) persona mapping. The mapping binds an IAM role ARN pattern to a Datadog user handle, which is used to authenticate delegated-token requests from that AWS identity. + * @param param The request object + */ + public createAwsWifPersonaMapping( + param: AWSWIFApiCreateAwsWifPersonaMappingRequest, + options?: Configuration + ): Promise { + const requestContextPromise = + this.requestFactory.createAwsWifPersonaMapping(param.body, options); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.createAwsWifPersonaMapping( + responseContext + ); + }); + }); + } + + /** + * Delete an AWS WIF intake mapping by UUID. The associated managed-rotation API key is left intact, but AWS workloads that previously matched this mapping will lose intake access. + * @param param The request object + */ + public deleteAwsWifIntakeMapping( + param: AWSWIFApiDeleteAwsWifIntakeMappingRequest, + options?: Configuration + ): Promise { + const requestContextPromise = this.requestFactory.deleteAwsWifIntakeMapping( + param.configUuid, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.deleteAwsWifIntakeMapping( + responseContext + ); + }); + }); + } + + /** + * Delete an AWS WIF persona mapping by UUID. Subsequent delegated-token requests from the previously mapped AWS identity will be denied. + * @param param The request object + */ + public deleteAwsWifPersonaMapping( + param: AWSWIFApiDeleteAwsWifPersonaMappingRequest, + options?: Configuration + ): Promise { + const requestContextPromise = + this.requestFactory.deleteAwsWifPersonaMapping(param.configUuid, options); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.deleteAwsWifPersonaMapping( + responseContext + ); + }); + }); + } + + /** + * Retrieve a single AWS WIF intake mapping by UUID. + * @param param The request object + */ + public getAwsWifIntakeMapping( + param: AWSWIFApiGetAwsWifIntakeMappingRequest, + options?: Configuration + ): Promise { + const requestContextPromise = this.requestFactory.getAwsWifIntakeMapping( + param.configUuid, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.getAwsWifIntakeMapping(responseContext); + }); + }); + } + + /** + * Retrieve a single AWS WIF persona mapping by UUID. + * @param param The request object + */ + public getAwsWifPersonaMapping( + param: AWSWIFApiGetAwsWifPersonaMappingRequest, + options?: Configuration + ): Promise { + const requestContextPromise = this.requestFactory.getAwsWifPersonaMapping( + param.configUuid, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.getAwsWifPersonaMapping( + responseContext + ); + }); + }); + } + + /** + * List every AWS WIF intake mapping configured for the caller's organization. + * @param param The request object + */ + public listAwsWifIntakeMappings( + options?: Configuration + ): Promise { + const requestContextPromise = + this.requestFactory.listAwsWifIntakeMappings(options); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.listAwsWifIntakeMappings( + responseContext + ); + }); + }); + } + + /** + * List every AWS WIF persona mapping configured for the caller's organization. + * @param param The request object + */ + public listAwsWifPersonaMappings( + options?: Configuration + ): Promise { + const requestContextPromise = + this.requestFactory.listAwsWifPersonaMappings(options); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.listAwsWifPersonaMappings( + responseContext + ); + }); + }); + } +} diff --git a/packages/datadog-api-client-v2/apis/DelegatedTokenApi.ts b/packages/datadog-api-client-v2/apis/DelegatedTokenApi.ts new file mode 100644 index 000000000000..ebaaad084f47 --- /dev/null +++ b/packages/datadog-api-client-v2/apis/DelegatedTokenApi.ts @@ -0,0 +1,163 @@ +import { BaseAPIRequestFactory } from "../../datadog-api-client-common/baseapi"; +import { Configuration } from "../../datadog-api-client-common/configuration"; +import { + RequestContext, + HttpMethod, + ResponseContext, +} from "../../datadog-api-client-common/http/http"; + +import { logger } from "../../../logger"; +import { ObjectSerializer } from "../models/ObjectSerializer"; +import { ApiException } from "../../datadog-api-client-common/exception"; + +import { APIErrorResponse } from "../models/APIErrorResponse"; +import { DelegatedTokenResponse } from "../models/DelegatedTokenResponse"; +import { JSONAPIErrorResponse } from "../models/JSONAPIErrorResponse"; + +export class DelegatedTokenApiRequestFactory extends BaseAPIRequestFactory { + public async getDelegatedToken( + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + // Path Params + const localVarPath = "/api/v2/delegated-token"; + + // Make Request Context + const requestContext = _config + .getServer("v2.DelegatedTokenApi.getDelegatedToken") + .makeRequestContext(localVarPath, HttpMethod.POST); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + return requestContext; + } +} + +export class DelegatedTokenApiResponseProcessor { + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to getDelegatedToken + * @throws ApiException if the response code was not in [200, 299] + */ + public async getDelegatedToken( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: DelegatedTokenResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "DelegatedTokenResponse" + ) as DelegatedTokenResponse; + return body; + } + if (response.httpStatusCode === 401 || response.httpStatusCode === 403) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: JSONAPIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "JSONAPIErrorResponse" + ) as JSONAPIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException( + response.httpStatusCode, + body + ); + } + if (response.httpStatusCode === 429) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + const body: DelegatedTokenResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "DelegatedTokenResponse", + "" + ) as DelegatedTokenResponse; + return body; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } +} + +export class DelegatedTokenApi { + private requestFactory: DelegatedTokenApiRequestFactory; + private responseProcessor: DelegatedTokenApiResponseProcessor; + private configuration: Configuration; + + public constructor( + configuration: Configuration, + requestFactory?: DelegatedTokenApiRequestFactory, + responseProcessor?: DelegatedTokenApiResponseProcessor + ) { + this.configuration = configuration; + this.requestFactory = + requestFactory || new DelegatedTokenApiRequestFactory(configuration); + this.responseProcessor = + responseProcessor || new DelegatedTokenApiResponseProcessor(); + } + + /** + * Exchange a Workload Identity Federation (WIF) proof or Datadog credentials for a short-lived access token + * scoped to a Datadog user. + * + * To authenticate with a WIF identity, pass the cloud-provider token in the `Authorization` header using + * the `Bearer` or `Delegated` scheme. Datadog resolves the Datadog user from the persona mapping configured + * for that cloud identity. + * + * To obtain a token for the calling user directly, authenticate with standard Datadog API and application keys. + * + * Use the returned `access_token` as a bearer token in subsequent API calls. + * @param param The request object + */ + public getDelegatedToken( + options?: Configuration + ): Promise { + const requestContextPromise = + this.requestFactory.getDelegatedToken(options); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.getDelegatedToken(responseContext); + }); + }); + } +} diff --git a/packages/datadog-api-client-v2/apis/IntakeKeyApi.ts b/packages/datadog-api-client-v2/apis/IntakeKeyApi.ts new file mode 100644 index 000000000000..0837324921a3 --- /dev/null +++ b/packages/datadog-api-client-v2/apis/IntakeKeyApi.ts @@ -0,0 +1,159 @@ +import { BaseAPIRequestFactory } from "../../datadog-api-client-common/baseapi"; +import { Configuration } from "../../datadog-api-client-common/configuration"; +import { + RequestContext, + HttpMethod, + ResponseContext, +} from "../../datadog-api-client-common/http/http"; + +import { logger } from "../../../logger"; +import { ObjectSerializer } from "../models/ObjectSerializer"; +import { ApiException } from "../../datadog-api-client-common/exception"; + +import { APIErrorResponse } from "../models/APIErrorResponse"; +import { IntakeAPIKeyResponse } from "../models/IntakeAPIKeyResponse"; +import { JSONAPIErrorResponse } from "../models/JSONAPIErrorResponse"; + +export class IntakeKeyApiRequestFactory extends BaseAPIRequestFactory { + public async getIntakeKey(_options?: Configuration): Promise { + const _config = _options || this.configuration; + + // Path Params + const localVarPath = "/api/v2/intake-key"; + + // Make Request Context + const requestContext = _config + .getServer("v2.IntakeKeyApi.getIntakeKey") + .makeRequestContext(localVarPath, HttpMethod.POST); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + return requestContext; + } +} + +export class IntakeKeyApiResponseProcessor { + /** + * Unwraps the actual response sent by the server from the response context and deserializes the response content + * to the expected objects + * + * @params response Response returned by the server for a request to getIntakeKey + * @throws ApiException if the response code was not in [200, 299] + */ + public async getIntakeKey( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: IntakeAPIKeyResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "IntakeAPIKeyResponse" + ) as IntakeAPIKeyResponse; + return body; + } + if (response.httpStatusCode === 401 || response.httpStatusCode === 403) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: JSONAPIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "JSONAPIErrorResponse" + ) as JSONAPIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException( + response.httpStatusCode, + body + ); + } + if (response.httpStatusCode === 429) { + const bodyText = ObjectSerializer.parse( + await response.body.text(), + contentType + ); + let body: APIErrorResponse; + try { + body = ObjectSerializer.deserialize( + bodyText, + "APIErrorResponse" + ) as APIErrorResponse; + } catch (error) { + logger.debug(`Got error deserializing error: ${error}`); + throw new ApiException( + response.httpStatusCode, + bodyText + ); + } + throw new ApiException(response.httpStatusCode, body); + } + + // Work around for missing responses in specification, e.g. for petstore.yaml + if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) { + const body: IntakeAPIKeyResponse = ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "IntakeAPIKeyResponse", + "" + ) as IntakeAPIKeyResponse; + return body; + } + + const body = (await response.body.text()) || ""; + throw new ApiException( + response.httpStatusCode, + 'Unknown API Status Code!\nBody: "' + body + '"' + ); + } +} + +export class IntakeKeyApi { + private requestFactory: IntakeKeyApiRequestFactory; + private responseProcessor: IntakeKeyApiResponseProcessor; + private configuration: Configuration; + + public constructor( + configuration: Configuration, + requestFactory?: IntakeKeyApiRequestFactory, + responseProcessor?: IntakeKeyApiResponseProcessor + ) { + this.configuration = configuration; + this.requestFactory = + requestFactory || new IntakeKeyApiRequestFactory(configuration); + this.responseProcessor = + responseProcessor || new IntakeKeyApiResponseProcessor(); + } + + /** + * Exchanges a Workload Identity Federation (WIF) identity proof for a Datadog API key associated with the matching WIF intake mapping. + * + * Pass a cloud-provider token in the `Authorization` header using the `Bearer` or `Delegated` scheme. + * The token is validated against the WIF intake mappings configured for the caller's organization. On success, + * a managed-rotation API key is returned that the workload can use to send telemetry to Datadog. + * + * Unlike the delegated-token endpoint (`POST /api/v2/delegated-token`), this endpoint authenticates + * the cloud workload at the organization level rather than mapping it to a specific Datadog user. + * + * Standard Datadog API and application key authentication is not accepted. Authenticate using a + * cloud-provider token in the `Authorization: Bearer` header. + * @param param The request object + */ + public getIntakeKey(options?: Configuration): Promise { + const requestContextPromise = this.requestFactory.getIntakeKey(options); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.getIntakeKey(responseContext); + }); + }); + } +} diff --git a/packages/datadog-api-client-v2/index.ts b/packages/datadog-api-client-v2/index.ts index e63334fa3afa..c0a0f3180b58 100644 --- a/packages/datadog-api-client-v2/index.ts +++ b/packages/datadog-api-client-v2/index.ts @@ -42,6 +42,16 @@ export { export { AWSLogsIntegrationApi } from "./apis/AWSLogsIntegrationApi"; +export { + AWSWIFApiCreateAwsWifIntakeMappingRequest, + AWSWIFApiCreateAwsWifPersonaMappingRequest, + AWSWIFApiDeleteAwsWifIntakeMappingRequest, + AWSWIFApiDeleteAwsWifPersonaMappingRequest, + AWSWIFApiGetAwsWifIntakeMappingRequest, + AWSWIFApiGetAwsWifPersonaMappingRequest, + AWSWIFApi, +} from "./apis/AWSWIFApi"; + export { ActionConnectionApiCreateActionConnectionRequest, ActionConnectionApiDeleteActionConnectionRequest, @@ -489,6 +499,8 @@ export { DatasetsApi, } from "./apis/DatasetsApi"; +export { DelegatedTokenApi } from "./apis/DelegatedTokenApi"; + export { DeploymentGatesApiCreateDeploymentGateRequest, DeploymentGatesApiCreateDeploymentRuleRequest, @@ -716,6 +728,8 @@ export { IncidentsApi, } from "./apis/IncidentsApi"; +export { IntakeKeyApi } from "./apis/IntakeKeyApi"; + export { IntegrationsApi } from "./apis/IntegrationsApi"; export { @@ -2320,6 +2334,21 @@ export { AwsScanOptionsUpdateAttributes } from "./models/AwsScanOptionsUpdateAtt export { AwsScanOptionsUpdateData } from "./models/AwsScanOptionsUpdateData"; export { AwsScanOptionsUpdateRequest } from "./models/AwsScanOptionsUpdateRequest"; export { AWSTracesConfig } from "./models/AWSTracesConfig"; +export { AwsWifIntakeMappingAttributes } from "./models/AwsWifIntakeMappingAttributes"; +export { AwsWifIntakeMappingCreateData } from "./models/AwsWifIntakeMappingCreateData"; +export { AwsWifIntakeMappingCreateRequest } from "./models/AwsWifIntakeMappingCreateRequest"; +export { AwsWifIntakeMappingData } from "./models/AwsWifIntakeMappingData"; +export { AwsWifIntakeMappingResponse } from "./models/AwsWifIntakeMappingResponse"; +export { AwsWifIntakeMappingsResponse } from "./models/AwsWifIntakeMappingsResponse"; +export { AwsWifIntakeMappingType } from "./models/AwsWifIntakeMappingType"; +export { AwsWifPersonaMappingAttributes } from "./models/AwsWifPersonaMappingAttributes"; +export { AwsWifPersonaMappingCreateAttributes } from "./models/AwsWifPersonaMappingCreateAttributes"; +export { AwsWifPersonaMappingCreateData } from "./models/AwsWifPersonaMappingCreateData"; +export { AwsWifPersonaMappingCreateRequest } from "./models/AwsWifPersonaMappingCreateRequest"; +export { AwsWifPersonaMappingData } from "./models/AwsWifPersonaMappingData"; +export { AwsWifPersonaMappingResponse } from "./models/AwsWifPersonaMappingResponse"; +export { AwsWifPersonaMappingsResponse } from "./models/AwsWifPersonaMappingsResponse"; +export { AwsWifPersonaMappingType } from "./models/AwsWifPersonaMappingType"; export { AzureCredentials } from "./models/AzureCredentials"; export { AzureCredentialsUpdate } from "./models/AzureCredentialsUpdate"; export { AzureIntegration } from "./models/AzureIntegration"; @@ -3362,6 +3391,10 @@ export { DegradationDataRelationshipsLastModifiedByUserData } from "./models/Deg export { DegradationDataRelationshipsStatusPage } from "./models/DegradationDataRelationshipsStatusPage"; export { DegradationDataRelationshipsStatusPageData } from "./models/DegradationDataRelationshipsStatusPageData"; export { DegradationIncluded } from "./models/DegradationIncluded"; +export { DelegatedTokenAttributes } from "./models/DelegatedTokenAttributes"; +export { DelegatedTokenData } from "./models/DelegatedTokenData"; +export { DelegatedTokenResponse } from "./models/DelegatedTokenResponse"; +export { DelegatedTokenType } from "./models/DelegatedTokenType"; export { DeleteAppResponse } from "./models/DeleteAppResponse"; export { DeleteAppResponseData } from "./models/DeleteAppResponseData"; export { DeleteAppsDatastoreItemRequest } from "./models/DeleteAppsDatastoreItemRequest"; @@ -4374,6 +4407,10 @@ export { IncludeType } from "./models/IncludeType"; export { InputSchema } from "./models/InputSchema"; export { InputSchemaParameters } from "./models/InputSchemaParameters"; export { InputSchemaParametersType } from "./models/InputSchemaParametersType"; +export { IntakeAPIKeyAttributes } from "./models/IntakeAPIKeyAttributes"; +export { IntakeAPIKeyData } from "./models/IntakeAPIKeyData"; +export { IntakeAPIKeyResponse } from "./models/IntakeAPIKeyResponse"; +export { IntakeAPIKeyType } from "./models/IntakeAPIKeyType"; export { IntakePayloadAccepted } from "./models/IntakePayloadAccepted"; export { Integration } from "./models/Integration"; export { IntegrationAttributes } from "./models/IntegrationAttributes"; diff --git a/packages/datadog-api-client-v2/models/AwsWifIntakeMappingAttributes.ts b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingAttributes.ts new file mode 100644 index 000000000000..99c157cf839d --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingAttributes.ts @@ -0,0 +1,54 @@ +/** + * 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. + */ + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Attributes of an AWS WIF intake mapping. + */ +export class AwsWifIntakeMappingAttributes { + /** + * The AWS IAM ARN pattern identifying the role or user permitted to obtain an intake API key. + * Supports wildcards (`*`) to match multiple principals within an account. + */ + "arnPattern": string; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + arnPattern: { + baseName: "arn_pattern", + type: "string", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return AwsWifIntakeMappingAttributes.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/AwsWifIntakeMappingCreateData.ts b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingCreateData.ts new file mode 100644 index 000000000000..e49b345b9b1a --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingCreateData.ts @@ -0,0 +1,64 @@ +/** + * 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. + */ +import { AwsWifIntakeMappingAttributes } from "./AwsWifIntakeMappingAttributes"; +import { AwsWifIntakeMappingType } from "./AwsWifIntakeMappingType"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Data for creating an AWS WIF intake mapping. + */ +export class AwsWifIntakeMappingCreateData { + /** + * Attributes of an AWS WIF intake mapping. + */ + "attributes": AwsWifIntakeMappingAttributes; + /** + * Type identifier for an AWS WIF intake mapping. + */ + "type": AwsWifIntakeMappingType; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + attributes: { + baseName: "attributes", + type: "AwsWifIntakeMappingAttributes", + required: true, + }, + type: { + baseName: "type", + type: "AwsWifIntakeMappingType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return AwsWifIntakeMappingCreateData.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/AwsWifIntakeMappingCreateRequest.ts b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingCreateRequest.ts new file mode 100644 index 000000000000..f4321fd5dabc --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingCreateRequest.ts @@ -0,0 +1,54 @@ +/** + * 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. + */ +import { AwsWifIntakeMappingCreateData } from "./AwsWifIntakeMappingCreateData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Request body for creating an AWS WIF intake mapping. + */ +export class AwsWifIntakeMappingCreateRequest { + /** + * Data for creating an AWS WIF intake mapping. + */ + "data": AwsWifIntakeMappingCreateData; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + data: { + baseName: "data", + type: "AwsWifIntakeMappingCreateData", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return AwsWifIntakeMappingCreateRequest.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/AwsWifIntakeMappingData.ts b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingData.ts new file mode 100644 index 000000000000..fccfc3f5caa3 --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingData.ts @@ -0,0 +1,74 @@ +/** + * 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. + */ +import { AwsWifIntakeMappingAttributes } from "./AwsWifIntakeMappingAttributes"; +import { AwsWifIntakeMappingType } from "./AwsWifIntakeMappingType"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * An AWS WIF intake mapping resource. + */ +export class AwsWifIntakeMappingData { + /** + * Attributes of an AWS WIF intake mapping. + */ + "attributes": AwsWifIntakeMappingAttributes; + /** + * The UUID of the intake mapping. + */ + "id": string; + /** + * Type identifier for an AWS WIF intake mapping. + */ + "type": AwsWifIntakeMappingType; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + attributes: { + baseName: "attributes", + type: "AwsWifIntakeMappingAttributes", + required: true, + }, + id: { + baseName: "id", + type: "string", + required: true, + format: "uuid", + }, + type: { + baseName: "type", + type: "AwsWifIntakeMappingType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return AwsWifIntakeMappingData.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/AwsWifIntakeMappingResponse.ts b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingResponse.ts new file mode 100644 index 000000000000..1e5158feeea3 --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingResponse.ts @@ -0,0 +1,54 @@ +/** + * 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. + */ +import { AwsWifIntakeMappingData } from "./AwsWifIntakeMappingData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Response containing a single AWS WIF intake mapping. + */ +export class AwsWifIntakeMappingResponse { + /** + * An AWS WIF intake mapping resource. + */ + "data": AwsWifIntakeMappingData; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + data: { + baseName: "data", + type: "AwsWifIntakeMappingData", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return AwsWifIntakeMappingResponse.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/AwsWifIntakeMappingType.ts b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingType.ts new file mode 100644 index 000000000000..4612f8db5636 --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingType.ts @@ -0,0 +1,16 @@ +/** + * 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. + */ + +import { UnparsedObject } from "../../datadog-api-client-common/util"; + +/** + * Type identifier for an AWS WIF intake mapping. + */ + +export type AwsWifIntakeMappingType = + | typeof AWS_WIF_INTAKE_MAPPING + | UnparsedObject; +export const AWS_WIF_INTAKE_MAPPING = "aws_wif_intake_mapping"; diff --git a/packages/datadog-api-client-v2/models/AwsWifIntakeMappingsResponse.ts b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingsResponse.ts new file mode 100644 index 000000000000..28bdb4e0e614 --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifIntakeMappingsResponse.ts @@ -0,0 +1,51 @@ +/** + * 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. + */ +import { AwsWifIntakeMappingData } from "./AwsWifIntakeMappingData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Response containing a list of AWS WIF intake mappings. + */ +export class AwsWifIntakeMappingsResponse { + "data": Array; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + data: { + baseName: "data", + type: "Array", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return AwsWifIntakeMappingsResponse.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/AwsWifPersonaMappingAttributes.ts b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingAttributes.ts new file mode 100644 index 000000000000..e65147a7d42f --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingAttributes.ts @@ -0,0 +1,72 @@ +/** + * 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. + */ + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Attributes of an AWS WIF persona mapping. + */ +export class AwsWifPersonaMappingAttributes { + /** + * The Datadog user handle (email address) to map the AWS principal to. + */ + "accountIdentifier": string; + /** + * The Datadog user UUID corresponding to `account_identifier`. Read-only — set by the server. + */ + "accountUuid"?: string; + /** + * The AWS IAM ARN pattern identifying the role or user that will be mapped. + * Supports wildcards (`*`) to match multiple principals within an account. + */ + "arnPattern": string; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + accountIdentifier: { + baseName: "account_identifier", + type: "string", + required: true, + }, + accountUuid: { + baseName: "account_uuid", + type: "string", + format: "uuid", + }, + arnPattern: { + baseName: "arn_pattern", + type: "string", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return AwsWifPersonaMappingAttributes.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/AwsWifPersonaMappingCreateAttributes.ts b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingCreateAttributes.ts new file mode 100644 index 000000000000..8681df83fb31 --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingCreateAttributes.ts @@ -0,0 +1,63 @@ +/** + * 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. + */ + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Attributes for creating an AWS WIF persona mapping. + */ +export class AwsWifPersonaMappingCreateAttributes { + /** + * The Datadog user handle (email address) to map the AWS principal to. + */ + "accountIdentifier": string; + /** + * The AWS IAM ARN pattern identifying the role or user that will be mapped. + * Supports wildcards (`*`) to match multiple principals within an account. + */ + "arnPattern": string; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + accountIdentifier: { + baseName: "account_identifier", + type: "string", + required: true, + }, + arnPattern: { + baseName: "arn_pattern", + type: "string", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return AwsWifPersonaMappingCreateAttributes.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/AwsWifPersonaMappingCreateData.ts b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingCreateData.ts new file mode 100644 index 000000000000..7df948c42b82 --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingCreateData.ts @@ -0,0 +1,64 @@ +/** + * 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. + */ +import { AwsWifPersonaMappingCreateAttributes } from "./AwsWifPersonaMappingCreateAttributes"; +import { AwsWifPersonaMappingType } from "./AwsWifPersonaMappingType"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Data for creating an AWS WIF persona mapping. + */ +export class AwsWifPersonaMappingCreateData { + /** + * Attributes for creating an AWS WIF persona mapping. + */ + "attributes": AwsWifPersonaMappingCreateAttributes; + /** + * Type identifier for an AWS WIF persona mapping. + */ + "type": AwsWifPersonaMappingType; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + attributes: { + baseName: "attributes", + type: "AwsWifPersonaMappingCreateAttributes", + required: true, + }, + type: { + baseName: "type", + type: "AwsWifPersonaMappingType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return AwsWifPersonaMappingCreateData.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/AwsWifPersonaMappingCreateRequest.ts b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingCreateRequest.ts new file mode 100644 index 000000000000..7bfc5b3fef2e --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingCreateRequest.ts @@ -0,0 +1,54 @@ +/** + * 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. + */ +import { AwsWifPersonaMappingCreateData } from "./AwsWifPersonaMappingCreateData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Request body for creating an AWS WIF persona mapping. + */ +export class AwsWifPersonaMappingCreateRequest { + /** + * Data for creating an AWS WIF persona mapping. + */ + "data": AwsWifPersonaMappingCreateData; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + data: { + baseName: "data", + type: "AwsWifPersonaMappingCreateData", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return AwsWifPersonaMappingCreateRequest.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/AwsWifPersonaMappingData.ts b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingData.ts new file mode 100644 index 000000000000..66d1d010c5b4 --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingData.ts @@ -0,0 +1,74 @@ +/** + * 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. + */ +import { AwsWifPersonaMappingAttributes } from "./AwsWifPersonaMappingAttributes"; +import { AwsWifPersonaMappingType } from "./AwsWifPersonaMappingType"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * An AWS WIF persona mapping resource. + */ +export class AwsWifPersonaMappingData { + /** + * Attributes of an AWS WIF persona mapping. + */ + "attributes": AwsWifPersonaMappingAttributes; + /** + * The UUID of the persona mapping. + */ + "id": string; + /** + * Type identifier for an AWS WIF persona mapping. + */ + "type": AwsWifPersonaMappingType; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + attributes: { + baseName: "attributes", + type: "AwsWifPersonaMappingAttributes", + required: true, + }, + id: { + baseName: "id", + type: "string", + required: true, + format: "uuid", + }, + type: { + baseName: "type", + type: "AwsWifPersonaMappingType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return AwsWifPersonaMappingData.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/AwsWifPersonaMappingResponse.ts b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingResponse.ts new file mode 100644 index 000000000000..aa0014e3773c --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingResponse.ts @@ -0,0 +1,54 @@ +/** + * 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. + */ +import { AwsWifPersonaMappingData } from "./AwsWifPersonaMappingData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Response containing a single AWS WIF persona mapping. + */ +export class AwsWifPersonaMappingResponse { + /** + * An AWS WIF persona mapping resource. + */ + "data": AwsWifPersonaMappingData; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + data: { + baseName: "data", + type: "AwsWifPersonaMappingData", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return AwsWifPersonaMappingResponse.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/AwsWifPersonaMappingType.ts b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingType.ts new file mode 100644 index 000000000000..f37d12c472a5 --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingType.ts @@ -0,0 +1,14 @@ +/** + * 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. + */ + +import { UnparsedObject } from "../../datadog-api-client-common/util"; + +/** + * Type identifier for an AWS WIF persona mapping. + */ + +export type AwsWifPersonaMappingType = typeof AWS_WIF_CONFIG | UnparsedObject; +export const AWS_WIF_CONFIG = "aws_wif_config"; diff --git a/packages/datadog-api-client-v2/models/AwsWifPersonaMappingsResponse.ts b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingsResponse.ts new file mode 100644 index 000000000000..6cbf19e7196f --- /dev/null +++ b/packages/datadog-api-client-v2/models/AwsWifPersonaMappingsResponse.ts @@ -0,0 +1,51 @@ +/** + * 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. + */ +import { AwsWifPersonaMappingData } from "./AwsWifPersonaMappingData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Response containing a list of AWS WIF persona mappings. + */ +export class AwsWifPersonaMappingsResponse { + "data": Array; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + data: { + baseName: "data", + type: "Array", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return AwsWifPersonaMappingsResponse.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/DelegatedTokenAttributes.ts b/packages/datadog-api-client-v2/models/DelegatedTokenAttributes.ts new file mode 100644 index 000000000000..4b6193f589d3 --- /dev/null +++ b/packages/datadog-api-client-v2/models/DelegatedTokenAttributes.ts @@ -0,0 +1,63 @@ +/** + * 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. + */ + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Attributes of a delegated token. + */ +export class DelegatedTokenAttributes { + /** + * A short-lived JWT representing the authenticated Datadog user. Pass this as a bearer token in subsequent API calls. + */ + "accessToken": string; + /** + * The expiry time of the token. + */ + "expires": Date; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + accessToken: { + baseName: "access_token", + type: "string", + required: true, + }, + expires: { + baseName: "expires", + type: "Date", + required: true, + format: "date-time", + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return DelegatedTokenAttributes.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/DelegatedTokenData.ts b/packages/datadog-api-client-v2/models/DelegatedTokenData.ts new file mode 100644 index 000000000000..d54bba8b6918 --- /dev/null +++ b/packages/datadog-api-client-v2/models/DelegatedTokenData.ts @@ -0,0 +1,74 @@ +/** + * 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. + */ +import { DelegatedTokenAttributes } from "./DelegatedTokenAttributes"; +import { DelegatedTokenType } from "./DelegatedTokenType"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * A delegated token resource. + */ +export class DelegatedTokenData { + /** + * Attributes of a delegated token. + */ + "attributes": DelegatedTokenAttributes; + /** + * A random UUID assigned to this token issuance. + */ + "id": string; + /** + * The resource type for a delegated token. + */ + "type": DelegatedTokenType; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + attributes: { + baseName: "attributes", + type: "DelegatedTokenAttributes", + required: true, + }, + id: { + baseName: "id", + type: "string", + required: true, + format: "uuid", + }, + type: { + baseName: "type", + type: "DelegatedTokenType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return DelegatedTokenData.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/DelegatedTokenResponse.ts b/packages/datadog-api-client-v2/models/DelegatedTokenResponse.ts new file mode 100644 index 000000000000..287d3ce5de8c --- /dev/null +++ b/packages/datadog-api-client-v2/models/DelegatedTokenResponse.ts @@ -0,0 +1,54 @@ +/** + * 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. + */ +import { DelegatedTokenData } from "./DelegatedTokenData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Response containing a delegated user token. + */ +export class DelegatedTokenResponse { + /** + * A delegated token resource. + */ + "data": DelegatedTokenData; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + data: { + baseName: "data", + type: "DelegatedTokenData", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return DelegatedTokenResponse.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/DelegatedTokenType.ts b/packages/datadog-api-client-v2/models/DelegatedTokenType.ts new file mode 100644 index 000000000000..6a405b618612 --- /dev/null +++ b/packages/datadog-api-client-v2/models/DelegatedTokenType.ts @@ -0,0 +1,14 @@ +/** + * 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. + */ + +import { UnparsedObject } from "../../datadog-api-client-common/util"; + +/** + * The resource type for a delegated token. + */ + +export type DelegatedTokenType = typeof TOKEN | UnparsedObject; +export const TOKEN = "token"; diff --git a/packages/datadog-api-client-v2/models/IntakeAPIKeyAttributes.ts b/packages/datadog-api-client-v2/models/IntakeAPIKeyAttributes.ts new file mode 100644 index 000000000000..22633dfb3fa7 --- /dev/null +++ b/packages/datadog-api-client-v2/models/IntakeAPIKeyAttributes.ts @@ -0,0 +1,63 @@ +/** + * 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. + */ + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Attributes of an intake API key returned after successful authentication. + */ +export class IntakeAPIKeyAttributes { + /** + * The Datadog API key the workload can use to send telemetry. + */ + "apiKey": string; + /** + * The numeric ID of the Datadog organization the API key belongs to. + */ + "orgId": number; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + apiKey: { + baseName: "api_key", + type: "string", + required: true, + }, + orgId: { + baseName: "org_id", + type: "number", + required: true, + format: "int64", + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return IntakeAPIKeyAttributes.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/IntakeAPIKeyData.ts b/packages/datadog-api-client-v2/models/IntakeAPIKeyData.ts new file mode 100644 index 000000000000..6b577c53b642 --- /dev/null +++ b/packages/datadog-api-client-v2/models/IntakeAPIKeyData.ts @@ -0,0 +1,73 @@ +/** + * 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. + */ +import { IntakeAPIKeyAttributes } from "./IntakeAPIKeyAttributes"; +import { IntakeAPIKeyType } from "./IntakeAPIKeyType"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * An intake API key resource. + */ +export class IntakeAPIKeyData { + /** + * Attributes of an intake API key returned after successful authentication. + */ + "attributes": IntakeAPIKeyAttributes; + /** + * A stable identifier for the intake key, scoped to the matched organization. + */ + "id": string; + /** + * The resource type for an intake API key. + */ + "type": IntakeAPIKeyType; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + attributes: { + baseName: "attributes", + type: "IntakeAPIKeyAttributes", + required: true, + }, + id: { + baseName: "id", + type: "string", + required: true, + }, + type: { + baseName: "type", + type: "IntakeAPIKeyType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return IntakeAPIKeyData.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/IntakeAPIKeyResponse.ts b/packages/datadog-api-client-v2/models/IntakeAPIKeyResponse.ts new file mode 100644 index 000000000000..54b310dc82a0 --- /dev/null +++ b/packages/datadog-api-client-v2/models/IntakeAPIKeyResponse.ts @@ -0,0 +1,54 @@ +/** + * 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. + */ +import { IntakeAPIKeyData } from "./IntakeAPIKeyData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Response containing an intake API key for the authenticated cloud workload. + */ +export class IntakeAPIKeyResponse { + /** + * An intake API key resource. + */ + "data": IntakeAPIKeyData; + + /** + * A container for additional, undeclared properties. + * This is a holder for any undeclared properties as specified with + * the 'additionalProperties' keyword in the OAS document. + */ + "additionalProperties"?: { [key: string]: any }; + + /** + * @ignore + */ + "_unparsed"?: boolean; + + /** + * @ignore + */ + static readonly attributeTypeMap: AttributeTypeMap = { + data: { + baseName: "data", + type: "IntakeAPIKeyData", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return IntakeAPIKeyResponse.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/IntakeAPIKeyType.ts b/packages/datadog-api-client-v2/models/IntakeAPIKeyType.ts new file mode 100644 index 000000000000..0512be466a18 --- /dev/null +++ b/packages/datadog-api-client-v2/models/IntakeAPIKeyType.ts @@ -0,0 +1,14 @@ +/** + * 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. + */ + +import { UnparsedObject } from "../../datadog-api-client-common/util"; + +/** + * The resource type for an intake API key. + */ + +export type IntakeAPIKeyType = typeof INTAKE_API_KEY | UnparsedObject; +export const INTAKE_API_KEY = "intake_api_key"; diff --git a/packages/datadog-api-client-v2/models/ObjectSerializer.ts b/packages/datadog-api-client-v2/models/ObjectSerializer.ts index 26c048d84a1d..120886e7c5a6 100644 --- a/packages/datadog-api-client-v2/models/ObjectSerializer.ts +++ b/packages/datadog-api-client-v2/models/ObjectSerializer.ts @@ -429,6 +429,19 @@ import { AwsScanOptionsResponse } from "./AwsScanOptionsResponse"; import { AwsScanOptionsUpdateAttributes } from "./AwsScanOptionsUpdateAttributes"; import { AwsScanOptionsUpdateData } from "./AwsScanOptionsUpdateData"; import { AwsScanOptionsUpdateRequest } from "./AwsScanOptionsUpdateRequest"; +import { AwsWifIntakeMappingAttributes } from "./AwsWifIntakeMappingAttributes"; +import { AwsWifIntakeMappingCreateData } from "./AwsWifIntakeMappingCreateData"; +import { AwsWifIntakeMappingCreateRequest } from "./AwsWifIntakeMappingCreateRequest"; +import { AwsWifIntakeMappingData } from "./AwsWifIntakeMappingData"; +import { AwsWifIntakeMappingResponse } from "./AwsWifIntakeMappingResponse"; +import { AwsWifIntakeMappingsResponse } from "./AwsWifIntakeMappingsResponse"; +import { AwsWifPersonaMappingAttributes } from "./AwsWifPersonaMappingAttributes"; +import { AwsWifPersonaMappingCreateAttributes } from "./AwsWifPersonaMappingCreateAttributes"; +import { AwsWifPersonaMappingCreateData } from "./AwsWifPersonaMappingCreateData"; +import { AwsWifPersonaMappingCreateRequest } from "./AwsWifPersonaMappingCreateRequest"; +import { AwsWifPersonaMappingData } from "./AwsWifPersonaMappingData"; +import { AwsWifPersonaMappingResponse } from "./AwsWifPersonaMappingResponse"; +import { AwsWifPersonaMappingsResponse } from "./AwsWifPersonaMappingsResponse"; import { AzureIntegration } from "./AzureIntegration"; import { AzureIntegrationUpdate } from "./AzureIntegrationUpdate"; import { AzureScanOptions } from "./AzureScanOptions"; @@ -1274,6 +1287,9 @@ import { DegradationDataRelationshipsLastModifiedByUser } from "./DegradationDat import { DegradationDataRelationshipsLastModifiedByUserData } from "./DegradationDataRelationshipsLastModifiedByUserData"; import { DegradationDataRelationshipsStatusPage } from "./DegradationDataRelationshipsStatusPage"; import { DegradationDataRelationshipsStatusPageData } from "./DegradationDataRelationshipsStatusPageData"; +import { DelegatedTokenAttributes } from "./DelegatedTokenAttributes"; +import { DelegatedTokenData } from "./DelegatedTokenData"; +import { DelegatedTokenResponse } from "./DelegatedTokenResponse"; import { DeleteAppResponse } from "./DeleteAppResponse"; import { DeleteAppResponseData } from "./DeleteAppResponseData"; import { DeleteAppsDatastoreItemRequest } from "./DeleteAppsDatastoreItemRequest"; @@ -2049,6 +2065,9 @@ import { IncidentUserDefinedFieldValidValue } from "./IncidentUserDefinedFieldVa import { IncidentsResponse } from "./IncidentsResponse"; import { InputSchema } from "./InputSchema"; import { InputSchemaParameters } from "./InputSchemaParameters"; +import { IntakeAPIKeyAttributes } from "./IntakeAPIKeyAttributes"; +import { IntakeAPIKeyData } from "./IntakeAPIKeyData"; +import { IntakeAPIKeyResponse } from "./IntakeAPIKeyResponse"; import { IntakePayloadAccepted } from "./IntakePayloadAccepted"; import { Integration } from "./Integration"; import { IntegrationAttributes } from "./IntegrationAttributes"; @@ -5388,6 +5407,8 @@ const enumsMap: { [key: string]: any[] } = { AwsCurConfigResponseDataType: ["aws_cur_config"], AwsOnDemandType: ["aws_resource"], AwsScanOptionsType: ["aws_scan_options"], + AwsWifIntakeMappingType: ["aws_wif_intake_mapping"], + AwsWifPersonaMappingType: ["aws_wif_config"], AzureIntegrationType: ["Azure"], AzureScanOptionsDataType: ["azure_scan_options"], AzureScanOptionsInputUpdateDataType: ["azure_scan_options"], @@ -5746,6 +5767,7 @@ const enumsMap: { [key: string]: any[] } = { DatastorePrimaryKeyGenerationStrategy: ["none", "uuid"], DefaultRulesetsPerLanguageDataType: ["defaultRulesetsPerLanguage"], DegradationDataAttributesSourceType: ["incident"], + DelegatedTokenType: ["token"], DeletedSuitesRequestType: ["delete_suites_request"], DeletedTestsRequestType: ["delete_tests_request"], DeletedTestsResponseType: ["delete_tests"], @@ -6092,6 +6114,7 @@ const enumsMap: { [key: string]: any[] } = { "ARRAY_BOOLEAN", "ARRAY_OBJECT", ], + IntakeAPIKeyType: ["intake_api_key"], IntegrationType: ["integration"], InterfaceAttributesStatus: ["up", "down", "warning", "off"], InvestigationType: ["investigation"], @@ -8393,6 +8416,19 @@ const typeMap: { [index: string]: any } = { AwsScanOptionsUpdateAttributes: AwsScanOptionsUpdateAttributes, AwsScanOptionsUpdateData: AwsScanOptionsUpdateData, AwsScanOptionsUpdateRequest: AwsScanOptionsUpdateRequest, + AwsWifIntakeMappingAttributes: AwsWifIntakeMappingAttributes, + AwsWifIntakeMappingCreateData: AwsWifIntakeMappingCreateData, + AwsWifIntakeMappingCreateRequest: AwsWifIntakeMappingCreateRequest, + AwsWifIntakeMappingData: AwsWifIntakeMappingData, + AwsWifIntakeMappingResponse: AwsWifIntakeMappingResponse, + AwsWifIntakeMappingsResponse: AwsWifIntakeMappingsResponse, + AwsWifPersonaMappingAttributes: AwsWifPersonaMappingAttributes, + AwsWifPersonaMappingCreateAttributes: AwsWifPersonaMappingCreateAttributes, + AwsWifPersonaMappingCreateData: AwsWifPersonaMappingCreateData, + AwsWifPersonaMappingCreateRequest: AwsWifPersonaMappingCreateRequest, + AwsWifPersonaMappingData: AwsWifPersonaMappingData, + AwsWifPersonaMappingResponse: AwsWifPersonaMappingResponse, + AwsWifPersonaMappingsResponse: AwsWifPersonaMappingsResponse, AzureIntegration: AzureIntegration, AzureIntegrationUpdate: AzureIntegrationUpdate, AzureScanOptions: AzureScanOptions, @@ -9384,6 +9420,9 @@ const typeMap: { [index: string]: any } = { DegradationDataRelationshipsStatusPage, DegradationDataRelationshipsStatusPageData: DegradationDataRelationshipsStatusPageData, + DelegatedTokenAttributes: DelegatedTokenAttributes, + DelegatedTokenData: DelegatedTokenData, + DelegatedTokenResponse: DelegatedTokenResponse, DeleteAppResponse: DeleteAppResponse, DeleteAppResponseData: DeleteAppResponseData, DeleteAppsDatastoreItemRequest: DeleteAppsDatastoreItemRequest, @@ -10272,6 +10311,9 @@ const typeMap: { [index: string]: any } = { IncidentsResponse: IncidentsResponse, InputSchema: InputSchema, InputSchemaParameters: InputSchemaParameters, + IntakeAPIKeyAttributes: IntakeAPIKeyAttributes, + IntakeAPIKeyData: IntakeAPIKeyData, + IntakeAPIKeyResponse: IntakeAPIKeyResponse, IntakePayloadAccepted: IntakePayloadAccepted, Integration: Integration, IntegrationAttributes: IntegrationAttributes,