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/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/private/bdd_runner/src/support/scenarios_model_mapping.ts b/private/bdd_runner/src/support/scenarios_model_mapping.ts index 9e276b44f642..445b2409fd37 100644 --- a/private/bdd_runner/src/support/scenarios_model_mapping.ts +++ b/private/bdd_runner/src/support/scenarios_model_mapping.ts @@ -10135,6 +10135,17 @@ export const ScenariosModelMappings: { [key: string]: OperationMapping } = { }, operationResponseType: "DegradationArray", }, + "StatusPagesApi.V2.CreateInternalEmailSubscription": { + pageId: { + type: "string", + format: "uuid", + }, + body: { + type: "StatusPageEmailSubscriptionRequest", + format: "", + }, + operationResponseType: "StatusPageEmailSubscriptionResponse", + }, "StatusPagesApi.V2.GetStatusPage": { pageId: { type: "string", @@ -10311,6 +10322,40 @@ export const ScenariosModelMappings: { [key: string]: OperationMapping } = { }, operationResponseType: "Degradation", }, + "StatusPagesApi.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", + }, + "StatusPagesApi.V2.ImportEmailSubscriptions": { + pageId: { + type: "string", + format: "uuid", + }, + body: { + type: "StatusPageEmailSubscriptionsRequest", + format: "", + }, + operationResponseType: "StatusPageEmailSubscriptionsResponse", + }, "SyntheticsApi.V2.GetOnDemandConcurrencyCap": { operationResponseType: "OnDemandConcurrencyCapResponse", }, diff --git a/services/status_pages/src/v2/StatusPagesApi.ts b/services/status_pages/src/v2/StatusPagesApi.ts index 3a20a5017042..a61e04fa23b5 100644 --- a/services/status_pages/src/v2/StatusPagesApi.ts +++ b/services/status_pages/src/v2/StatusPagesApi.ts @@ -22,17 +22,24 @@ import { } from "@datadog/datadog-api-client"; import { TypingInfo } from "./models/TypingInfo"; +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"; import { version } from "../version"; @@ -194,6 +201,76 @@ export class StatusPagesApiRequestFactory extends BaseAPIRequestFactory { return requestContext; } + public async createInternalEmailSubscription( + pageId: string, + body: StatusPageEmailSubscriptionRequest, + _options?: Configuration, + ): Promise { + const _config = _options || this.configuration; + + if ( + !_config.unstableOperations[ + "StatusPagesApi.v2.createInternalEmailSubscription" + ] + ) { + throw new Error( + "Unstable operation 'createInternalEmailSubscription' is disabled. Enable it by setting `configuration.unstableOperations['StatusPagesApi.v2.createInternalEmailSubscription'] = true`", + ); + } + + // 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 { server, overrides } = _config.getServerAndOverrides( + "StatusPagesApi.v2.createInternalEmailSubscription", + StatusPagesApi.operationServers, + ); + const requestContext = server.makeRequestContext( + localVarPath, + HttpMethod.POST, + overrides, + ); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Set User-Agent + if (this.userAgent) { + requestContext.setHeaderParam("User-Agent", this.userAgent); + } + + // Body Params + const contentType = getPreferredMediaType(["application/json"]); + requestContext.setHeaderParam("Content-Type", contentType); + const serializedBody = stringify( + serialize(body, TypingInfo, "StatusPageEmailSubscriptionRequest", ""), + contentType, + ); + requestContext.setBody(serializedBody); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + ]); + + return requestContext; + } + public async createStatusPage( body: CreateStatusPageRequest, include?: string, @@ -579,6 +656,74 @@ export class StatusPagesApiRequestFactory extends BaseAPIRequestFactory { return requestContext; } + public async importEmailSubscriptions( + pageId: string, + body: StatusPageEmailSubscriptionsRequest, + _options?: Configuration, + ): Promise { + const _config = _options || this.configuration; + + if ( + !_config.unstableOperations["StatusPagesApi.v2.importEmailSubscriptions"] + ) { + throw new Error( + "Unstable operation 'importEmailSubscriptions' is disabled. Enable it by setting `configuration.unstableOperations['StatusPagesApi.v2.importEmailSubscriptions'] = true`", + ); + } + + // 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 { server, overrides } = _config.getServerAndOverrides( + "StatusPagesApi.v2.importEmailSubscriptions", + StatusPagesApi.operationServers, + ); + const requestContext = server.makeRequestContext( + localVarPath, + HttpMethod.POST, + overrides, + ); + requestContext.setHeaderParam("Accept", "*/*"); + requestContext.setHttpConfig(_config.httpConfig); + + // Set User-Agent + if (this.userAgent) { + requestContext.setHeaderParam("User-Agent", this.userAgent); + } + + // Body Params + const contentType = getPreferredMediaType(["application/json"]); + requestContext.setHeaderParam("Content-Type", contentType); + const serializedBody = stringify( + serialize(body, TypingInfo, "StatusPageEmailSubscriptionsRequest", ""), + contentType, + ); + requestContext.setBody(serializedBody); + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + ]); + + return requestContext; + } + public async listComponents( pageId: string, include?: string, @@ -712,6 +857,98 @@ 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; + + if ( + !_config.unstableOperations["StatusPagesApi.v2.listEmailSubscriptions"] + ) { + throw new Error( + "Unstable operation 'listEmailSubscriptions' is disabled. Enable it by setting `configuration.unstableOperations['StatusPagesApi.v2.listEmailSubscriptions'] = true`", + ); + } + + // 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 { server, overrides } = _config.getServerAndOverrides( + "StatusPagesApi.v2.listEmailSubscriptions", + StatusPagesApi.operationServers, + ); + const requestContext = server.makeRequestContext( + localVarPath, + HttpMethod.GET, + overrides, + ); + requestContext.setHeaderParam("Accept", "application/json"); + requestContext.setHttpConfig(_config.httpConfig); + + // Set User-Agent + if (this.userAgent) { + requestContext.setHeaderParam("User-Agent", this.userAgent); + } + + // Query Params + if (filterStatus !== undefined) { + requestContext.setQueryParam( + "filter[status]", + serialize( + filterStatus, + TypingInfo, + "StatusPageEmailSubscriptionStatus", + "", + ), + "", + ); + } + if (pageOffset !== undefined) { + requestContext.setQueryParam( + "page[offset]", + serialize(pageOffset, TypingInfo, "number", "int64"), + "", + ); + } + if (pageLimit !== undefined) { + requestContext.setQueryParam( + "page[limit]", + serialize(pageLimit, TypingInfo, "number", "int64"), + "", + ); + } + if (sort !== undefined) { + requestContext.setQueryParam( + "sort", + serialize(sort, TypingInfo, "string", ""), + "", + ); + } + + // Apply auth methods + applySecurityAuthentication(_config, requestContext, [ + "apiKeyAuth", + "appKeyAuth", + ]); + + return requestContext; + } + public async listStatusPages( pageOffset?: number, pageLimit?: number, @@ -1126,6 +1363,83 @@ 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 = normalizeMediaType(response.headers["content-type"]); + if (response.httpStatusCode === 201) { + const body: StatusPageEmailSubscriptionResponse = deserialize( + parse(await response.body.text(), contentType), + TypingInfo, + "StatusPageEmailSubscriptionResponse", + ) as StatusPageEmailSubscriptionResponse; + return body; + } + if (response.httpStatusCode === 400 || response.httpStatusCode === 403) { + const bodyText = parse(await response.body.text(), contentType); + let body: JSONAPIErrorResponse; + try { + body = deserialize( + bodyText, + TypingInfo, + "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 = parse(await response.body.text(), contentType); + let body: APIErrorResponse; + try { + body = deserialize( + bodyText, + TypingInfo, + "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 = deserialize( + parse(await response.body.text(), contentType), + TypingInfo, + "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 @@ -1475,6 +1789,86 @@ 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 = normalizeMediaType(response.headers["content-type"]); + if (response.httpStatusCode === 201) { + const body: StatusPageEmailSubscriptionsResponse = deserialize( + parse(await response.body.text(), contentType), + TypingInfo, + "StatusPageEmailSubscriptionsResponse", + ) as StatusPageEmailSubscriptionsResponse; + return body; + } + if (response.httpStatusCode === 204) { + return; + } + if (response.httpStatusCode === 400 || response.httpStatusCode === 403) { + const bodyText = parse(await response.body.text(), contentType); + let body: JSONAPIErrorResponse; + try { + body = deserialize( + bodyText, + TypingInfo, + "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 = parse(await response.body.text(), contentType); + let body: APIErrorResponse; + try { + body = deserialize( + bodyText, + TypingInfo, + "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 = deserialize( + parse(await response.body.text(), contentType), + TypingInfo, + "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 @@ -1587,6 +1981,87 @@ 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 = normalizeMediaType(response.headers["content-type"]); + if (response.httpStatusCode === 200) { + const body: StatusPageEmailSubscriptionsResponse = deserialize( + parse(await response.body.text(), contentType), + TypingInfo, + "StatusPageEmailSubscriptionsResponse", + ) as StatusPageEmailSubscriptionsResponse; + return body; + } + if ( + response.httpStatusCode === 400 || + response.httpStatusCode === 403 || + response.httpStatusCode === 404 + ) { + const bodyText = parse(await response.body.text(), contentType); + let body: JSONAPIErrorResponse; + try { + body = deserialize( + bodyText, + TypingInfo, + "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 = parse(await response.body.text(), contentType); + let body: APIErrorResponse; + try { + body = deserialize( + bodyText, + TypingInfo, + "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 = deserialize( + parse(await response.body.text(), contentType), + TypingInfo, + "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 @@ -1851,6 +2326,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 @@ -1946,6 +2433,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. @@ -1987,6 +2486,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. @@ -2142,6 +2669,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 @@ -2297,6 +2849,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 @@ -2344,6 +2920,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/services/status_pages/src/v2/index.ts b/services/status_pages/src/v2/index.ts index 4accfe93aebe..3be90282d64e 100644 --- a/services/status_pages/src/v2/index.ts +++ b/services/status_pages/src/v2/index.ts @@ -1,6 +1,7 @@ export { StatusPagesApiCreateComponentRequest, StatusPagesApiCreateDegradationRequest, + StatusPagesApiCreateInternalEmailSubscriptionRequest, StatusPagesApiCreateStatusPageRequest, StatusPagesApiDeleteComponentRequest, StatusPagesApiDeleteDegradationRequest, @@ -8,8 +9,10 @@ export { StatusPagesApiGetComponentRequest, StatusPagesApiGetDegradationRequest, StatusPagesApiGetStatusPageRequest, + StatusPagesApiImportEmailSubscriptionsRequest, StatusPagesApiListComponentsRequest, StatusPagesApiListDegradationsRequest, + StatusPagesApiListEmailSubscriptionsRequest, StatusPagesApiListStatusPagesRequest, StatusPagesApiUpdateComponentRequest, StatusPagesApiUpdateDegradationRequest, @@ -53,6 +56,9 @@ export { DegradationDataRelationshipsLastModifiedByUser } from "./models/Degrada export { DegradationDataRelationshipsLastModifiedByUserData } from "./models/DegradationDataRelationshipsLastModifiedByUserData"; export { DegradationDataRelationshipsStatusPage } from "./models/DegradationDataRelationshipsStatusPage"; export { DegradationDataRelationshipsStatusPageData } from "./models/DegradationDataRelationshipsStatusPageData"; +export { JSONAPIErrorItem } from "./models/JSONAPIErrorItem"; +export { JSONAPIErrorItemSource } from "./models/JSONAPIErrorItemSource"; +export { JSONAPIErrorResponse } from "./models/JSONAPIErrorResponse"; export { PatchComponentRequest } from "./models/PatchComponentRequest"; export { PatchComponentRequestData } from "./models/PatchComponentRequestData"; export { PatchComponentRequestDataAttributes } from "./models/PatchComponentRequestDataAttributes"; @@ -77,6 +83,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"; @@ -87,6 +94,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/services/status_pages/src/v2/models/JSONAPIErrorItem.ts b/services/status_pages/src/v2/models/JSONAPIErrorItem.ts new file mode 100644 index 000000000000..a1ca45cd463c --- /dev/null +++ b/services/status_pages/src/v2/models/JSONAPIErrorItem.ts @@ -0,0 +1,78 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { JSONAPIErrorItemSource } from "./JSONAPIErrorItemSource"; + +/** + * API error response body + */ +export class JSONAPIErrorItem { + /** + * A human-readable explanation specific to this occurrence of the error. + */ + "detail"?: string; + /** + * Non-standard meta-information about the error + */ + "meta"?: { [key: string]: any }; + /** + * References to the source of the error. + */ + "source"?: JSONAPIErrorItemSource; + /** + * Status code of the response. + */ + "status"?: string; + /** + * Short human-readable summary of the error. + */ + "title"?: 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 = { + detail: { + baseName: "detail", + type: "string", + }, + meta: { + baseName: "meta", + type: "{ [key: string]: any; }", + }, + source: { + baseName: "source", + type: "JSONAPIErrorItemSource", + }, + status: { + baseName: "status", + type: "string", + }, + title: { + baseName: "title", + type: "string", + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return JSONAPIErrorItem.attributeTypeMap; + } + + public constructor() {} +} diff --git a/services/status_pages/src/v2/models/JSONAPIErrorItemSource.ts b/services/status_pages/src/v2/models/JSONAPIErrorItemSource.ts new file mode 100644 index 000000000000..5889114315fa --- /dev/null +++ b/services/status_pages/src/v2/models/JSONAPIErrorItemSource.ts @@ -0,0 +1,60 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +/** + * References to the source of the error. + */ +export class JSONAPIErrorItemSource { + /** + * A string indicating the name of a single request header which caused the error. + */ + "header"?: string; + /** + * A string indicating which URI query parameter caused the error. + */ + "parameter"?: string; + /** + * A JSON pointer to the value in the request document that caused the error. + */ + "pointer"?: 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 = { + header: { + baseName: "header", + type: "string", + }, + parameter: { + baseName: "parameter", + type: "string", + }, + pointer: { + baseName: "pointer", + type: "string", + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return JSONAPIErrorItemSource.attributeTypeMap; + } + + public constructor() {} +} diff --git a/services/status_pages/src/v2/models/JSONAPIErrorResponse.ts b/services/status_pages/src/v2/models/JSONAPIErrorResponse.ts new file mode 100644 index 000000000000..68aa04ffc27b --- /dev/null +++ b/services/status_pages/src/v2/models/JSONAPIErrorResponse.ts @@ -0,0 +1,47 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { JSONAPIErrorItem } from "./JSONAPIErrorItem"; + +/** + * API error response. + */ +export class JSONAPIErrorResponse { + /** + * A list of errors. + */ + "errors": 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 = { + errors: { + baseName: "errors", + type: "Array", + required: true, + }, + additionalProperties: { + baseName: "additionalProperties", + type: "{ [key: string]: any; }", + }, + }; + + /** + * @ignore + */ + static getAttributeTypeMap(): AttributeTypeMap { + return JSONAPIErrorResponse.attributeTypeMap; + } + + public constructor() {} +} diff --git a/services/status_pages/src/v2/models/StatusPageComponentType.ts b/services/status_pages/src/v2/models/StatusPageComponentType.ts new file mode 100644 index 000000000000..67c7841ac19f --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageComponentType.ts @@ -0,0 +1,9 @@ +import { UnparsedObject } from "@datadog/datadog-api-client"; + +/** + * Status page component resource type. + */ +export type StatusPageComponentType = + | typeof STATUS_PAGE_COMPONENTS + | UnparsedObject; +export const STATUS_PAGE_COMPONENTS = "status_page_components"; diff --git a/services/status_pages/src/v2/models/StatusPageEmailSubscriptionRequest.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionRequest.ts new file mode 100644 index 000000000000..d596ec7783ed --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionRequest.ts @@ -0,0 +1,47 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageEmailSubscriptionRequestData } from "./StatusPageEmailSubscriptionRequestData"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageEmailSubscriptionRequestAttributes.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionRequestAttributes.ts new file mode 100644 index 000000000000..3338a3cbe1be --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionRequestAttributes.ts @@ -0,0 +1,45 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageEmailSubscriptionRequestData.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionRequestData.ts new file mode 100644 index 000000000000..45264c9da5c3 --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionRequestData.ts @@ -0,0 +1,66 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageEmailSubscriptionRequestAttributes } from "./StatusPageEmailSubscriptionRequestAttributes"; +import { StatusPageEmailSubscriptionRequestRelationships } from "./StatusPageEmailSubscriptionRequestRelationships"; +import { StatusPageEmailSubscriptionType } from "./StatusPageEmailSubscriptionType"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageEmailSubscriptionRequestRelationships.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionRequestRelationships.ts new file mode 100644 index 000000000000..d39210946d37 --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionRequestRelationships.ts @@ -0,0 +1,46 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageRelationshipSubscribedComponents } from "./StatusPageRelationshipSubscribedComponents"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageEmailSubscriptionResponse.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionResponse.ts new file mode 100644 index 000000000000..28741a52e687 --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionResponse.ts @@ -0,0 +1,47 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageEmailSubscriptionResponseData } from "./StatusPageEmailSubscriptionResponseData"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageEmailSubscriptionResponseAttributes.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionResponseAttributes.ts new file mode 100644 index 000000000000..67d65ab53400 --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionResponseAttributes.ts @@ -0,0 +1,76 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageEmailSubscriptionStatus } from "./StatusPageEmailSubscriptionStatus"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageEmailSubscriptionResponseData.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionResponseData.ts new file mode 100644 index 000000000000..bcd7f3bb3858 --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionResponseData.ts @@ -0,0 +1,77 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageEmailSubscriptionResponseAttributes } from "./StatusPageEmailSubscriptionResponseAttributes"; +import { StatusPageEmailSubscriptionResponseRelationships } from "./StatusPageEmailSubscriptionResponseRelationships"; +import { StatusPageEmailSubscriptionType } from "./StatusPageEmailSubscriptionType"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageEmailSubscriptionResponseRelationships.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionResponseRelationships.ts new file mode 100644 index 000000000000..b7bd8730abda --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionResponseRelationships.ts @@ -0,0 +1,57 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageRelationshipStatusPage } from "./StatusPageRelationshipStatusPage"; +import { StatusPageRelationshipSubscribedComponents } from "./StatusPageRelationshipSubscribedComponents"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageEmailSubscriptionStatus.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionStatus.ts new file mode 100644 index 000000000000..3387e0cfb409 --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionStatus.ts @@ -0,0 +1,11 @@ +import { UnparsedObject } from "@datadog/datadog-api-client"; + +/** + * Status of the email subscription. + */ +export type StatusPageEmailSubscriptionStatus = + | typeof ACTIVE + | typeof UNCONFIRMED + | UnparsedObject; +export const ACTIVE = "active"; +export const UNCONFIRMED = "unconfirmed"; diff --git a/services/status_pages/src/v2/models/StatusPageEmailSubscriptionType.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionType.ts new file mode 100644 index 000000000000..8dfb76947aad --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionType.ts @@ -0,0 +1,9 @@ +import { UnparsedObject } from "@datadog/datadog-api-client"; + +/** + * Status page email subscription resource type. + */ +export type StatusPageEmailSubscriptionType = + | typeof EMAIL_SUBSCRIPTIONS + | UnparsedObject; +export const EMAIL_SUBSCRIPTIONS = "email_subscriptions"; diff --git a/services/status_pages/src/v2/models/StatusPageEmailSubscriptionsRequest.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionsRequest.ts new file mode 100644 index 000000000000..8dbb70320462 --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionsRequest.ts @@ -0,0 +1,47 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageEmailSubscriptionRequestData } from "./StatusPageEmailSubscriptionRequestData"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageEmailSubscriptionsResponse.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionsResponse.ts new file mode 100644 index 000000000000..6ff210caa06a --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionsResponse.ts @@ -0,0 +1,57 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageEmailSubscriptionResponseData } from "./StatusPageEmailSubscriptionResponseData"; +import { StatusPageEmailSubscriptionsResponseMeta } from "./StatusPageEmailSubscriptionsResponseMeta"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageEmailSubscriptionsResponseMeta.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionsResponseMeta.ts new file mode 100644 index 000000000000..dc756f6c5ad4 --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionsResponseMeta.ts @@ -0,0 +1,47 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageEmailSubscriptionsResponseMetaPage } from "./StatusPageEmailSubscriptionsResponseMetaPage"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageEmailSubscriptionsResponseMetaPage.ts b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionsResponseMetaPage.ts new file mode 100644 index 000000000000..da7ad264abd6 --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageEmailSubscriptionsResponseMetaPage.ts @@ -0,0 +1,113 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageRelationshipStatusPage.ts b/services/status_pages/src/v2/models/StatusPageRelationshipStatusPage.ts new file mode 100644 index 000000000000..ead0cc24057c --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageRelationshipStatusPage.ts @@ -0,0 +1,47 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageRelationshipStatusPageData } from "./StatusPageRelationshipStatusPageData"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageRelationshipStatusPageData.ts b/services/status_pages/src/v2/models/StatusPageRelationshipStatusPageData.ts new file mode 100644 index 000000000000..0a2ed1c7f20b --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageRelationshipStatusPageData.ts @@ -0,0 +1,57 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageDataType } from "./StatusPageDataType"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageRelationshipSubscribedComponentData.ts b/services/status_pages/src/v2/models/StatusPageRelationshipSubscribedComponentData.ts new file mode 100644 index 000000000000..0894be34bb73 --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageRelationshipSubscribedComponentData.ts @@ -0,0 +1,57 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageComponentType } from "./StatusPageComponentType"; + +/** + * 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/services/status_pages/src/v2/models/StatusPageRelationshipSubscribedComponents.ts b/services/status_pages/src/v2/models/StatusPageRelationshipSubscribedComponents.ts new file mode 100644 index 000000000000..2f110ca2af86 --- /dev/null +++ b/services/status_pages/src/v2/models/StatusPageRelationshipSubscribedComponents.ts @@ -0,0 +1,47 @@ +import { AttributeTypeMap } from "@datadog/datadog-api-client"; + +import { StatusPageRelationshipSubscribedComponentData } from "./StatusPageRelationshipSubscribedComponentData"; + +/** + * 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() {} +} diff --git a/services/status_pages/src/v2/models/TypingInfo.ts b/services/status_pages/src/v2/models/TypingInfo.ts index 322e71f13e7f..48c1272ba592 100644 --- a/services/status_pages/src/v2/models/TypingInfo.ts +++ b/services/status_pages/src/v2/models/TypingInfo.ts @@ -31,6 +31,9 @@ import { DegradationDataRelationshipsLastModifiedByUser } from "./DegradationDat import { DegradationDataRelationshipsLastModifiedByUserData } from "./DegradationDataRelationshipsLastModifiedByUserData"; import { DegradationDataRelationshipsStatusPage } from "./DegradationDataRelationshipsStatusPage"; import { DegradationDataRelationshipsStatusPageData } from "./DegradationDataRelationshipsStatusPageData"; +import { JSONAPIErrorItem } from "./JSONAPIErrorItem"; +import { JSONAPIErrorItemSource } from "./JSONAPIErrorItemSource"; +import { JSONAPIErrorResponse } from "./JSONAPIErrorResponse"; import { PatchComponentRequest } from "./PatchComponentRequest"; import { PatchComponentRequestData } from "./PatchComponentRequestData"; import { PatchComponentRequestDataAttributes } from "./PatchComponentRequestDataAttributes"; @@ -61,6 +64,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"; @@ -114,7 +133,10 @@ export const TypingInfo: ModelTypingInfo = { "resolved", ], PatchDegradationRequestDataType: ["degradations"], + StatusPageComponentType: ["status_page_components"], StatusPageDataType: ["status_pages"], + StatusPageEmailSubscriptionStatus: ["active", "unconfirmed"], + StatusPageEmailSubscriptionType: ["email_subscriptions"], StatusPagesComponentDataAttributesStatus: [ "operational", "degraded", @@ -191,6 +213,9 @@ export const TypingInfo: ModelTypingInfo = { DegradationDataRelationshipsStatusPage, DegradationDataRelationshipsStatusPageData: DegradationDataRelationshipsStatusPageData, + JSONAPIErrorItem: JSONAPIErrorItem, + JSONAPIErrorItemSource: JSONAPIErrorItemSource, + JSONAPIErrorResponse: JSONAPIErrorResponse, PatchComponentRequest: PatchComponentRequest, PatchComponentRequestData: PatchComponentRequestData, PatchComponentRequestDataAttributes: PatchComponentRequestDataAttributes, @@ -235,6 +260,32 @@ export const TypingInfo: ModelTypingInfo = { 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,