diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 07cf64fab0e1..43bf54300d5b 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -467,6 +467,13 @@ components: required: false schema: $ref: '#/components/schemas/RelationType' + FilterStatusQueryParameter: + description: Filter subscriptions by status. + in: query + name: filter[status] + required: false + schema: + $ref: '#/components/schemas/StatusPageEmailSubscriptionStatus' FromTimestamp: description: The starting timestamp for the SLO status query in epoch seconds. in: query @@ -844,6 +851,26 @@ components: example: f9ec96b0-8c8a-4b0a-9b0a-1b2c3d4e5f6a format: uuid type: string + PageIDPathParameter: + description: The ID of the status page. + in: path + name: page_id + required: true + schema: + example: ed50804f-f823-4d2c-ba56-c998cbd0ae0a + format: uuid + type: string + PageLimitQueryParameter: + description: The maximum number of items to return per page. + in: query + name: page[limit] + required: false + schema: + default: 1000 + example: 1000 + format: int64 + maximum: 1000 + type: integer PageNumber: description: Specific page number to return. in: query @@ -864,6 +891,16 @@ components: example: 0 format: int64 type: integer + PageOffsetQueryParameter: + description: The offset for pagination. + in: query + name: page[offset] + required: false + schema: + default: 0 + example: 0 + format: int64 + type: integer PageSize: description: Size for a given page. The maximum allowed value is 100. in: query @@ -1152,6 +1189,26 @@ components: schema: example: 00000000-0000-0000-0000-000000000000 type: string + SortQueryParameter: + description: Sort field for the list of subscriptions. Prefix with '-' for descending + order. + in: query + name: sort + required: false + schema: + default: created_at + enum: + - created_at + - -created_at + - modified_at + - -modified_at + example: created_at + type: string + x-enum-varnames: + - CREATED_AT + - NOT_CREATED_AT + - MODIFIED_AT + - NOT_MODIFIED_AT SpansMetricIDParameter: description: The name of the span-based metric. in: path @@ -60623,6 +60680,15 @@ components: - type - id type: object + StatusPageComponentType: + default: status_page_components + description: Status page component resource type. + enum: + - status_page_components + example: status_page_components + type: string + x-enum-varnames: + - STATUS_PAGE_COMPONENTS StatusPageData: properties: attributes: @@ -60795,6 +60861,258 @@ components: type: string x-enum-varnames: - STATUS_PAGES + StatusPageEmailSubscriptionRequest: + description: Request to create an email subscription. + properties: + data: + $ref: '#/components/schemas/StatusPageEmailSubscriptionRequestData' + required: + - data + type: object + StatusPageEmailSubscriptionRequestAttributes: + description: The email subscription attributes for a request. + properties: + email_address: + description: The email address to subscribe. + example: test@example.com + type: string + required: + - email_address + type: object + StatusPageEmailSubscriptionRequestData: + description: Email subscription data for a request. + properties: + attributes: + $ref: '#/components/schemas/StatusPageEmailSubscriptionRequestAttributes' + relationships: + $ref: '#/components/schemas/StatusPageEmailSubscriptionRequestRelationships' + type: + $ref: '#/components/schemas/StatusPageEmailSubscriptionType' + required: + - type + - attributes + type: object + StatusPageEmailSubscriptionRequestRelationships: + description: The email subscription relationships for a request. + properties: + subscribed_components: + $ref: '#/components/schemas/StatusPageRelationshipSubscribedComponents' + type: object + StatusPageEmailSubscriptionResponse: + description: Response containing a single email subscription. + properties: + data: + $ref: '#/components/schemas/StatusPageEmailSubscriptionResponseData' + required: + - data + type: object + StatusPageEmailSubscriptionResponseAttributes: + description: The email subscription attributes from a response. + properties: + created_at: + description: Timestamp when the subscription was created. + example: '2026-01-13T17:18:16.290086Z' + format: date-time + type: string + email_address: + description: The email address subscribed to the status page. + example: test+active@example.com + type: string + modified_at: + description: Timestamp when the subscription was last modified. + example: '2026-01-13T17:18:16.290086Z' + format: date-time + type: string + status: + $ref: '#/components/schemas/StatusPageEmailSubscriptionStatus' + required: + - email_address + - status + - created_at + - modified_at + type: object + StatusPageEmailSubscriptionResponseData: + description: Email subscription data from a response. + properties: + attributes: + $ref: '#/components/schemas/StatusPageEmailSubscriptionResponseAttributes' + id: + description: The email subscription ID. + example: 19121f53-04ae-4913-a7fd-64bcc2f812c2 + format: uuid + type: string + relationships: + $ref: '#/components/schemas/StatusPageEmailSubscriptionResponseRelationships' + type: + $ref: '#/components/schemas/StatusPageEmailSubscriptionType' + required: + - id + - type + - attributes + - relationships + type: object + StatusPageEmailSubscriptionResponseRelationships: + description: The email subscription relationships from a response. + properties: + status_page: + $ref: '#/components/schemas/StatusPageRelationshipStatusPage' + subscribed_components: + $ref: '#/components/schemas/StatusPageRelationshipSubscribedComponents' + required: + - status_page + - subscribed_components + type: object + StatusPageEmailSubscriptionStatus: + description: Status of the email subscription. + enum: + - active + - unconfirmed + example: active + type: string + x-enum-varnames: + - ACTIVE + - UNCONFIRMED + StatusPageEmailSubscriptionType: + default: email_subscriptions + description: Status page email subscription resource type. + enum: + - email_subscriptions + example: email_subscriptions + type: string + x-enum-varnames: + - EMAIL_SUBSCRIPTIONS + StatusPageEmailSubscriptionsRequest: + description: Request to import multiple email subscriptions. + properties: + data: + description: List of email subscriptions to import. + items: + $ref: '#/components/schemas/StatusPageEmailSubscriptionRequestData' + type: array + required: + - data + type: object + StatusPageEmailSubscriptionsResponse: + description: Response containing a list of email subscriptions. + properties: + data: + description: List of email subscriptions. + items: + $ref: '#/components/schemas/StatusPageEmailSubscriptionResponseData' + type: array + meta: + $ref: '#/components/schemas/StatusPageEmailSubscriptionsResponseMeta' + required: + - data + - meta + type: object + StatusPageEmailSubscriptionsResponseMeta: + description: Metadata for the list of email subscriptions. + properties: + page: + $ref: '#/components/schemas/StatusPageEmailSubscriptionsResponseMetaPage' + required: + - page + type: object + StatusPageEmailSubscriptionsResponseMetaPage: + description: Pagination metadata. + properties: + first_offset: + description: The offset of the first page. + example: 0 + format: int64 + type: integer + last_offset: + description: The offset of the last page. + example: 0 + format: int64 + type: integer + limit: + description: The maximum number of items per page. + example: 1000 + format: int64 + type: integer + next_offset: + description: The offset of the next page. + example: null + format: int64 + nullable: true + type: integer + offset: + description: The current offset. + example: 0 + format: int64 + type: integer + prev_offset: + description: The offset of the previous page. + example: null + format: int64 + nullable: true + type: integer + total: + description: The total number of items. + example: 1 + format: int64 + type: integer + type: + description: The pagination type. + example: offset_limit + type: string + required: + - type + - offset + - limit + - total + - first_offset + - last_offset + type: object + StatusPageRelationshipStatusPage: + description: Relationship to the status page. + properties: + data: + $ref: '#/components/schemas/StatusPageRelationshipStatusPageData' + required: + - data + type: object + StatusPageRelationshipStatusPageData: + description: Status page relationship data. + properties: + id: + description: The status page ID. + example: ed50804f-f823-4d2c-ba56-c998cbd0ae0a + format: uuid + type: string + type: + $ref: '#/components/schemas/StatusPageDataType' + required: + - id + - type + type: object + StatusPageRelationshipSubscribedComponentData: + description: Subscribed component relationship data. + properties: + id: + description: The component ID. + example: 00000000-0000-0000-0000-000000000000 + format: uuid + type: string + type: + $ref: '#/components/schemas/StatusPageComponentType' + required: + - id + - type + type: object + StatusPageRelationshipSubscribedComponents: + description: Relationship to subscribed components. + properties: + data: + description: List of subscribed components. + items: + $ref: '#/components/schemas/StatusPageRelationshipSubscribedComponentData' + type: array + required: + - data + type: object StatusPagesComponent: properties: data: @@ -99146,6 +99464,48 @@ paths: operator: AND permissions: - status_pages_settings_read + /api/v2/statuspages/internal/{page_id}/subscriptions/email: + post: + description: Creates an internal email subscription for a status page. + operationId: CreateInternalEmailSubscription + parameters: + - $ref: '#/components/parameters/PageIDPathParameter' + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/StatusPageEmailSubscriptionRequest' + required: true + responses: + '201': + content: + application/json: + schema: + $ref: '#/components/schemas/StatusPageEmailSubscriptionResponse' + 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 + '429': + $ref: '#/components/responses/TooManyRequestsResponse' + security: + - apiKeyAuth: [] + appKeyAuth: [] + summary: Create an internal email subscription + tags: + - Status Pages + x-unstable: '**Note**: This endpoint is in preview and is subject to change. + + If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/).' /api/v2/statuspages/{page_id}: delete: description: Deletes a status page by its ID. @@ -99674,6 +100034,98 @@ paths: operator: AND permissions: - status_pages_incident_write + /api/v2/statuspages/{page_id}/subscriptions/email: + get: + description: Returns a list of email subscriptions for a status page. Supports + filtering by status and pagination. + operationId: ListEmailSubscriptions + parameters: + - $ref: '#/components/parameters/PageIDPathParameter' + - $ref: '#/components/parameters/FilterStatusQueryParameter' + - $ref: '#/components/parameters/PageOffsetQueryParameter' + - $ref: '#/components/parameters/PageLimitQueryParameter' + - $ref: '#/components/parameters/SortQueryParameter' + responses: + '200': + content: + application/json: + schema: + $ref: '#/components/schemas/StatusPageEmailSubscriptionsResponse' + 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: [] + summary: List email subscriptions + tags: + - Status Pages + x-unstable: '**Note**: This endpoint is in preview and is subject to change. + + If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/).' + /api/v2/statuspages/{page_id}/subscriptions/email/import: + post: + description: Imports multiple email subscriptions for a status page. Accepts + up to 1000 subscriptions at once. + operationId: ImportEmailSubscriptions + parameters: + - $ref: '#/components/parameters/PageIDPathParameter' + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/StatusPageEmailSubscriptionsRequest' + required: true + responses: + '201': + content: + application/json: + schema: + $ref: '#/components/schemas/StatusPageEmailSubscriptionsResponse' + description: Created + '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 + '429': + $ref: '#/components/responses/TooManyRequestsResponse' + security: + - apiKeyAuth: [] + appKeyAuth: [] + summary: Import email subscriptions + tags: + - Status Pages + x-unstable: '**Note**: This endpoint is in preview and is subject to change. + + If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/).' /api/v2/synthetics/settings/on_demand_concurrency_cap: get: description: Get the on-demand concurrency cap. diff --git a/examples/v2/status-pages/CreateInternalEmailSubscription.ts b/examples/v2/status-pages/CreateInternalEmailSubscription.ts new file mode 100644 index 000000000000..4954bd28e4eb --- /dev/null +++ b/examples/v2/status-pages/CreateInternalEmailSubscription.ts @@ -0,0 +1,40 @@ +/** + * Create an internal email subscription returns "Created" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +configuration.unstableOperations["v2.createInternalEmailSubscription"] = true; +const apiInstance = new v2.StatusPagesApi(configuration); + +const params: v2.StatusPagesApiCreateInternalEmailSubscriptionRequest = { + body: { + data: { + attributes: { + emailAddress: "test@example.com", + }, + relationships: { + subscribedComponents: { + data: [ + { + id: "00000000-0000-0000-0000-000000000000", + type: "status_page_components", + }, + ], + }, + }, + type: "email_subscriptions", + }, + }, + pageId: "ed50804f-f823-4d2c-ba56-c998cbd0ae0a", +}; + +apiInstance + .createInternalEmailSubscription(params) + .then((data: v2.StatusPageEmailSubscriptionResponse) => { + console.log( + "API called successfully. Returned data: " + JSON.stringify(data) + ); + }) + .catch((error: any) => console.error(error)); diff --git a/examples/v2/status-pages/ImportEmailSubscriptions.ts b/examples/v2/status-pages/ImportEmailSubscriptions.ts new file mode 100644 index 000000000000..9cdae3fc6714 --- /dev/null +++ b/examples/v2/status-pages/ImportEmailSubscriptions.ts @@ -0,0 +1,42 @@ +/** + * Import email subscriptions returns "No Content" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +configuration.unstableOperations["v2.importEmailSubscriptions"] = true; +const apiInstance = new v2.StatusPagesApi(configuration); + +const params: v2.StatusPagesApiImportEmailSubscriptionsRequest = { + body: { + data: [ + { + attributes: { + emailAddress: "test@example.com", + }, + relationships: { + subscribedComponents: { + data: [ + { + id: "00000000-0000-0000-0000-000000000000", + type: "status_page_components", + }, + ], + }, + }, + type: "email_subscriptions", + }, + ], + }, + pageId: "ed50804f-f823-4d2c-ba56-c998cbd0ae0a", +}; + +apiInstance + .importEmailSubscriptions(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/status-pages/ListEmailSubscriptions.ts b/examples/v2/status-pages/ListEmailSubscriptions.ts new file mode 100644 index 000000000000..f12b0d3865e2 --- /dev/null +++ b/examples/v2/status-pages/ListEmailSubscriptions.ts @@ -0,0 +1,22 @@ +/** + * List email subscriptions returns "OK" response + */ + +import { client, v2 } from "@datadog/datadog-api-client"; + +const configuration = client.createConfiguration(); +configuration.unstableOperations["v2.listEmailSubscriptions"] = true; +const apiInstance = new v2.StatusPagesApi(configuration); + +const params: v2.StatusPagesApiListEmailSubscriptionsRequest = { + pageId: "ed50804f-f823-4d2c-ba56-c998cbd0ae0a", +}; + +apiInstance + .listEmailSubscriptions(params) + .then((data: v2.StatusPageEmailSubscriptionsResponse) => { + 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 4a879d22e07f..8880b78103d8 100644 --- a/features/support/scenarios_model_mapping.ts +++ b/features/support/scenarios_model_mapping.ts @@ -10125,6 +10125,17 @@ export const ScenariosModelMappings: {[key: string]: {[key: string]: any}} = { }, "operationResponseType": "DegradationArray", }, + "v2.CreateInternalEmailSubscription": { + "pageId": { + "type": "string", + "format": "uuid", + }, + "body": { + "type": "StatusPageEmailSubscriptionRequest", + "format": "", + }, + "operationResponseType": "StatusPageEmailSubscriptionResponse", + }, "v2.GetStatusPage": { "pageId": { "type": "string", @@ -10301,6 +10312,40 @@ export const ScenariosModelMappings: {[key: string]: {[key: string]: any}} = { }, "operationResponseType": "Degradation", }, + "v2.ListEmailSubscriptions": { + "pageId": { + "type": "string", + "format": "uuid", + }, + "filterStatus": { + "type": "StatusPageEmailSubscriptionStatus", + "format": "", + }, + "pageOffset": { + "type": "number", + "format": "int64", + }, + "pageLimit": { + "type": "number", + "format": "int64", + }, + "sort": { + "type": "string", + "format": "", + }, + "operationResponseType": "StatusPageEmailSubscriptionsResponse", + }, + "v2.ImportEmailSubscriptions": { + "pageId": { + "type": "string", + "format": "uuid", + }, + "body": { + "type": "StatusPageEmailSubscriptionsRequest", + "format": "", + }, + "operationResponseType": "StatusPageEmailSubscriptionsResponse", + }, "v2.GetOnDemandConcurrencyCap": { "operationResponseType": "OnDemandConcurrencyCapResponse", }, diff --git a/features/v2/status_pages.feature b/features/v2/status_pages.feature index 35d80dd2fedd..8eeb1d75f029 100644 --- a/features/v2/status_pages.feature +++ b/features/v2/status_pages.feature @@ -10,6 +10,24 @@ Feature: Status Pages And a valid "appKeyAuth" key in the system And an instance of "StatusPages" API + @generated @skip @team:DataDog/incident-app + Scenario: Create an internal email subscription returns "Bad Request" response + Given operation "CreateInternalEmailSubscription" enabled + And new "CreateInternalEmailSubscription" request + And request contains "page_id" parameter from "REPLACE.ME" + And body with value {"data": {"attributes": {"email_address": "test@example.com"}, "relationships": {"subscribed_components": {"data": [{"id": "00000000-0000-0000-0000-000000000000", "type": "status_page_components"}]}}, "type": "email_subscriptions"}} + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/incident-app + Scenario: Create an internal email subscription returns "Created" response + Given operation "CreateInternalEmailSubscription" enabled + And new "CreateInternalEmailSubscription" request + And request contains "page_id" parameter from "REPLACE.ME" + And body with value {"data": {"attributes": {"email_address": "test@example.com"}, "relationships": {"subscribed_components": {"data": [{"id": "00000000-0000-0000-0000-000000000000", "type": "status_page_components"}]}}, "type": "email_subscriptions"}} + When the request is sent + Then the response status is 201 Created + @team:DataDog/incident-app Scenario: Create component returns "Created" response Given there is a valid "status_page" in the system @@ -91,6 +109,33 @@ Feature: Status Pages When the request is sent Then the response status is 200 OK + @generated @skip @team:DataDog/incident-app + Scenario: Import email subscriptions returns "Bad Request" response + Given operation "ImportEmailSubscriptions" enabled + And new "ImportEmailSubscriptions" request + And request contains "page_id" parameter from "REPLACE.ME" + And body with value {"data": [{"attributes": {"email_address": "test@example.com"}, "relationships": {"subscribed_components": {"data": [{"id": "00000000-0000-0000-0000-000000000000", "type": "status_page_components"}]}}, "type": "email_subscriptions"}]} + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/incident-app + Scenario: Import email subscriptions returns "Created" response + Given operation "ImportEmailSubscriptions" enabled + And new "ImportEmailSubscriptions" request + And request contains "page_id" parameter from "REPLACE.ME" + And body with value {"data": [{"attributes": {"email_address": "test@example.com"}, "relationships": {"subscribed_components": {"data": [{"id": "00000000-0000-0000-0000-000000000000", "type": "status_page_components"}]}}, "type": "email_subscriptions"}]} + When the request is sent + Then the response status is 201 Created + + @generated @skip @team:DataDog/incident-app + Scenario: Import email subscriptions returns "No Content" response + Given operation "ImportEmailSubscriptions" enabled + And new "ImportEmailSubscriptions" request + And request contains "page_id" parameter from "REPLACE.ME" + And body with value {"data": [{"attributes": {"email_address": "test@example.com"}, "relationships": {"subscribed_components": {"data": [{"id": "00000000-0000-0000-0000-000000000000", "type": "status_page_components"}]}}, "type": "email_subscriptions"}]} + When the request is sent + Then the response status is 204 No Content + @team:DataDog/incident-app Scenario: List components returns "OK" response Given new "ListComponents" request @@ -107,6 +152,30 @@ Feature: Status Pages When the request is sent Then the response status is 200 OK + @generated @skip @team:DataDog/incident-app + Scenario: List email subscriptions returns "Bad Request" response + Given operation "ListEmailSubscriptions" enabled + And new "ListEmailSubscriptions" request + And request contains "page_id" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/incident-app + Scenario: List email subscriptions returns "Not Found" response + Given operation "ListEmailSubscriptions" enabled + And new "ListEmailSubscriptions" request + And request contains "page_id" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 404 Not Found + + @generated @skip @team:DataDog/incident-app + Scenario: List email subscriptions returns "OK" response + Given operation "ListEmailSubscriptions" enabled + And new "ListEmailSubscriptions" request + And request contains "page_id" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 200 OK + @team:DataDog/incident-app Scenario: List status pages returns "OK" response Given new "ListStatusPages" request diff --git a/features/v2/undo.json b/features/v2/undo.json index 75d0d7f71ed7..e166376c17c3 100644 --- a/features/v2/undo.json +++ b/features/v2/undo.json @@ -5201,6 +5201,14 @@ "type": "safe" } }, + "CreateInternalEmailSubscription": { + "tag": "Status Pages", + "undo": { + "operationId": "TODO", + "parameters": [], + "type": "unsafe" + } + }, "DeleteStatusPage": { "tag": "Status Pages", "undo": { @@ -5295,6 +5303,20 @@ "type": "idempotent" } }, + "ListEmailSubscriptions": { + "tag": "Status Pages", + "undo": { + "type": "safe" + } + }, + "ImportEmailSubscriptions": { + "tag": "Status Pages", + "undo": { + "operationId": "TODO", + "parameters": [], + "type": "unsafe" + } + }, "GetOnDemandConcurrencyCap": { "tag": "Synthetics", "undo": { diff --git a/packages/datadog-api-client-common/configuration.ts b/packages/datadog-api-client-common/configuration.ts index 7be692784bc7..cf8dcf2b385d 100644 --- a/packages/datadog-api-client-common/configuration.ts +++ b/packages/datadog-api-client-common/configuration.ts @@ -416,6 +416,9 @@ export function createConfiguration( "v2.listCustomRuleRevisions": false, "v2.revertCustomRuleRevision": false, "v2.updateCustomRuleset": false, + "v2.createInternalEmailSubscription": false, + "v2.importEmailSubscriptions": false, + "v2.listEmailSubscriptions": false, "v2.addMemberTeam": false, "v2.listMemberTeams": false, "v2.removeMemberTeam": false, diff --git a/packages/datadog-api-client-v2/apis/StatusPagesApi.ts b/packages/datadog-api-client-v2/apis/StatusPagesApi.ts index c5044073b84c..8a9b6b9fc7a3 100644 --- a/packages/datadog-api-client-v2/apis/StatusPagesApi.ts +++ b/packages/datadog-api-client-v2/apis/StatusPagesApi.ts @@ -16,17 +16,24 @@ import { logger } from "../../../logger"; import { ObjectSerializer } from "../models/ObjectSerializer"; import { ApiException } from "../../datadog-api-client-common/exception"; +import {} from "../models/"; import { APIErrorResponse } from "../models/APIErrorResponse"; import { CreateComponentRequest } from "../models/CreateComponentRequest"; import { CreateDegradationRequest } from "../models/CreateDegradationRequest"; import { CreateStatusPageRequest } from "../models/CreateStatusPageRequest"; import { Degradation } from "../models/Degradation"; import { DegradationArray } from "../models/DegradationArray"; +import { JSONAPIErrorResponse } from "../models/JSONAPIErrorResponse"; import { PatchComponentRequest } from "../models/PatchComponentRequest"; import { PatchDegradationRequest } from "../models/PatchDegradationRequest"; import { PatchStatusPageRequest } from "../models/PatchStatusPageRequest"; import { StatusPage } from "../models/StatusPage"; import { StatusPageArray } from "../models/StatusPageArray"; +import { StatusPageEmailSubscriptionRequest } from "../models/StatusPageEmailSubscriptionRequest"; +import { StatusPageEmailSubscriptionResponse } from "../models/StatusPageEmailSubscriptionResponse"; +import { StatusPageEmailSubscriptionsRequest } from "../models/StatusPageEmailSubscriptionsRequest"; +import { StatusPageEmailSubscriptionsResponse } from "../models/StatusPageEmailSubscriptionsResponse"; +import { StatusPageEmailSubscriptionStatus } from "../models/StatusPageEmailSubscriptionStatus"; import { StatusPagesComponent } from "../models/StatusPagesComponent"; import { StatusPagesComponentArray } from "../models/StatusPagesComponentArray"; @@ -161,6 +168,68 @@ export class StatusPagesApiRequestFactory extends BaseAPIRequestFactory { return requestContext; } + public async createInternalEmailSubscription( + pageId: string, + body: StatusPageEmailSubscriptionRequest, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + logger.warn("Using unstable operation 'createInternalEmailSubscription'"); + if (!_config.unstableOperations["v2.createInternalEmailSubscription"]) { + throw new Error( + "Unstable operation 'createInternalEmailSubscription' is disabled" + ); + } + + // verify required parameter 'pageId' is not null or undefined + if (pageId === null || pageId === undefined) { + throw new RequiredError("pageId", "createInternalEmailSubscription"); + } + + // verify required parameter 'body' is not null or undefined + if (body === null || body === undefined) { + throw new RequiredError("body", "createInternalEmailSubscription"); + } + + // Path Params + const localVarPath = + "/api/v2/statuspages/internal/{page_id}/subscriptions/email".replace( + "{page_id}", + encodeURIComponent(String(pageId)) + ); + + // Make Request Context + const requestContext = _config + .getServer("v2.StatusPagesApi.createInternalEmailSubscription") + .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, + "StatusPageEmailSubscriptionRequest", + "" + ), + contentType + ); + requestContext.setBody(serializedBody); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + ]); + + return requestContext; + } + public async createStatusPage( body: CreateStatusPageRequest, include?: string, @@ -471,6 +540,68 @@ export class StatusPagesApiRequestFactory extends BaseAPIRequestFactory { return requestContext; } + public async importEmailSubscriptions( + pageId: string, + body: StatusPageEmailSubscriptionsRequest, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + logger.warn("Using unstable operation 'importEmailSubscriptions'"); + if (!_config.unstableOperations["v2.importEmailSubscriptions"]) { + throw new Error( + "Unstable operation 'importEmailSubscriptions' is disabled" + ); + } + + // verify required parameter 'pageId' is not null or undefined + if (pageId === null || pageId === undefined) { + throw new RequiredError("pageId", "importEmailSubscriptions"); + } + + // verify required parameter 'body' is not null or undefined + if (body === null || body === undefined) { + throw new RequiredError("body", "importEmailSubscriptions"); + } + + // Path Params + const localVarPath = + "/api/v2/statuspages/{page_id}/subscriptions/email/import".replace( + "{page_id}", + encodeURIComponent(String(pageId)) + ); + + // Make Request Context + const requestContext = _config + .getServer("v2.StatusPagesApi.importEmailSubscriptions") + .makeRequestContext(localVarPath, HttpMethod.POST); + requestContext.setHeaderParam("Accept", "*/*"); + requestContext.setHttpConfig(_config.httpConfig); + + // Body Params + const contentType = ObjectSerializer.getPreferredMediaType([ + "application/json", + ]); + requestContext.setHeaderParam("Content-Type", contentType); + const serializedBody = ObjectSerializer.stringify( + ObjectSerializer.serialize( + body, + "StatusPageEmailSubscriptionsRequest", + "" + ), + contentType + ); + requestContext.setBody(serializedBody); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + ]); + + return requestContext; + } + public async listComponents( pageId: string, include?: string, @@ -582,6 +713,85 @@ export class StatusPagesApiRequestFactory extends BaseAPIRequestFactory { return requestContext; } + public async listEmailSubscriptions( + pageId: string, + filterStatus?: StatusPageEmailSubscriptionStatus, + pageOffset?: number, + pageLimit?: number, + sort?: string, + _options?: Configuration + ): Promise { + const _config = _options || this.configuration; + + logger.warn("Using unstable operation 'listEmailSubscriptions'"); + if (!_config.unstableOperations["v2.listEmailSubscriptions"]) { + throw new Error( + "Unstable operation 'listEmailSubscriptions' is disabled" + ); + } + + // verify required parameter 'pageId' is not null or undefined + if (pageId === null || pageId === undefined) { + throw new RequiredError("pageId", "listEmailSubscriptions"); + } + + // Path Params + const localVarPath = + "/api/v2/statuspages/{page_id}/subscriptions/email".replace( + "{page_id}", + encodeURIComponent(String(pageId)) + ); + + // Make Request Context + const requestContext = _config + .getServer("v2.StatusPagesApi.listEmailSubscriptions") + .makeRequestContext(localVarPath, HttpMethod.GET); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Query Params + if (filterStatus !== undefined) { + requestContext.setQueryParam( + "filter[status]", + ObjectSerializer.serialize( + filterStatus, + "StatusPageEmailSubscriptionStatus", + "" + ), + "" + ); + } + if (pageOffset !== undefined) { + requestContext.setQueryParam( + "page[offset]", + ObjectSerializer.serialize(pageOffset, "number", "int64"), + "" + ); + } + if (pageLimit !== undefined) { + requestContext.setQueryParam( + "page[limit]", + ObjectSerializer.serialize(pageLimit, "number", "int64"), + "" + ); + } + if (sort !== undefined) { + requestContext.setQueryParam( + "sort", + ObjectSerializer.serialize(sort, "string", ""), + "" + ); + } + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + ]); + + return requestContext; + } + public async listStatusPages( pageOffset?: number, pageLimit?: number, @@ -962,6 +1172,89 @@ export class StatusPagesApiResponseProcessor { ); } + /** + * 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 createInternalEmailSubscription + * @throws ApiException if the response code was not in [200, 299] + */ + public async createInternalEmailSubscription( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 201) { + const body: StatusPageEmailSubscriptionResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "StatusPageEmailSubscriptionResponse" + ) as StatusPageEmailSubscriptionResponse; + return body; + } + if (response.httpStatusCode === 400 || 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: StatusPageEmailSubscriptionResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "StatusPageEmailSubscriptionResponse", + "" + ) as StatusPageEmailSubscriptionResponse; + 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 @@ -1331,6 +1624,92 @@ export class StatusPagesApiResponseProcessor { ); } + /** + * 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 importEmailSubscriptions + * @throws ApiException if the response code was not in [200, 299] + */ + public async importEmailSubscriptions( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 201) { + const body: StatusPageEmailSubscriptionsResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "StatusPageEmailSubscriptionsResponse" + ) as StatusPageEmailSubscriptionsResponse; + return body; + } + if (response.httpStatusCode === 204) { + return; + } + if (response.httpStatusCode === 400 || 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: StatusPageEmailSubscriptionsResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "StatusPageEmailSubscriptionsResponse", + "" + ) as StatusPageEmailSubscriptionsResponse; + 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 @@ -1447,6 +1826,93 @@ export class StatusPagesApiResponseProcessor { ); } + /** + * 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 listEmailSubscriptions + * @throws ApiException if the response code was not in [200, 299] + */ + public async listEmailSubscriptions( + response: ResponseContext + ): Promise { + const contentType = ObjectSerializer.normalizeMediaType( + response.headers["content-type"] + ); + if (response.httpStatusCode === 200) { + const body: StatusPageEmailSubscriptionsResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "StatusPageEmailSubscriptionsResponse" + ) as StatusPageEmailSubscriptionsResponse; + 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: StatusPageEmailSubscriptionsResponse = + ObjectSerializer.deserialize( + ObjectSerializer.parse(await response.body.text(), contentType), + "StatusPageEmailSubscriptionsResponse", + "" + ) as StatusPageEmailSubscriptionsResponse; + 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 @@ -1719,6 +2185,18 @@ export interface StatusPagesApiCreateDegradationRequest { include?: string; } +export interface StatusPagesApiCreateInternalEmailSubscriptionRequest { + /** + * The ID of the status page. + * @type string + */ + pageId: string; + /** + * @type StatusPageEmailSubscriptionRequest + */ + body: StatusPageEmailSubscriptionRequest; +} + export interface StatusPagesApiCreateStatusPageRequest { /** * @type CreateStatusPageRequest @@ -1814,6 +2292,18 @@ export interface StatusPagesApiGetStatusPageRequest { include?: string; } +export interface StatusPagesApiImportEmailSubscriptionsRequest { + /** + * The ID of the status page. + * @type string + */ + pageId: string; + /** + * @type StatusPageEmailSubscriptionsRequest + */ + body: StatusPageEmailSubscriptionsRequest; +} + export interface StatusPagesApiListComponentsRequest { /** * The ID of the status page. @@ -1855,6 +2345,34 @@ export interface StatusPagesApiListDegradationsRequest { filterStatus?: string; } +export interface StatusPagesApiListEmailSubscriptionsRequest { + /** + * The ID of the status page. + * @type string + */ + pageId: string; + /** + * Filter subscriptions by status. + * @type StatusPageEmailSubscriptionStatus + */ + filterStatus?: StatusPageEmailSubscriptionStatus; + /** + * The offset for pagination. + * @type number + */ + pageOffset?: number; + /** + * The maximum number of items to return per page. + * @type number + */ + pageLimit?: number; + /** + * Sort field for the list of subscriptions. Prefix with '-' for descending order. + * @type string + */ + sort?: string; +} + export interface StatusPagesApiListStatusPagesRequest { /** * Offset to use as the start of the page. @@ -2008,6 +2526,31 @@ export class StatusPagesApi { }); } + /** + * Creates an internal email subscription for a status page. + * @param param The request object + */ + public createInternalEmailSubscription( + param: StatusPagesApiCreateInternalEmailSubscriptionRequest, + options?: Configuration + ): Promise { + const requestContextPromise = + this.requestFactory.createInternalEmailSubscription( + param.pageId, + param.body, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.createInternalEmailSubscription( + responseContext + ); + }); + }); + } + /** * Creates a new status page. * @param param The request object @@ -2163,6 +2706,30 @@ export class StatusPagesApi { }); } + /** + * Imports multiple email subscriptions for a status page. Accepts up to 1000 subscriptions at once. + * @param param The request object + */ + public importEmailSubscriptions( + param: StatusPagesApiImportEmailSubscriptionsRequest, + options?: Configuration + ): Promise { + const requestContextPromise = this.requestFactory.importEmailSubscriptions( + param.pageId, + param.body, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.importEmailSubscriptions( + responseContext + ); + }); + }); + } + /** * Lists all components for a status page. * @param param The request object @@ -2210,6 +2777,31 @@ export class StatusPagesApi { }); } + /** + * Returns a list of email subscriptions for a status page. Supports filtering by status and pagination. + * @param param The request object + */ + public listEmailSubscriptions( + param: StatusPagesApiListEmailSubscriptionsRequest, + options?: Configuration + ): Promise { + const requestContextPromise = this.requestFactory.listEmailSubscriptions( + param.pageId, + param.filterStatus, + param.pageOffset, + param.pageLimit, + param.sort, + options + ); + return requestContextPromise.then((requestContext) => { + return this.configuration.httpApi + .send(requestContext) + .then((responseContext) => { + return this.responseProcessor.listEmailSubscriptions(responseContext); + }); + }); + } + /** * Lists all status pages for the organization. * @param param The request object diff --git a/packages/datadog-api-client-v2/index.ts b/packages/datadog-api-client-v2/index.ts index 8b67c1c38586..d0b9717387f2 100644 --- a/packages/datadog-api-client-v2/index.ts +++ b/packages/datadog-api-client-v2/index.ts @@ -1031,6 +1031,7 @@ export { export { StatusPagesApiCreateComponentRequest, StatusPagesApiCreateDegradationRequest, + StatusPagesApiCreateInternalEmailSubscriptionRequest, StatusPagesApiCreateStatusPageRequest, StatusPagesApiDeleteComponentRequest, StatusPagesApiDeleteDegradationRequest, @@ -1038,8 +1039,10 @@ export { StatusPagesApiGetComponentRequest, StatusPagesApiGetDegradationRequest, StatusPagesApiGetStatusPageRequest, + StatusPagesApiImportEmailSubscriptionsRequest, StatusPagesApiListComponentsRequest, StatusPagesApiListDegradationsRequest, + StatusPagesApiListEmailSubscriptionsRequest, StatusPagesApiListStatusPagesRequest, StatusPagesApiUpdateComponentRequest, StatusPagesApiUpdateDegradationRequest, @@ -4928,6 +4931,7 @@ export { StatusPageAsIncludedRelationshipsCreatedByUser } from "./models/StatusP export { StatusPageAsIncludedRelationshipsCreatedByUserData } from "./models/StatusPageAsIncludedRelationshipsCreatedByUserData"; export { StatusPageAsIncludedRelationshipsLastModifiedByUser } from "./models/StatusPageAsIncludedRelationshipsLastModifiedByUser"; export { StatusPageAsIncludedRelationshipsLastModifiedByUserData } from "./models/StatusPageAsIncludedRelationshipsLastModifiedByUserData"; +export { StatusPageComponentType } from "./models/StatusPageComponentType"; export { StatusPageData } from "./models/StatusPageData"; export { StatusPageDataAttributes } from "./models/StatusPageDataAttributes"; export { StatusPageDataAttributesComponentsItems } from "./models/StatusPageDataAttributesComponentsItems"; @@ -4938,6 +4942,24 @@ export { StatusPageDataRelationshipsCreatedByUserData } from "./models/StatusPag export { StatusPageDataRelationshipsLastModifiedByUser } from "./models/StatusPageDataRelationshipsLastModifiedByUser"; export { StatusPageDataRelationshipsLastModifiedByUserData } from "./models/StatusPageDataRelationshipsLastModifiedByUserData"; export { StatusPageDataType } from "./models/StatusPageDataType"; +export { StatusPageEmailSubscriptionRequest } from "./models/StatusPageEmailSubscriptionRequest"; +export { StatusPageEmailSubscriptionRequestAttributes } from "./models/StatusPageEmailSubscriptionRequestAttributes"; +export { StatusPageEmailSubscriptionRequestData } from "./models/StatusPageEmailSubscriptionRequestData"; +export { StatusPageEmailSubscriptionRequestRelationships } from "./models/StatusPageEmailSubscriptionRequestRelationships"; +export { StatusPageEmailSubscriptionResponse } from "./models/StatusPageEmailSubscriptionResponse"; +export { StatusPageEmailSubscriptionResponseAttributes } from "./models/StatusPageEmailSubscriptionResponseAttributes"; +export { StatusPageEmailSubscriptionResponseData } from "./models/StatusPageEmailSubscriptionResponseData"; +export { StatusPageEmailSubscriptionResponseRelationships } from "./models/StatusPageEmailSubscriptionResponseRelationships"; +export { StatusPageEmailSubscriptionsRequest } from "./models/StatusPageEmailSubscriptionsRequest"; +export { StatusPageEmailSubscriptionsResponse } from "./models/StatusPageEmailSubscriptionsResponse"; +export { StatusPageEmailSubscriptionsResponseMeta } from "./models/StatusPageEmailSubscriptionsResponseMeta"; +export { StatusPageEmailSubscriptionsResponseMetaPage } from "./models/StatusPageEmailSubscriptionsResponseMetaPage"; +export { StatusPageEmailSubscriptionStatus } from "./models/StatusPageEmailSubscriptionStatus"; +export { StatusPageEmailSubscriptionType } from "./models/StatusPageEmailSubscriptionType"; +export { StatusPageRelationshipStatusPage } from "./models/StatusPageRelationshipStatusPage"; +export { StatusPageRelationshipStatusPageData } from "./models/StatusPageRelationshipStatusPageData"; +export { StatusPageRelationshipSubscribedComponentData } from "./models/StatusPageRelationshipSubscribedComponentData"; +export { StatusPageRelationshipSubscribedComponents } from "./models/StatusPageRelationshipSubscribedComponents"; export { StatusPagesComponent } from "./models/StatusPagesComponent"; export { StatusPagesComponentArray } from "./models/StatusPagesComponentArray"; export { StatusPagesComponentArrayIncluded } from "./models/StatusPagesComponentArrayIncluded"; diff --git a/packages/datadog-api-client-v2/models/ObjectSerializer.ts b/packages/datadog-api-client-v2/models/ObjectSerializer.ts index bcfe470f3096..e4cf39a1ddef 100644 --- a/packages/datadog-api-client-v2/models/ObjectSerializer.ts +++ b/packages/datadog-api-client-v2/models/ObjectSerializer.ts @@ -2860,6 +2860,22 @@ import { StatusPageDataRelationshipsCreatedByUser } from "./StatusPageDataRelati import { StatusPageDataRelationshipsCreatedByUserData } from "./StatusPageDataRelationshipsCreatedByUserData"; import { StatusPageDataRelationshipsLastModifiedByUser } from "./StatusPageDataRelationshipsLastModifiedByUser"; import { StatusPageDataRelationshipsLastModifiedByUserData } from "./StatusPageDataRelationshipsLastModifiedByUserData"; +import { StatusPageEmailSubscriptionRequest } from "./StatusPageEmailSubscriptionRequest"; +import { StatusPageEmailSubscriptionRequestAttributes } from "./StatusPageEmailSubscriptionRequestAttributes"; +import { StatusPageEmailSubscriptionRequestData } from "./StatusPageEmailSubscriptionRequestData"; +import { StatusPageEmailSubscriptionRequestRelationships } from "./StatusPageEmailSubscriptionRequestRelationships"; +import { StatusPageEmailSubscriptionResponse } from "./StatusPageEmailSubscriptionResponse"; +import { StatusPageEmailSubscriptionResponseAttributes } from "./StatusPageEmailSubscriptionResponseAttributes"; +import { StatusPageEmailSubscriptionResponseData } from "./StatusPageEmailSubscriptionResponseData"; +import { StatusPageEmailSubscriptionResponseRelationships } from "./StatusPageEmailSubscriptionResponseRelationships"; +import { StatusPageEmailSubscriptionsRequest } from "./StatusPageEmailSubscriptionsRequest"; +import { StatusPageEmailSubscriptionsResponse } from "./StatusPageEmailSubscriptionsResponse"; +import { StatusPageEmailSubscriptionsResponseMeta } from "./StatusPageEmailSubscriptionsResponseMeta"; +import { StatusPageEmailSubscriptionsResponseMetaPage } from "./StatusPageEmailSubscriptionsResponseMetaPage"; +import { StatusPageRelationshipStatusPage } from "./StatusPageRelationshipStatusPage"; +import { StatusPageRelationshipStatusPageData } from "./StatusPageRelationshipStatusPageData"; +import { StatusPageRelationshipSubscribedComponentData } from "./StatusPageRelationshipSubscribedComponentData"; +import { StatusPageRelationshipSubscribedComponents } from "./StatusPageRelationshipSubscribedComponents"; import { StatusPagesComponent } from "./StatusPagesComponent"; import { StatusPagesComponentArray } from "./StatusPagesComponentArray"; import { StatusPagesComponentData } from "./StatusPagesComponentData"; @@ -4894,7 +4910,10 @@ const enumsMap: { [key: string]: any[] } = { StateVariableType: ["stateVariable"], StatsigAPIKeyType: ["StatsigAPIKey"], StatsigIntegrationType: ["Statsig"], + StatusPageComponentType: ["status_page_components"], StatusPageDataType: ["status_pages"], + StatusPageEmailSubscriptionStatus: ["active", "unconfirmed"], + StatusPageEmailSubscriptionType: ["email_subscriptions"], StatusPagesComponentDataAttributesStatus: [ "operational", "degraded", @@ -8556,6 +8575,32 @@ const typeMap: { [index: string]: any } = { StatusPageDataRelationshipsLastModifiedByUser, StatusPageDataRelationshipsLastModifiedByUserData: StatusPageDataRelationshipsLastModifiedByUserData, + StatusPageEmailSubscriptionRequest: StatusPageEmailSubscriptionRequest, + StatusPageEmailSubscriptionRequestAttributes: + StatusPageEmailSubscriptionRequestAttributes, + StatusPageEmailSubscriptionRequestData: + StatusPageEmailSubscriptionRequestData, + StatusPageEmailSubscriptionRequestRelationships: + StatusPageEmailSubscriptionRequestRelationships, + StatusPageEmailSubscriptionResponse: StatusPageEmailSubscriptionResponse, + StatusPageEmailSubscriptionResponseAttributes: + StatusPageEmailSubscriptionResponseAttributes, + StatusPageEmailSubscriptionResponseData: + StatusPageEmailSubscriptionResponseData, + StatusPageEmailSubscriptionResponseRelationships: + StatusPageEmailSubscriptionResponseRelationships, + StatusPageEmailSubscriptionsRequest: StatusPageEmailSubscriptionsRequest, + StatusPageEmailSubscriptionsResponse: StatusPageEmailSubscriptionsResponse, + StatusPageEmailSubscriptionsResponseMeta: + StatusPageEmailSubscriptionsResponseMeta, + StatusPageEmailSubscriptionsResponseMetaPage: + StatusPageEmailSubscriptionsResponseMetaPage, + StatusPageRelationshipStatusPage: StatusPageRelationshipStatusPage, + StatusPageRelationshipStatusPageData: StatusPageRelationshipStatusPageData, + StatusPageRelationshipSubscribedComponentData: + StatusPageRelationshipSubscribedComponentData, + StatusPageRelationshipSubscribedComponents: + StatusPageRelationshipSubscribedComponents, StatusPagesComponent: StatusPagesComponent, StatusPagesComponentArray: StatusPagesComponentArray, StatusPagesComponentData: StatusPagesComponentData, diff --git a/packages/datadog-api-client-v2/models/StatusPageComponentType.ts b/packages/datadog-api-client-v2/models/StatusPageComponentType.ts new file mode 100644 index 000000000000..96d9f44df8bb --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageComponentType.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"; + +/** + * Status page component resource type. + */ + +export type StatusPageComponentType = + | typeof STATUS_PAGE_COMPONENTS + | UnparsedObject; +export const STATUS_PAGE_COMPONENTS = "status_page_components"; diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionRequest.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionRequest.ts new file mode 100644 index 000000000000..bf588b5738cd --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionRequest.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 { StatusPageEmailSubscriptionRequestData } from "./StatusPageEmailSubscriptionRequestData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Request to create an email subscription. + */ +export class StatusPageEmailSubscriptionRequest { + /** + * Email subscription data for a request. + */ + "data": StatusPageEmailSubscriptionRequestData; + + /** + * 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: "StatusPageEmailSubscriptionRequestData", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageEmailSubscriptionRequest.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionRequestAttributes.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionRequestAttributes.ts new file mode 100644 index 000000000000..d06e4348b9f2 --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionRequestAttributes.ts @@ -0,0 +1,53 @@ +/** + * 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"; + +/** + * The email subscription attributes for a request. + */ +export class StatusPageEmailSubscriptionRequestAttributes { + /** + * The email address to subscribe. + */ + "emailAddress": 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 = { + emailAddress: { + baseName: "email_address", + type: "string", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageEmailSubscriptionRequestAttributes.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionRequestData.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionRequestData.ts new file mode 100644 index 000000000000..2b9099c9c851 --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionRequestData.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 { StatusPageEmailSubscriptionRequestAttributes } from "./StatusPageEmailSubscriptionRequestAttributes"; +import { StatusPageEmailSubscriptionRequestRelationships } from "./StatusPageEmailSubscriptionRequestRelationships"; +import { StatusPageEmailSubscriptionType } from "./StatusPageEmailSubscriptionType"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Email subscription data for a request. + */ +export class StatusPageEmailSubscriptionRequestData { + /** + * The email subscription attributes for a request. + */ + "attributes": StatusPageEmailSubscriptionRequestAttributes; + /** + * The email subscription relationships for a request. + */ + "relationships"?: StatusPageEmailSubscriptionRequestRelationships; + /** + * Status page email subscription resource type. + */ + "type": StatusPageEmailSubscriptionType; + + /** + * 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: "StatusPageEmailSubscriptionRequestAttributes", + required: true, + }, + relationships: { + baseName: "relationships", + type: "StatusPageEmailSubscriptionRequestRelationships", + }, + type: { + baseName: "type", + type: "StatusPageEmailSubscriptionType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageEmailSubscriptionRequestData.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionRequestRelationships.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionRequestRelationships.ts new file mode 100644 index 000000000000..0f75ca8803f6 --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionRequestRelationships.ts @@ -0,0 +1,53 @@ +/** + * 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 { StatusPageRelationshipSubscribedComponents } from "./StatusPageRelationshipSubscribedComponents"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * The email subscription relationships for a request. + */ +export class StatusPageEmailSubscriptionRequestRelationships { + /** + * Relationship to subscribed components. + */ + "subscribedComponents"?: StatusPageRelationshipSubscribedComponents; + + /** + * 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 = { + subscribedComponents: { + baseName: "subscribed_components", + type: "StatusPageRelationshipSubscribedComponents", + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageEmailSubscriptionRequestRelationships.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionResponse.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionResponse.ts new file mode 100644 index 000000000000..dedfe52d944b --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionResponse.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 { StatusPageEmailSubscriptionResponseData } from "./StatusPageEmailSubscriptionResponseData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Response containing a single email subscription. + */ +export class StatusPageEmailSubscriptionResponse { + /** + * Email subscription data from a response. + */ + "data": StatusPageEmailSubscriptionResponseData; + + /** + * 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: "StatusPageEmailSubscriptionResponseData", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageEmailSubscriptionResponse.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionResponseAttributes.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionResponseAttributes.ts new file mode 100644 index 000000000000..71dfa2857043 --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionResponseAttributes.ts @@ -0,0 +1,83 @@ +/** + * 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 { StatusPageEmailSubscriptionStatus } from "./StatusPageEmailSubscriptionStatus"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * The email subscription attributes from a response. + */ +export class StatusPageEmailSubscriptionResponseAttributes { + /** + * Timestamp when the subscription was created. + */ + "createdAt": Date; + /** + * The email address subscribed to the status page. + */ + "emailAddress": string; + /** + * Timestamp when the subscription was last modified. + */ + "modifiedAt": Date; + /** + * Status of the email subscription. + */ + "status": StatusPageEmailSubscriptionStatus; + + /** + * 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 = { + createdAt: { + baseName: "created_at", + type: "Date", + required: true, + format: "date-time", + }, + emailAddress: { + baseName: "email_address", + type: "string", + required: true, + }, + modifiedAt: { + baseName: "modified_at", + type: "Date", + required: true, + format: "date-time", + }, + status: { + baseName: "status", + type: "StatusPageEmailSubscriptionStatus", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageEmailSubscriptionResponseAttributes.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionResponseData.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionResponseData.ts new file mode 100644 index 000000000000..b06d78eeddd2 --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionResponseData.ts @@ -0,0 +1,84 @@ +/** + * 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 { StatusPageEmailSubscriptionResponseAttributes } from "./StatusPageEmailSubscriptionResponseAttributes"; +import { StatusPageEmailSubscriptionResponseRelationships } from "./StatusPageEmailSubscriptionResponseRelationships"; +import { StatusPageEmailSubscriptionType } from "./StatusPageEmailSubscriptionType"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Email subscription data from a response. + */ +export class StatusPageEmailSubscriptionResponseData { + /** + * The email subscription attributes from a response. + */ + "attributes": StatusPageEmailSubscriptionResponseAttributes; + /** + * The email subscription ID. + */ + "id": string; + /** + * The email subscription relationships from a response. + */ + "relationships": StatusPageEmailSubscriptionResponseRelationships; + /** + * Status page email subscription resource type. + */ + "type": StatusPageEmailSubscriptionType; + + /** + * 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: "StatusPageEmailSubscriptionResponseAttributes", + required: true, + }, + id: { + baseName: "id", + type: "string", + required: true, + format: "uuid", + }, + relationships: { + baseName: "relationships", + type: "StatusPageEmailSubscriptionResponseRelationships", + required: true, + }, + type: { + baseName: "type", + type: "StatusPageEmailSubscriptionType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageEmailSubscriptionResponseData.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionResponseRelationships.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionResponseRelationships.ts new file mode 100644 index 000000000000..da95201f07e7 --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionResponseRelationships.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 { StatusPageRelationshipStatusPage } from "./StatusPageRelationshipStatusPage"; +import { StatusPageRelationshipSubscribedComponents } from "./StatusPageRelationshipSubscribedComponents"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * The email subscription relationships from a response. + */ +export class StatusPageEmailSubscriptionResponseRelationships { + /** + * Relationship to the status page. + */ + "statusPage": StatusPageRelationshipStatusPage; + /** + * Relationship to subscribed components. + */ + "subscribedComponents": StatusPageRelationshipSubscribedComponents; + + /** + * 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 = { + statusPage: { + baseName: "status_page", + type: "StatusPageRelationshipStatusPage", + required: true, + }, + subscribedComponents: { + baseName: "subscribed_components", + type: "StatusPageRelationshipSubscribedComponents", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageEmailSubscriptionResponseRelationships.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionStatus.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionStatus.ts new file mode 100644 index 000000000000..5cabc58da79e --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionStatus.ts @@ -0,0 +1,18 @@ +/** + * 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"; + +/** + * Status of the email subscription. + */ + +export type StatusPageEmailSubscriptionStatus = + | typeof ACTIVE + | typeof UNCONFIRMED + | UnparsedObject; +export const ACTIVE = "active"; +export const UNCONFIRMED = "unconfirmed"; diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionType.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionType.ts new file mode 100644 index 000000000000..aac532507133 --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionType.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"; + +/** + * Status page email subscription resource type. + */ + +export type StatusPageEmailSubscriptionType = + | typeof EMAIL_SUBSCRIPTIONS + | UnparsedObject; +export const EMAIL_SUBSCRIPTIONS = "email_subscriptions"; diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionsRequest.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionsRequest.ts new file mode 100644 index 000000000000..671a7a72f817 --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionsRequest.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 { StatusPageEmailSubscriptionRequestData } from "./StatusPageEmailSubscriptionRequestData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Request to import multiple email subscriptions. + */ +export class StatusPageEmailSubscriptionsRequest { + /** + * List of email subscriptions to import. + */ + "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 StatusPageEmailSubscriptionsRequest.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionsResponse.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionsResponse.ts new file mode 100644 index 000000000000..bfbcdc18c66f --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionsResponse.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 { StatusPageEmailSubscriptionResponseData } from "./StatusPageEmailSubscriptionResponseData"; +import { StatusPageEmailSubscriptionsResponseMeta } from "./StatusPageEmailSubscriptionsResponseMeta"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Response containing a list of email subscriptions. + */ +export class StatusPageEmailSubscriptionsResponse { + /** + * List of email subscriptions. + */ + "data": Array; + /** + * Metadata for the list of email subscriptions. + */ + "meta": StatusPageEmailSubscriptionsResponseMeta; + + /** + * 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, + }, + meta: { + baseName: "meta", + type: "StatusPageEmailSubscriptionsResponseMeta", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageEmailSubscriptionsResponse.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionsResponseMeta.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionsResponseMeta.ts new file mode 100644 index 000000000000..53ca3b217349 --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionsResponseMeta.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 { StatusPageEmailSubscriptionsResponseMetaPage } from "./StatusPageEmailSubscriptionsResponseMetaPage"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Metadata for the list of email subscriptions. + */ +export class StatusPageEmailSubscriptionsResponseMeta { + /** + * Pagination metadata. + */ + "page": StatusPageEmailSubscriptionsResponseMetaPage; + + /** + * 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 = { + page: { + baseName: "page", + type: "StatusPageEmailSubscriptionsResponseMetaPage", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageEmailSubscriptionsResponseMeta.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionsResponseMetaPage.ts b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionsResponseMetaPage.ts new file mode 100644 index 000000000000..6660a4c21d66 --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageEmailSubscriptionsResponseMetaPage.ts @@ -0,0 +1,121 @@ +/** + * 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"; + +/** + * Pagination metadata. + */ +export class StatusPageEmailSubscriptionsResponseMetaPage { + /** + * The offset of the first page. + */ + "firstOffset": number; + /** + * The offset of the last page. + */ + "lastOffset": number; + /** + * The maximum number of items per page. + */ + "limit": number; + /** + * The offset of the next page. + */ + "nextOffset"?: number; + /** + * The current offset. + */ + "offset": number; + /** + * The offset of the previous page. + */ + "prevOffset"?: number; + /** + * The total number of items. + */ + "total": number; + /** + * The pagination type. + */ + "type": 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 = { + firstOffset: { + baseName: "first_offset", + type: "number", + required: true, + format: "int64", + }, + lastOffset: { + baseName: "last_offset", + type: "number", + required: true, + format: "int64", + }, + limit: { + baseName: "limit", + type: "number", + required: true, + format: "int64", + }, + nextOffset: { + baseName: "next_offset", + type: "number", + format: "int64", + }, + offset: { + baseName: "offset", + type: "number", + required: true, + format: "int64", + }, + prevOffset: { + baseName: "prev_offset", + type: "number", + format: "int64", + }, + total: { + baseName: "total", + type: "number", + required: true, + format: "int64", + }, + type: { + baseName: "type", + type: "string", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageEmailSubscriptionsResponseMetaPage.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageRelationshipStatusPage.ts b/packages/datadog-api-client-v2/models/StatusPageRelationshipStatusPage.ts new file mode 100644 index 000000000000..01674b5eaea3 --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageRelationshipStatusPage.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 { StatusPageRelationshipStatusPageData } from "./StatusPageRelationshipStatusPageData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Relationship to the status page. + */ +export class StatusPageRelationshipStatusPage { + /** + * Status page relationship data. + */ + "data": StatusPageRelationshipStatusPageData; + + /** + * 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: "StatusPageRelationshipStatusPageData", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageRelationshipStatusPage.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageRelationshipStatusPageData.ts b/packages/datadog-api-client-v2/models/StatusPageRelationshipStatusPageData.ts new file mode 100644 index 000000000000..ce2e30a56f6b --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageRelationshipStatusPageData.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 { StatusPageDataType } from "./StatusPageDataType"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Status page relationship data. + */ +export class StatusPageRelationshipStatusPageData { + /** + * The status page ID. + */ + "id": string; + /** + * Status pages resource type. + */ + "type": StatusPageDataType; + + /** + * 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 = { + id: { + baseName: "id", + type: "string", + required: true, + format: "uuid", + }, + type: { + baseName: "type", + type: "StatusPageDataType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageRelationshipStatusPageData.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageRelationshipSubscribedComponentData.ts b/packages/datadog-api-client-v2/models/StatusPageRelationshipSubscribedComponentData.ts new file mode 100644 index 000000000000..310a0f84cf7b --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageRelationshipSubscribedComponentData.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 { StatusPageComponentType } from "./StatusPageComponentType"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Subscribed component relationship data. + */ +export class StatusPageRelationshipSubscribedComponentData { + /** + * The component ID. + */ + "id": string; + /** + * Status page component resource type. + */ + "type": StatusPageComponentType; + + /** + * 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 = { + id: { + baseName: "id", + type: "string", + required: true, + format: "uuid", + }, + type: { + baseName: "type", + type: "StatusPageComponentType", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return StatusPageRelationshipSubscribedComponentData.attributeTypeMap; + } + + public constructor() {} +} diff --git a/packages/datadog-api-client-v2/models/StatusPageRelationshipSubscribedComponents.ts b/packages/datadog-api-client-v2/models/StatusPageRelationshipSubscribedComponents.ts new file mode 100644 index 000000000000..623c56df3b2e --- /dev/null +++ b/packages/datadog-api-client-v2/models/StatusPageRelationshipSubscribedComponents.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 { StatusPageRelationshipSubscribedComponentData } from "./StatusPageRelationshipSubscribedComponentData"; + +import { AttributeTypeMap } from "../../datadog-api-client-common/util"; + +/** + * Relationship to subscribed components. + */ +export class StatusPageRelationshipSubscribedComponents { + /** + * List of subscribed components. + */ + "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 StatusPageRelationshipSubscribedComponents.attributeTypeMap; + } + + public constructor() {} +}