@aws-sdk/client-cloudtrail 3.45.0 → 3.46.0

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

@@ -15,7 +15,7 @@ export interface AddTagsRequest {
     
     ResourceId: string | undefined;
     
-    TagsList?: Tag[];
+    TagsList: Tag[] | undefined;
 }
 export declare namespace AddTagsRequest {
     
@@ -40,6 +40,39 @@ export declare namespace CloudTrailARNInvalidException {
     const filterSensitiveLog: (obj: CloudTrailARNInvalidException) => any;
 }
 
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ConflictException {
+    
+    const filterSensitiveLog: (obj: ConflictException) => any;
+}
+
+export interface EventDataStoreNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "EventDataStoreNotFoundException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace EventDataStoreNotFoundException {
+    
+    const filterSensitiveLog: (obj: EventDataStoreNotFoundException) => any;
+}
+
+export interface InactiveEventDataStoreException extends __SmithyException, $MetadataBearer {
+    name: "InactiveEventDataStoreException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InactiveEventDataStoreException {
+    
+    const filterSensitiveLog: (obj: InactiveEventDataStoreException) => any;
+}
+
 export interface InvalidTagParameterException extends __SmithyException, $MetadataBearer {
     name: "InvalidTagParameterException";
     $fault: "client";
@@ -159,6 +192,77 @@ export declare namespace AdvancedEventSelector {
     
     const filterSensitiveLog: (obj: AdvancedEventSelector) => any;
 }
+export interface CancelQueryRequest {
+    
+    EventDataStore: string | undefined;
+    
+    QueryId: string | undefined;
+}
+export declare namespace CancelQueryRequest {
+    
+    const filterSensitiveLog: (obj: CancelQueryRequest) => any;
+}
+export declare enum QueryStatus {
+    CANCELLED = "CANCELLED",
+    FAILED = "FAILED",
+    FINISHED = "FINISHED",
+    QUEUED = "QUEUED",
+    RUNNING = "RUNNING"
+}
+export interface CancelQueryResponse {
+    
+    QueryId: string | undefined;
+    
+    QueryStatus: QueryStatus | string | undefined;
+}
+export declare namespace CancelQueryResponse {
+    
+    const filterSensitiveLog: (obj: CancelQueryResponse) => any;
+}
+
+export interface EventDataStoreARNInvalidException extends __SmithyException, $MetadataBearer {
+    name: "EventDataStoreARNInvalidException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace EventDataStoreARNInvalidException {
+    
+    const filterSensitiveLog: (obj: EventDataStoreARNInvalidException) => any;
+}
+
+export interface InactiveQueryException extends __SmithyException, $MetadataBearer {
+    name: "InactiveQueryException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InactiveQueryException {
+    
+    const filterSensitiveLog: (obj: InactiveQueryException) => any;
+}
+
+export interface InvalidParameterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidParameterException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidParameterException {
+    
+    const filterSensitiveLog: (obj: InvalidParameterException) => any;
+}
+
+export interface QueryIdNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "QueryIdNotFoundException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace QueryIdNotFoundException {
+    
+    const filterSensitiveLog: (obj: QueryIdNotFoundException) => any;
+}
 
 export interface CloudTrailAccessNotEnabledException extends __SmithyException, $MetadataBearer {
     name: "CloudTrailAccessNotEnabledException";
@@ -170,6 +274,114 @@ export declare namespace CloudTrailAccessNotEnabledException {
     
     const filterSensitiveLog: (obj: CloudTrailAccessNotEnabledException) => any;
 }
+export interface CreateEventDataStoreRequest {
+    
+    Name: string | undefined;
+    
+    AdvancedEventSelectors?: AdvancedEventSelector[];
+    
+    MultiRegionEnabled?: boolean;
+    
+    OrganizationEnabled?: boolean;
+    
+    RetentionPeriod?: number;
+    
+    TerminationProtectionEnabled?: boolean;
+    
+    TagsList?: Tag[];
+}
+export declare namespace CreateEventDataStoreRequest {
+    
+    const filterSensitiveLog: (obj: CreateEventDataStoreRequest) => any;
+}
+export declare enum EventDataStoreStatus {
+    CREATED = "CREATED",
+    ENABLED = "ENABLED",
+    PENDING_DELETION = "PENDING_DELETION"
+}
+export interface CreateEventDataStoreResponse {
+    
+    EventDataStoreArn?: string;
+    
+    Name?: string;
+    
+    Status?: EventDataStoreStatus | string;
+    
+    AdvancedEventSelectors?: AdvancedEventSelector[];
+    
+    MultiRegionEnabled?: boolean;
+    
+    OrganizationEnabled?: boolean;
+    
+    RetentionPeriod?: number;
+    
+    TerminationProtectionEnabled?: boolean;
+    
+    TagsList?: Tag[];
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+}
+export declare namespace CreateEventDataStoreResponse {
+    
+    const filterSensitiveLog: (obj: CreateEventDataStoreResponse) => any;
+}
+
+export interface EventDataStoreAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "EventDataStoreAlreadyExistsException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace EventDataStoreAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: EventDataStoreAlreadyExistsException) => any;
+}
+
+export interface EventDataStoreMaxLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "EventDataStoreMaxLimitExceededException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace EventDataStoreMaxLimitExceededException {
+    
+    const filterSensitiveLog: (obj: EventDataStoreMaxLimitExceededException) => any;
+}
+
+export interface InsufficientDependencyServiceAccessPermissionException extends __SmithyException, $MetadataBearer {
+    name: "InsufficientDependencyServiceAccessPermissionException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InsufficientDependencyServiceAccessPermissionException {
+    
+    const filterSensitiveLog: (obj: InsufficientDependencyServiceAccessPermissionException) => any;
+}
+
+export interface OrganizationNotInAllFeaturesModeException extends __SmithyException, $MetadataBearer {
+    name: "OrganizationNotInAllFeaturesModeException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace OrganizationNotInAllFeaturesModeException {
+    
+    const filterSensitiveLog: (obj: OrganizationNotInAllFeaturesModeException) => any;
+}
+
+export interface OrganizationsNotInUseException extends __SmithyException, $MetadataBearer {
+    name: "OrganizationsNotInUseException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace OrganizationsNotInUseException {
+    
+    const filterSensitiveLog: (obj: OrganizationsNotInUseException) => any;
+}
 
 export interface CloudTrailInvalidClientTokenIdException extends __SmithyException, $MetadataBearer {
     name: "CloudTrailInvalidClientTokenIdException";
@@ -257,17 +469,6 @@ export declare namespace CreateTrailResponse {
     const filterSensitiveLog: (obj: CreateTrailResponse) => any;
 }
 
-export interface InsufficientDependencyServiceAccessPermissionException extends __SmithyException, $MetadataBearer {
-    name: "InsufficientDependencyServiceAccessPermissionException";
-    $fault: "client";
-    
-    Message?: string;
-}
-export declare namespace InsufficientDependencyServiceAccessPermissionException {
-    
-    const filterSensitiveLog: (obj: InsufficientDependencyServiceAccessPermissionException) => any;
-}
-
 export interface InsufficientEncryptionPolicyException extends __SmithyException, $MetadataBearer {
     name: "InsufficientEncryptionPolicyException";
     $fault: "client";
@@ -422,28 +623,6 @@ export declare namespace MaximumNumberOfTrailsExceededException {
     const filterSensitiveLog: (obj: MaximumNumberOfTrailsExceededException) => any;
 }
 
-export interface OrganizationNotInAllFeaturesModeException extends __SmithyException, $MetadataBearer {
-    name: "OrganizationNotInAllFeaturesModeException";
-    $fault: "client";
-    
-    Message?: string;
-}
-export declare namespace OrganizationNotInAllFeaturesModeException {
-    
-    const filterSensitiveLog: (obj: OrganizationNotInAllFeaturesModeException) => any;
-}
-
-export interface OrganizationsNotInUseException extends __SmithyException, $MetadataBearer {
-    name: "OrganizationsNotInUseException";
-    $fault: "client";
-    
-    Message?: string;
-}
-export declare namespace OrganizationsNotInUseException {
-    
-    const filterSensitiveLog: (obj: OrganizationsNotInUseException) => any;
-}
-
 export interface S3BucketDoesNotExistException extends __SmithyException, $MetadataBearer {
     name: "S3BucketDoesNotExistException";
     $fault: "client";
@@ -476,16 +655,30 @@ export declare namespace TrailNotProvidedException {
     
     const filterSensitiveLog: (obj: TrailNotProvidedException) => any;
 }
+export interface DeleteEventDataStoreRequest {
+    
+    EventDataStore: string | undefined;
+}
+export declare namespace DeleteEventDataStoreRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEventDataStoreRequest) => any;
+}
+export interface DeleteEventDataStoreResponse {
+}
+export declare namespace DeleteEventDataStoreResponse {
+    
+    const filterSensitiveLog: (obj: DeleteEventDataStoreResponse) => any;
+}
 
-export interface ConflictException extends __SmithyException, $MetadataBearer {
-    name: "ConflictException";
+export interface EventDataStoreTerminationProtectedException extends __SmithyException, $MetadataBearer {
+    name: "EventDataStoreTerminationProtectedException";
     $fault: "client";
     
     Message?: string;
 }
-export declare namespace ConflictException {
+export declare namespace EventDataStoreTerminationProtectedException {
     
-    const filterSensitiveLog: (obj: ConflictException) => any;
+    const filterSensitiveLog: (obj: EventDataStoreTerminationProtectedException) => any;
 }
 
 export interface DeleteTrailRequest {
@@ -525,6 +718,47 @@ export declare namespace TrailNotFoundException {
     
     const filterSensitiveLog: (obj: TrailNotFoundException) => any;
 }
+export interface DescribeQueryRequest {
+    
+    EventDataStore: string | undefined;
+    
+    QueryId: string | undefined;
+}
+export declare namespace DescribeQueryRequest {
+    
+    const filterSensitiveLog: (obj: DescribeQueryRequest) => any;
+}
+
+export interface QueryStatisticsForDescribeQuery {
+    
+    EventsMatched?: number;
+    
+    EventsScanned?: number;
+    
+    ExecutionTimeInMillis?: number;
+    
+    CreationTime?: Date;
+}
+export declare namespace QueryStatisticsForDescribeQuery {
+    
+    const filterSensitiveLog: (obj: QueryStatisticsForDescribeQuery) => any;
+}
+export interface DescribeQueryResponse {
+    
+    QueryId?: string;
+    
+    QueryString?: string;
+    
+    QueryStatus?: QueryStatus | string;
+    
+    QueryStatistics?: QueryStatisticsForDescribeQuery;
+    
+    ErrorMessage?: string;
+}
+export declare namespace DescribeQueryResponse {
+    
+    const filterSensitiveLog: (obj: DescribeQueryResponse) => any;
+}
 
 export interface DescribeTrailsRequest {
     
@@ -584,6 +818,40 @@ export declare namespace DescribeTrailsResponse {
     
     const filterSensitiveLog: (obj: DescribeTrailsResponse) => any;
 }
+export interface GetEventDataStoreRequest {
+    
+    EventDataStore: string | undefined;
+}
+export declare namespace GetEventDataStoreRequest {
+    
+    const filterSensitiveLog: (obj: GetEventDataStoreRequest) => any;
+}
+export interface GetEventDataStoreResponse {
+    
+    EventDataStoreArn?: string;
+    
+    Name?: string;
+    
+    Status?: EventDataStoreStatus | string;
+    
+    AdvancedEventSelectors?: AdvancedEventSelector[];
+    
+    MultiRegionEnabled?: boolean;
+    
+    OrganizationEnabled?: boolean;
+    
+    RetentionPeriod?: number;
+    
+    TerminationProtectionEnabled?: boolean;
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+}
+export declare namespace GetEventDataStoreResponse {
+    
+    const filterSensitiveLog: (obj: GetEventDataStoreResponse) => any;
+}
 export interface GetEventSelectorsRequest {
     
     TrailName: string | undefined;
@@ -677,6 +945,71 @@ export declare namespace InsightNotEnabledException {
     
     const filterSensitiveLog: (obj: InsightNotEnabledException) => any;
 }
+export interface GetQueryResultsRequest {
+    
+    EventDataStore: string | undefined;
+    
+    QueryId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxQueryResults?: number;
+}
+export declare namespace GetQueryResultsRequest {
+    
+    const filterSensitiveLog: (obj: GetQueryResultsRequest) => any;
+}
+
+export interface QueryStatistics {
+    
+    ResultsCount?: number;
+    
+    TotalResultsCount?: number;
+}
+export declare namespace QueryStatistics {
+    
+    const filterSensitiveLog: (obj: QueryStatistics) => any;
+}
+export interface GetQueryResultsResponse {
+    
+    QueryStatus?: QueryStatus | string;
+    
+    QueryStatistics?: QueryStatistics;
+    
+    QueryResultRows?: {
+        [key: string]: string;
+    }[][];
+    
+    NextToken?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace GetQueryResultsResponse {
+    
+    const filterSensitiveLog: (obj: GetQueryResultsResponse) => any;
+}
+
+export interface InvalidMaxResultsException extends __SmithyException, $MetadataBearer {
+    name: "InvalidMaxResultsException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidMaxResultsException {
+    
+    const filterSensitiveLog: (obj: InvalidMaxResultsException) => any;
+}
+
+export interface InvalidNextTokenException extends __SmithyException, $MetadataBearer {
+    name: "InvalidNextTokenException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidNextTokenException {
+    
+    const filterSensitiveLog: (obj: InvalidNextTokenException) => any;
+}
 export interface GetTrailRequest {
     
     Name: string | undefined;
@@ -743,6 +1076,53 @@ export declare namespace GetTrailStatusResponse {
     
     const filterSensitiveLog: (obj: GetTrailStatusResponse) => any;
 }
+export interface ListEventDataStoresRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListEventDataStoresRequest {
+    
+    const filterSensitiveLog: (obj: ListEventDataStoresRequest) => any;
+}
+
+export interface EventDataStore {
+    
+    EventDataStoreArn?: string;
+    
+    Name?: string;
+    
+    TerminationProtectionEnabled?: boolean;
+    
+    Status?: EventDataStoreStatus | string;
+    
+    AdvancedEventSelectors?: AdvancedEventSelector[];
+    
+    MultiRegionEnabled?: boolean;
+    
+    OrganizationEnabled?: boolean;
+    
+    RetentionPeriod?: number;
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+}
+export declare namespace EventDataStore {
+    
+    const filterSensitiveLog: (obj: EventDataStore) => any;
+}
+export interface ListEventDataStoresResponse {
+    
+    EventDataStores?: EventDataStore[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEventDataStoresResponse {
+    
+    const filterSensitiveLog: (obj: ListEventDataStoresResponse) => any;
+}
 
 export interface InvalidTimeRangeException extends __SmithyException, $MetadataBearer {
     name: "InvalidTimeRangeException";
@@ -805,6 +1185,69 @@ export declare namespace ListPublicKeysResponse {
     const filterSensitiveLog: (obj: ListPublicKeysResponse) => any;
 }
 
+export interface InvalidDateRangeException extends __SmithyException, $MetadataBearer {
+    name: "InvalidDateRangeException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidDateRangeException {
+    
+    const filterSensitiveLog: (obj: InvalidDateRangeException) => any;
+}
+
+export interface InvalidQueryStatusException extends __SmithyException, $MetadataBearer {
+    name: "InvalidQueryStatusException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidQueryStatusException {
+    
+    const filterSensitiveLog: (obj: InvalidQueryStatusException) => any;
+}
+export interface ListQueriesRequest {
+    
+    EventDataStore: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    QueryStatus?: QueryStatus | string;
+}
+export declare namespace ListQueriesRequest {
+    
+    const filterSensitiveLog: (obj: ListQueriesRequest) => any;
+}
+
+export interface Query {
+    
+    QueryId?: string;
+    
+    QueryStatus?: QueryStatus | string;
+    
+    CreationTime?: Date;
+}
+export declare namespace Query {
+    
+    const filterSensitiveLog: (obj: Query) => any;
+}
+export interface ListQueriesResponse {
+    
+    Queries?: Query[];
+    
+    NextToken?: string;
+}
+export declare namespace ListQueriesResponse {
+    
+    const filterSensitiveLog: (obj: ListQueriesResponse) => any;
+}
+
 export interface ListTagsRequest {
     
     ResourceIdList: string[] | undefined;
@@ -890,28 +1333,6 @@ export declare namespace InvalidLookupAttributesException {
     
     const filterSensitiveLog: (obj: InvalidLookupAttributesException) => any;
 }
-
-export interface InvalidMaxResultsException extends __SmithyException, $MetadataBearer {
-    name: "InvalidMaxResultsException";
-    $fault: "client";
-    
-    Message?: string;
-}
-export declare namespace InvalidMaxResultsException {
-    
-    const filterSensitiveLog: (obj: InvalidMaxResultsException) => any;
-}
-
-export interface InvalidNextTokenException extends __SmithyException, $MetadataBearer {
-    name: "InvalidNextTokenException";
-    $fault: "client";
-    
-    Message?: string;
-}
-export declare namespace InvalidNextTokenException {
-    
-    const filterSensitiveLog: (obj: InvalidNextTokenException) => any;
-}
 export declare enum EventCategory {
     Insight = "insight"
 }
@@ -1073,7 +1494,7 @@ export interface RemoveTagsRequest {
     
     ResourceId: string | undefined;
     
-    TagsList?: Tag[];
+    TagsList: Tag[] | undefined;
 }
 export declare namespace RemoveTagsRequest {
     
@@ -1087,6 +1508,51 @@ export declare namespace RemoveTagsResponse {
     const filterSensitiveLog: (obj: RemoveTagsResponse) => any;
 }
 
+export interface InvalidEventDataStoreStatusException extends __SmithyException, $MetadataBearer {
+    name: "InvalidEventDataStoreStatusException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidEventDataStoreStatusException {
+    
+    const filterSensitiveLog: (obj: InvalidEventDataStoreStatusException) => any;
+}
+export interface RestoreEventDataStoreRequest {
+    
+    EventDataStore: string | undefined;
+}
+export declare namespace RestoreEventDataStoreRequest {
+    
+    const filterSensitiveLog: (obj: RestoreEventDataStoreRequest) => any;
+}
+export interface RestoreEventDataStoreResponse {
+    
+    EventDataStoreArn?: string;
+    
+    Name?: string;
+    
+    Status?: EventDataStoreStatus | string;
+    
+    AdvancedEventSelectors?: AdvancedEventSelector[];
+    
+    MultiRegionEnabled?: boolean;
+    
+    OrganizationEnabled?: boolean;
+    
+    RetentionPeriod?: number;
+    
+    TerminationProtectionEnabled?: boolean;
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+}
+export declare namespace RestoreEventDataStoreResponse {
+    
+    const filterSensitiveLog: (obj: RestoreEventDataStoreResponse) => any;
+}
+
 export interface StartLoggingRequest {
     
     Name: string | undefined;
@@ -1103,6 +1569,44 @@ export declare namespace StartLoggingResponse {
     const filterSensitiveLog: (obj: StartLoggingResponse) => any;
 }
 
+export interface InvalidQueryStatementException extends __SmithyException, $MetadataBearer {
+    name: "InvalidQueryStatementException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidQueryStatementException {
+    
+    const filterSensitiveLog: (obj: InvalidQueryStatementException) => any;
+}
+
+export interface MaxConcurrentQueriesException extends __SmithyException, $MetadataBearer {
+    name: "MaxConcurrentQueriesException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace MaxConcurrentQueriesException {
+    
+    const filterSensitiveLog: (obj: MaxConcurrentQueriesException) => any;
+}
+export interface StartQueryRequest {
+    
+    QueryStatement: string | undefined;
+}
+export declare namespace StartQueryRequest {
+    
+    const filterSensitiveLog: (obj: StartQueryRequest) => any;
+}
+export interface StartQueryResponse {
+    
+    QueryId?: string;
+}
+export declare namespace StartQueryResponse {
+    
+    const filterSensitiveLog: (obj: StartQueryResponse) => any;
+}
+
 export interface StopLoggingRequest {
     
     Name: string | undefined;
@@ -1118,6 +1622,52 @@ export declare namespace StopLoggingResponse {
     
     const filterSensitiveLog: (obj: StopLoggingResponse) => any;
 }
+export interface UpdateEventDataStoreRequest {
+    
+    EventDataStore: string | undefined;
+    
+    Name?: string;
+    
+    AdvancedEventSelectors?: AdvancedEventSelector[];
+    
+    MultiRegionEnabled?: boolean;
+    
+    OrganizationEnabled?: boolean;
+    
+    RetentionPeriod?: number;
+    
+    TerminationProtectionEnabled?: boolean;
+}
+export declare namespace UpdateEventDataStoreRequest {
+    
+    const filterSensitiveLog: (obj: UpdateEventDataStoreRequest) => any;
+}
+export interface UpdateEventDataStoreResponse {
+    
+    EventDataStoreArn?: string;
+    
+    Name?: string;
+    
+    Status?: EventDataStoreStatus | string;
+    
+    AdvancedEventSelectors?: AdvancedEventSelector[];
+    
+    MultiRegionEnabled?: boolean;
+    
+    OrganizationEnabled?: boolean;
+    
+    RetentionPeriod?: number;
+    
+    TerminationProtectionEnabled?: boolean;
+    
+    CreatedTimestamp?: Date;
+    
+    UpdatedTimestamp?: Date;
+}
+export declare namespace UpdateEventDataStoreResponse {
+    
+    const filterSensitiveLog: (obj: UpdateEventDataStoreResponse) => any;
+}
 
 export interface UpdateTrailRequest {