@aws-sdk/client-health 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,601 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { HealthServiceException as __BaseException } from "./HealthServiceException";
+export declare enum EntityStatusCode {
+    IMPAIRED = "IMPAIRED",
+    UNIMPAIRED = "UNIMPAIRED",
+    UNKNOWN = "UNKNOWN"
+}
+
+export interface AffectedEntity {
+    
+    entityArn?: string;
+    
+    eventArn?: string;
+    
+    entityValue?: string;
+    
+    entityUrl?: string;
+    
+    awsAccountId?: string;
+    
+    lastUpdatedTime?: Date;
+    
+    statusCode?: EntityStatusCode | string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace AffectedEntity {
+    
+    const filterSensitiveLog: (obj: AffectedEntity) => any;
+}
+export interface DescribeAffectedAccountsForOrganizationRequest {
+    
+    eventArn: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace DescribeAffectedAccountsForOrganizationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAffectedAccountsForOrganizationRequest) => any;
+}
+export declare enum EventScopeCode {
+    ACCOUNT_SPECIFIC = "ACCOUNT_SPECIFIC",
+    NONE = "NONE",
+    PUBLIC = "PUBLIC"
+}
+export interface DescribeAffectedAccountsForOrganizationResponse {
+    
+    affectedAccounts?: string[];
+    
+    eventScopeCode?: EventScopeCode | string;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeAffectedAccountsForOrganizationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAffectedAccountsForOrganizationResponse) => any;
+}
+
+export declare class InvalidPaginationToken extends __BaseException {
+    readonly name: "InvalidPaginationToken";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidPaginationToken, __BaseException>);
+}
+
+export interface DateTimeRange {
+    
+    from?: Date;
+    
+    to?: Date;
+}
+export declare namespace DateTimeRange {
+    
+    const filterSensitiveLog: (obj: DateTimeRange) => any;
+}
+
+export interface EntityFilter {
+    
+    eventArns: string[] | undefined;
+    
+    entityArns?: string[];
+    
+    entityValues?: string[];
+    
+    lastUpdatedTimes?: DateTimeRange[];
+    
+    tags?: {
+        [key: string]: string;
+    }[];
+    
+    statusCodes?: (EntityStatusCode | string)[];
+}
+export declare namespace EntityFilter {
+    
+    const filterSensitiveLog: (obj: EntityFilter) => any;
+}
+export interface DescribeAffectedEntitiesRequest {
+    
+    filter: EntityFilter | undefined;
+    
+    locale?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace DescribeAffectedEntitiesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAffectedEntitiesRequest) => any;
+}
+export interface DescribeAffectedEntitiesResponse {
+    
+    entities?: AffectedEntity[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeAffectedEntitiesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAffectedEntitiesResponse) => any;
+}
+
+export declare class UnsupportedLocale extends __BaseException {
+    readonly name: "UnsupportedLocale";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedLocale, __BaseException>);
+}
+
+export interface EventAccountFilter {
+    
+    eventArn: string | undefined;
+    
+    awsAccountId?: string;
+}
+export declare namespace EventAccountFilter {
+    
+    const filterSensitiveLog: (obj: EventAccountFilter) => any;
+}
+export interface DescribeAffectedEntitiesForOrganizationRequest {
+    
+    organizationEntityFilters: EventAccountFilter[] | undefined;
+    
+    locale?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace DescribeAffectedEntitiesForOrganizationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAffectedEntitiesForOrganizationRequest) => any;
+}
+
+export interface OrganizationAffectedEntitiesErrorItem {
+    
+    awsAccountId?: string;
+    
+    eventArn?: string;
+    
+    errorName?: string;
+    
+    errorMessage?: string;
+}
+export declare namespace OrganizationAffectedEntitiesErrorItem {
+    
+    const filterSensitiveLog: (obj: OrganizationAffectedEntitiesErrorItem) => any;
+}
+export interface DescribeAffectedEntitiesForOrganizationResponse {
+    
+    entities?: AffectedEntity[];
+    
+    failedSet?: OrganizationAffectedEntitiesErrorItem[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeAffectedEntitiesForOrganizationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAffectedEntitiesForOrganizationResponse) => any;
+}
+export interface DescribeEntityAggregatesRequest {
+    
+    eventArns?: string[];
+}
+export declare namespace DescribeEntityAggregatesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEntityAggregatesRequest) => any;
+}
+
+export interface EntityAggregate {
+    
+    eventArn?: string;
+    
+    count?: number;
+}
+export declare namespace EntityAggregate {
+    
+    const filterSensitiveLog: (obj: EntityAggregate) => any;
+}
+export interface DescribeEntityAggregatesResponse {
+    
+    entityAggregates?: EntityAggregate[];
+}
+export declare namespace DescribeEntityAggregatesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEntityAggregatesResponse) => any;
+}
+export declare enum EventAggregateField {
+    EventTypeCategory = "eventTypeCategory"
+}
+export declare enum EventStatusCode {
+    CLOSED = "closed",
+    OPEN = "open",
+    UPCOMING = "upcoming"
+}
+export declare enum EventTypeCategory {
+    ACCOUNT_NOTIFICATION = "accountNotification",
+    INVESTIGATION = "investigation",
+    ISSUE = "issue",
+    SCHEDULED_CHANGE = "scheduledChange"
+}
+
+export interface EventFilter {
+    
+    eventArns?: string[];
+    
+    eventTypeCodes?: string[];
+    
+    services?: string[];
+    
+    regions?: string[];
+    
+    availabilityZones?: string[];
+    
+    startTimes?: DateTimeRange[];
+    
+    endTimes?: DateTimeRange[];
+    
+    lastUpdatedTimes?: DateTimeRange[];
+    
+    entityArns?: string[];
+    
+    entityValues?: string[];
+    
+    eventTypeCategories?: (EventTypeCategory | string)[];
+    
+    tags?: {
+        [key: string]: string;
+    }[];
+    
+    eventStatusCodes?: (EventStatusCode | string)[];
+}
+export declare namespace EventFilter {
+    
+    const filterSensitiveLog: (obj: EventFilter) => any;
+}
+export interface DescribeEventAggregatesRequest {
+    
+    filter?: EventFilter;
+    
+    aggregateField: EventAggregateField | string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeEventAggregatesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEventAggregatesRequest) => any;
+}
+
+export interface EventAggregate {
+    
+    aggregateValue?: string;
+    
+    count?: number;
+}
+export declare namespace EventAggregate {
+    
+    const filterSensitiveLog: (obj: EventAggregate) => any;
+}
+export interface DescribeEventAggregatesResponse {
+    
+    eventAggregates?: EventAggregate[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeEventAggregatesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEventAggregatesResponse) => any;
+}
+export interface DescribeEventDetailsRequest {
+    
+    eventArns: string[] | undefined;
+    
+    locale?: string;
+}
+export declare namespace DescribeEventDetailsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEventDetailsRequest) => any;
+}
+
+export interface EventDetailsErrorItem {
+    
+    eventArn?: string;
+    
+    errorName?: string;
+    
+    errorMessage?: string;
+}
+export declare namespace EventDetailsErrorItem {
+    
+    const filterSensitiveLog: (obj: EventDetailsErrorItem) => any;
+}
+
+export interface Event {
+    
+    arn?: string;
+    
+    service?: string;
+    
+    eventTypeCode?: string;
+    
+    eventTypeCategory?: EventTypeCategory | string;
+    
+    region?: string;
+    
+    availabilityZone?: string;
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+    
+    lastUpdatedTime?: Date;
+    
+    statusCode?: EventStatusCode | string;
+    
+    eventScopeCode?: EventScopeCode | string;
+}
+export declare namespace Event {
+    
+    const filterSensitiveLog: (obj: Event) => any;
+}
+
+export interface EventDescription {
+    
+    latestDescription?: string;
+}
+export declare namespace EventDescription {
+    
+    const filterSensitiveLog: (obj: EventDescription) => any;
+}
+
+export interface EventDetails {
+    
+    event?: Event;
+    
+    eventDescription?: EventDescription;
+    
+    eventMetadata?: {
+        [key: string]: string;
+    };
+}
+export declare namespace EventDetails {
+    
+    const filterSensitiveLog: (obj: EventDetails) => any;
+}
+export interface DescribeEventDetailsResponse {
+    
+    successfulSet?: EventDetails[];
+    
+    failedSet?: EventDetailsErrorItem[];
+}
+export declare namespace DescribeEventDetailsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEventDetailsResponse) => any;
+}
+export interface DescribeEventDetailsForOrganizationRequest {
+    
+    organizationEventDetailFilters: EventAccountFilter[] | undefined;
+    
+    locale?: string;
+}
+export declare namespace DescribeEventDetailsForOrganizationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEventDetailsForOrganizationRequest) => any;
+}
+
+export interface OrganizationEventDetailsErrorItem {
+    
+    awsAccountId?: string;
+    
+    eventArn?: string;
+    
+    errorName?: string;
+    
+    errorMessage?: string;
+}
+export declare namespace OrganizationEventDetailsErrorItem {
+    
+    const filterSensitiveLog: (obj: OrganizationEventDetailsErrorItem) => any;
+}
+
+export interface OrganizationEventDetails {
+    
+    awsAccountId?: string;
+    
+    event?: Event;
+    
+    eventDescription?: EventDescription;
+    
+    eventMetadata?: {
+        [key: string]: string;
+    };
+}
+export declare namespace OrganizationEventDetails {
+    
+    const filterSensitiveLog: (obj: OrganizationEventDetails) => any;
+}
+export interface DescribeEventDetailsForOrganizationResponse {
+    
+    successfulSet?: OrganizationEventDetails[];
+    
+    failedSet?: OrganizationEventDetailsErrorItem[];
+}
+export declare namespace DescribeEventDetailsForOrganizationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEventDetailsForOrganizationResponse) => any;
+}
+export interface DescribeEventsRequest {
+    
+    filter?: EventFilter;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    locale?: string;
+}
+export declare namespace DescribeEventsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEventsRequest) => any;
+}
+export interface DescribeEventsResponse {
+    
+    events?: Event[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeEventsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEventsResponse) => any;
+}
+
+export interface OrganizationEventFilter {
+    
+    eventTypeCodes?: string[];
+    
+    awsAccountIds?: string[];
+    
+    services?: string[];
+    
+    regions?: string[];
+    
+    startTime?: DateTimeRange;
+    
+    endTime?: DateTimeRange;
+    
+    lastUpdatedTime?: DateTimeRange;
+    
+    entityArns?: string[];
+    
+    entityValues?: string[];
+    
+    eventTypeCategories?: (EventTypeCategory | string)[];
+    
+    eventStatusCodes?: (EventStatusCode | string)[];
+}
+export declare namespace OrganizationEventFilter {
+    
+    const filterSensitiveLog: (obj: OrganizationEventFilter) => any;
+}
+export interface DescribeEventsForOrganizationRequest {
+    
+    filter?: OrganizationEventFilter;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    locale?: string;
+}
+export declare namespace DescribeEventsForOrganizationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEventsForOrganizationRequest) => any;
+}
+
+export interface OrganizationEvent {
+    
+    arn?: string;
+    
+    service?: string;
+    
+    eventTypeCode?: string;
+    
+    eventTypeCategory?: EventTypeCategory | string;
+    
+    eventScopeCode?: EventScopeCode | string;
+    
+    region?: string;
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+    
+    lastUpdatedTime?: Date;
+    
+    statusCode?: EventStatusCode | string;
+}
+export declare namespace OrganizationEvent {
+    
+    const filterSensitiveLog: (obj: OrganizationEvent) => any;
+}
+export interface DescribeEventsForOrganizationResponse {
+    
+    events?: OrganizationEvent[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeEventsForOrganizationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEventsForOrganizationResponse) => any;
+}
+
+export interface EventTypeFilter {
+    
+    eventTypeCodes?: string[];
+    
+    services?: string[];
+    
+    eventTypeCategories?: (EventTypeCategory | string)[];
+}
+export declare namespace EventTypeFilter {
+    
+    const filterSensitiveLog: (obj: EventTypeFilter) => any;
+}
+export interface DescribeEventTypesRequest {
+    
+    filter?: EventTypeFilter;
+    
+    locale?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace DescribeEventTypesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEventTypesRequest) => any;
+}
+
+export interface EventType {
+    
+    service?: string;
+    
+    code?: string;
+    
+    category?: EventTypeCategory | string;
+}
+export declare namespace EventType {
+    
+    const filterSensitiveLog: (obj: EventType) => any;
+}
+export interface DescribeEventTypesResponse {
+    
+    eventTypes?: EventType[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeEventTypesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEventTypesResponse) => any;
+}
+export interface DescribeHealthServiceStatusForOrganizationResponse {
+    
+    healthServiceAccessStatusForOrganization?: string;
+}
+export declare namespace DescribeHealthServiceStatusForOrganizationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeHealthServiceStatusForOrganizationResponse) => any;
+}
+
+export declare class ConcurrentModificationException extends __BaseException {
+    readonly name: "ConcurrentModificationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ConcurrentModificationException, __BaseException>);
+}

package/dist-types/ts3.4/pagination/DescribeAffectedAccountsForOrganizationPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeAffectedAccountsForOrganizationCommandInput, DescribeAffectedAccountsForOrganizationCommandOutput } from "../commands/DescribeAffectedAccountsForOrganizationCommand";
+import { HealthPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeAffectedAccountsForOrganization(config: HealthPaginationConfiguration, input: DescribeAffectedAccountsForOrganizationCommandInput, ...additionalArguments: any): Paginator<DescribeAffectedAccountsForOrganizationCommandOutput>;

package/dist-types/ts3.4/pagination/DescribeAffectedEntitiesForOrganizationPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeAffectedEntitiesForOrganizationCommandInput, DescribeAffectedEntitiesForOrganizationCommandOutput } from "../commands/DescribeAffectedEntitiesForOrganizationCommand";
+import { HealthPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeAffectedEntitiesForOrganization(config: HealthPaginationConfiguration, input: DescribeAffectedEntitiesForOrganizationCommandInput, ...additionalArguments: any): Paginator<DescribeAffectedEntitiesForOrganizationCommandOutput>;

package/dist-types/ts3.4/pagination/DescribeAffectedEntitiesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeAffectedEntitiesCommandInput, DescribeAffectedEntitiesCommandOutput } from "../commands/DescribeAffectedEntitiesCommand";
+import { HealthPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeAffectedEntities(config: HealthPaginationConfiguration, input: DescribeAffectedEntitiesCommandInput, ...additionalArguments: any): Paginator<DescribeAffectedEntitiesCommandOutput>;

package/dist-types/ts3.4/pagination/DescribeEventAggregatesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeEventAggregatesCommandInput, DescribeEventAggregatesCommandOutput } from "../commands/DescribeEventAggregatesCommand";
+import { HealthPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeEventAggregates(config: HealthPaginationConfiguration, input: DescribeEventAggregatesCommandInput, ...additionalArguments: any): Paginator<DescribeEventAggregatesCommandOutput>;

package/dist-types/ts3.4/pagination/DescribeEventTypesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeEventTypesCommandInput, DescribeEventTypesCommandOutput } from "../commands/DescribeEventTypesCommand";
+import { HealthPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeEventTypes(config: HealthPaginationConfiguration, input: DescribeEventTypesCommandInput, ...additionalArguments: any): Paginator<DescribeEventTypesCommandOutput>;

package/dist-types/ts3.4/pagination/DescribeEventsForOrganizationPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeEventsForOrganizationCommandInput, DescribeEventsForOrganizationCommandOutput } from "../commands/DescribeEventsForOrganizationCommand";
+import { HealthPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeEventsForOrganization(config: HealthPaginationConfiguration, input: DescribeEventsForOrganizationCommandInput, ...additionalArguments: any): Paginator<DescribeEventsForOrganizationCommandOutput>;

package/dist-types/ts3.4/pagination/DescribeEventsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeEventsCommandInput, DescribeEventsCommandOutput } from "../commands/DescribeEventsCommand";
+import { HealthPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeEvents(config: HealthPaginationConfiguration, input: DescribeEventsCommandInput, ...additionalArguments: any): Paginator<DescribeEventsCommandOutput>;

package/dist-types/ts3.4/pagination/Interfaces.d.ts

@@ -0,0 +1,6 @@
+import { PaginationConfiguration } from "@aws-sdk/types";
+import { Health } from "../Health";
+import { HealthClient } from "../HealthClient";
+export interface HealthPaginationConfiguration extends PaginationConfiguration {
+    client: Health | HealthClient;
+}

package/dist-types/ts3.4/pagination/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./DescribeAffectedAccountsForOrganizationPaginator";
+export * from "./DescribeAffectedEntitiesForOrganizationPaginator";
+export * from "./DescribeAffectedEntitiesPaginator";
+export * from "./DescribeEventAggregatesPaginator";
+export * from "./DescribeEventTypesPaginator";
+export * from "./DescribeEventsForOrganizationPaginator";
+export * from "./DescribeEventsPaginator";
+export * from "./Interfaces";