@aws-sdk/client-cloudtrail 3.50.0 → 3.53.0

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

@@ -0,0 +1,1617 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { CloudTrailServiceException as __BaseException } from "./CloudTrailServiceException";
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface AddTagsRequest {
+    
+    ResourceId: string | undefined;
+    
+    TagsList: Tag[] | undefined;
+}
+export declare namespace AddTagsRequest {
+    
+    const filterSensitiveLog: (obj: AddTagsRequest) => any;
+}
+
+export interface AddTagsResponse {
+}
+export declare namespace AddTagsResponse {
+    
+    const filterSensitiveLog: (obj: AddTagsResponse) => any;
+}
+
+export declare class CloudTrailARNInvalidException extends __BaseException {
+    readonly name: "CloudTrailARNInvalidException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<CloudTrailARNInvalidException, __BaseException>);
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+
+export declare class EventDataStoreNotFoundException extends __BaseException {
+    readonly name: "EventDataStoreNotFoundException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<EventDataStoreNotFoundException, __BaseException>);
+}
+
+export declare class InactiveEventDataStoreException extends __BaseException {
+    readonly name: "InactiveEventDataStoreException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InactiveEventDataStoreException, __BaseException>);
+}
+
+export declare class InvalidTagParameterException extends __BaseException {
+    readonly name: "InvalidTagParameterException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidTagParameterException, __BaseException>);
+}
+
+export declare class InvalidTrailNameException extends __BaseException {
+    readonly name: "InvalidTrailNameException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidTrailNameException, __BaseException>);
+}
+
+export declare class NotOrganizationMasterAccountException extends __BaseException {
+    readonly name: "NotOrganizationMasterAccountException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<NotOrganizationMasterAccountException, __BaseException>);
+}
+
+export declare class OperationNotPermittedException extends __BaseException {
+    readonly name: "OperationNotPermittedException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<OperationNotPermittedException, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export declare class ResourceTypeNotSupportedException extends __BaseException {
+    readonly name: "ResourceTypeNotSupportedException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceTypeNotSupportedException, __BaseException>);
+}
+
+export declare class TagsLimitExceededException extends __BaseException {
+    readonly name: "TagsLimitExceededException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TagsLimitExceededException, __BaseException>);
+}
+
+export declare class UnsupportedOperationException extends __BaseException {
+    readonly name: "UnsupportedOperationException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedOperationException, __BaseException>);
+}
+
+export interface AdvancedFieldSelector {
+    
+    Field: string | undefined;
+    
+    Equals?: string[];
+    
+    StartsWith?: string[];
+    
+    EndsWith?: string[];
+    
+    NotEquals?: string[];
+    
+    NotStartsWith?: string[];
+    
+    NotEndsWith?: string[];
+}
+export declare namespace AdvancedFieldSelector {
+    
+    const filterSensitiveLog: (obj: AdvancedFieldSelector) => any;
+}
+
+export interface AdvancedEventSelector {
+    
+    Name?: string;
+    
+    FieldSelectors: AdvancedFieldSelector[] | undefined;
+}
+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 declare class EventDataStoreARNInvalidException extends __BaseException {
+    readonly name: "EventDataStoreARNInvalidException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<EventDataStoreARNInvalidException, __BaseException>);
+}
+
+export declare class InactiveQueryException extends __BaseException {
+    readonly name: "InactiveQueryException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InactiveQueryException, __BaseException>);
+}
+
+export declare class InvalidParameterException extends __BaseException {
+    readonly name: "InvalidParameterException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameterException, __BaseException>);
+}
+
+export declare class QueryIdNotFoundException extends __BaseException {
+    readonly name: "QueryIdNotFoundException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<QueryIdNotFoundException, __BaseException>);
+}
+
+export declare class CloudTrailAccessNotEnabledException extends __BaseException {
+    readonly name: "CloudTrailAccessNotEnabledException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<CloudTrailAccessNotEnabledException, __BaseException>);
+}
+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 declare class EventDataStoreAlreadyExistsException extends __BaseException {
+    readonly name: "EventDataStoreAlreadyExistsException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<EventDataStoreAlreadyExistsException, __BaseException>);
+}
+
+export declare class EventDataStoreMaxLimitExceededException extends __BaseException {
+    readonly name: "EventDataStoreMaxLimitExceededException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<EventDataStoreMaxLimitExceededException, __BaseException>);
+}
+
+export declare class InsufficientDependencyServiceAccessPermissionException extends __BaseException {
+    readonly name: "InsufficientDependencyServiceAccessPermissionException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InsufficientDependencyServiceAccessPermissionException, __BaseException>);
+}
+
+export declare class OrganizationNotInAllFeaturesModeException extends __BaseException {
+    readonly name: "OrganizationNotInAllFeaturesModeException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<OrganizationNotInAllFeaturesModeException, __BaseException>);
+}
+
+export declare class OrganizationsNotInUseException extends __BaseException {
+    readonly name: "OrganizationsNotInUseException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<OrganizationsNotInUseException, __BaseException>);
+}
+
+export declare class CloudTrailInvalidClientTokenIdException extends __BaseException {
+    readonly name: "CloudTrailInvalidClientTokenIdException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<CloudTrailInvalidClientTokenIdException, __BaseException>);
+}
+
+export declare class CloudWatchLogsDeliveryUnavailableException extends __BaseException {
+    readonly name: "CloudWatchLogsDeliveryUnavailableException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<CloudWatchLogsDeliveryUnavailableException, __BaseException>);
+}
+
+export interface CreateTrailRequest {
+    
+    Name: string | undefined;
+    
+    S3BucketName: string | undefined;
+    
+    S3KeyPrefix?: string;
+    
+    SnsTopicName?: string;
+    
+    IncludeGlobalServiceEvents?: boolean;
+    
+    IsMultiRegionTrail?: boolean;
+    
+    EnableLogFileValidation?: boolean;
+    
+    CloudWatchLogsLogGroupArn?: string;
+    
+    CloudWatchLogsRoleArn?: string;
+    
+    KmsKeyId?: string;
+    
+    IsOrganizationTrail?: boolean;
+    
+    TagsList?: Tag[];
+}
+export declare namespace CreateTrailRequest {
+    
+    const filterSensitiveLog: (obj: CreateTrailRequest) => any;
+}
+
+export interface CreateTrailResponse {
+    
+    Name?: string;
+    
+    S3BucketName?: string;
+    
+    S3KeyPrefix?: string;
+    
+    SnsTopicName?: string;
+    
+    SnsTopicARN?: string;
+    
+    IncludeGlobalServiceEvents?: boolean;
+    
+    IsMultiRegionTrail?: boolean;
+    
+    TrailARN?: string;
+    
+    LogFileValidationEnabled?: boolean;
+    
+    CloudWatchLogsLogGroupArn?: string;
+    
+    CloudWatchLogsRoleArn?: string;
+    
+    KmsKeyId?: string;
+    
+    IsOrganizationTrail?: boolean;
+}
+export declare namespace CreateTrailResponse {
+    
+    const filterSensitiveLog: (obj: CreateTrailResponse) => any;
+}
+
+export declare class InsufficientEncryptionPolicyException extends __BaseException {
+    readonly name: "InsufficientEncryptionPolicyException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InsufficientEncryptionPolicyException, __BaseException>);
+}
+
+export declare class InsufficientS3BucketPolicyException extends __BaseException {
+    readonly name: "InsufficientS3BucketPolicyException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InsufficientS3BucketPolicyException, __BaseException>);
+}
+
+export declare class InsufficientSnsTopicPolicyException extends __BaseException {
+    readonly name: "InsufficientSnsTopicPolicyException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InsufficientSnsTopicPolicyException, __BaseException>);
+}
+
+export declare class InvalidCloudWatchLogsLogGroupArnException extends __BaseException {
+    readonly name: "InvalidCloudWatchLogsLogGroupArnException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidCloudWatchLogsLogGroupArnException, __BaseException>);
+}
+
+export declare class InvalidCloudWatchLogsRoleArnException extends __BaseException {
+    readonly name: "InvalidCloudWatchLogsRoleArnException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidCloudWatchLogsRoleArnException, __BaseException>);
+}
+
+export declare class InvalidKmsKeyIdException extends __BaseException {
+    readonly name: "InvalidKmsKeyIdException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidKmsKeyIdException, __BaseException>);
+}
+
+export declare class InvalidParameterCombinationException extends __BaseException {
+    readonly name: "InvalidParameterCombinationException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameterCombinationException, __BaseException>);
+}
+
+export declare class InvalidS3BucketNameException extends __BaseException {
+    readonly name: "InvalidS3BucketNameException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidS3BucketNameException, __BaseException>);
+}
+
+export declare class InvalidS3PrefixException extends __BaseException {
+    readonly name: "InvalidS3PrefixException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidS3PrefixException, __BaseException>);
+}
+
+export declare class InvalidSnsTopicNameException extends __BaseException {
+    readonly name: "InvalidSnsTopicNameException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidSnsTopicNameException, __BaseException>);
+}
+
+export declare class KmsException extends __BaseException {
+    readonly name: "KmsException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<KmsException, __BaseException>);
+}
+
+export declare class KmsKeyDisabledException extends __BaseException {
+    readonly name: "KmsKeyDisabledException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<KmsKeyDisabledException, __BaseException>);
+}
+
+export declare class KmsKeyNotFoundException extends __BaseException {
+    readonly name: "KmsKeyNotFoundException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<KmsKeyNotFoundException, __BaseException>);
+}
+
+export declare class MaximumNumberOfTrailsExceededException extends __BaseException {
+    readonly name: "MaximumNumberOfTrailsExceededException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<MaximumNumberOfTrailsExceededException, __BaseException>);
+}
+
+export declare class S3BucketDoesNotExistException extends __BaseException {
+    readonly name: "S3BucketDoesNotExistException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<S3BucketDoesNotExistException, __BaseException>);
+}
+
+export declare class TrailAlreadyExistsException extends __BaseException {
+    readonly name: "TrailAlreadyExistsException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TrailAlreadyExistsException, __BaseException>);
+}
+
+export declare class TrailNotProvidedException extends __BaseException {
+    readonly name: "TrailNotProvidedException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TrailNotProvidedException, __BaseException>);
+}
+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 declare class EventDataStoreTerminationProtectedException extends __BaseException {
+    readonly name: "EventDataStoreTerminationProtectedException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<EventDataStoreTerminationProtectedException, __BaseException>);
+}
+
+export interface DeleteTrailRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteTrailRequest {
+    
+    const filterSensitiveLog: (obj: DeleteTrailRequest) => any;
+}
+
+export interface DeleteTrailResponse {
+}
+export declare namespace DeleteTrailResponse {
+    
+    const filterSensitiveLog: (obj: DeleteTrailResponse) => any;
+}
+
+export declare class InvalidHomeRegionException extends __BaseException {
+    readonly name: "InvalidHomeRegionException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidHomeRegionException, __BaseException>);
+}
+
+export declare class TrailNotFoundException extends __BaseException {
+    readonly name: "TrailNotFoundException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TrailNotFoundException, __BaseException>);
+}
+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 {
+    
+    trailNameList?: string[];
+    
+    includeShadowTrails?: boolean;
+}
+export declare namespace DescribeTrailsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeTrailsRequest) => any;
+}
+
+export interface Trail {
+    
+    Name?: string;
+    
+    S3BucketName?: string;
+    
+    S3KeyPrefix?: string;
+    
+    SnsTopicName?: string;
+    
+    SnsTopicARN?: string;
+    
+    IncludeGlobalServiceEvents?: boolean;
+    
+    IsMultiRegionTrail?: boolean;
+    
+    HomeRegion?: string;
+    
+    TrailARN?: string;
+    
+    LogFileValidationEnabled?: boolean;
+    
+    CloudWatchLogsLogGroupArn?: string;
+    
+    CloudWatchLogsRoleArn?: string;
+    
+    KmsKeyId?: string;
+    
+    HasCustomEventSelectors?: boolean;
+    
+    HasInsightSelectors?: boolean;
+    
+    IsOrganizationTrail?: boolean;
+}
+export declare namespace Trail {
+    
+    const filterSensitiveLog: (obj: Trail) => any;
+}
+
+export interface DescribeTrailsResponse {
+    
+    trailList?: Trail[];
+}
+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;
+}
+export declare namespace GetEventSelectorsRequest {
+    
+    const filterSensitiveLog: (obj: GetEventSelectorsRequest) => any;
+}
+
+export interface DataResource {
+    
+    Type?: string;
+    
+    Values?: string[];
+}
+export declare namespace DataResource {
+    
+    const filterSensitiveLog: (obj: DataResource) => any;
+}
+export declare enum ReadWriteType {
+    All = "All",
+    ReadOnly = "ReadOnly",
+    WriteOnly = "WriteOnly"
+}
+
+export interface EventSelector {
+    
+    ReadWriteType?: ReadWriteType | string;
+    
+    IncludeManagementEvents?: boolean;
+    
+    DataResources?: DataResource[];
+    
+    ExcludeManagementEventSources?: string[];
+}
+export declare namespace EventSelector {
+    
+    const filterSensitiveLog: (obj: EventSelector) => any;
+}
+export interface GetEventSelectorsResponse {
+    
+    TrailARN?: string;
+    
+    EventSelectors?: EventSelector[];
+    
+    AdvancedEventSelectors?: AdvancedEventSelector[];
+}
+export declare namespace GetEventSelectorsResponse {
+    
+    const filterSensitiveLog: (obj: GetEventSelectorsResponse) => any;
+}
+export interface GetInsightSelectorsRequest {
+    
+    TrailName: string | undefined;
+}
+export declare namespace GetInsightSelectorsRequest {
+    
+    const filterSensitiveLog: (obj: GetInsightSelectorsRequest) => any;
+}
+export declare enum InsightType {
+    ApiCallRateInsight = "ApiCallRateInsight",
+    ApiErrorRateInsight = "ApiErrorRateInsight"
+}
+
+export interface InsightSelector {
+    
+    InsightType?: InsightType | string;
+}
+export declare namespace InsightSelector {
+    
+    const filterSensitiveLog: (obj: InsightSelector) => any;
+}
+export interface GetInsightSelectorsResponse {
+    
+    TrailARN?: string;
+    
+    InsightSelectors?: InsightSelector[];
+}
+export declare namespace GetInsightSelectorsResponse {
+    
+    const filterSensitiveLog: (obj: GetInsightSelectorsResponse) => any;
+}
+
+export declare class InsightNotEnabledException extends __BaseException {
+    readonly name: "InsightNotEnabledException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InsightNotEnabledException, __BaseException>);
+}
+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 declare class InvalidMaxResultsException extends __BaseException {
+    readonly name: "InvalidMaxResultsException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidMaxResultsException, __BaseException>);
+}
+
+export declare class InvalidNextTokenException extends __BaseException {
+    readonly name: "InvalidNextTokenException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidNextTokenException, __BaseException>);
+}
+export interface GetTrailRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace GetTrailRequest {
+    
+    const filterSensitiveLog: (obj: GetTrailRequest) => any;
+}
+export interface GetTrailResponse {
+    
+    Trail?: Trail;
+}
+export declare namespace GetTrailResponse {
+    
+    const filterSensitiveLog: (obj: GetTrailResponse) => any;
+}
+
+export interface GetTrailStatusRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace GetTrailStatusRequest {
+    
+    const filterSensitiveLog: (obj: GetTrailStatusRequest) => any;
+}
+
+export interface GetTrailStatusResponse {
+    
+    IsLogging?: boolean;
+    
+    LatestDeliveryError?: string;
+    
+    LatestNotificationError?: string;
+    
+    LatestDeliveryTime?: Date;
+    
+    LatestNotificationTime?: Date;
+    
+    StartLoggingTime?: Date;
+    
+    StopLoggingTime?: Date;
+    
+    LatestCloudWatchLogsDeliveryError?: string;
+    
+    LatestCloudWatchLogsDeliveryTime?: Date;
+    
+    LatestDigestDeliveryTime?: Date;
+    
+    LatestDigestDeliveryError?: string;
+    
+    LatestDeliveryAttemptTime?: string;
+    
+    LatestNotificationAttemptTime?: string;
+    
+    LatestNotificationAttemptSucceeded?: string;
+    
+    LatestDeliveryAttemptSucceeded?: string;
+    
+    TimeLoggingStarted?: string;
+    
+    TimeLoggingStopped?: string;
+}
+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 declare class InvalidTimeRangeException extends __BaseException {
+    readonly name: "InvalidTimeRangeException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidTimeRangeException, __BaseException>);
+}
+
+export declare class InvalidTokenException extends __BaseException {
+    readonly name: "InvalidTokenException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidTokenException, __BaseException>);
+}
+
+export interface ListPublicKeysRequest {
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    NextToken?: string;
+}
+export declare namespace ListPublicKeysRequest {
+    
+    const filterSensitiveLog: (obj: ListPublicKeysRequest) => any;
+}
+
+export interface PublicKey {
+    
+    Value?: Uint8Array;
+    
+    ValidityStartTime?: Date;
+    
+    ValidityEndTime?: Date;
+    
+    Fingerprint?: string;
+}
+export declare namespace PublicKey {
+    
+    const filterSensitiveLog: (obj: PublicKey) => any;
+}
+
+export interface ListPublicKeysResponse {
+    
+    PublicKeyList?: PublicKey[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPublicKeysResponse {
+    
+    const filterSensitiveLog: (obj: ListPublicKeysResponse) => any;
+}
+
+export declare class InvalidDateRangeException extends __BaseException {
+    readonly name: "InvalidDateRangeException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidDateRangeException, __BaseException>);
+}
+
+export declare class InvalidQueryStatusException extends __BaseException {
+    readonly name: "InvalidQueryStatusException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidQueryStatusException, __BaseException>);
+}
+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;
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsRequest) => any;
+}
+
+export interface ResourceTag {
+    
+    ResourceId?: string;
+    
+    TagsList?: Tag[];
+}
+export declare namespace ResourceTag {
+    
+    const filterSensitiveLog: (obj: ResourceTag) => any;
+}
+
+export interface ListTagsResponse {
+    
+    ResourceTagList?: ResourceTag[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsResponse) => any;
+}
+export interface ListTrailsRequest {
+    
+    NextToken?: string;
+}
+export declare namespace ListTrailsRequest {
+    
+    const filterSensitiveLog: (obj: ListTrailsRequest) => any;
+}
+
+export interface TrailInfo {
+    
+    TrailARN?: string;
+    
+    Name?: string;
+    
+    HomeRegion?: string;
+}
+export declare namespace TrailInfo {
+    
+    const filterSensitiveLog: (obj: TrailInfo) => any;
+}
+export interface ListTrailsResponse {
+    
+    Trails?: TrailInfo[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTrailsResponse {
+    
+    const filterSensitiveLog: (obj: ListTrailsResponse) => any;
+}
+
+export declare class InvalidEventCategoryException extends __BaseException {
+    readonly name: "InvalidEventCategoryException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidEventCategoryException, __BaseException>);
+}
+
+export declare class InvalidLookupAttributesException extends __BaseException {
+    readonly name: "InvalidLookupAttributesException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidLookupAttributesException, __BaseException>);
+}
+export declare enum EventCategory {
+    Insight = "insight"
+}
+export declare enum LookupAttributeKey {
+    ACCESS_KEY_ID = "AccessKeyId",
+    EVENT_ID = "EventId",
+    EVENT_NAME = "EventName",
+    EVENT_SOURCE = "EventSource",
+    READ_ONLY = "ReadOnly",
+    RESOURCE_NAME = "ResourceName",
+    RESOURCE_TYPE = "ResourceType",
+    USERNAME = "Username"
+}
+
+export interface LookupAttribute {
+    
+    AttributeKey: LookupAttributeKey | string | undefined;
+    
+    AttributeValue: string | undefined;
+}
+export declare namespace LookupAttribute {
+    
+    const filterSensitiveLog: (obj: LookupAttribute) => any;
+}
+
+export interface LookupEventsRequest {
+    
+    LookupAttributes?: LookupAttribute[];
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    EventCategory?: EventCategory | string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace LookupEventsRequest {
+    
+    const filterSensitiveLog: (obj: LookupEventsRequest) => any;
+}
+
+export interface Resource {
+    
+    ResourceType?: string;
+    
+    ResourceName?: string;
+}
+export declare namespace Resource {
+    
+    const filterSensitiveLog: (obj: Resource) => any;
+}
+
+export interface Event {
+    
+    EventId?: string;
+    
+    EventName?: string;
+    
+    ReadOnly?: string;
+    
+    AccessKeyId?: string;
+    
+    EventTime?: Date;
+    
+    EventSource?: string;
+    
+    Username?: string;
+    
+    Resources?: Resource[];
+    
+    CloudTrailEvent?: string;
+}
+export declare namespace Event {
+    
+    const filterSensitiveLog: (obj: Event) => any;
+}
+
+export interface LookupEventsResponse {
+    
+    Events?: Event[];
+    
+    NextToken?: string;
+}
+export declare namespace LookupEventsResponse {
+    
+    const filterSensitiveLog: (obj: LookupEventsResponse) => any;
+}
+
+export declare class InvalidEventSelectorsException extends __BaseException {
+    readonly name: "InvalidEventSelectorsException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidEventSelectorsException, __BaseException>);
+}
+export interface PutEventSelectorsRequest {
+    
+    TrailName: string | undefined;
+    
+    EventSelectors?: EventSelector[];
+    
+    AdvancedEventSelectors?: AdvancedEventSelector[];
+}
+export declare namespace PutEventSelectorsRequest {
+    
+    const filterSensitiveLog: (obj: PutEventSelectorsRequest) => any;
+}
+export interface PutEventSelectorsResponse {
+    
+    TrailARN?: string;
+    
+    EventSelectors?: EventSelector[];
+    
+    AdvancedEventSelectors?: AdvancedEventSelector[];
+}
+export declare namespace PutEventSelectorsResponse {
+    
+    const filterSensitiveLog: (obj: PutEventSelectorsResponse) => any;
+}
+
+export declare class InvalidInsightSelectorsException extends __BaseException {
+    readonly name: "InvalidInsightSelectorsException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidInsightSelectorsException, __BaseException>);
+}
+export interface PutInsightSelectorsRequest {
+    
+    TrailName: string | undefined;
+    
+    InsightSelectors: InsightSelector[] | undefined;
+}
+export declare namespace PutInsightSelectorsRequest {
+    
+    const filterSensitiveLog: (obj: PutInsightSelectorsRequest) => any;
+}
+export interface PutInsightSelectorsResponse {
+    
+    TrailARN?: string;
+    
+    InsightSelectors?: InsightSelector[];
+}
+export declare namespace PutInsightSelectorsResponse {
+    
+    const filterSensitiveLog: (obj: PutInsightSelectorsResponse) => any;
+}
+
+export interface RemoveTagsRequest {
+    
+    ResourceId: string | undefined;
+    
+    TagsList: Tag[] | undefined;
+}
+export declare namespace RemoveTagsRequest {
+    
+    const filterSensitiveLog: (obj: RemoveTagsRequest) => any;
+}
+
+export interface RemoveTagsResponse {
+}
+export declare namespace RemoveTagsResponse {
+    
+    const filterSensitiveLog: (obj: RemoveTagsResponse) => any;
+}
+
+export declare class InvalidEventDataStoreStatusException extends __BaseException {
+    readonly name: "InvalidEventDataStoreStatusException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidEventDataStoreStatusException, __BaseException>);
+}
+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;
+}
+export declare namespace StartLoggingRequest {
+    
+    const filterSensitiveLog: (obj: StartLoggingRequest) => any;
+}
+
+export interface StartLoggingResponse {
+}
+export declare namespace StartLoggingResponse {
+    
+    const filterSensitiveLog: (obj: StartLoggingResponse) => any;
+}
+
+export declare class InvalidQueryStatementException extends __BaseException {
+    readonly name: "InvalidQueryStatementException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidQueryStatementException, __BaseException>);
+}
+
+export declare class MaxConcurrentQueriesException extends __BaseException {
+    readonly name: "MaxConcurrentQueriesException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<MaxConcurrentQueriesException, __BaseException>);
+}
+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;
+}
+export declare namespace StopLoggingRequest {
+    
+    const filterSensitiveLog: (obj: StopLoggingRequest) => any;
+}
+
+export interface StopLoggingResponse {
+}
+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 {
+    
+    Name: string | undefined;
+    
+    S3BucketName?: string;
+    
+    S3KeyPrefix?: string;
+    
+    SnsTopicName?: string;
+    
+    IncludeGlobalServiceEvents?: boolean;
+    
+    IsMultiRegionTrail?: boolean;
+    
+    EnableLogFileValidation?: boolean;
+    
+    CloudWatchLogsLogGroupArn?: string;
+    
+    CloudWatchLogsRoleArn?: string;
+    
+    KmsKeyId?: string;
+    
+    IsOrganizationTrail?: boolean;
+}
+export declare namespace UpdateTrailRequest {
+    
+    const filterSensitiveLog: (obj: UpdateTrailRequest) => any;
+}
+
+export interface UpdateTrailResponse {
+    
+    Name?: string;
+    
+    S3BucketName?: string;
+    
+    S3KeyPrefix?: string;
+    
+    SnsTopicName?: string;
+    
+    SnsTopicARN?: string;
+    
+    IncludeGlobalServiceEvents?: boolean;
+    
+    IsMultiRegionTrail?: boolean;
+    
+    TrailARN?: string;
+    
+    LogFileValidationEnabled?: boolean;
+    
+    CloudWatchLogsLogGroupArn?: string;
+    
+    CloudWatchLogsRoleArn?: string;
+    
+    KmsKeyId?: string;
+    
+    IsOrganizationTrail?: boolean;
+}
+export declare namespace UpdateTrailResponse {
+    
+    const filterSensitiveLog: (obj: UpdateTrailResponse) => any;
+}