@aws-sdk/client-securityhub 3.50.0 → 3.51.0

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

@@ -0,0 +1,3667 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+import { AccountDetails, Action, ActionTarget, Adjustment, AdminAccount, AwsApiGatewayRestApiDetails, AwsApiGatewayStageDetails, AwsApiGatewayV2ApiDetails, AwsApiGatewayV2StageDetails, AwsAutoScalingAutoScalingGroupDetails, AwsAutoScalingLaunchConfigurationDetails, AwsCertificateManagerCertificateDetails, AwsCloudFrontDistributionDetails, AwsCloudTrailTrailDetails, AwsCodeBuildProjectDetails, AwsDynamoDbTableDetails, AwsEc2EipDetails, AwsEc2InstanceDetails, AwsEc2NetworkAclDetails, AwsEc2NetworkInterfaceDetails, AwsEc2SecurityGroupDetails, AwsEc2SubnetDetails, AwsEc2VolumeDetails, AwsEc2VpcDetails, AwsEc2VpcEndpointServiceDetails, AwsEc2VpnConnectionDetails, AwsEcrContainerImageDetails, AwsEcrRepositoryDetails, AwsEcsClusterDetails, AwsEcsServiceDetails, AwsEcsTaskDefinitionDetails, AwsEksClusterDetails, AwsElasticBeanstalkEnvironmentDetails, AwsElasticsearchDomainDetails, AwsElbLoadBalancerDetails, AwsElbv2LoadBalancerDetails, AwsIamAccessKeyDetails, AwsIamGroupDetails, AwsIamPolicyDetails, AwsIamRoleDetails, AwsIamUserDetails, AwsKmsKeyDetails, AwsLambdaFunctionDetails, AwsLambdaLayerVersionDetails, AwsNetworkFirewallFirewallDetails, AwsNetworkFirewallFirewallPolicyDetails, AwsNetworkFirewallRuleGroupDetails, AwsOpenSearchServiceDomainDetails, AwsRdsDbClusterDetails, AwsRdsDbClusterSnapshotDetails, AwsRdsDbDomainMembership, AwsRdsDbInstanceAssociatedRole, AwsRdsDbInstanceEndpoint, AwsRdsDbInstanceVpcSecurityGroup, AwsRdsDbOptionGroupMembership, AwsRdsDbParameterGroup, AwsRdsDbSubnetGroup, AwsRdsPendingCloudWatchLogsExports } from "./models_0";
+
+export interface AwsRdsDbProcessorFeature {
+    
+    Name?: string;
+    
+    Value?: string;
+}
+export declare namespace AwsRdsDbProcessorFeature {
+    
+    const filterSensitiveLog: (obj: AwsRdsDbProcessorFeature) => any;
+}
+
+export interface AwsRdsDbPendingModifiedValues {
+    
+    DbInstanceClass?: string;
+    
+    AllocatedStorage?: number;
+    
+    MasterUserPassword?: string;
+    
+    Port?: number;
+    
+    BackupRetentionPeriod?: number;
+    
+    MultiAZ?: boolean;
+    
+    EngineVersion?: string;
+    
+    LicenseModel?: string;
+    
+    Iops?: number;
+    
+    DbInstanceIdentifier?: string;
+    
+    StorageType?: string;
+    
+    CaCertificateIdentifier?: string;
+    
+    DbSubnetGroupName?: string;
+    
+    PendingCloudWatchLogsExports?: AwsRdsPendingCloudWatchLogsExports;
+    
+    ProcessorFeatures?: AwsRdsDbProcessorFeature[];
+}
+export declare namespace AwsRdsDbPendingModifiedValues {
+    
+    const filterSensitiveLog: (obj: AwsRdsDbPendingModifiedValues) => any;
+}
+
+export interface AwsRdsDbStatusInfo {
+    
+    StatusType?: string;
+    
+    Normal?: boolean;
+    
+    Status?: string;
+    
+    Message?: string;
+}
+export declare namespace AwsRdsDbStatusInfo {
+    
+    const filterSensitiveLog: (obj: AwsRdsDbStatusInfo) => any;
+}
+
+export interface AwsRdsDbInstanceDetails {
+    
+    AssociatedRoles?: AwsRdsDbInstanceAssociatedRole[];
+    
+    CACertificateIdentifier?: string;
+    
+    DBClusterIdentifier?: string;
+    
+    DBInstanceIdentifier?: string;
+    
+    DBInstanceClass?: string;
+    
+    DbInstancePort?: number;
+    
+    DbiResourceId?: string;
+    
+    DBName?: string;
+    
+    DeletionProtection?: boolean;
+    
+    Endpoint?: AwsRdsDbInstanceEndpoint;
+    
+    Engine?: string;
+    
+    EngineVersion?: string;
+    
+    IAMDatabaseAuthenticationEnabled?: boolean;
+    
+    InstanceCreateTime?: string;
+    
+    KmsKeyId?: string;
+    
+    PubliclyAccessible?: boolean;
+    
+    StorageEncrypted?: boolean;
+    
+    TdeCredentialArn?: string;
+    
+    VpcSecurityGroups?: AwsRdsDbInstanceVpcSecurityGroup[];
+    
+    MultiAz?: boolean;
+    
+    EnhancedMonitoringResourceArn?: string;
+    
+    DbInstanceStatus?: string;
+    
+    MasterUsername?: string;
+    
+    AllocatedStorage?: number;
+    
+    PreferredBackupWindow?: string;
+    
+    BackupRetentionPeriod?: number;
+    
+    DbSecurityGroups?: string[];
+    
+    DbParameterGroups?: AwsRdsDbParameterGroup[];
+    
+    AvailabilityZone?: string;
+    
+    DbSubnetGroup?: AwsRdsDbSubnetGroup;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    PendingModifiedValues?: AwsRdsDbPendingModifiedValues;
+    
+    LatestRestorableTime?: string;
+    
+    AutoMinorVersionUpgrade?: boolean;
+    
+    ReadReplicaSourceDBInstanceIdentifier?: string;
+    
+    ReadReplicaDBInstanceIdentifiers?: string[];
+    
+    ReadReplicaDBClusterIdentifiers?: string[];
+    
+    LicenseModel?: string;
+    
+    Iops?: number;
+    
+    OptionGroupMemberships?: AwsRdsDbOptionGroupMembership[];
+    
+    CharacterSetName?: string;
+    
+    SecondaryAvailabilityZone?: string;
+    
+    StatusInfos?: AwsRdsDbStatusInfo[];
+    
+    StorageType?: string;
+    
+    DomainMemberships?: AwsRdsDbDomainMembership[];
+    
+    CopyTagsToSnapshot?: boolean;
+    
+    MonitoringInterval?: number;
+    
+    MonitoringRoleArn?: string;
+    
+    PromotionTier?: number;
+    
+    Timezone?: string;
+    
+    PerformanceInsightsEnabled?: boolean;
+    
+    PerformanceInsightsKmsKeyId?: string;
+    
+    PerformanceInsightsRetentionPeriod?: number;
+    
+    EnabledCloudWatchLogsExports?: string[];
+    
+    ProcessorFeatures?: AwsRdsDbProcessorFeature[];
+    
+    ListenerEndpoint?: AwsRdsDbInstanceEndpoint;
+    
+    MaxAllocatedStorage?: number;
+}
+export declare namespace AwsRdsDbInstanceDetails {
+    
+    const filterSensitiveLog: (obj: AwsRdsDbInstanceDetails) => any;
+}
+
+export interface AwsRdsDbSnapshotDetails {
+    
+    DbSnapshotIdentifier?: string;
+    
+    DbInstanceIdentifier?: string;
+    
+    SnapshotCreateTime?: string;
+    
+    Engine?: string;
+    
+    AllocatedStorage?: number;
+    
+    Status?: string;
+    
+    Port?: number;
+    
+    AvailabilityZone?: string;
+    
+    VpcId?: string;
+    
+    InstanceCreateTime?: string;
+    
+    MasterUsername?: string;
+    
+    EngineVersion?: string;
+    
+    LicenseModel?: string;
+    
+    SnapshotType?: string;
+    
+    Iops?: number;
+    
+    OptionGroupName?: string;
+    
+    PercentProgress?: number;
+    
+    SourceRegion?: string;
+    
+    SourceDbSnapshotIdentifier?: string;
+    
+    StorageType?: string;
+    
+    TdeCredentialArn?: string;
+    
+    Encrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    Timezone?: string;
+    
+    IamDatabaseAuthenticationEnabled?: boolean;
+    
+    ProcessorFeatures?: AwsRdsDbProcessorFeature[];
+    
+    DbiResourceId?: string;
+}
+export declare namespace AwsRdsDbSnapshotDetails {
+    
+    const filterSensitiveLog: (obj: AwsRdsDbSnapshotDetails) => any;
+}
+
+export interface AwsRdsEventSubscriptionDetails {
+    
+    CustSubscriptionId?: string;
+    
+    CustomerAwsId?: string;
+    
+    Enabled?: boolean;
+    
+    EventCategoriesList?: string[];
+    
+    EventSubscriptionArn?: string;
+    
+    SnsTopicArn?: string;
+    
+    SourceIdsList?: string[];
+    
+    SourceType?: string;
+    
+    Status?: string;
+    
+    SubscriptionCreationTime?: string;
+}
+export declare namespace AwsRdsEventSubscriptionDetails {
+    
+    const filterSensitiveLog: (obj: AwsRdsEventSubscriptionDetails) => any;
+}
+
+export interface AwsRedshiftClusterClusterNode {
+    
+    NodeRole?: string;
+    
+    PrivateIpAddress?: string;
+    
+    PublicIpAddress?: string;
+}
+export declare namespace AwsRedshiftClusterClusterNode {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterClusterNode) => any;
+}
+
+export interface AwsRedshiftClusterClusterParameterStatus {
+    
+    ParameterName?: string;
+    
+    ParameterApplyStatus?: string;
+    
+    ParameterApplyErrorDescription?: string;
+}
+export declare namespace AwsRedshiftClusterClusterParameterStatus {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterClusterParameterStatus) => any;
+}
+
+export interface AwsRedshiftClusterClusterParameterGroup {
+    
+    ClusterParameterStatusList?: AwsRedshiftClusterClusterParameterStatus[];
+    
+    ParameterApplyStatus?: string;
+    
+    ParameterGroupName?: string;
+}
+export declare namespace AwsRedshiftClusterClusterParameterGroup {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterClusterParameterGroup) => any;
+}
+
+export interface AwsRedshiftClusterClusterSecurityGroup {
+    
+    ClusterSecurityGroupName?: string;
+    
+    Status?: string;
+}
+export declare namespace AwsRedshiftClusterClusterSecurityGroup {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterClusterSecurityGroup) => any;
+}
+
+export interface AwsRedshiftClusterClusterSnapshotCopyStatus {
+    
+    DestinationRegion?: string;
+    
+    ManualSnapshotRetentionPeriod?: number;
+    
+    RetentionPeriod?: number;
+    
+    SnapshotCopyGrantName?: string;
+}
+export declare namespace AwsRedshiftClusterClusterSnapshotCopyStatus {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterClusterSnapshotCopyStatus) => any;
+}
+
+export interface AwsRedshiftClusterDeferredMaintenanceWindow {
+    
+    DeferMaintenanceEndTime?: string;
+    
+    DeferMaintenanceIdentifier?: string;
+    
+    DeferMaintenanceStartTime?: string;
+}
+export declare namespace AwsRedshiftClusterDeferredMaintenanceWindow {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterDeferredMaintenanceWindow) => any;
+}
+
+export interface AwsRedshiftClusterElasticIpStatus {
+    
+    ElasticIp?: string;
+    
+    Status?: string;
+}
+export declare namespace AwsRedshiftClusterElasticIpStatus {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterElasticIpStatus) => any;
+}
+
+export interface AwsRedshiftClusterEndpoint {
+    
+    Address?: string;
+    
+    Port?: number;
+}
+export declare namespace AwsRedshiftClusterEndpoint {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterEndpoint) => any;
+}
+
+export interface AwsRedshiftClusterHsmStatus {
+    
+    HsmClientCertificateIdentifier?: string;
+    
+    HsmConfigurationIdentifier?: string;
+    
+    Status?: string;
+}
+export declare namespace AwsRedshiftClusterHsmStatus {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterHsmStatus) => any;
+}
+
+export interface AwsRedshiftClusterIamRole {
+    
+    ApplyStatus?: string;
+    
+    IamRoleArn?: string;
+}
+export declare namespace AwsRedshiftClusterIamRole {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterIamRole) => any;
+}
+
+export interface AwsRedshiftClusterPendingModifiedValues {
+    
+    AutomatedSnapshotRetentionPeriod?: number;
+    
+    ClusterIdentifier?: string;
+    
+    ClusterType?: string;
+    
+    ClusterVersion?: string;
+    
+    EncryptionType?: string;
+    
+    EnhancedVpcRouting?: boolean;
+    
+    MaintenanceTrackName?: string;
+    
+    MasterUserPassword?: string;
+    
+    NodeType?: string;
+    
+    NumberOfNodes?: number;
+    
+    PubliclyAccessible?: boolean;
+}
+export declare namespace AwsRedshiftClusterPendingModifiedValues {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterPendingModifiedValues) => any;
+}
+
+export interface AwsRedshiftClusterResizeInfo {
+    
+    AllowCancelResize?: boolean;
+    
+    ResizeType?: string;
+}
+export declare namespace AwsRedshiftClusterResizeInfo {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterResizeInfo) => any;
+}
+
+export interface AwsRedshiftClusterRestoreStatus {
+    
+    CurrentRestoreRateInMegaBytesPerSecond?: number;
+    
+    ElapsedTimeInSeconds?: number;
+    
+    EstimatedTimeToCompletionInSeconds?: number;
+    
+    ProgressInMegaBytes?: number;
+    
+    SnapshotSizeInMegaBytes?: number;
+    
+    Status?: string;
+}
+export declare namespace AwsRedshiftClusterRestoreStatus {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterRestoreStatus) => any;
+}
+
+export interface AwsRedshiftClusterVpcSecurityGroup {
+    
+    Status?: string;
+    
+    VpcSecurityGroupId?: string;
+}
+export declare namespace AwsRedshiftClusterVpcSecurityGroup {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterVpcSecurityGroup) => any;
+}
+
+export interface AwsRedshiftClusterDetails {
+    
+    AllowVersionUpgrade?: boolean;
+    
+    AutomatedSnapshotRetentionPeriod?: number;
+    
+    AvailabilityZone?: string;
+    
+    ClusterAvailabilityStatus?: string;
+    
+    ClusterCreateTime?: string;
+    
+    ClusterIdentifier?: string;
+    
+    ClusterNodes?: AwsRedshiftClusterClusterNode[];
+    
+    ClusterParameterGroups?: AwsRedshiftClusterClusterParameterGroup[];
+    
+    ClusterPublicKey?: string;
+    
+    ClusterRevisionNumber?: string;
+    
+    ClusterSecurityGroups?: AwsRedshiftClusterClusterSecurityGroup[];
+    
+    ClusterSnapshotCopyStatus?: AwsRedshiftClusterClusterSnapshotCopyStatus;
+    
+    ClusterStatus?: string;
+    
+    ClusterSubnetGroupName?: string;
+    
+    ClusterVersion?: string;
+    
+    DBName?: string;
+    
+    DeferredMaintenanceWindows?: AwsRedshiftClusterDeferredMaintenanceWindow[];
+    
+    ElasticIpStatus?: AwsRedshiftClusterElasticIpStatus;
+    
+    ElasticResizeNumberOfNodeOptions?: string;
+    
+    Encrypted?: boolean;
+    
+    Endpoint?: AwsRedshiftClusterEndpoint;
+    
+    EnhancedVpcRouting?: boolean;
+    
+    ExpectedNextSnapshotScheduleTime?: string;
+    
+    ExpectedNextSnapshotScheduleTimeStatus?: string;
+    
+    HsmStatus?: AwsRedshiftClusterHsmStatus;
+    
+    IamRoles?: AwsRedshiftClusterIamRole[];
+    
+    KmsKeyId?: string;
+    
+    MaintenanceTrackName?: string;
+    
+    ManualSnapshotRetentionPeriod?: number;
+    
+    MasterUsername?: string;
+    
+    NextMaintenanceWindowStartTime?: string;
+    
+    NodeType?: string;
+    
+    NumberOfNodes?: number;
+    
+    PendingActions?: string[];
+    
+    PendingModifiedValues?: AwsRedshiftClusterPendingModifiedValues;
+    
+    PreferredMaintenanceWindow?: string;
+    
+    PubliclyAccessible?: boolean;
+    
+    ResizeInfo?: AwsRedshiftClusterResizeInfo;
+    
+    RestoreStatus?: AwsRedshiftClusterRestoreStatus;
+    
+    SnapshotScheduleIdentifier?: string;
+    
+    SnapshotScheduleState?: string;
+    
+    VpcId?: string;
+    
+    VpcSecurityGroups?: AwsRedshiftClusterVpcSecurityGroup[];
+}
+export declare namespace AwsRedshiftClusterDetails {
+    
+    const filterSensitiveLog: (obj: AwsRedshiftClusterDetails) => any;
+}
+
+export interface AwsS3AccountPublicAccessBlockDetails {
+    
+    BlockPublicAcls?: boolean;
+    
+    BlockPublicPolicy?: boolean;
+    
+    IgnorePublicAcls?: boolean;
+    
+    RestrictPublicBuckets?: boolean;
+}
+export declare namespace AwsS3AccountPublicAccessBlockDetails {
+    
+    const filterSensitiveLog: (obj: AwsS3AccountPublicAccessBlockDetails) => any;
+}
+
+export interface AwsS3BucketBucketLifecycleConfigurationRulesAbortIncompleteMultipartUploadDetails {
+    
+    DaysAfterInitiation?: number;
+}
+export declare namespace AwsS3BucketBucketLifecycleConfigurationRulesAbortIncompleteMultipartUploadDetails {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketBucketLifecycleConfigurationRulesAbortIncompleteMultipartUploadDetails) => any;
+}
+
+export interface AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateOperandsTagDetails {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateOperandsTagDetails {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateOperandsTagDetails) => any;
+}
+
+export interface AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateOperandsDetails {
+    
+    Prefix?: string;
+    
+    Tag?: AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateOperandsTagDetails;
+    
+    Type?: string;
+}
+export declare namespace AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateOperandsDetails {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateOperandsDetails) => any;
+}
+
+export interface AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateTagDetails {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateTagDetails {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateTagDetails) => any;
+}
+
+export interface AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateDetails {
+    
+    Operands?: AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateOperandsDetails[];
+    
+    Prefix?: string;
+    
+    Tag?: AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateTagDetails;
+    
+    Type?: string;
+}
+export declare namespace AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateDetails {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateDetails) => any;
+}
+
+export interface AwsS3BucketBucketLifecycleConfigurationRulesFilterDetails {
+    
+    Predicate?: AwsS3BucketBucketLifecycleConfigurationRulesFilterPredicateDetails;
+}
+export declare namespace AwsS3BucketBucketLifecycleConfigurationRulesFilterDetails {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketBucketLifecycleConfigurationRulesFilterDetails) => any;
+}
+
+export interface AwsS3BucketBucketLifecycleConfigurationRulesNoncurrentVersionTransitionsDetails {
+    
+    Days?: number;
+    
+    StorageClass?: string;
+}
+export declare namespace AwsS3BucketBucketLifecycleConfigurationRulesNoncurrentVersionTransitionsDetails {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketBucketLifecycleConfigurationRulesNoncurrentVersionTransitionsDetails) => any;
+}
+
+export interface AwsS3BucketBucketLifecycleConfigurationRulesTransitionsDetails {
+    
+    Date?: string;
+    
+    Days?: number;
+    
+    StorageClass?: string;
+}
+export declare namespace AwsS3BucketBucketLifecycleConfigurationRulesTransitionsDetails {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketBucketLifecycleConfigurationRulesTransitionsDetails) => any;
+}
+
+export interface AwsS3BucketBucketLifecycleConfigurationRulesDetails {
+    
+    AbortIncompleteMultipartUpload?: AwsS3BucketBucketLifecycleConfigurationRulesAbortIncompleteMultipartUploadDetails;
+    
+    ExpirationDate?: string;
+    
+    ExpirationInDays?: number;
+    
+    ExpiredObjectDeleteMarker?: boolean;
+    
+    Filter?: AwsS3BucketBucketLifecycleConfigurationRulesFilterDetails;
+    
+    ID?: string;
+    
+    NoncurrentVersionExpirationInDays?: number;
+    
+    NoncurrentVersionTransitions?: AwsS3BucketBucketLifecycleConfigurationRulesNoncurrentVersionTransitionsDetails[];
+    
+    Prefix?: string;
+    
+    Status?: string;
+    
+    Transitions?: AwsS3BucketBucketLifecycleConfigurationRulesTransitionsDetails[];
+}
+export declare namespace AwsS3BucketBucketLifecycleConfigurationRulesDetails {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketBucketLifecycleConfigurationRulesDetails) => any;
+}
+
+export interface AwsS3BucketBucketLifecycleConfigurationDetails {
+    
+    Rules?: AwsS3BucketBucketLifecycleConfigurationRulesDetails[];
+}
+export declare namespace AwsS3BucketBucketLifecycleConfigurationDetails {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketBucketLifecycleConfigurationDetails) => any;
+}
+
+export interface AwsS3BucketBucketVersioningConfiguration {
+    
+    IsMfaDeleteEnabled?: boolean;
+    
+    Status?: string;
+}
+export declare namespace AwsS3BucketBucketVersioningConfiguration {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketBucketVersioningConfiguration) => any;
+}
+
+export interface AwsS3BucketLoggingConfiguration {
+    
+    DestinationBucketName?: string;
+    
+    LogFilePrefix?: string;
+}
+export declare namespace AwsS3BucketLoggingConfiguration {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketLoggingConfiguration) => any;
+}
+export declare enum AwsS3BucketNotificationConfigurationS3KeyFilterRuleName {
+    PREFIX = "Prefix",
+    SUFFIX = "Suffix"
+}
+
+export interface AwsS3BucketNotificationConfigurationS3KeyFilterRule {
+    
+    Name?: AwsS3BucketNotificationConfigurationS3KeyFilterRuleName | string;
+    
+    Value?: string;
+}
+export declare namespace AwsS3BucketNotificationConfigurationS3KeyFilterRule {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketNotificationConfigurationS3KeyFilterRule) => any;
+}
+
+export interface AwsS3BucketNotificationConfigurationS3KeyFilter {
+    
+    FilterRules?: AwsS3BucketNotificationConfigurationS3KeyFilterRule[];
+}
+export declare namespace AwsS3BucketNotificationConfigurationS3KeyFilter {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketNotificationConfigurationS3KeyFilter) => any;
+}
+
+export interface AwsS3BucketNotificationConfigurationFilter {
+    
+    S3KeyFilter?: AwsS3BucketNotificationConfigurationS3KeyFilter;
+}
+export declare namespace AwsS3BucketNotificationConfigurationFilter {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketNotificationConfigurationFilter) => any;
+}
+
+export interface AwsS3BucketNotificationConfigurationDetail {
+    
+    Events?: string[];
+    
+    Filter?: AwsS3BucketNotificationConfigurationFilter;
+    
+    Destination?: string;
+    
+    Type?: string;
+}
+export declare namespace AwsS3BucketNotificationConfigurationDetail {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketNotificationConfigurationDetail) => any;
+}
+
+export interface AwsS3BucketNotificationConfiguration {
+    
+    Configurations?: AwsS3BucketNotificationConfigurationDetail[];
+}
+export declare namespace AwsS3BucketNotificationConfiguration {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketNotificationConfiguration) => any;
+}
+
+export interface AwsS3BucketWebsiteConfigurationRedirectTo {
+    
+    Hostname?: string;
+    
+    Protocol?: string;
+}
+export declare namespace AwsS3BucketWebsiteConfigurationRedirectTo {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketWebsiteConfigurationRedirectTo) => any;
+}
+
+export interface AwsS3BucketWebsiteConfigurationRoutingRuleCondition {
+    
+    HttpErrorCodeReturnedEquals?: string;
+    
+    KeyPrefixEquals?: string;
+}
+export declare namespace AwsS3BucketWebsiteConfigurationRoutingRuleCondition {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketWebsiteConfigurationRoutingRuleCondition) => any;
+}
+
+export interface AwsS3BucketWebsiteConfigurationRoutingRuleRedirect {
+    
+    Hostname?: string;
+    
+    HttpRedirectCode?: string;
+    
+    Protocol?: string;
+    
+    ReplaceKeyPrefixWith?: string;
+    
+    ReplaceKeyWith?: string;
+}
+export declare namespace AwsS3BucketWebsiteConfigurationRoutingRuleRedirect {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketWebsiteConfigurationRoutingRuleRedirect) => any;
+}
+
+export interface AwsS3BucketWebsiteConfigurationRoutingRule {
+    
+    Condition?: AwsS3BucketWebsiteConfigurationRoutingRuleCondition;
+    
+    Redirect?: AwsS3BucketWebsiteConfigurationRoutingRuleRedirect;
+}
+export declare namespace AwsS3BucketWebsiteConfigurationRoutingRule {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketWebsiteConfigurationRoutingRule) => any;
+}
+
+export interface AwsS3BucketWebsiteConfiguration {
+    
+    ErrorDocument?: string;
+    
+    IndexDocumentSuffix?: string;
+    
+    RedirectAllRequestsTo?: AwsS3BucketWebsiteConfigurationRedirectTo;
+    
+    RoutingRules?: AwsS3BucketWebsiteConfigurationRoutingRule[];
+}
+export declare namespace AwsS3BucketWebsiteConfiguration {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketWebsiteConfiguration) => any;
+}
+
+export interface AwsS3BucketServerSideEncryptionByDefault {
+    
+    SSEAlgorithm?: string;
+    
+    KMSMasterKeyID?: string;
+}
+export declare namespace AwsS3BucketServerSideEncryptionByDefault {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketServerSideEncryptionByDefault) => any;
+}
+
+export interface AwsS3BucketServerSideEncryptionRule {
+    
+    ApplyServerSideEncryptionByDefault?: AwsS3BucketServerSideEncryptionByDefault;
+}
+export declare namespace AwsS3BucketServerSideEncryptionRule {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketServerSideEncryptionRule) => any;
+}
+
+export interface AwsS3BucketServerSideEncryptionConfiguration {
+    
+    Rules?: AwsS3BucketServerSideEncryptionRule[];
+}
+export declare namespace AwsS3BucketServerSideEncryptionConfiguration {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketServerSideEncryptionConfiguration) => any;
+}
+
+export interface AwsS3BucketDetails {
+    
+    OwnerId?: string;
+    
+    OwnerName?: string;
+    
+    OwnerAccountId?: string;
+    
+    CreatedAt?: string;
+    
+    ServerSideEncryptionConfiguration?: AwsS3BucketServerSideEncryptionConfiguration;
+    
+    BucketLifecycleConfiguration?: AwsS3BucketBucketLifecycleConfigurationDetails;
+    
+    PublicAccessBlockConfiguration?: AwsS3AccountPublicAccessBlockDetails;
+    
+    AccessControlList?: string;
+    
+    BucketLoggingConfiguration?: AwsS3BucketLoggingConfiguration;
+    
+    BucketWebsiteConfiguration?: AwsS3BucketWebsiteConfiguration;
+    
+    BucketNotificationConfiguration?: AwsS3BucketNotificationConfiguration;
+    
+    BucketVersioningConfiguration?: AwsS3BucketBucketVersioningConfiguration;
+}
+export declare namespace AwsS3BucketDetails {
+    
+    const filterSensitiveLog: (obj: AwsS3BucketDetails) => any;
+}
+
+export interface AwsS3ObjectDetails {
+    
+    LastModified?: string;
+    
+    ETag?: string;
+    
+    VersionId?: string;
+    
+    ContentType?: string;
+    
+    ServerSideEncryption?: string;
+    
+    SSEKMSKeyId?: string;
+}
+export declare namespace AwsS3ObjectDetails {
+    
+    const filterSensitiveLog: (obj: AwsS3ObjectDetails) => any;
+}
+
+export interface AwsSecretsManagerSecretRotationRules {
+    
+    AutomaticallyAfterDays?: number;
+}
+export declare namespace AwsSecretsManagerSecretRotationRules {
+    
+    const filterSensitiveLog: (obj: AwsSecretsManagerSecretRotationRules) => any;
+}
+
+export interface AwsSecretsManagerSecretDetails {
+    
+    RotationRules?: AwsSecretsManagerSecretRotationRules;
+    
+    RotationOccurredWithinFrequency?: boolean;
+    
+    KmsKeyId?: string;
+    
+    RotationEnabled?: boolean;
+    
+    RotationLambdaArn?: string;
+    
+    Deleted?: boolean;
+    
+    Name?: string;
+    
+    Description?: string;
+}
+export declare namespace AwsSecretsManagerSecretDetails {
+    
+    const filterSensitiveLog: (obj: AwsSecretsManagerSecretDetails) => any;
+}
+export declare enum ComplianceStatus {
+    FAILED = "FAILED",
+    NOT_AVAILABLE = "NOT_AVAILABLE",
+    PASSED = "PASSED",
+    WARNING = "WARNING"
+}
+
+export interface StatusReason {
+    
+    ReasonCode: string | undefined;
+    
+    Description?: string;
+}
+export declare namespace StatusReason {
+    
+    const filterSensitiveLog: (obj: StatusReason) => any;
+}
+
+export interface Compliance {
+    
+    Status?: ComplianceStatus | string;
+    
+    RelatedRequirements?: string[];
+    
+    StatusReasons?: StatusReason[];
+}
+export declare namespace Compliance {
+    
+    const filterSensitiveLog: (obj: Compliance) => any;
+}
+
+export interface RelatedFinding {
+    
+    ProductArn: string | undefined;
+    
+    Id: string | undefined;
+}
+export declare namespace RelatedFinding {
+    
+    const filterSensitiveLog: (obj: RelatedFinding) => any;
+}
+export declare enum SeverityLabel {
+    CRITICAL = "CRITICAL",
+    HIGH = "HIGH",
+    INFORMATIONAL = "INFORMATIONAL",
+    LOW = "LOW",
+    MEDIUM = "MEDIUM"
+}
+
+export interface FindingProviderSeverity {
+    
+    Label?: SeverityLabel | string;
+    
+    Original?: string;
+}
+export declare namespace FindingProviderSeverity {
+    
+    const filterSensitiveLog: (obj: FindingProviderSeverity) => any;
+}
+
+export interface FindingProviderFields {
+    
+    Confidence?: number;
+    
+    Criticality?: number;
+    
+    RelatedFindings?: RelatedFinding[];
+    
+    Severity?: FindingProviderSeverity;
+    
+    Types?: string[];
+}
+export declare namespace FindingProviderFields {
+    
+    const filterSensitiveLog: (obj: FindingProviderFields) => any;
+}
+export declare enum MalwareState {
+    OBSERVED = "OBSERVED",
+    REMOVAL_FAILED = "REMOVAL_FAILED",
+    REMOVED = "REMOVED"
+}
+export declare enum MalwareType {
+    ADWARE = "ADWARE",
+    BLENDED_THREAT = "BLENDED_THREAT",
+    BOTNET_AGENT = "BOTNET_AGENT",
+    COIN_MINER = "COIN_MINER",
+    EXPLOIT_KIT = "EXPLOIT_KIT",
+    KEYLOGGER = "KEYLOGGER",
+    MACRO = "MACRO",
+    POTENTIALLY_UNWANTED = "POTENTIALLY_UNWANTED",
+    RANSOMWARE = "RANSOMWARE",
+    REMOTE_ACCESS = "REMOTE_ACCESS",
+    ROOTKIT = "ROOTKIT",
+    SPYWARE = "SPYWARE",
+    TROJAN = "TROJAN",
+    VIRUS = "VIRUS",
+    WORM = "WORM"
+}
+
+export interface Malware {
+    
+    Name: string | undefined;
+    
+    Type?: MalwareType | string;
+    
+    Path?: string;
+    
+    State?: MalwareState | string;
+}
+export declare namespace Malware {
+    
+    const filterSensitiveLog: (obj: Malware) => any;
+}
+export declare enum NetworkDirection {
+    IN = "IN",
+    OUT = "OUT"
+}
+
+export interface PortRange {
+    
+    Begin?: number;
+    
+    End?: number;
+}
+export declare namespace PortRange {
+    
+    const filterSensitiveLog: (obj: PortRange) => any;
+}
+
+export interface Network {
+    
+    Direction?: NetworkDirection | string;
+    
+    Protocol?: string;
+    
+    OpenPortRange?: PortRange;
+    
+    SourceIpV4?: string;
+    
+    SourceIpV6?: string;
+    
+    SourcePort?: number;
+    
+    SourceDomain?: string;
+    
+    SourceMac?: string;
+    
+    DestinationIpV4?: string;
+    
+    DestinationIpV6?: string;
+    
+    DestinationPort?: number;
+    
+    DestinationDomain?: string;
+}
+export declare namespace Network {
+    
+    const filterSensitiveLog: (obj: Network) => any;
+}
+
+export interface NetworkPathComponentDetails {
+    
+    Address?: string[];
+    
+    PortRanges?: PortRange[];
+}
+export declare namespace NetworkPathComponentDetails {
+    
+    const filterSensitiveLog: (obj: NetworkPathComponentDetails) => any;
+}
+
+export interface NetworkHeader {
+    
+    Protocol?: string;
+    
+    Destination?: NetworkPathComponentDetails;
+    
+    Source?: NetworkPathComponentDetails;
+}
+export declare namespace NetworkHeader {
+    
+    const filterSensitiveLog: (obj: NetworkHeader) => any;
+}
+
+export interface NetworkPathComponent {
+    
+    ComponentId?: string;
+    
+    ComponentType?: string;
+    
+    Egress?: NetworkHeader;
+    
+    Ingress?: NetworkHeader;
+}
+export declare namespace NetworkPathComponent {
+    
+    const filterSensitiveLog: (obj: NetworkPathComponent) => any;
+}
+
+export interface Note {
+    
+    Text: string | undefined;
+    
+    UpdatedBy: string | undefined;
+    
+    UpdatedAt: string | undefined;
+}
+export declare namespace Note {
+    
+    const filterSensitiveLog: (obj: Note) => any;
+}
+
+export interface PatchSummary {
+    
+    Id: string | undefined;
+    
+    InstalledCount?: number;
+    
+    MissingCount?: number;
+    
+    FailedCount?: number;
+    
+    InstalledOtherCount?: number;
+    
+    InstalledRejectedCount?: number;
+    
+    InstalledPendingReboot?: number;
+    
+    OperationStartTime?: string;
+    
+    OperationEndTime?: string;
+    
+    RebootOption?: string;
+    
+    Operation?: string;
+}
+export declare namespace PatchSummary {
+    
+    const filterSensitiveLog: (obj: PatchSummary) => any;
+}
+
+export interface ProcessDetails {
+    
+    Name?: string;
+    
+    Path?: string;
+    
+    Pid?: number;
+    
+    ParentPid?: number;
+    
+    LaunchedAt?: string;
+    
+    TerminatedAt?: string;
+}
+export declare namespace ProcessDetails {
+    
+    const filterSensitiveLog: (obj: ProcessDetails) => any;
+}
+export declare enum RecordState {
+    ACTIVE = "ACTIVE",
+    ARCHIVED = "ARCHIVED"
+}
+
+export interface Recommendation {
+    
+    Text?: string;
+    
+    Url?: string;
+}
+export declare namespace Recommendation {
+    
+    const filterSensitiveLog: (obj: Recommendation) => any;
+}
+
+export interface Remediation {
+    
+    Recommendation?: Recommendation;
+}
+export declare namespace Remediation {
+    
+    const filterSensitiveLog: (obj: Remediation) => any;
+}
+
+export interface Cell {
+    
+    Column?: number;
+    
+    Row?: number;
+    
+    ColumnName?: string;
+    
+    CellReference?: string;
+}
+export declare namespace Cell {
+    
+    const filterSensitiveLog: (obj: Cell) => any;
+}
+
+export interface Range {
+    
+    Start?: number;
+    
+    End?: number;
+    
+    StartColumn?: number;
+}
+export declare namespace Range {
+    
+    const filterSensitiveLog: (obj: Range) => any;
+}
+
+export interface Page {
+    
+    PageNumber?: number;
+    
+    LineRange?: Range;
+    
+    OffsetRange?: Range;
+}
+export declare namespace Page {
+    
+    const filterSensitiveLog: (obj: Page) => any;
+}
+
+export interface _Record {
+    
+    JsonPath?: string;
+    
+    RecordIndex?: number;
+}
+export declare namespace _Record {
+    
+    const filterSensitiveLog: (obj: _Record) => any;
+}
+
+export interface Occurrences {
+    
+    LineRanges?: Range[];
+    
+    OffsetRanges?: Range[];
+    
+    Pages?: Page[];
+    
+    Records?: _Record[];
+    
+    Cells?: Cell[];
+}
+export declare namespace Occurrences {
+    
+    const filterSensitiveLog: (obj: Occurrences) => any;
+}
+
+export interface CustomDataIdentifiersDetections {
+    
+    Count?: number;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    Occurrences?: Occurrences;
+}
+export declare namespace CustomDataIdentifiersDetections {
+    
+    const filterSensitiveLog: (obj: CustomDataIdentifiersDetections) => any;
+}
+
+export interface CustomDataIdentifiersResult {
+    
+    Detections?: CustomDataIdentifiersDetections[];
+    
+    TotalCount?: number;
+}
+export declare namespace CustomDataIdentifiersResult {
+    
+    const filterSensitiveLog: (obj: CustomDataIdentifiersResult) => any;
+}
+
+export interface SensitiveDataDetections {
+    
+    Count?: number;
+    
+    Type?: string;
+    
+    Occurrences?: Occurrences;
+}
+export declare namespace SensitiveDataDetections {
+    
+    const filterSensitiveLog: (obj: SensitiveDataDetections) => any;
+}
+
+export interface SensitiveDataResult {
+    
+    Category?: string;
+    
+    Detections?: SensitiveDataDetections[];
+    
+    TotalCount?: number;
+}
+export declare namespace SensitiveDataResult {
+    
+    const filterSensitiveLog: (obj: SensitiveDataResult) => any;
+}
+
+export interface ClassificationStatus {
+    
+    Code?: string;
+    
+    Reason?: string;
+}
+export declare namespace ClassificationStatus {
+    
+    const filterSensitiveLog: (obj: ClassificationStatus) => any;
+}
+
+export interface ClassificationResult {
+    
+    MimeType?: string;
+    
+    SizeClassified?: number;
+    
+    AdditionalOccurrences?: boolean;
+    
+    Status?: ClassificationStatus;
+    
+    SensitiveData?: SensitiveDataResult[];
+    
+    CustomDataIdentifiers?: CustomDataIdentifiersResult;
+}
+export declare namespace ClassificationResult {
+    
+    const filterSensitiveLog: (obj: ClassificationResult) => any;
+}
+
+export interface DataClassificationDetails {
+    
+    DetailedResultsLocation?: string;
+    
+    Result?: ClassificationResult;
+}
+export declare namespace DataClassificationDetails {
+    
+    const filterSensitiveLog: (obj: DataClassificationDetails) => any;
+}
+
+export interface AwsSnsTopicSubscription {
+    
+    Endpoint?: string;
+    
+    Protocol?: string;
+}
+export declare namespace AwsSnsTopicSubscription {
+    
+    const filterSensitiveLog: (obj: AwsSnsTopicSubscription) => any;
+}
+
+export interface AwsSnsTopicDetails {
+    
+    KmsMasterKeyId?: string;
+    
+    Subscription?: AwsSnsTopicSubscription[];
+    
+    TopicName?: string;
+    
+    Owner?: string;
+}
+export declare namespace AwsSnsTopicDetails {
+    
+    const filterSensitiveLog: (obj: AwsSnsTopicDetails) => any;
+}
+
+export interface AwsSqsQueueDetails {
+    
+    KmsDataKeyReusePeriodSeconds?: number;
+    
+    KmsMasterKeyId?: string;
+    
+    QueueName?: string;
+    
+    DeadLetterTargetArn?: string;
+}
+export declare namespace AwsSqsQueueDetails {
+    
+    const filterSensitiveLog: (obj: AwsSqsQueueDetails) => any;
+}
+
+export interface AwsSsmComplianceSummary {
+    
+    Status?: string;
+    
+    CompliantCriticalCount?: number;
+    
+    CompliantHighCount?: number;
+    
+    CompliantMediumCount?: number;
+    
+    ExecutionType?: string;
+    
+    NonCompliantCriticalCount?: number;
+    
+    CompliantInformationalCount?: number;
+    
+    NonCompliantInformationalCount?: number;
+    
+    CompliantUnspecifiedCount?: number;
+    
+    NonCompliantLowCount?: number;
+    
+    NonCompliantHighCount?: number;
+    
+    CompliantLowCount?: number;
+    
+    ComplianceType?: string;
+    
+    PatchBaselineId?: string;
+    
+    OverallSeverity?: string;
+    
+    NonCompliantMediumCount?: number;
+    
+    NonCompliantUnspecifiedCount?: number;
+    
+    PatchGroup?: string;
+}
+export declare namespace AwsSsmComplianceSummary {
+    
+    const filterSensitiveLog: (obj: AwsSsmComplianceSummary) => any;
+}
+
+export interface AwsSsmPatch {
+    
+    ComplianceSummary?: AwsSsmComplianceSummary;
+}
+export declare namespace AwsSsmPatch {
+    
+    const filterSensitiveLog: (obj: AwsSsmPatch) => any;
+}
+
+export interface AwsSsmPatchComplianceDetails {
+    
+    Patch?: AwsSsmPatch;
+}
+export declare namespace AwsSsmPatchComplianceDetails {
+    
+    const filterSensitiveLog: (obj: AwsSsmPatchComplianceDetails) => any;
+}
+
+export interface AwsWafRateBasedRuleMatchPredicate {
+    
+    DataId?: string;
+    
+    Negated?: boolean;
+    
+    Type?: string;
+}
+export declare namespace AwsWafRateBasedRuleMatchPredicate {
+    
+    const filterSensitiveLog: (obj: AwsWafRateBasedRuleMatchPredicate) => any;
+}
+
+export interface AwsWafRateBasedRuleDetails {
+    
+    MetricName?: string;
+    
+    Name?: string;
+    
+    RateKey?: string;
+    
+    RateLimit?: number;
+    
+    RuleId?: string;
+    
+    MatchPredicates?: AwsWafRateBasedRuleMatchPredicate[];
+}
+export declare namespace AwsWafRateBasedRuleDetails {
+    
+    const filterSensitiveLog: (obj: AwsWafRateBasedRuleDetails) => any;
+}
+
+export interface AwsWafRegionalRateBasedRuleMatchPredicate {
+    
+    DataId?: string;
+    
+    Negated?: boolean;
+    
+    Type?: string;
+}
+export declare namespace AwsWafRegionalRateBasedRuleMatchPredicate {
+    
+    const filterSensitiveLog: (obj: AwsWafRegionalRateBasedRuleMatchPredicate) => any;
+}
+
+export interface AwsWafRegionalRateBasedRuleDetails {
+    
+    MetricName?: string;
+    
+    Name?: string;
+    
+    RateKey?: string;
+    
+    RateLimit?: number;
+    
+    RuleId?: string;
+    
+    MatchPredicates?: AwsWafRegionalRateBasedRuleMatchPredicate[];
+}
+export declare namespace AwsWafRegionalRateBasedRuleDetails {
+    
+    const filterSensitiveLog: (obj: AwsWafRegionalRateBasedRuleDetails) => any;
+}
+
+export interface WafAction {
+    
+    Type?: string;
+}
+export declare namespace WafAction {
+    
+    const filterSensitiveLog: (obj: WafAction) => any;
+}
+
+export interface WafExcludedRule {
+    
+    RuleId?: string;
+}
+export declare namespace WafExcludedRule {
+    
+    const filterSensitiveLog: (obj: WafExcludedRule) => any;
+}
+
+export interface WafOverrideAction {
+    
+    Type?: string;
+}
+export declare namespace WafOverrideAction {
+    
+    const filterSensitiveLog: (obj: WafOverrideAction) => any;
+}
+
+export interface AwsWafWebAclRule {
+    
+    Action?: WafAction;
+    
+    ExcludedRules?: WafExcludedRule[];
+    
+    OverrideAction?: WafOverrideAction;
+    
+    Priority?: number;
+    
+    RuleId?: string;
+    
+    Type?: string;
+}
+export declare namespace AwsWafWebAclRule {
+    
+    const filterSensitiveLog: (obj: AwsWafWebAclRule) => any;
+}
+
+export interface AwsWafWebAclDetails {
+    
+    Name?: string;
+    
+    DefaultAction?: string;
+    
+    Rules?: AwsWafWebAclRule[];
+    
+    WebAclId?: string;
+}
+export declare namespace AwsWafWebAclDetails {
+    
+    const filterSensitiveLog: (obj: AwsWafWebAclDetails) => any;
+}
+
+export interface AwsXrayEncryptionConfigDetails {
+    
+    KeyId?: string;
+    
+    Status?: string;
+    
+    Type?: string;
+}
+export declare namespace AwsXrayEncryptionConfigDetails {
+    
+    const filterSensitiveLog: (obj: AwsXrayEncryptionConfigDetails) => any;
+}
+
+export interface ContainerDetails {
+    
+    Name?: string;
+    
+    ImageId?: string;
+    
+    ImageName?: string;
+    
+    LaunchedAt?: string;
+}
+export declare namespace ContainerDetails {
+    
+    const filterSensitiveLog: (obj: ContainerDetails) => any;
+}
+
+export interface ResourceDetails {
+    
+    AwsAutoScalingAutoScalingGroup?: AwsAutoScalingAutoScalingGroupDetails;
+    
+    AwsCodeBuildProject?: AwsCodeBuildProjectDetails;
+    
+    AwsCloudFrontDistribution?: AwsCloudFrontDistributionDetails;
+    
+    AwsEc2Instance?: AwsEc2InstanceDetails;
+    
+    AwsEc2NetworkInterface?: AwsEc2NetworkInterfaceDetails;
+    
+    AwsEc2SecurityGroup?: AwsEc2SecurityGroupDetails;
+    
+    AwsEc2Volume?: AwsEc2VolumeDetails;
+    
+    AwsEc2Vpc?: AwsEc2VpcDetails;
+    
+    AwsEc2Eip?: AwsEc2EipDetails;
+    
+    AwsEc2Subnet?: AwsEc2SubnetDetails;
+    
+    AwsEc2NetworkAcl?: AwsEc2NetworkAclDetails;
+    
+    AwsElbv2LoadBalancer?: AwsElbv2LoadBalancerDetails;
+    
+    AwsElasticBeanstalkEnvironment?: AwsElasticBeanstalkEnvironmentDetails;
+    
+    AwsElasticsearchDomain?: AwsElasticsearchDomainDetails;
+    
+    AwsS3Bucket?: AwsS3BucketDetails;
+    
+    AwsS3AccountPublicAccessBlock?: AwsS3AccountPublicAccessBlockDetails;
+    
+    AwsS3Object?: AwsS3ObjectDetails;
+    
+    AwsSecretsManagerSecret?: AwsSecretsManagerSecretDetails;
+    
+    AwsIamAccessKey?: AwsIamAccessKeyDetails;
+    
+    AwsIamUser?: AwsIamUserDetails;
+    
+    AwsIamPolicy?: AwsIamPolicyDetails;
+    
+    AwsApiGatewayV2Stage?: AwsApiGatewayV2StageDetails;
+    
+    AwsApiGatewayV2Api?: AwsApiGatewayV2ApiDetails;
+    
+    AwsDynamoDbTable?: AwsDynamoDbTableDetails;
+    
+    AwsApiGatewayStage?: AwsApiGatewayStageDetails;
+    
+    AwsApiGatewayRestApi?: AwsApiGatewayRestApiDetails;
+    
+    AwsCloudTrailTrail?: AwsCloudTrailTrailDetails;
+    
+    AwsSsmPatchCompliance?: AwsSsmPatchComplianceDetails;
+    
+    AwsCertificateManagerCertificate?: AwsCertificateManagerCertificateDetails;
+    
+    AwsRedshiftCluster?: AwsRedshiftClusterDetails;
+    
+    AwsElbLoadBalancer?: AwsElbLoadBalancerDetails;
+    
+    AwsIamGroup?: AwsIamGroupDetails;
+    
+    AwsIamRole?: AwsIamRoleDetails;
+    
+    AwsKmsKey?: AwsKmsKeyDetails;
+    
+    AwsLambdaFunction?: AwsLambdaFunctionDetails;
+    
+    AwsLambdaLayerVersion?: AwsLambdaLayerVersionDetails;
+    
+    AwsRdsDbInstance?: AwsRdsDbInstanceDetails;
+    
+    AwsSnsTopic?: AwsSnsTopicDetails;
+    
+    AwsSqsQueue?: AwsSqsQueueDetails;
+    
+    AwsWafWebAcl?: AwsWafWebAclDetails;
+    
+    AwsRdsDbSnapshot?: AwsRdsDbSnapshotDetails;
+    
+    AwsRdsDbClusterSnapshot?: AwsRdsDbClusterSnapshotDetails;
+    
+    AwsRdsDbCluster?: AwsRdsDbClusterDetails;
+    
+    AwsEcsCluster?: AwsEcsClusterDetails;
+    
+    AwsEcsTaskDefinition?: AwsEcsTaskDefinitionDetails;
+    
+    Container?: ContainerDetails;
+    
+    Other?: {
+        [key: string]: string;
+    };
+    
+    AwsRdsEventSubscription?: AwsRdsEventSubscriptionDetails;
+    
+    AwsEcsService?: AwsEcsServiceDetails;
+    
+    AwsAutoScalingLaunchConfiguration?: AwsAutoScalingLaunchConfigurationDetails;
+    
+    AwsEc2VpnConnection?: AwsEc2VpnConnectionDetails;
+    
+    AwsEcrContainerImage?: AwsEcrContainerImageDetails;
+    
+    AwsOpenSearchServiceDomain?: AwsOpenSearchServiceDomainDetails;
+    
+    AwsEc2VpcEndpointService?: AwsEc2VpcEndpointServiceDetails;
+    
+    AwsXrayEncryptionConfig?: AwsXrayEncryptionConfigDetails;
+    
+    AwsWafRateBasedRule?: AwsWafRateBasedRuleDetails;
+    
+    AwsWafRegionalRateBasedRule?: AwsWafRegionalRateBasedRuleDetails;
+    
+    AwsEcrRepository?: AwsEcrRepositoryDetails;
+    
+    AwsEksCluster?: AwsEksClusterDetails;
+    
+    AwsNetworkFirewallFirewallPolicy?: AwsNetworkFirewallFirewallPolicyDetails;
+    
+    AwsNetworkFirewallFirewall?: AwsNetworkFirewallFirewallDetails;
+    
+    AwsNetworkFirewallRuleGroup?: AwsNetworkFirewallRuleGroupDetails;
+}
+export declare namespace ResourceDetails {
+    
+    const filterSensitiveLog: (obj: ResourceDetails) => any;
+}
+export declare enum Partition {
+    AWS = "aws",
+    AWS_CN = "aws-cn",
+    AWS_US_GOV = "aws-us-gov"
+}
+
+export interface Resource {
+    
+    Type: string | undefined;
+    
+    Id: string | undefined;
+    
+    Partition?: Partition | string;
+    
+    Region?: string;
+    
+    ResourceRole?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    DataClassification?: DataClassificationDetails;
+    
+    Details?: ResourceDetails;
+}
+export declare namespace Resource {
+    
+    const filterSensitiveLog: (obj: Resource) => any;
+}
+
+export interface Severity {
+    
+    Product?: number;
+    
+    Label?: SeverityLabel | string;
+    
+    Normalized?: number;
+    
+    Original?: string;
+}
+export declare namespace Severity {
+    
+    const filterSensitiveLog: (obj: Severity) => any;
+}
+export declare enum ThreatIntelIndicatorCategory {
+    BACKDOOR = "BACKDOOR",
+    CARD_STEALER = "CARD_STEALER",
+    COMMAND_AND_CONTROL = "COMMAND_AND_CONTROL",
+    DROP_SITE = "DROP_SITE",
+    EXPLOIT_SITE = "EXPLOIT_SITE",
+    KEYLOGGER = "KEYLOGGER"
+}
+export declare enum ThreatIntelIndicatorType {
+    DOMAIN = "DOMAIN",
+    EMAIL_ADDRESS = "EMAIL_ADDRESS",
+    HASH_MD5 = "HASH_MD5",
+    HASH_SHA1 = "HASH_SHA1",
+    HASH_SHA256 = "HASH_SHA256",
+    HASH_SHA512 = "HASH_SHA512",
+    IPV4_ADDRESS = "IPV4_ADDRESS",
+    IPV6_ADDRESS = "IPV6_ADDRESS",
+    MUTEX = "MUTEX",
+    PROCESS = "PROCESS",
+    URL = "URL"
+}
+
+export interface ThreatIntelIndicator {
+    
+    Type?: ThreatIntelIndicatorType | string;
+    
+    Value?: string;
+    
+    Category?: ThreatIntelIndicatorCategory | string;
+    
+    LastObservedAt?: string;
+    
+    Source?: string;
+    
+    SourceUrl?: string;
+}
+export declare namespace ThreatIntelIndicator {
+    
+    const filterSensitiveLog: (obj: ThreatIntelIndicator) => any;
+}
+export declare enum VerificationState {
+    BENIGN_POSITIVE = "BENIGN_POSITIVE",
+    FALSE_POSITIVE = "FALSE_POSITIVE",
+    TRUE_POSITIVE = "TRUE_POSITIVE",
+    UNKNOWN = "UNKNOWN"
+}
+
+export interface Cvss {
+    
+    Version?: string;
+    
+    BaseScore?: number;
+    
+    BaseVector?: string;
+    
+    Source?: string;
+    
+    Adjustments?: Adjustment[];
+}
+export declare namespace Cvss {
+    
+    const filterSensitiveLog: (obj: Cvss) => any;
+}
+
+export interface VulnerabilityVendor {
+    
+    Name: string | undefined;
+    
+    Url?: string;
+    
+    VendorSeverity?: string;
+    
+    VendorCreatedAt?: string;
+    
+    VendorUpdatedAt?: string;
+}
+export declare namespace VulnerabilityVendor {
+    
+    const filterSensitiveLog: (obj: VulnerabilityVendor) => any;
+}
+
+export interface SoftwarePackage {
+    
+    Name?: string;
+    
+    Version?: string;
+    
+    Epoch?: string;
+    
+    Release?: string;
+    
+    Architecture?: string;
+    
+    PackageManager?: string;
+    
+    FilePath?: string;
+}
+export declare namespace SoftwarePackage {
+    
+    const filterSensitiveLog: (obj: SoftwarePackage) => any;
+}
+
+export interface Vulnerability {
+    
+    Id: string | undefined;
+    
+    VulnerablePackages?: SoftwarePackage[];
+    
+    Cvss?: Cvss[];
+    
+    RelatedVulnerabilities?: string[];
+    
+    Vendor?: VulnerabilityVendor;
+    
+    ReferenceUrls?: string[];
+}
+export declare namespace Vulnerability {
+    
+    const filterSensitiveLog: (obj: Vulnerability) => any;
+}
+export declare enum WorkflowStatus {
+    NEW = "NEW",
+    NOTIFIED = "NOTIFIED",
+    RESOLVED = "RESOLVED",
+    SUPPRESSED = "SUPPRESSED"
+}
+
+export interface Workflow {
+    
+    Status?: WorkflowStatus | string;
+}
+export declare namespace Workflow {
+    
+    const filterSensitiveLog: (obj: Workflow) => any;
+}
+export declare enum WorkflowState {
+    ASSIGNED = "ASSIGNED",
+    DEFERRED = "DEFERRED",
+    IN_PROGRESS = "IN_PROGRESS",
+    NEW = "NEW",
+    RESOLVED = "RESOLVED"
+}
+
+export interface AwsSecurityFinding {
+    
+    SchemaVersion: string | undefined;
+    
+    Id: string | undefined;
+    
+    ProductArn: string | undefined;
+    
+    ProductName?: string;
+    
+    CompanyName?: string;
+    
+    Region?: string;
+    
+    GeneratorId: string | undefined;
+    
+    AwsAccountId: string | undefined;
+    
+    Types?: string[];
+    
+    FirstObservedAt?: string;
+    
+    LastObservedAt?: string;
+    
+    CreatedAt: string | undefined;
+    
+    UpdatedAt: string | undefined;
+    
+    Severity?: Severity;
+    
+    Confidence?: number;
+    
+    Criticality?: number;
+    
+    Title: string | undefined;
+    
+    Description: string | undefined;
+    
+    Remediation?: Remediation;
+    
+    SourceUrl?: string;
+    
+    ProductFields?: {
+        [key: string]: string;
+    };
+    
+    UserDefinedFields?: {
+        [key: string]: string;
+    };
+    
+    Malware?: Malware[];
+    
+    Network?: Network;
+    
+    NetworkPath?: NetworkPathComponent[];
+    
+    Process?: ProcessDetails;
+    
+    ThreatIntelIndicators?: ThreatIntelIndicator[];
+    
+    Resources: Resource[] | undefined;
+    
+    Compliance?: Compliance;
+    
+    VerificationState?: VerificationState | string;
+    
+    WorkflowState?: WorkflowState | string;
+    
+    Workflow?: Workflow;
+    
+    RecordState?: RecordState | string;
+    
+    RelatedFindings?: RelatedFinding[];
+    
+    Note?: Note;
+    
+    Vulnerabilities?: Vulnerability[];
+    
+    PatchSummary?: PatchSummary;
+    
+    Action?: Action;
+    
+    FindingProviderFields?: FindingProviderFields;
+    
+    Sample?: boolean;
+}
+export declare namespace AwsSecurityFinding {
+    
+    const filterSensitiveLog: (obj: AwsSecurityFinding) => any;
+}
+export declare enum StringFilterComparison {
+    EQUALS = "EQUALS",
+    NOT_EQUALS = "NOT_EQUALS",
+    PREFIX = "PREFIX",
+    PREFIX_NOT_EQUALS = "PREFIX_NOT_EQUALS"
+}
+
+export interface StringFilter {
+    
+    Value?: string;
+    
+    Comparison?: StringFilterComparison | string;
+}
+export declare namespace StringFilter {
+    
+    const filterSensitiveLog: (obj: StringFilter) => any;
+}
+
+export interface NumberFilter {
+    
+    Gte?: number;
+    
+    Lte?: number;
+    
+    Eq?: number;
+}
+export declare namespace NumberFilter {
+    
+    const filterSensitiveLog: (obj: NumberFilter) => any;
+}
+export declare enum DateRangeUnit {
+    DAYS = "DAYS"
+}
+
+export interface DateRange {
+    
+    Value?: number;
+    
+    Unit?: DateRangeUnit | string;
+}
+export declare namespace DateRange {
+    
+    const filterSensitiveLog: (obj: DateRange) => any;
+}
+
+export interface DateFilter {
+    
+    Start?: string;
+    
+    End?: string;
+    
+    DateRange?: DateRange;
+}
+export declare namespace DateFilter {
+    
+    const filterSensitiveLog: (obj: DateFilter) => any;
+}
+
+export interface KeywordFilter {
+    
+    Value?: string;
+}
+export declare namespace KeywordFilter {
+    
+    const filterSensitiveLog: (obj: KeywordFilter) => any;
+}
+
+export interface IpFilter {
+    
+    Cidr?: string;
+}
+export declare namespace IpFilter {
+    
+    const filterSensitiveLog: (obj: IpFilter) => any;
+}
+export declare enum MapFilterComparison {
+    EQUALS = "EQUALS",
+    NOT_EQUALS = "NOT_EQUALS"
+}
+
+export interface MapFilter {
+    
+    Key?: string;
+    
+    Value?: string;
+    
+    Comparison?: MapFilterComparison | string;
+}
+export declare namespace MapFilter {
+    
+    const filterSensitiveLog: (obj: MapFilter) => any;
+}
+
+export interface BooleanFilter {
+    
+    Value?: boolean;
+}
+export declare namespace BooleanFilter {
+    
+    const filterSensitiveLog: (obj: BooleanFilter) => any;
+}
+
+export interface AwsSecurityFindingFilters {
+    
+    ProductArn?: StringFilter[];
+    
+    AwsAccountId?: StringFilter[];
+    
+    Id?: StringFilter[];
+    
+    GeneratorId?: StringFilter[];
+    
+    Region?: StringFilter[];
+    
+    Type?: StringFilter[];
+    
+    FirstObservedAt?: DateFilter[];
+    
+    LastObservedAt?: DateFilter[];
+    
+    CreatedAt?: DateFilter[];
+    
+    UpdatedAt?: DateFilter[];
+    
+    SeverityProduct?: NumberFilter[];
+    
+    SeverityNormalized?: NumberFilter[];
+    
+    SeverityLabel?: StringFilter[];
+    
+    Confidence?: NumberFilter[];
+    
+    Criticality?: NumberFilter[];
+    
+    Title?: StringFilter[];
+    
+    Description?: StringFilter[];
+    
+    RecommendationText?: StringFilter[];
+    
+    SourceUrl?: StringFilter[];
+    
+    ProductFields?: MapFilter[];
+    
+    ProductName?: StringFilter[];
+    
+    CompanyName?: StringFilter[];
+    
+    UserDefinedFields?: MapFilter[];
+    
+    MalwareName?: StringFilter[];
+    
+    MalwareType?: StringFilter[];
+    
+    MalwarePath?: StringFilter[];
+    
+    MalwareState?: StringFilter[];
+    
+    NetworkDirection?: StringFilter[];
+    
+    NetworkProtocol?: StringFilter[];
+    
+    NetworkSourceIpV4?: IpFilter[];
+    
+    NetworkSourceIpV6?: IpFilter[];
+    
+    NetworkSourcePort?: NumberFilter[];
+    
+    NetworkSourceDomain?: StringFilter[];
+    
+    NetworkSourceMac?: StringFilter[];
+    
+    NetworkDestinationIpV4?: IpFilter[];
+    
+    NetworkDestinationIpV6?: IpFilter[];
+    
+    NetworkDestinationPort?: NumberFilter[];
+    
+    NetworkDestinationDomain?: StringFilter[];
+    
+    ProcessName?: StringFilter[];
+    
+    ProcessPath?: StringFilter[];
+    
+    ProcessPid?: NumberFilter[];
+    
+    ProcessParentPid?: NumberFilter[];
+    
+    ProcessLaunchedAt?: DateFilter[];
+    
+    ProcessTerminatedAt?: DateFilter[];
+    
+    ThreatIntelIndicatorType?: StringFilter[];
+    
+    ThreatIntelIndicatorValue?: StringFilter[];
+    
+    ThreatIntelIndicatorCategory?: StringFilter[];
+    
+    ThreatIntelIndicatorLastObservedAt?: DateFilter[];
+    
+    ThreatIntelIndicatorSource?: StringFilter[];
+    
+    ThreatIntelIndicatorSourceUrl?: StringFilter[];
+    
+    ResourceType?: StringFilter[];
+    
+    ResourceId?: StringFilter[];
+    
+    ResourcePartition?: StringFilter[];
+    
+    ResourceRegion?: StringFilter[];
+    
+    ResourceTags?: MapFilter[];
+    
+    ResourceAwsEc2InstanceType?: StringFilter[];
+    
+    ResourceAwsEc2InstanceImageId?: StringFilter[];
+    
+    ResourceAwsEc2InstanceIpV4Addresses?: IpFilter[];
+    
+    ResourceAwsEc2InstanceIpV6Addresses?: IpFilter[];
+    
+    ResourceAwsEc2InstanceKeyName?: StringFilter[];
+    
+    ResourceAwsEc2InstanceIamInstanceProfileArn?: StringFilter[];
+    
+    ResourceAwsEc2InstanceVpcId?: StringFilter[];
+    
+    ResourceAwsEc2InstanceSubnetId?: StringFilter[];
+    
+    ResourceAwsEc2InstanceLaunchedAt?: DateFilter[];
+    
+    ResourceAwsS3BucketOwnerId?: StringFilter[];
+    
+    ResourceAwsS3BucketOwnerName?: StringFilter[];
+    
+    ResourceAwsIamAccessKeyUserName?: StringFilter[];
+    
+    ResourceAwsIamAccessKeyPrincipalName?: StringFilter[];
+    
+    ResourceAwsIamAccessKeyStatus?: StringFilter[];
+    
+    ResourceAwsIamAccessKeyCreatedAt?: DateFilter[];
+    
+    ResourceAwsIamUserUserName?: StringFilter[];
+    
+    ResourceContainerName?: StringFilter[];
+    
+    ResourceContainerImageId?: StringFilter[];
+    
+    ResourceContainerImageName?: StringFilter[];
+    
+    ResourceContainerLaunchedAt?: DateFilter[];
+    
+    ResourceDetailsOther?: MapFilter[];
+    
+    ComplianceStatus?: StringFilter[];
+    
+    VerificationState?: StringFilter[];
+    
+    WorkflowState?: StringFilter[];
+    
+    WorkflowStatus?: StringFilter[];
+    
+    RecordState?: StringFilter[];
+    
+    RelatedFindingsProductArn?: StringFilter[];
+    
+    RelatedFindingsId?: StringFilter[];
+    
+    NoteText?: StringFilter[];
+    
+    NoteUpdatedAt?: DateFilter[];
+    
+    NoteUpdatedBy?: StringFilter[];
+    
+    Keyword?: KeywordFilter[];
+    
+    FindingProviderFieldsConfidence?: NumberFilter[];
+    
+    FindingProviderFieldsCriticality?: NumberFilter[];
+    
+    FindingProviderFieldsRelatedFindingsId?: StringFilter[];
+    
+    FindingProviderFieldsRelatedFindingsProductArn?: StringFilter[];
+    
+    FindingProviderFieldsSeverityLabel?: StringFilter[];
+    
+    FindingProviderFieldsSeverityOriginal?: StringFilter[];
+    
+    FindingProviderFieldsTypes?: StringFilter[];
+    
+    Sample?: BooleanFilter[];
+}
+export declare namespace AwsSecurityFindingFilters {
+    
+    const filterSensitiveLog: (obj: AwsSecurityFindingFilters) => any;
+}
+
+export interface AwsSecurityFindingIdentifier {
+    
+    Id: string | undefined;
+    
+    ProductArn: string | undefined;
+}
+export declare namespace AwsSecurityFindingIdentifier {
+    
+    const filterSensitiveLog: (obj: AwsSecurityFindingIdentifier) => any;
+}
+export interface BatchDisableStandardsRequest {
+    
+    StandardsSubscriptionArns: string[] | undefined;
+}
+export declare namespace BatchDisableStandardsRequest {
+    
+    const filterSensitiveLog: (obj: BatchDisableStandardsRequest) => any;
+}
+export declare enum StandardsStatus {
+    DELETING = "DELETING",
+    FAILED = "FAILED",
+    INCOMPLETE = "INCOMPLETE",
+    PENDING = "PENDING",
+    READY = "READY"
+}
+export declare enum StatusReasonCode {
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    NO_AVAILABLE_CONFIGURATION_RECORDER = "NO_AVAILABLE_CONFIGURATION_RECORDER"
+}
+
+export interface StandardsStatusReason {
+    
+    StatusReasonCode: StatusReasonCode | string | undefined;
+}
+export declare namespace StandardsStatusReason {
+    
+    const filterSensitiveLog: (obj: StandardsStatusReason) => any;
+}
+
+export interface StandardsSubscription {
+    
+    StandardsSubscriptionArn: string | undefined;
+    
+    StandardsArn: string | undefined;
+    
+    StandardsInput: {
+        [key: string]: string;
+    } | undefined;
+    
+    StandardsStatus: StandardsStatus | string | undefined;
+    
+    StandardsStatusReason?: StandardsStatusReason;
+}
+export declare namespace StandardsSubscription {
+    
+    const filterSensitiveLog: (obj: StandardsSubscription) => any;
+}
+export interface BatchDisableStandardsResponse {
+    
+    StandardsSubscriptions?: StandardsSubscription[];
+}
+export declare namespace BatchDisableStandardsResponse {
+    
+    const filterSensitiveLog: (obj: BatchDisableStandardsResponse) => any;
+}
+
+export interface StandardsSubscriptionRequest {
+    
+    StandardsArn: string | undefined;
+    
+    StandardsInput?: {
+        [key: string]: string;
+    };
+}
+export declare namespace StandardsSubscriptionRequest {
+    
+    const filterSensitiveLog: (obj: StandardsSubscriptionRequest) => any;
+}
+export interface BatchEnableStandardsRequest {
+    
+    StandardsSubscriptionRequests: StandardsSubscriptionRequest[] | undefined;
+}
+export declare namespace BatchEnableStandardsRequest {
+    
+    const filterSensitiveLog: (obj: BatchEnableStandardsRequest) => any;
+}
+export interface BatchEnableStandardsResponse {
+    
+    StandardsSubscriptions?: StandardsSubscription[];
+}
+export declare namespace BatchEnableStandardsResponse {
+    
+    const filterSensitiveLog: (obj: BatchEnableStandardsResponse) => any;
+}
+export interface BatchImportFindingsRequest {
+    
+    Findings: AwsSecurityFinding[] | undefined;
+}
+export declare namespace BatchImportFindingsRequest {
+    
+    const filterSensitiveLog: (obj: BatchImportFindingsRequest) => any;
+}
+
+export interface ImportFindingsError {
+    
+    Id: string | undefined;
+    
+    ErrorCode: string | undefined;
+    
+    ErrorMessage: string | undefined;
+}
+export declare namespace ImportFindingsError {
+    
+    const filterSensitiveLog: (obj: ImportFindingsError) => any;
+}
+export interface BatchImportFindingsResponse {
+    
+    FailedCount: number | undefined;
+    
+    SuccessCount: number | undefined;
+    
+    FailedFindings?: ImportFindingsError[];
+}
+export declare namespace BatchImportFindingsResponse {
+    
+    const filterSensitiveLog: (obj: BatchImportFindingsResponse) => any;
+}
+
+export interface NoteUpdate {
+    
+    Text: string | undefined;
+    
+    UpdatedBy: string | undefined;
+}
+export declare namespace NoteUpdate {
+    
+    const filterSensitiveLog: (obj: NoteUpdate) => any;
+}
+
+export interface SeverityUpdate {
+    
+    Normalized?: number;
+    
+    Product?: number;
+    
+    Label?: SeverityLabel | string;
+}
+export declare namespace SeverityUpdate {
+    
+    const filterSensitiveLog: (obj: SeverityUpdate) => any;
+}
+
+export interface WorkflowUpdate {
+    
+    Status?: WorkflowStatus | string;
+}
+export declare namespace WorkflowUpdate {
+    
+    const filterSensitiveLog: (obj: WorkflowUpdate) => any;
+}
+export interface BatchUpdateFindingsRequest {
+    
+    FindingIdentifiers: AwsSecurityFindingIdentifier[] | undefined;
+    
+    Note?: NoteUpdate;
+    
+    Severity?: SeverityUpdate;
+    
+    VerificationState?: VerificationState | string;
+    
+    Confidence?: number;
+    
+    Criticality?: number;
+    
+    Types?: string[];
+    
+    UserDefinedFields?: {
+        [key: string]: string;
+    };
+    
+    Workflow?: WorkflowUpdate;
+    
+    RelatedFindings?: RelatedFinding[];
+}
+export declare namespace BatchUpdateFindingsRequest {
+    
+    const filterSensitiveLog: (obj: BatchUpdateFindingsRequest) => any;
+}
+
+export interface BatchUpdateFindingsUnprocessedFinding {
+    
+    FindingIdentifier: AwsSecurityFindingIdentifier | undefined;
+    
+    ErrorCode: string | undefined;
+    
+    ErrorMessage: string | undefined;
+}
+export declare namespace BatchUpdateFindingsUnprocessedFinding {
+    
+    const filterSensitiveLog: (obj: BatchUpdateFindingsUnprocessedFinding) => any;
+}
+export interface BatchUpdateFindingsResponse {
+    
+    ProcessedFindings: AwsSecurityFindingIdentifier[] | undefined;
+    
+    UnprocessedFindings: BatchUpdateFindingsUnprocessedFinding[] | undefined;
+}
+export declare namespace BatchUpdateFindingsResponse {
+    
+    const filterSensitiveLog: (obj: BatchUpdateFindingsResponse) => any;
+}
+export declare enum ControlStatus {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export interface CreateActionTargetRequest {
+    
+    Name: string | undefined;
+    
+    Description: string | undefined;
+    
+    Id: string | undefined;
+}
+export declare namespace CreateActionTargetRequest {
+    
+    const filterSensitiveLog: (obj: CreateActionTargetRequest) => any;
+}
+export interface CreateActionTargetResponse {
+    
+    ActionTargetArn: string | undefined;
+}
+export declare namespace CreateActionTargetResponse {
+    
+    const filterSensitiveLog: (obj: CreateActionTargetResponse) => any;
+}
+
+export interface ResourceConflictException extends __SmithyException, $MetadataBearer {
+    name: "ResourceConflictException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+}
+export interface CreateFindingAggregatorRequest {
+    
+    RegionLinkingMode: string | undefined;
+    
+    Regions?: string[];
+}
+export declare namespace CreateFindingAggregatorRequest {
+    
+    const filterSensitiveLog: (obj: CreateFindingAggregatorRequest) => any;
+}
+export interface CreateFindingAggregatorResponse {
+    
+    FindingAggregatorArn?: string;
+    
+    FindingAggregationRegion?: string;
+    
+    RegionLinkingMode?: string;
+    
+    Regions?: string[];
+}
+export declare namespace CreateFindingAggregatorResponse {
+    
+    const filterSensitiveLog: (obj: CreateFindingAggregatorResponse) => any;
+}
+export interface CreateInsightRequest {
+    
+    Name: string | undefined;
+    
+    Filters: AwsSecurityFindingFilters | undefined;
+    
+    GroupByAttribute: string | undefined;
+}
+export declare namespace CreateInsightRequest {
+    
+    const filterSensitiveLog: (obj: CreateInsightRequest) => any;
+}
+export interface CreateInsightResponse {
+    
+    InsightArn: string | undefined;
+}
+export declare namespace CreateInsightResponse {
+    
+    const filterSensitiveLog: (obj: CreateInsightResponse) => any;
+}
+export interface CreateMembersRequest {
+    
+    AccountDetails: AccountDetails[] | undefined;
+}
+export declare namespace CreateMembersRequest {
+    
+    const filterSensitiveLog: (obj: CreateMembersRequest) => any;
+}
+
+export interface Result {
+    
+    AccountId?: string;
+    
+    ProcessingResult?: string;
+}
+export declare namespace Result {
+    
+    const filterSensitiveLog: (obj: Result) => any;
+}
+export interface CreateMembersResponse {
+    
+    UnprocessedAccounts?: Result[];
+}
+export declare namespace CreateMembersResponse {
+    
+    const filterSensitiveLog: (obj: CreateMembersResponse) => any;
+}
+export interface DeclineInvitationsRequest {
+    
+    AccountIds: string[] | undefined;
+}
+export declare namespace DeclineInvitationsRequest {
+    
+    const filterSensitiveLog: (obj: DeclineInvitationsRequest) => any;
+}
+export interface DeclineInvitationsResponse {
+    
+    UnprocessedAccounts?: Result[];
+}
+export declare namespace DeclineInvitationsResponse {
+    
+    const filterSensitiveLog: (obj: DeclineInvitationsResponse) => any;
+}
+export interface DeleteActionTargetRequest {
+    
+    ActionTargetArn: string | undefined;
+}
+export declare namespace DeleteActionTargetRequest {
+    
+    const filterSensitiveLog: (obj: DeleteActionTargetRequest) => any;
+}
+export interface DeleteActionTargetResponse {
+    
+    ActionTargetArn: string | undefined;
+}
+export declare namespace DeleteActionTargetResponse {
+    
+    const filterSensitiveLog: (obj: DeleteActionTargetResponse) => any;
+}
+export interface DeleteFindingAggregatorRequest {
+    
+    FindingAggregatorArn: string | undefined;
+}
+export declare namespace DeleteFindingAggregatorRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFindingAggregatorRequest) => any;
+}
+export interface DeleteFindingAggregatorResponse {
+}
+export declare namespace DeleteFindingAggregatorResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFindingAggregatorResponse) => any;
+}
+export interface DeleteInsightRequest {
+    
+    InsightArn: string | undefined;
+}
+export declare namespace DeleteInsightRequest {
+    
+    const filterSensitiveLog: (obj: DeleteInsightRequest) => any;
+}
+export interface DeleteInsightResponse {
+    
+    InsightArn: string | undefined;
+}
+export declare namespace DeleteInsightResponse {
+    
+    const filterSensitiveLog: (obj: DeleteInsightResponse) => any;
+}
+export interface DeleteInvitationsRequest {
+    
+    AccountIds: string[] | undefined;
+}
+export declare namespace DeleteInvitationsRequest {
+    
+    const filterSensitiveLog: (obj: DeleteInvitationsRequest) => any;
+}
+export interface DeleteInvitationsResponse {
+    
+    UnprocessedAccounts?: Result[];
+}
+export declare namespace DeleteInvitationsResponse {
+    
+    const filterSensitiveLog: (obj: DeleteInvitationsResponse) => any;
+}
+export interface DeleteMembersRequest {
+    
+    AccountIds: string[] | undefined;
+}
+export declare namespace DeleteMembersRequest {
+    
+    const filterSensitiveLog: (obj: DeleteMembersRequest) => any;
+}
+export interface DeleteMembersResponse {
+    
+    UnprocessedAccounts?: Result[];
+}
+export declare namespace DeleteMembersResponse {
+    
+    const filterSensitiveLog: (obj: DeleteMembersResponse) => any;
+}
+export interface DescribeActionTargetsRequest {
+    
+    ActionTargetArns?: string[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeActionTargetsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeActionTargetsRequest) => any;
+}
+export interface DescribeActionTargetsResponse {
+    
+    ActionTargets: ActionTarget[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeActionTargetsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeActionTargetsResponse) => any;
+}
+export interface DescribeHubRequest {
+    
+    HubArn?: string;
+}
+export declare namespace DescribeHubRequest {
+    
+    const filterSensitiveLog: (obj: DescribeHubRequest) => any;
+}
+export interface DescribeHubResponse {
+    
+    HubArn?: string;
+    
+    SubscribedAt?: string;
+    
+    AutoEnableControls?: boolean;
+}
+export declare namespace DescribeHubResponse {
+    
+    const filterSensitiveLog: (obj: DescribeHubResponse) => any;
+}
+export interface DescribeOrganizationConfigurationRequest {
+}
+export declare namespace DescribeOrganizationConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeOrganizationConfigurationRequest) => any;
+}
+export interface DescribeOrganizationConfigurationResponse {
+    
+    AutoEnable?: boolean;
+    
+    MemberAccountLimitReached?: boolean;
+}
+export declare namespace DescribeOrganizationConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeOrganizationConfigurationResponse) => any;
+}
+export interface DescribeProductsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ProductArn?: string;
+}
+export declare namespace DescribeProductsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeProductsRequest) => any;
+}
+export declare enum IntegrationType {
+    RECEIVE_FINDINGS_FROM_SECURITY_HUB = "RECEIVE_FINDINGS_FROM_SECURITY_HUB",
+    SEND_FINDINGS_TO_SECURITY_HUB = "SEND_FINDINGS_TO_SECURITY_HUB",
+    UPDATE_FINDINGS_IN_SECURITY_HUB = "UPDATE_FINDINGS_IN_SECURITY_HUB"
+}
+
+export interface Product {
+    
+    ProductArn: string | undefined;
+    
+    ProductName?: string;
+    
+    CompanyName?: string;
+    
+    Description?: string;
+    
+    Categories?: string[];
+    
+    IntegrationTypes?: (IntegrationType | string)[];
+    
+    MarketplaceUrl?: string;
+    
+    ActivationUrl?: string;
+    
+    ProductSubscriptionResourcePolicy?: string;
+}
+export declare namespace Product {
+    
+    const filterSensitiveLog: (obj: Product) => any;
+}
+export interface DescribeProductsResponse {
+    
+    Products: Product[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeProductsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeProductsResponse) => any;
+}
+export interface DescribeStandardsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeStandardsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeStandardsRequest) => any;
+}
+
+export interface Standard {
+    
+    StandardsArn?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    EnabledByDefault?: boolean;
+}
+export declare namespace Standard {
+    
+    const filterSensitiveLog: (obj: Standard) => any;
+}
+export interface DescribeStandardsResponse {
+    
+    Standards?: Standard[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeStandardsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeStandardsResponse) => any;
+}
+export interface DescribeStandardsControlsRequest {
+    
+    StandardsSubscriptionArn: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeStandardsControlsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeStandardsControlsRequest) => any;
+}
+export declare enum SeverityRating {
+    CRITICAL = "CRITICAL",
+    HIGH = "HIGH",
+    LOW = "LOW",
+    MEDIUM = "MEDIUM"
+}
+
+export interface StandardsControl {
+    
+    StandardsControlArn?: string;
+    
+    ControlStatus?: ControlStatus | string;
+    
+    DisabledReason?: string;
+    
+    ControlStatusUpdatedAt?: Date;
+    
+    ControlId?: string;
+    
+    Title?: string;
+    
+    Description?: string;
+    
+    RemediationUrl?: string;
+    
+    SeverityRating?: SeverityRating | string;
+    
+    RelatedRequirements?: string[];
+}
+export declare namespace StandardsControl {
+    
+    const filterSensitiveLog: (obj: StandardsControl) => any;
+}
+export interface DescribeStandardsControlsResponse {
+    
+    Controls?: StandardsControl[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeStandardsControlsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeStandardsControlsResponse) => any;
+}
+export interface DisableImportFindingsForProductRequest {
+    
+    ProductSubscriptionArn: string | undefined;
+}
+export declare namespace DisableImportFindingsForProductRequest {
+    
+    const filterSensitiveLog: (obj: DisableImportFindingsForProductRequest) => any;
+}
+export interface DisableImportFindingsForProductResponse {
+}
+export declare namespace DisableImportFindingsForProductResponse {
+    
+    const filterSensitiveLog: (obj: DisableImportFindingsForProductResponse) => any;
+}
+export interface DisableOrganizationAdminAccountRequest {
+    
+    AdminAccountId: string | undefined;
+}
+export declare namespace DisableOrganizationAdminAccountRequest {
+    
+    const filterSensitiveLog: (obj: DisableOrganizationAdminAccountRequest) => any;
+}
+export interface DisableOrganizationAdminAccountResponse {
+}
+export declare namespace DisableOrganizationAdminAccountResponse {
+    
+    const filterSensitiveLog: (obj: DisableOrganizationAdminAccountResponse) => any;
+}
+export interface DisableSecurityHubRequest {
+}
+export declare namespace DisableSecurityHubRequest {
+    
+    const filterSensitiveLog: (obj: DisableSecurityHubRequest) => any;
+}
+export interface DisableSecurityHubResponse {
+}
+export declare namespace DisableSecurityHubResponse {
+    
+    const filterSensitiveLog: (obj: DisableSecurityHubResponse) => any;
+}
+export interface DisassociateFromAdministratorAccountRequest {
+}
+export declare namespace DisassociateFromAdministratorAccountRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateFromAdministratorAccountRequest) => any;
+}
+export interface DisassociateFromAdministratorAccountResponse {
+}
+export declare namespace DisassociateFromAdministratorAccountResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateFromAdministratorAccountResponse) => any;
+}
+export interface DisassociateFromMasterAccountRequest {
+}
+export declare namespace DisassociateFromMasterAccountRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateFromMasterAccountRequest) => any;
+}
+export interface DisassociateFromMasterAccountResponse {
+}
+export declare namespace DisassociateFromMasterAccountResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateFromMasterAccountResponse) => any;
+}
+export interface DisassociateMembersRequest {
+    
+    AccountIds: string[] | undefined;
+}
+export declare namespace DisassociateMembersRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateMembersRequest) => any;
+}
+export interface DisassociateMembersResponse {
+}
+export declare namespace DisassociateMembersResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateMembersResponse) => any;
+}
+export interface EnableImportFindingsForProductRequest {
+    
+    ProductArn: string | undefined;
+}
+export declare namespace EnableImportFindingsForProductRequest {
+    
+    const filterSensitiveLog: (obj: EnableImportFindingsForProductRequest) => any;
+}
+export interface EnableImportFindingsForProductResponse {
+    
+    ProductSubscriptionArn?: string;
+}
+export declare namespace EnableImportFindingsForProductResponse {
+    
+    const filterSensitiveLog: (obj: EnableImportFindingsForProductResponse) => any;
+}
+export interface EnableOrganizationAdminAccountRequest {
+    
+    AdminAccountId: string | undefined;
+}
+export declare namespace EnableOrganizationAdminAccountRequest {
+    
+    const filterSensitiveLog: (obj: EnableOrganizationAdminAccountRequest) => any;
+}
+export interface EnableOrganizationAdminAccountResponse {
+}
+export declare namespace EnableOrganizationAdminAccountResponse {
+    
+    const filterSensitiveLog: (obj: EnableOrganizationAdminAccountResponse) => any;
+}
+export interface EnableSecurityHubRequest {
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    EnableDefaultStandards?: boolean;
+}
+export declare namespace EnableSecurityHubRequest {
+    
+    const filterSensitiveLog: (obj: EnableSecurityHubRequest) => any;
+}
+export interface EnableSecurityHubResponse {
+}
+export declare namespace EnableSecurityHubResponse {
+    
+    const filterSensitiveLog: (obj: EnableSecurityHubResponse) => any;
+}
+
+export interface FindingAggregator {
+    
+    FindingAggregatorArn?: string;
+}
+export declare namespace FindingAggregator {
+    
+    const filterSensitiveLog: (obj: FindingAggregator) => any;
+}
+export interface GetAdministratorAccountRequest {
+}
+export declare namespace GetAdministratorAccountRequest {
+    
+    const filterSensitiveLog: (obj: GetAdministratorAccountRequest) => any;
+}
+
+export interface Invitation {
+    
+    AccountId?: string;
+    
+    InvitationId?: string;
+    
+    InvitedAt?: Date;
+    
+    MemberStatus?: string;
+}
+export declare namespace Invitation {
+    
+    const filterSensitiveLog: (obj: Invitation) => any;
+}
+export interface GetAdministratorAccountResponse {
+    
+    Administrator?: Invitation;
+}
+export declare namespace GetAdministratorAccountResponse {
+    
+    const filterSensitiveLog: (obj: GetAdministratorAccountResponse) => any;
+}
+export interface GetEnabledStandardsRequest {
+    
+    StandardsSubscriptionArns?: string[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace GetEnabledStandardsRequest {
+    
+    const filterSensitiveLog: (obj: GetEnabledStandardsRequest) => any;
+}
+export interface GetEnabledStandardsResponse {
+    
+    StandardsSubscriptions?: StandardsSubscription[];
+    
+    NextToken?: string;
+}
+export declare namespace GetEnabledStandardsResponse {
+    
+    const filterSensitiveLog: (obj: GetEnabledStandardsResponse) => any;
+}
+export interface GetFindingAggregatorRequest {
+    
+    FindingAggregatorArn: string | undefined;
+}
+export declare namespace GetFindingAggregatorRequest {
+    
+    const filterSensitiveLog: (obj: GetFindingAggregatorRequest) => any;
+}
+export interface GetFindingAggregatorResponse {
+    
+    FindingAggregatorArn?: string;
+    
+    FindingAggregationRegion?: string;
+    
+    RegionLinkingMode?: string;
+    
+    Regions?: string[];
+}
+export declare namespace GetFindingAggregatorResponse {
+    
+    const filterSensitiveLog: (obj: GetFindingAggregatorResponse) => any;
+}
+export declare enum SortOrder {
+    ASCENDING = "asc",
+    DESCENDING = "desc"
+}
+
+export interface SortCriterion {
+    
+    Field?: string;
+    
+    SortOrder?: SortOrder | string;
+}
+export declare namespace SortCriterion {
+    
+    const filterSensitiveLog: (obj: SortCriterion) => any;
+}
+export interface GetFindingsRequest {
+    
+    Filters?: AwsSecurityFindingFilters;
+    
+    SortCriteria?: SortCriterion[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace GetFindingsRequest {
+    
+    const filterSensitiveLog: (obj: GetFindingsRequest) => any;
+}
+export interface GetFindingsResponse {
+    
+    Findings: AwsSecurityFinding[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace GetFindingsResponse {
+    
+    const filterSensitiveLog: (obj: GetFindingsResponse) => any;
+}
+export interface GetInsightResultsRequest {
+    
+    InsightArn: string | undefined;
+}
+export declare namespace GetInsightResultsRequest {
+    
+    const filterSensitiveLog: (obj: GetInsightResultsRequest) => any;
+}
+
+export interface InsightResultValue {
+    
+    GroupByAttributeValue: string | undefined;
+    
+    Count: number | undefined;
+}
+export declare namespace InsightResultValue {
+    
+    const filterSensitiveLog: (obj: InsightResultValue) => any;
+}
+
+export interface InsightResults {
+    
+    InsightArn: string | undefined;
+    
+    GroupByAttribute: string | undefined;
+    
+    ResultValues: InsightResultValue[] | undefined;
+}
+export declare namespace InsightResults {
+    
+    const filterSensitiveLog: (obj: InsightResults) => any;
+}
+export interface GetInsightResultsResponse {
+    
+    InsightResults: InsightResults | undefined;
+}
+export declare namespace GetInsightResultsResponse {
+    
+    const filterSensitiveLog: (obj: GetInsightResultsResponse) => any;
+}
+export interface GetInsightsRequest {
+    
+    InsightArns?: string[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace GetInsightsRequest {
+    
+    const filterSensitiveLog: (obj: GetInsightsRequest) => any;
+}
+
+export interface Insight {
+    
+    InsightArn: string | undefined;
+    
+    Name: string | undefined;
+    
+    Filters: AwsSecurityFindingFilters | undefined;
+    
+    GroupByAttribute: string | undefined;
+}
+export declare namespace Insight {
+    
+    const filterSensitiveLog: (obj: Insight) => any;
+}
+export interface GetInsightsResponse {
+    
+    Insights: Insight[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace GetInsightsResponse {
+    
+    const filterSensitiveLog: (obj: GetInsightsResponse) => any;
+}
+export interface GetInvitationsCountRequest {
+}
+export declare namespace GetInvitationsCountRequest {
+    
+    const filterSensitiveLog: (obj: GetInvitationsCountRequest) => any;
+}
+export interface GetInvitationsCountResponse {
+    
+    InvitationsCount?: number;
+}
+export declare namespace GetInvitationsCountResponse {
+    
+    const filterSensitiveLog: (obj: GetInvitationsCountResponse) => any;
+}
+export interface GetMasterAccountRequest {
+}
+export declare namespace GetMasterAccountRequest {
+    
+    const filterSensitiveLog: (obj: GetMasterAccountRequest) => any;
+}
+export interface GetMasterAccountResponse {
+    
+    Master?: Invitation;
+}
+export declare namespace GetMasterAccountResponse {
+    
+    const filterSensitiveLog: (obj: GetMasterAccountResponse) => any;
+}
+export interface GetMembersRequest {
+    
+    AccountIds: string[] | undefined;
+}
+export declare namespace GetMembersRequest {
+    
+    const filterSensitiveLog: (obj: GetMembersRequest) => any;
+}
+
+export interface Member {
+    
+    AccountId?: string;
+    
+    Email?: string;
+    
+    MasterId?: string;
+    
+    AdministratorId?: string;
+    
+    MemberStatus?: string;
+    
+    InvitedAt?: Date;
+    
+    UpdatedAt?: Date;
+}
+export declare namespace Member {
+    
+    const filterSensitiveLog: (obj: Member) => any;
+}
+export interface GetMembersResponse {
+    
+    Members?: Member[];
+    
+    UnprocessedAccounts?: Result[];
+}
+export declare namespace GetMembersResponse {
+    
+    const filterSensitiveLog: (obj: GetMembersResponse) => any;
+}
+export interface InviteMembersRequest {
+    
+    AccountIds: string[] | undefined;
+}
+export declare namespace InviteMembersRequest {
+    
+    const filterSensitiveLog: (obj: InviteMembersRequest) => any;
+}
+export interface InviteMembersResponse {
+    
+    UnprocessedAccounts?: Result[];
+}
+export declare namespace InviteMembersResponse {
+    
+    const filterSensitiveLog: (obj: InviteMembersResponse) => any;
+}
+export interface ListEnabledProductsForImportRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListEnabledProductsForImportRequest {
+    
+    const filterSensitiveLog: (obj: ListEnabledProductsForImportRequest) => any;
+}
+export interface ListEnabledProductsForImportResponse {
+    
+    ProductSubscriptions?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEnabledProductsForImportResponse {
+    
+    const filterSensitiveLog: (obj: ListEnabledProductsForImportResponse) => any;
+}
+export interface ListFindingAggregatorsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListFindingAggregatorsRequest {
+    
+    const filterSensitiveLog: (obj: ListFindingAggregatorsRequest) => any;
+}
+export interface ListFindingAggregatorsResponse {
+    
+    FindingAggregators?: FindingAggregator[];
+    
+    NextToken?: string;
+}
+export declare namespace ListFindingAggregatorsResponse {
+    
+    const filterSensitiveLog: (obj: ListFindingAggregatorsResponse) => any;
+}
+export interface ListInvitationsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListInvitationsRequest {
+    
+    const filterSensitiveLog: (obj: ListInvitationsRequest) => any;
+}
+export interface ListInvitationsResponse {
+    
+    Invitations?: Invitation[];
+    
+    NextToken?: string;
+}
+export declare namespace ListInvitationsResponse {
+    
+    const filterSensitiveLog: (obj: ListInvitationsResponse) => any;
+}
+export interface ListMembersRequest {
+    
+    OnlyAssociated?: boolean;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListMembersRequest {
+    
+    const filterSensitiveLog: (obj: ListMembersRequest) => any;
+}
+export interface ListMembersResponse {
+    
+    Members?: Member[];
+    
+    NextToken?: string;
+}
+export declare namespace ListMembersResponse {
+    
+    const filterSensitiveLog: (obj: ListMembersResponse) => any;
+}
+export interface ListOrganizationAdminAccountsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListOrganizationAdminAccountsRequest {
+    
+    const filterSensitiveLog: (obj: ListOrganizationAdminAccountsRequest) => any;
+}
+export interface ListOrganizationAdminAccountsResponse {
+    
+    AdminAccounts?: AdminAccount[];
+    
+    NextToken?: string;
+}
+export declare namespace ListOrganizationAdminAccountsResponse {
+    
+    const filterSensitiveLog: (obj: ListOrganizationAdminAccountsResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateActionTargetRequest {
+    
+    ActionTargetArn: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+}
+export declare namespace UpdateActionTargetRequest {
+    
+    const filterSensitiveLog: (obj: UpdateActionTargetRequest) => any;
+}
+export interface UpdateActionTargetResponse {
+}
+export declare namespace UpdateActionTargetResponse {
+    
+    const filterSensitiveLog: (obj: UpdateActionTargetResponse) => any;
+}
+export interface UpdateFindingAggregatorRequest {
+    
+    FindingAggregatorArn: string | undefined;
+    
+    RegionLinkingMode: string | undefined;
+    
+    Regions?: string[];
+}
+export declare namespace UpdateFindingAggregatorRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFindingAggregatorRequest) => any;
+}
+export interface UpdateFindingAggregatorResponse {
+    
+    FindingAggregatorArn?: string;
+    
+    FindingAggregationRegion?: string;
+    
+    RegionLinkingMode?: string;
+    
+    Regions?: string[];
+}
+export declare namespace UpdateFindingAggregatorResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFindingAggregatorResponse) => any;
+}
+export interface UpdateFindingsRequest {
+    
+    Filters: AwsSecurityFindingFilters | undefined;
+    
+    Note?: NoteUpdate;
+    
+    RecordState?: RecordState | string;
+}
+export declare namespace UpdateFindingsRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFindingsRequest) => any;
+}
+export interface UpdateFindingsResponse {
+}
+export declare namespace UpdateFindingsResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFindingsResponse) => any;
+}
+export interface UpdateInsightRequest {
+    
+    InsightArn: string | undefined;
+    
+    Name?: string;
+    
+    Filters?: AwsSecurityFindingFilters;
+    
+    GroupByAttribute?: string;
+}
+export declare namespace UpdateInsightRequest {
+    
+    const filterSensitiveLog: (obj: UpdateInsightRequest) => any;
+}
+export interface UpdateInsightResponse {
+}
+export declare namespace UpdateInsightResponse {
+    
+    const filterSensitiveLog: (obj: UpdateInsightResponse) => any;
+}
+export interface UpdateOrganizationConfigurationRequest {
+    
+    AutoEnable: boolean | undefined;
+}
+export declare namespace UpdateOrganizationConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateOrganizationConfigurationRequest) => any;
+}
+export interface UpdateOrganizationConfigurationResponse {
+}
+export declare namespace UpdateOrganizationConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateOrganizationConfigurationResponse) => any;
+}
+export interface UpdateSecurityHubConfigurationRequest {
+    
+    AutoEnableControls?: boolean;
+}
+export declare namespace UpdateSecurityHubConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateSecurityHubConfigurationRequest) => any;
+}
+export interface UpdateSecurityHubConfigurationResponse {
+}
+export declare namespace UpdateSecurityHubConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateSecurityHubConfigurationResponse) => any;
+}
+export interface UpdateStandardsControlRequest {
+    
+    StandardsControlArn: string | undefined;
+    
+    ControlStatus?: ControlStatus | string;
+    
+    DisabledReason?: string;
+}
+export declare namespace UpdateStandardsControlRequest {
+    
+    const filterSensitiveLog: (obj: UpdateStandardsControlRequest) => any;
+}
+export interface UpdateStandardsControlResponse {
+}
+export declare namespace UpdateStandardsControlResponse {
+    
+    const filterSensitiveLog: (obj: UpdateStandardsControlResponse) => any;
+}