@aws-sdk/client-cloudtrail 3.33.0 → 3.36.1

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

@@ -0,0 +1,1181 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+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[];
+}
+export declare namespace AddTagsRequest {
+    
+    const filterSensitiveLog: (obj: AddTagsRequest) => any;
+}
+
+export interface AddTagsResponse {
+}
+export declare namespace AddTagsResponse {
+    
+    const filterSensitiveLog: (obj: AddTagsResponse) => any;
+}
+
+export interface CloudTrailARNInvalidException extends __SmithyException, $MetadataBearer {
+    name: "CloudTrailARNInvalidException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace CloudTrailARNInvalidException {
+    
+    const filterSensitiveLog: (obj: CloudTrailARNInvalidException) => any;
+}
+
+export interface InvalidTagParameterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTagParameterException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidTagParameterException {
+    
+    const filterSensitiveLog: (obj: InvalidTagParameterException) => any;
+}
+
+export interface InvalidTrailNameException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTrailNameException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidTrailNameException {
+    
+    const filterSensitiveLog: (obj: InvalidTrailNameException) => any;
+}
+
+export interface NotOrganizationMasterAccountException extends __SmithyException, $MetadataBearer {
+    name: "NotOrganizationMasterAccountException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace NotOrganizationMasterAccountException {
+    
+    const filterSensitiveLog: (obj: NotOrganizationMasterAccountException) => any;
+}
+
+export interface OperationNotPermittedException extends __SmithyException, $MetadataBearer {
+    name: "OperationNotPermittedException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace OperationNotPermittedException {
+    
+    const filterSensitiveLog: (obj: OperationNotPermittedException) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ResourceNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+
+export interface ResourceTypeNotSupportedException extends __SmithyException, $MetadataBearer {
+    name: "ResourceTypeNotSupportedException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ResourceTypeNotSupportedException {
+    
+    const filterSensitiveLog: (obj: ResourceTypeNotSupportedException) => any;
+}
+
+export interface TagsLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "TagsLimitExceededException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace TagsLimitExceededException {
+    
+    const filterSensitiveLog: (obj: TagsLimitExceededException) => any;
+}
+
+export interface UnsupportedOperationException extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedOperationException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace UnsupportedOperationException {
+    
+    const filterSensitiveLog: (obj: UnsupportedOperationException) => any;
+}
+
+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 CloudTrailAccessNotEnabledException extends __SmithyException, $MetadataBearer {
+    name: "CloudTrailAccessNotEnabledException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace CloudTrailAccessNotEnabledException {
+    
+    const filterSensitiveLog: (obj: CloudTrailAccessNotEnabledException) => any;
+}
+
+export interface CloudTrailInvalidClientTokenIdException extends __SmithyException, $MetadataBearer {
+    name: "CloudTrailInvalidClientTokenIdException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace CloudTrailInvalidClientTokenIdException {
+    
+    const filterSensitiveLog: (obj: CloudTrailInvalidClientTokenIdException) => any;
+}
+
+export interface CloudWatchLogsDeliveryUnavailableException extends __SmithyException, $MetadataBearer {
+    name: "CloudWatchLogsDeliveryUnavailableException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace CloudWatchLogsDeliveryUnavailableException {
+    
+    const filterSensitiveLog: (obj: CloudWatchLogsDeliveryUnavailableException) => any;
+}
+
+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 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";
+    
+    Message?: string;
+}
+export declare namespace InsufficientEncryptionPolicyException {
+    
+    const filterSensitiveLog: (obj: InsufficientEncryptionPolicyException) => any;
+}
+
+export interface InsufficientS3BucketPolicyException extends __SmithyException, $MetadataBearer {
+    name: "InsufficientS3BucketPolicyException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InsufficientS3BucketPolicyException {
+    
+    const filterSensitiveLog: (obj: InsufficientS3BucketPolicyException) => any;
+}
+
+export interface InsufficientSnsTopicPolicyException extends __SmithyException, $MetadataBearer {
+    name: "InsufficientSnsTopicPolicyException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InsufficientSnsTopicPolicyException {
+    
+    const filterSensitiveLog: (obj: InsufficientSnsTopicPolicyException) => any;
+}
+
+export interface InvalidCloudWatchLogsLogGroupArnException extends __SmithyException, $MetadataBearer {
+    name: "InvalidCloudWatchLogsLogGroupArnException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidCloudWatchLogsLogGroupArnException {
+    
+    const filterSensitiveLog: (obj: InvalidCloudWatchLogsLogGroupArnException) => any;
+}
+
+export interface InvalidCloudWatchLogsRoleArnException extends __SmithyException, $MetadataBearer {
+    name: "InvalidCloudWatchLogsRoleArnException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidCloudWatchLogsRoleArnException {
+    
+    const filterSensitiveLog: (obj: InvalidCloudWatchLogsRoleArnException) => any;
+}
+
+export interface InvalidKmsKeyIdException extends __SmithyException, $MetadataBearer {
+    name: "InvalidKmsKeyIdException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidKmsKeyIdException {
+    
+    const filterSensitiveLog: (obj: InvalidKmsKeyIdException) => any;
+}
+
+export interface InvalidParameterCombinationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidParameterCombinationException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidParameterCombinationException {
+    
+    const filterSensitiveLog: (obj: InvalidParameterCombinationException) => any;
+}
+
+export interface InvalidS3BucketNameException extends __SmithyException, $MetadataBearer {
+    name: "InvalidS3BucketNameException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidS3BucketNameException {
+    
+    const filterSensitiveLog: (obj: InvalidS3BucketNameException) => any;
+}
+
+export interface InvalidS3PrefixException extends __SmithyException, $MetadataBearer {
+    name: "InvalidS3PrefixException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidS3PrefixException {
+    
+    const filterSensitiveLog: (obj: InvalidS3PrefixException) => any;
+}
+
+export interface InvalidSnsTopicNameException extends __SmithyException, $MetadataBearer {
+    name: "InvalidSnsTopicNameException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidSnsTopicNameException {
+    
+    const filterSensitiveLog: (obj: InvalidSnsTopicNameException) => any;
+}
+
+export interface KmsException extends __SmithyException, $MetadataBearer {
+    name: "KmsException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace KmsException {
+    
+    const filterSensitiveLog: (obj: KmsException) => any;
+}
+
+export interface KmsKeyDisabledException extends __SmithyException, $MetadataBearer {
+    name: "KmsKeyDisabledException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace KmsKeyDisabledException {
+    
+    const filterSensitiveLog: (obj: KmsKeyDisabledException) => any;
+}
+
+export interface KmsKeyNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "KmsKeyNotFoundException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace KmsKeyNotFoundException {
+    
+    const filterSensitiveLog: (obj: KmsKeyNotFoundException) => any;
+}
+
+export interface MaximumNumberOfTrailsExceededException extends __SmithyException, $MetadataBearer {
+    name: "MaximumNumberOfTrailsExceededException";
+    $fault: "client";
+    
+    Message?: string;
+}
+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";
+    
+    Message?: string;
+}
+export declare namespace S3BucketDoesNotExistException {
+    
+    const filterSensitiveLog: (obj: S3BucketDoesNotExistException) => any;
+}
+
+export interface TrailAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "TrailAlreadyExistsException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace TrailAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: TrailAlreadyExistsException) => any;
+}
+
+export interface TrailNotProvidedException extends __SmithyException, $MetadataBearer {
+    name: "TrailNotProvidedException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace TrailNotProvidedException {
+    
+    const filterSensitiveLog: (obj: TrailNotProvidedException) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ConflictException {
+    
+    const filterSensitiveLog: (obj: ConflictException) => any;
+}
+
+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 interface InvalidHomeRegionException extends __SmithyException, $MetadataBearer {
+    name: "InvalidHomeRegionException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidHomeRegionException {
+    
+    const filterSensitiveLog: (obj: InvalidHomeRegionException) => any;
+}
+
+export interface TrailNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "TrailNotFoundException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace TrailNotFoundException {
+    
+    const filterSensitiveLog: (obj: TrailNotFoundException) => 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 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"
+}
+
+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 interface InsightNotEnabledException extends __SmithyException, $MetadataBearer {
+    name: "InsightNotEnabledException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InsightNotEnabledException {
+    
+    const filterSensitiveLog: (obj: InsightNotEnabledException) => any;
+}
+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 InvalidTimeRangeException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTimeRangeException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidTimeRangeException {
+    
+    const filterSensitiveLog: (obj: InvalidTimeRangeException) => any;
+}
+
+export interface InvalidTokenException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTokenException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidTokenException {
+    
+    const filterSensitiveLog: (obj: InvalidTokenException) => any;
+}
+
+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 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 interface InvalidEventCategoryException extends __SmithyException, $MetadataBearer {
+    name: "InvalidEventCategoryException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidEventCategoryException {
+    
+    const filterSensitiveLog: (obj: InvalidEventCategoryException) => any;
+}
+
+export interface InvalidLookupAttributesException extends __SmithyException, $MetadataBearer {
+    name: "InvalidLookupAttributesException";
+    $fault: "client";
+    
+    Message?: string;
+}
+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"
+}
+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 interface InvalidEventSelectorsException extends __SmithyException, $MetadataBearer {
+    name: "InvalidEventSelectorsException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidEventSelectorsException {
+    
+    const filterSensitiveLog: (obj: InvalidEventSelectorsException) => any;
+}
+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 interface InvalidInsightSelectorsException extends __SmithyException, $MetadataBearer {
+    name: "InvalidInsightSelectorsException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidInsightSelectorsException {
+    
+    const filterSensitiveLog: (obj: InvalidInsightSelectorsException) => any;
+}
+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[];
+}
+export declare namespace RemoveTagsRequest {
+    
+    const filterSensitiveLog: (obj: RemoveTagsRequest) => any;
+}
+
+export interface RemoveTagsResponse {
+}
+export declare namespace RemoveTagsResponse {
+    
+    const filterSensitiveLog: (obj: RemoveTagsResponse) => 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 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 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;
+}