@aws-sdk/client-config-service 3.50.0 → 3.53.0

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

@@ -0,0 +1,3448 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { ConfigServiceServiceException as __BaseException } from "./ConfigServiceServiceException";
+
+export interface AccountAggregationSource {
+    
+    AccountIds: string[] | undefined;
+    
+    AllAwsRegions?: boolean;
+    
+    AwsRegions?: string[];
+}
+export declare namespace AccountAggregationSource {
+    
+    const filterSensitiveLog: (obj: AccountAggregationSource) => any;
+}
+
+export interface ComplianceContributorCount {
+    
+    CappedCount?: number;
+    
+    CapExceeded?: boolean;
+}
+export declare namespace ComplianceContributorCount {
+    
+    const filterSensitiveLog: (obj: ComplianceContributorCount) => any;
+}
+export declare enum ComplianceType {
+    Compliant = "COMPLIANT",
+    Insufficient_Data = "INSUFFICIENT_DATA",
+    Non_Compliant = "NON_COMPLIANT",
+    Not_Applicable = "NOT_APPLICABLE"
+}
+
+export interface Compliance {
+    
+    ComplianceType?: ComplianceType | string;
+    
+    ComplianceContributorCount?: ComplianceContributorCount;
+}
+export declare namespace Compliance {
+    
+    const filterSensitiveLog: (obj: Compliance) => any;
+}
+
+export interface AggregateComplianceByConfigRule {
+    
+    ConfigRuleName?: string;
+    
+    Compliance?: Compliance;
+    
+    AccountId?: string;
+    
+    AwsRegion?: string;
+}
+export declare namespace AggregateComplianceByConfigRule {
+    
+    const filterSensitiveLog: (obj: AggregateComplianceByConfigRule) => any;
+}
+export declare enum ConformancePackComplianceType {
+    COMPLIANT = "COMPLIANT",
+    INSUFFICIENT_DATA = "INSUFFICIENT_DATA",
+    NON_COMPLIANT = "NON_COMPLIANT"
+}
+
+export interface AggregateConformancePackCompliance {
+    
+    ComplianceType?: ConformancePackComplianceType | string;
+    
+    CompliantRuleCount?: number;
+    
+    NonCompliantRuleCount?: number;
+    
+    TotalRuleCount?: number;
+}
+export declare namespace AggregateConformancePackCompliance {
+    
+    const filterSensitiveLog: (obj: AggregateConformancePackCompliance) => any;
+}
+
+export interface AggregateComplianceByConformancePack {
+    
+    ConformancePackName?: string;
+    
+    Compliance?: AggregateConformancePackCompliance;
+    
+    AccountId?: string;
+    
+    AwsRegion?: string;
+}
+export declare namespace AggregateComplianceByConformancePack {
+    
+    const filterSensitiveLog: (obj: AggregateComplianceByConformancePack) => any;
+}
+
+export interface ComplianceSummary {
+    
+    CompliantResourceCount?: ComplianceContributorCount;
+    
+    NonCompliantResourceCount?: ComplianceContributorCount;
+    
+    ComplianceSummaryTimestamp?: Date;
+}
+export declare namespace ComplianceSummary {
+    
+    const filterSensitiveLog: (obj: ComplianceSummary) => any;
+}
+
+export interface AggregateComplianceCount {
+    
+    GroupName?: string;
+    
+    ComplianceSummary?: ComplianceSummary;
+}
+export declare namespace AggregateComplianceCount {
+    
+    const filterSensitiveLog: (obj: AggregateComplianceCount) => any;
+}
+
+export interface AggregateConformancePackComplianceCount {
+    
+    CompliantConformancePackCount?: number;
+    
+    NonCompliantConformancePackCount?: number;
+}
+export declare namespace AggregateConformancePackComplianceCount {
+    
+    const filterSensitiveLog: (obj: AggregateConformancePackComplianceCount) => any;
+}
+
+export interface AggregateConformancePackComplianceFilters {
+    
+    ConformancePackName?: string;
+    
+    ComplianceType?: ConformancePackComplianceType | string;
+    
+    AccountId?: string;
+    
+    AwsRegion?: string;
+}
+export declare namespace AggregateConformancePackComplianceFilters {
+    
+    const filterSensitiveLog: (obj: AggregateConformancePackComplianceFilters) => any;
+}
+
+export interface AggregateConformancePackComplianceSummary {
+    
+    ComplianceSummary?: AggregateConformancePackComplianceCount;
+    
+    GroupName?: string;
+}
+export declare namespace AggregateConformancePackComplianceSummary {
+    
+    const filterSensitiveLog: (obj: AggregateConformancePackComplianceSummary) => any;
+}
+
+export interface AggregateConformancePackComplianceSummaryFilters {
+    
+    AccountId?: string;
+    
+    AwsRegion?: string;
+}
+export declare namespace AggregateConformancePackComplianceSummaryFilters {
+    
+    const filterSensitiveLog: (obj: AggregateConformancePackComplianceSummaryFilters) => any;
+}
+export declare enum AggregateConformancePackComplianceSummaryGroupKey {
+    ACCOUNT_ID = "ACCOUNT_ID",
+    AWS_REGION = "AWS_REGION"
+}
+export declare enum AggregatedSourceStatusType {
+    FAILED = "FAILED",
+    OUTDATED = "OUTDATED",
+    SUCCEEDED = "SUCCEEDED"
+}
+export declare enum AggregatedSourceType {
+    ACCOUNT = "ACCOUNT",
+    ORGANIZATION = "ORGANIZATION"
+}
+
+export interface AggregatedSourceStatus {
+    
+    SourceId?: string;
+    
+    SourceType?: AggregatedSourceType | string;
+    
+    AwsRegion?: string;
+    
+    LastUpdateStatus?: AggregatedSourceStatusType | string;
+    
+    LastUpdateTime?: Date;
+    
+    LastErrorCode?: string;
+    
+    LastErrorMessage?: string;
+}
+export declare namespace AggregatedSourceStatus {
+    
+    const filterSensitiveLog: (obj: AggregatedSourceStatus) => any;
+}
+
+export interface EvaluationResultQualifier {
+    
+    ConfigRuleName?: string;
+    
+    ResourceType?: string;
+    
+    ResourceId?: string;
+}
+export declare namespace EvaluationResultQualifier {
+    
+    const filterSensitiveLog: (obj: EvaluationResultQualifier) => any;
+}
+
+export interface EvaluationResultIdentifier {
+    
+    EvaluationResultQualifier?: EvaluationResultQualifier;
+    
+    OrderingTimestamp?: Date;
+}
+export declare namespace EvaluationResultIdentifier {
+    
+    const filterSensitiveLog: (obj: EvaluationResultIdentifier) => any;
+}
+
+export interface AggregateEvaluationResult {
+    
+    EvaluationResultIdentifier?: EvaluationResultIdentifier;
+    
+    ComplianceType?: ComplianceType | string;
+    
+    ResultRecordedTime?: Date;
+    
+    ConfigRuleInvokedTime?: Date;
+    
+    Annotation?: string;
+    
+    AccountId?: string;
+    
+    AwsRegion?: string;
+}
+export declare namespace AggregateEvaluationResult {
+    
+    const filterSensitiveLog: (obj: AggregateEvaluationResult) => any;
+}
+export declare enum ResourceType {
+    AccountPublicAccessBlock = "AWS::S3::AccountPublicAccessBlock",
+    Alarm = "AWS::CloudWatch::Alarm",
+    Api = "AWS::ApiGatewayV2::Api",
+    Application = "AWS::ElasticBeanstalk::Application",
+    ApplicationVersion = "AWS::ElasticBeanstalk::ApplicationVersion",
+    AssociationCompliance = "AWS::SSM::AssociationCompliance",
+    AutoScalingGroup = "AWS::AutoScaling::AutoScalingGroup",
+    BackupPlan = "AWS::Backup::BackupPlan",
+    BackupRecoveryPoint = "AWS::Backup::RecoveryPoint",
+    BackupSelection = "AWS::Backup::BackupSelection",
+    BackupVault = "AWS::Backup::BackupVault",
+    Bucket = "AWS::S3::Bucket",
+    Certificate = "AWS::ACM::Certificate",
+    CloudFormationProduct = "AWS::ServiceCatalog::CloudFormationProduct",
+    CloudFormationProvisionedProduct = "AWS::ServiceCatalog::CloudFormationProvisionedProduct",
+    Cluster = "AWS::Redshift::Cluster",
+    ClusterParameterGroup = "AWS::Redshift::ClusterParameterGroup",
+    ClusterSecurityGroup = "AWS::Redshift::ClusterSecurityGroup",
+    ClusterSnapshot = "AWS::Redshift::ClusterSnapshot",
+    ClusterSubnetGroup = "AWS::Redshift::ClusterSubnetGroup",
+    CodeDeployApplication = "AWS::CodeDeploy::Application",
+    CodeDeployDeploymentConfig = "AWS::CodeDeploy::DeploymentConfig",
+    CodeDeployDeploymentGroup = "AWS::CodeDeploy::DeploymentGroup",
+    ConformancePackCompliance = "AWS::Config::ConformancePackCompliance",
+    CustomerGateway = "AWS::EC2::CustomerGateway",
+    DBCluster = "AWS::RDS::DBCluster",
+    DBClusterSnapshot = "AWS::RDS::DBClusterSnapshot",
+    DBInstance = "AWS::RDS::DBInstance",
+    DBSecurityGroup = "AWS::RDS::DBSecurityGroup",
+    DBSnapshot = "AWS::RDS::DBSnapshot",
+    DBSubnetGroup = "AWS::RDS::DBSubnetGroup",
+    Distribution = "AWS::CloudFront::Distribution",
+    Domain = "AWS::Elasticsearch::Domain",
+    ECRRepository = "AWS::ECR::Repository",
+    ECSCluster = "AWS::ECS::Cluster",
+    ECSService = "AWS::ECS::Service",
+    ECSTaskDefinition = "AWS::ECS::TaskDefinition",
+    EFSAccessPoint = "AWS::EFS::AccessPoint",
+    EFSFileSystem = "AWS::EFS::FileSystem",
+    EIP = "AWS::EC2::EIP",
+    EKSCluster = "AWS::EKS::Cluster",
+    EgressOnlyInternetGateway = "AWS::EC2::EgressOnlyInternetGateway",
+    EncryptionConfig = "AWS::XRay::EncryptionConfig",
+    Environment = "AWS::ElasticBeanstalk::Environment",
+    EventSubscription = "AWS::RDS::EventSubscription",
+    FileData = "AWS::SSM::FileData",
+    FlowLog = "AWS::EC2::FlowLog",
+    Function = "AWS::Lambda::Function",
+    Group = "AWS::IAM::Group",
+    Host = "AWS::EC2::Host",
+    IPSetV2 = "AWS::WAFv2::IPSet",
+    Instance = "AWS::EC2::Instance",
+    InternetGateway = "AWS::EC2::InternetGateway",
+    Key = "AWS::KMS::Key",
+    KinesisStream = "AWS::Kinesis::Stream",
+    KinesisStreamConsumer = "AWS::Kinesis::StreamConsumer",
+    LaunchConfiguration = "AWS::AutoScaling::LaunchConfiguration",
+    LoadBalancer = "AWS::ElasticLoadBalancing::LoadBalancer",
+    LoadBalancerV2 = "AWS::ElasticLoadBalancingV2::LoadBalancer",
+    ManagedInstanceInventory = "AWS::SSM::ManagedInstanceInventory",
+    ManagedRuleSetV2 = "AWS::WAFv2::ManagedRuleSet",
+    NatGateway = "AWS::EC2::NatGateway",
+    NetworkAcl = "AWS::EC2::NetworkAcl",
+    NetworkFirewallFirewall = "AWS::NetworkFirewall::Firewall",
+    NetworkFirewallFirewallPolicy = "AWS::NetworkFirewall::FirewallPolicy",
+    NetworkFirewallRuleGroup = "AWS::NetworkFirewall::RuleGroup",
+    NetworkInterface = "AWS::EC2::NetworkInterface",
+    OpenSearchDomain = "AWS::OpenSearch::Domain",
+    PatchCompliance = "AWS::SSM::PatchCompliance",
+    Pipeline = "AWS::CodePipeline::Pipeline",
+    Policy = "AWS::IAM::Policy",
+    Portfolio = "AWS::ServiceCatalog::Portfolio",
+    Project = "AWS::CodeBuild::Project",
+    Protection = "AWS::Shield::Protection",
+    QLDBLedger = "AWS::QLDB::Ledger",
+    Queue = "AWS::SQS::Queue",
+    RateBasedRule = "AWS::WAF::RateBasedRule",
+    RedshiftEventSubscription = "AWS::Redshift::EventSubscription",
+    RegexPatternSetV2 = "AWS::WAFv2::RegexPatternSet",
+    RegionalProtection = "AWS::ShieldRegional::Protection",
+    RegionalRateBasedRule = "AWS::WAFRegional::RateBasedRule",
+    RegionalRule = "AWS::WAFRegional::Rule",
+    RegionalRuleGroup = "AWS::WAFRegional::RuleGroup",
+    RegionalWebACL = "AWS::WAFRegional::WebACL",
+    RegisteredHAInstance = "AWS::EC2::RegisteredHAInstance",
+    ResourceCompliance = "AWS::Config::ResourceCompliance",
+    RestApi = "AWS::ApiGateway::RestApi",
+    Role = "AWS::IAM::Role",
+    RouteTable = "AWS::EC2::RouteTable",
+    Rule = "AWS::WAF::Rule",
+    RuleGroup = "AWS::WAF::RuleGroup",
+    RuleGroupV2 = "AWS::WAFv2::RuleGroup",
+    ScalingPolicy = "AWS::AutoScaling::ScalingPolicy",
+    ScheduledAction = "AWS::AutoScaling::ScheduledAction",
+    Secret = "AWS::SecretsManager::Secret",
+    SecurityGroup = "AWS::EC2::SecurityGroup",
+    Stack = "AWS::CloudFormation::Stack",
+    Stage = "AWS::ApiGateway::Stage",
+    StageV2 = "AWS::ApiGatewayV2::Stage",
+    StreamingDistribution = "AWS::CloudFront::StreamingDistribution",
+    Subnet = "AWS::EC2::Subnet",
+    Table = "AWS::DynamoDB::Table",
+    Topic = "AWS::SNS::Topic",
+    Trail = "AWS::CloudTrail::Trail",
+    TransitGateway = "AWS::EC2::TransitGateway",
+    User = "AWS::IAM::User",
+    VPC = "AWS::EC2::VPC",
+    VPCEndpoint = "AWS::EC2::VPCEndpoint",
+    VPCEndpointService = "AWS::EC2::VPCEndpointService",
+    VPCPeeringConnection = "AWS::EC2::VPCPeeringConnection",
+    VPNConnection = "AWS::EC2::VPNConnection",
+    VPNGateway = "AWS::EC2::VPNGateway",
+    Volume = "AWS::EC2::Volume",
+    WebACL = "AWS::WAF::WebACL",
+    WebACLV2 = "AWS::WAFv2::WebACL"
+}
+
+export interface AggregateResourceIdentifier {
+    
+    SourceAccountId: string | undefined;
+    
+    SourceRegion: string | undefined;
+    
+    ResourceId: string | undefined;
+    
+    ResourceType: ResourceType | string | undefined;
+    
+    ResourceName?: string;
+}
+export declare namespace AggregateResourceIdentifier {
+    
+    const filterSensitiveLog: (obj: AggregateResourceIdentifier) => any;
+}
+
+export interface AggregationAuthorization {
+    
+    AggregationAuthorizationArn?: string;
+    
+    AuthorizedAccountId?: string;
+    
+    AuthorizedAwsRegion?: string;
+    
+    CreationTime?: Date;
+}
+export declare namespace AggregationAuthorization {
+    
+    const filterSensitiveLog: (obj: AggregationAuthorization) => any;
+}
+export declare enum ConfigurationItemStatus {
+    OK = "OK",
+    ResourceDeleted = "ResourceDeleted",
+    ResourceDeletedNotRecorded = "ResourceDeletedNotRecorded",
+    ResourceDiscovered = "ResourceDiscovered",
+    ResourceNotRecorded = "ResourceNotRecorded"
+}
+
+export interface BaseConfigurationItem {
+    
+    version?: string;
+    
+    accountId?: string;
+    
+    configurationItemCaptureTime?: Date;
+    
+    configurationItemStatus?: ConfigurationItemStatus | string;
+    
+    configurationStateId?: string;
+    
+    arn?: string;
+    
+    resourceType?: ResourceType | string;
+    
+    resourceId?: string;
+    
+    resourceName?: string;
+    
+    awsRegion?: string;
+    
+    availabilityZone?: string;
+    
+    resourceCreationTime?: Date;
+    
+    configuration?: string;
+    
+    supplementaryConfiguration?: {
+        [key: string]: string;
+    };
+}
+export declare namespace BaseConfigurationItem {
+    
+    const filterSensitiveLog: (obj: BaseConfigurationItem) => any;
+}
+export interface BatchGetAggregateResourceConfigRequest {
+    
+    ConfigurationAggregatorName: string | undefined;
+    
+    ResourceIdentifiers: AggregateResourceIdentifier[] | undefined;
+}
+export declare namespace BatchGetAggregateResourceConfigRequest {
+    
+    const filterSensitiveLog: (obj: BatchGetAggregateResourceConfigRequest) => any;
+}
+export interface BatchGetAggregateResourceConfigResponse {
+    
+    BaseConfigurationItems?: BaseConfigurationItem[];
+    
+    UnprocessedResourceIdentifiers?: AggregateResourceIdentifier[];
+}
+export declare namespace BatchGetAggregateResourceConfigResponse {
+    
+    const filterSensitiveLog: (obj: BatchGetAggregateResourceConfigResponse) => any;
+}
+
+export declare class NoSuchConfigurationAggregatorException extends __BaseException {
+    readonly name: "NoSuchConfigurationAggregatorException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoSuchConfigurationAggregatorException, __BaseException>);
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+
+export interface ResourceKey {
+    
+    resourceType: ResourceType | string | undefined;
+    
+    resourceId: string | undefined;
+}
+export declare namespace ResourceKey {
+    
+    const filterSensitiveLog: (obj: ResourceKey) => any;
+}
+export interface BatchGetResourceConfigRequest {
+    
+    resourceKeys: ResourceKey[] | undefined;
+}
+export declare namespace BatchGetResourceConfigRequest {
+    
+    const filterSensitiveLog: (obj: BatchGetResourceConfigRequest) => any;
+}
+export interface BatchGetResourceConfigResponse {
+    
+    baseConfigurationItems?: BaseConfigurationItem[];
+    
+    unprocessedResourceKeys?: ResourceKey[];
+}
+export declare namespace BatchGetResourceConfigResponse {
+    
+    const filterSensitiveLog: (obj: BatchGetResourceConfigResponse) => any;
+}
+
+export declare class NoAvailableConfigurationRecorderException extends __BaseException {
+    readonly name: "NoAvailableConfigurationRecorderException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoAvailableConfigurationRecorderException, __BaseException>);
+}
+export declare enum ChronologicalOrder {
+    Forward = "Forward",
+    Reverse = "Reverse"
+}
+
+export interface ComplianceByConfigRule {
+    
+    ConfigRuleName?: string;
+    
+    Compliance?: Compliance;
+}
+export declare namespace ComplianceByConfigRule {
+    
+    const filterSensitiveLog: (obj: ComplianceByConfigRule) => any;
+}
+
+export interface ComplianceByResource {
+    
+    ResourceType?: string;
+    
+    ResourceId?: string;
+    
+    Compliance?: Compliance;
+}
+export declare namespace ComplianceByResource {
+    
+    const filterSensitiveLog: (obj: ComplianceByResource) => any;
+}
+
+export interface ComplianceSummaryByResourceType {
+    
+    ResourceType?: string;
+    
+    ComplianceSummary?: ComplianceSummary;
+}
+export declare namespace ComplianceSummaryByResourceType {
+    
+    const filterSensitiveLog: (obj: ComplianceSummaryByResourceType) => any;
+}
+export declare enum DeliveryStatus {
+    Failure = "Failure",
+    Not_Applicable = "Not_Applicable",
+    Success = "Success"
+}
+
+export interface ConfigExportDeliveryInfo {
+    
+    lastStatus?: DeliveryStatus | string;
+    
+    lastErrorCode?: string;
+    
+    lastErrorMessage?: string;
+    
+    lastAttemptTime?: Date;
+    
+    lastSuccessfulTime?: Date;
+    
+    nextDeliveryTime?: Date;
+}
+export declare namespace ConfigExportDeliveryInfo {
+    
+    const filterSensitiveLog: (obj: ConfigExportDeliveryInfo) => any;
+}
+export declare enum ConfigRuleState {
+    ACTIVE = "ACTIVE",
+    DELETING = "DELETING",
+    DELETING_RESULTS = "DELETING_RESULTS",
+    EVALUATING = "EVALUATING"
+}
+export declare enum MaximumExecutionFrequency {
+    One_Hour = "One_Hour",
+    Six_Hours = "Six_Hours",
+    Three_Hours = "Three_Hours",
+    Twelve_Hours = "Twelve_Hours",
+    TwentyFour_Hours = "TwentyFour_Hours"
+}
+
+export interface Scope {
+    
+    ComplianceResourceTypes?: string[];
+    
+    TagKey?: string;
+    
+    TagValue?: string;
+    
+    ComplianceResourceId?: string;
+}
+export declare namespace Scope {
+    
+    const filterSensitiveLog: (obj: Scope) => any;
+}
+export declare enum Owner {
+    Aws = "AWS",
+    Custom_Lambda = "CUSTOM_LAMBDA"
+}
+export declare enum EventSource {
+    Aws_Config = "aws.config"
+}
+export declare enum MessageType {
+    ConfigurationItemChangeNotification = "ConfigurationItemChangeNotification",
+    ConfigurationSnapshotDeliveryCompleted = "ConfigurationSnapshotDeliveryCompleted",
+    OversizedConfigurationItemChangeNotification = "OversizedConfigurationItemChangeNotification",
+    ScheduledNotification = "ScheduledNotification"
+}
+
+export interface SourceDetail {
+    
+    EventSource?: EventSource | string;
+    
+    MessageType?: MessageType | string;
+    
+    MaximumExecutionFrequency?: MaximumExecutionFrequency | string;
+}
+export declare namespace SourceDetail {
+    
+    const filterSensitiveLog: (obj: SourceDetail) => any;
+}
+
+export interface Source {
+    
+    Owner: Owner | string | undefined;
+    
+    SourceIdentifier: string | undefined;
+    
+    SourceDetails?: SourceDetail[];
+}
+export declare namespace Source {
+    
+    const filterSensitiveLog: (obj: Source) => any;
+}
+
+export interface ConfigRule {
+    
+    ConfigRuleName?: string;
+    
+    ConfigRuleArn?: string;
+    
+    ConfigRuleId?: string;
+    
+    Description?: string;
+    
+    Scope?: Scope;
+    
+    Source: Source | undefined;
+    
+    InputParameters?: string;
+    
+    MaximumExecutionFrequency?: MaximumExecutionFrequency | string;
+    
+    ConfigRuleState?: ConfigRuleState | string;
+    
+    CreatedBy?: string;
+}
+export declare namespace ConfigRule {
+    
+    const filterSensitiveLog: (obj: ConfigRule) => any;
+}
+
+export interface ConfigRuleComplianceFilters {
+    
+    ConfigRuleName?: string;
+    
+    ComplianceType?: ComplianceType | string;
+    
+    AccountId?: string;
+    
+    AwsRegion?: string;
+}
+export declare namespace ConfigRuleComplianceFilters {
+    
+    const filterSensitiveLog: (obj: ConfigRuleComplianceFilters) => any;
+}
+
+export interface ConfigRuleComplianceSummaryFilters {
+    
+    AccountId?: string;
+    
+    AwsRegion?: string;
+}
+export declare namespace ConfigRuleComplianceSummaryFilters {
+    
+    const filterSensitiveLog: (obj: ConfigRuleComplianceSummaryFilters) => any;
+}
+export declare enum ConfigRuleComplianceSummaryGroupKey {
+    ACCOUNT_ID = "ACCOUNT_ID",
+    AWS_REGION = "AWS_REGION"
+}
+
+export interface ConfigRuleEvaluationStatus {
+    
+    ConfigRuleName?: string;
+    
+    ConfigRuleArn?: string;
+    
+    ConfigRuleId?: string;
+    
+    LastSuccessfulInvocationTime?: Date;
+    
+    LastFailedInvocationTime?: Date;
+    
+    LastSuccessfulEvaluationTime?: Date;
+    
+    LastFailedEvaluationTime?: Date;
+    
+    FirstActivatedTime?: Date;
+    
+    LastDeactivatedTime?: Date;
+    
+    LastErrorCode?: string;
+    
+    LastErrorMessage?: string;
+    
+    FirstEvaluationStarted?: boolean;
+}
+export declare namespace ConfigRuleEvaluationStatus {
+    
+    const filterSensitiveLog: (obj: ConfigRuleEvaluationStatus) => any;
+}
+
+export interface ConfigSnapshotDeliveryProperties {
+    
+    deliveryFrequency?: MaximumExecutionFrequency | string;
+}
+export declare namespace ConfigSnapshotDeliveryProperties {
+    
+    const filterSensitiveLog: (obj: ConfigSnapshotDeliveryProperties) => any;
+}
+
+export interface ConfigStreamDeliveryInfo {
+    
+    lastStatus?: DeliveryStatus | string;
+    
+    lastErrorCode?: string;
+    
+    lastErrorMessage?: string;
+    
+    lastStatusChangeTime?: Date;
+}
+export declare namespace ConfigStreamDeliveryInfo {
+    
+    const filterSensitiveLog: (obj: ConfigStreamDeliveryInfo) => any;
+}
+
+export interface OrganizationAggregationSource {
+    
+    RoleArn: string | undefined;
+    
+    AwsRegions?: string[];
+    
+    AllAwsRegions?: boolean;
+}
+export declare namespace OrganizationAggregationSource {
+    
+    const filterSensitiveLog: (obj: OrganizationAggregationSource) => any;
+}
+
+export interface ConfigurationAggregator {
+    
+    ConfigurationAggregatorName?: string;
+    
+    ConfigurationAggregatorArn?: string;
+    
+    AccountAggregationSources?: AccountAggregationSource[];
+    
+    OrganizationAggregationSource?: OrganizationAggregationSource;
+    
+    CreationTime?: Date;
+    
+    LastUpdatedTime?: Date;
+    
+    CreatedBy?: string;
+}
+export declare namespace ConfigurationAggregator {
+    
+    const filterSensitiveLog: (obj: ConfigurationAggregator) => any;
+}
+
+export interface Relationship {
+    
+    resourceType?: ResourceType | string;
+    
+    resourceId?: string;
+    
+    resourceName?: string;
+    
+    relationshipName?: string;
+}
+export declare namespace Relationship {
+    
+    const filterSensitiveLog: (obj: Relationship) => any;
+}
+
+export interface ConfigurationItem {
+    
+    version?: string;
+    
+    accountId?: string;
+    
+    configurationItemCaptureTime?: Date;
+    
+    configurationItemStatus?: ConfigurationItemStatus | string;
+    
+    configurationStateId?: string;
+    
+    configurationItemMD5Hash?: string;
+    
+    arn?: string;
+    
+    resourceType?: ResourceType | string;
+    
+    resourceId?: string;
+    
+    resourceName?: string;
+    
+    awsRegion?: string;
+    
+    availabilityZone?: string;
+    
+    resourceCreationTime?: Date;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    relatedEvents?: string[];
+    
+    relationships?: Relationship[];
+    
+    configuration?: string;
+    
+    supplementaryConfiguration?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ConfigurationItem {
+    
+    const filterSensitiveLog: (obj: ConfigurationItem) => any;
+}
+
+export interface RecordingGroup {
+    
+    allSupported?: boolean;
+    
+    includeGlobalResourceTypes?: boolean;
+    
+    resourceTypes?: (ResourceType | string)[];
+}
+export declare namespace RecordingGroup {
+    
+    const filterSensitiveLog: (obj: RecordingGroup) => any;
+}
+
+export interface ConfigurationRecorder {
+    
+    name?: string;
+    
+    roleARN?: string;
+    
+    recordingGroup?: RecordingGroup;
+}
+export declare namespace ConfigurationRecorder {
+    
+    const filterSensitiveLog: (obj: ConfigurationRecorder) => any;
+}
+export declare enum RecorderStatus {
+    Failure = "Failure",
+    Pending = "Pending",
+    Success = "Success"
+}
+
+export interface ConfigurationRecorderStatus {
+    
+    name?: string;
+    
+    lastStartTime?: Date;
+    
+    lastStopTime?: Date;
+    
+    recording?: boolean;
+    
+    lastStatus?: RecorderStatus | string;
+    
+    lastErrorCode?: string;
+    
+    lastErrorMessage?: string;
+    
+    lastStatusChangeTime?: Date;
+}
+export declare namespace ConfigurationRecorderStatus {
+    
+    const filterSensitiveLog: (obj: ConfigurationRecorderStatus) => any;
+}
+
+export interface ConformancePackComplianceFilters {
+    
+    ConfigRuleNames?: string[];
+    
+    ComplianceType?: ConformancePackComplianceType | string;
+}
+export declare namespace ConformancePackComplianceFilters {
+    
+    const filterSensitiveLog: (obj: ConformancePackComplianceFilters) => any;
+}
+
+export interface ConformancePackComplianceSummary {
+    
+    ConformancePackName: string | undefined;
+    
+    ConformancePackComplianceStatus: ConformancePackComplianceType | string | undefined;
+}
+export declare namespace ConformancePackComplianceSummary {
+    
+    const filterSensitiveLog: (obj: ConformancePackComplianceSummary) => any;
+}
+
+export interface ConformancePackInputParameter {
+    
+    ParameterName: string | undefined;
+    
+    ParameterValue: string | undefined;
+}
+export declare namespace ConformancePackInputParameter {
+    
+    const filterSensitiveLog: (obj: ConformancePackInputParameter) => any;
+}
+
+export interface ConformancePackDetail {
+    
+    ConformancePackName: string | undefined;
+    
+    ConformancePackArn: string | undefined;
+    
+    ConformancePackId: string | undefined;
+    
+    DeliveryS3Bucket?: string;
+    
+    DeliveryS3KeyPrefix?: string;
+    
+    ConformancePackInputParameters?: ConformancePackInputParameter[];
+    
+    LastUpdateRequestedTime?: Date;
+    
+    CreatedBy?: string;
+}
+export declare namespace ConformancePackDetail {
+    
+    const filterSensitiveLog: (obj: ConformancePackDetail) => any;
+}
+
+export interface ConformancePackEvaluationFilters {
+    
+    ConfigRuleNames?: string[];
+    
+    ComplianceType?: ConformancePackComplianceType | string;
+    
+    ResourceType?: string;
+    
+    ResourceIds?: string[];
+}
+export declare namespace ConformancePackEvaluationFilters {
+    
+    const filterSensitiveLog: (obj: ConformancePackEvaluationFilters) => any;
+}
+
+export interface ConformancePackEvaluationResult {
+    
+    ComplianceType: ConformancePackComplianceType | string | undefined;
+    
+    EvaluationResultIdentifier: EvaluationResultIdentifier | undefined;
+    
+    ConfigRuleInvokedTime: Date | undefined;
+    
+    ResultRecordedTime: Date | undefined;
+    
+    Annotation?: string;
+}
+export declare namespace ConformancePackEvaluationResult {
+    
+    const filterSensitiveLog: (obj: ConformancePackEvaluationResult) => any;
+}
+
+export interface ConformancePackRuleCompliance {
+    
+    ConfigRuleName?: string;
+    
+    ComplianceType?: ConformancePackComplianceType | string;
+    
+    Controls?: string[];
+}
+export declare namespace ConformancePackRuleCompliance {
+    
+    const filterSensitiveLog: (obj: ConformancePackRuleCompliance) => any;
+}
+export declare enum ConformancePackState {
+    CREATE_COMPLETE = "CREATE_COMPLETE",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS"
+}
+
+export interface ConformancePackStatusDetail {
+    
+    ConformancePackName: string | undefined;
+    
+    ConformancePackId: string | undefined;
+    
+    ConformancePackArn: string | undefined;
+    
+    ConformancePackState: ConformancePackState | string | undefined;
+    
+    StackArn: string | undefined;
+    
+    ConformancePackStatusReason?: string;
+    
+    LastUpdateRequestedTime: Date | undefined;
+    
+    LastUpdateCompletedTime?: Date;
+}
+export declare namespace ConformancePackStatusDetail {
+    
+    const filterSensitiveLog: (obj: ConformancePackStatusDetail) => any;
+}
+
+export declare class ConformancePackTemplateValidationException extends __BaseException {
+    readonly name: "ConformancePackTemplateValidationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ConformancePackTemplateValidationException, __BaseException>);
+}
+export interface DeleteAggregationAuthorizationRequest {
+    
+    AuthorizedAccountId: string | undefined;
+    
+    AuthorizedAwsRegion: string | undefined;
+}
+export declare namespace DeleteAggregationAuthorizationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAggregationAuthorizationRequest) => any;
+}
+
+export declare class InvalidParameterValueException extends __BaseException {
+    readonly name: "InvalidParameterValueException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameterValueException, __BaseException>);
+}
+
+export interface DeleteConfigRuleRequest {
+    
+    ConfigRuleName: string | undefined;
+}
+export declare namespace DeleteConfigRuleRequest {
+    
+    const filterSensitiveLog: (obj: DeleteConfigRuleRequest) => any;
+}
+
+export declare class NoSuchConfigRuleException extends __BaseException {
+    readonly name: "NoSuchConfigRuleException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoSuchConfigRuleException, __BaseException>);
+}
+
+export declare class ResourceInUseException extends __BaseException {
+    readonly name: "ResourceInUseException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceInUseException, __BaseException>);
+}
+export interface DeleteConfigurationAggregatorRequest {
+    
+    ConfigurationAggregatorName: string | undefined;
+}
+export declare namespace DeleteConfigurationAggregatorRequest {
+    
+    const filterSensitiveLog: (obj: DeleteConfigurationAggregatorRequest) => any;
+}
+
+export interface DeleteConfigurationRecorderRequest {
+    
+    ConfigurationRecorderName: string | undefined;
+}
+export declare namespace DeleteConfigurationRecorderRequest {
+    
+    const filterSensitiveLog: (obj: DeleteConfigurationRecorderRequest) => any;
+}
+
+export declare class NoSuchConfigurationRecorderException extends __BaseException {
+    readonly name: "NoSuchConfigurationRecorderException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoSuchConfigurationRecorderException, __BaseException>);
+}
+export interface DeleteConformancePackRequest {
+    
+    ConformancePackName: string | undefined;
+}
+export declare namespace DeleteConformancePackRequest {
+    
+    const filterSensitiveLog: (obj: DeleteConformancePackRequest) => any;
+}
+
+export declare class NoSuchConformancePackException extends __BaseException {
+    readonly name: "NoSuchConformancePackException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoSuchConformancePackException, __BaseException>);
+}
+
+export interface DeleteDeliveryChannelRequest {
+    
+    DeliveryChannelName: string | undefined;
+}
+export declare namespace DeleteDeliveryChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDeliveryChannelRequest) => any;
+}
+
+export declare class LastDeliveryChannelDeleteFailedException extends __BaseException {
+    readonly name: "LastDeliveryChannelDeleteFailedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<LastDeliveryChannelDeleteFailedException, __BaseException>);
+}
+
+export declare class NoSuchDeliveryChannelException extends __BaseException {
+    readonly name: "NoSuchDeliveryChannelException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoSuchDeliveryChannelException, __BaseException>);
+}
+
+export interface DeleteEvaluationResultsRequest {
+    
+    ConfigRuleName: string | undefined;
+}
+export declare namespace DeleteEvaluationResultsRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEvaluationResultsRequest) => any;
+}
+
+export interface DeleteEvaluationResultsResponse {
+}
+export declare namespace DeleteEvaluationResultsResponse {
+    
+    const filterSensitiveLog: (obj: DeleteEvaluationResultsResponse) => any;
+}
+export interface DeleteOrganizationConfigRuleRequest {
+    
+    OrganizationConfigRuleName: string | undefined;
+}
+export declare namespace DeleteOrganizationConfigRuleRequest {
+    
+    const filterSensitiveLog: (obj: DeleteOrganizationConfigRuleRequest) => any;
+}
+
+export declare class NoSuchOrganizationConfigRuleException extends __BaseException {
+    readonly name: "NoSuchOrganizationConfigRuleException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoSuchOrganizationConfigRuleException, __BaseException>);
+}
+
+export declare class OrganizationAccessDeniedException extends __BaseException {
+    readonly name: "OrganizationAccessDeniedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OrganizationAccessDeniedException, __BaseException>);
+}
+export interface DeleteOrganizationConformancePackRequest {
+    
+    OrganizationConformancePackName: string | undefined;
+}
+export declare namespace DeleteOrganizationConformancePackRequest {
+    
+    const filterSensitiveLog: (obj: DeleteOrganizationConformancePackRequest) => any;
+}
+
+export declare class NoSuchOrganizationConformancePackException extends __BaseException {
+    readonly name: "NoSuchOrganizationConformancePackException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoSuchOrganizationConformancePackException, __BaseException>);
+}
+export interface DeletePendingAggregationRequestRequest {
+    
+    RequesterAccountId: string | undefined;
+    
+    RequesterAwsRegion: string | undefined;
+}
+export declare namespace DeletePendingAggregationRequestRequest {
+    
+    const filterSensitiveLog: (obj: DeletePendingAggregationRequestRequest) => any;
+}
+export interface DeleteRemediationConfigurationRequest {
+    
+    ConfigRuleName: string | undefined;
+    
+    ResourceType?: string;
+}
+export declare namespace DeleteRemediationConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRemediationConfigurationRequest) => any;
+}
+export interface DeleteRemediationConfigurationResponse {
+}
+export declare namespace DeleteRemediationConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteRemediationConfigurationResponse) => any;
+}
+
+export declare class InsufficientPermissionsException extends __BaseException {
+    readonly name: "InsufficientPermissionsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InsufficientPermissionsException, __BaseException>);
+}
+
+export declare class NoSuchRemediationConfigurationException extends __BaseException {
+    readonly name: "NoSuchRemediationConfigurationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoSuchRemediationConfigurationException, __BaseException>);
+}
+
+export declare class RemediationInProgressException extends __BaseException {
+    readonly name: "RemediationInProgressException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<RemediationInProgressException, __BaseException>);
+}
+
+export interface RemediationExceptionResourceKey {
+    
+    ResourceType?: string;
+    
+    ResourceId?: string;
+}
+export declare namespace RemediationExceptionResourceKey {
+    
+    const filterSensitiveLog: (obj: RemediationExceptionResourceKey) => any;
+}
+export interface DeleteRemediationExceptionsRequest {
+    
+    ConfigRuleName: string | undefined;
+    
+    ResourceKeys: RemediationExceptionResourceKey[] | undefined;
+}
+export declare namespace DeleteRemediationExceptionsRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRemediationExceptionsRequest) => any;
+}
+
+export interface FailedDeleteRemediationExceptionsBatch {
+    
+    FailureMessage?: string;
+    
+    FailedItems?: RemediationExceptionResourceKey[];
+}
+export declare namespace FailedDeleteRemediationExceptionsBatch {
+    
+    const filterSensitiveLog: (obj: FailedDeleteRemediationExceptionsBatch) => any;
+}
+export interface DeleteRemediationExceptionsResponse {
+    
+    FailedBatches?: FailedDeleteRemediationExceptionsBatch[];
+}
+export declare namespace DeleteRemediationExceptionsResponse {
+    
+    const filterSensitiveLog: (obj: DeleteRemediationExceptionsResponse) => any;
+}
+
+export declare class NoSuchRemediationExceptionException extends __BaseException {
+    readonly name: "NoSuchRemediationExceptionException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoSuchRemediationExceptionException, __BaseException>);
+}
+export interface DeleteResourceConfigRequest {
+    
+    ResourceType: string | undefined;
+    
+    ResourceId: string | undefined;
+}
+export declare namespace DeleteResourceConfigRequest {
+    
+    const filterSensitiveLog: (obj: DeleteResourceConfigRequest) => any;
+}
+
+export declare class NoRunningConfigurationRecorderException extends __BaseException {
+    readonly name: "NoRunningConfigurationRecorderException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoRunningConfigurationRecorderException, __BaseException>);
+}
+export interface DeleteRetentionConfigurationRequest {
+    
+    RetentionConfigurationName: string | undefined;
+}
+export declare namespace DeleteRetentionConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRetentionConfigurationRequest) => any;
+}
+
+export declare class NoSuchRetentionConfigurationException extends __BaseException {
+    readonly name: "NoSuchRetentionConfigurationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoSuchRetentionConfigurationException, __BaseException>);
+}
+export interface DeleteStoredQueryRequest {
+    
+    QueryName: string | undefined;
+}
+export declare namespace DeleteStoredQueryRequest {
+    
+    const filterSensitiveLog: (obj: DeleteStoredQueryRequest) => any;
+}
+export interface DeleteStoredQueryResponse {
+}
+export declare namespace DeleteStoredQueryResponse {
+    
+    const filterSensitiveLog: (obj: DeleteStoredQueryResponse) => any;
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export interface DeliverConfigSnapshotRequest {
+    
+    deliveryChannelName: string | undefined;
+}
+export declare namespace DeliverConfigSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: DeliverConfigSnapshotRequest) => any;
+}
+
+export interface DeliverConfigSnapshotResponse {
+    
+    configSnapshotId?: string;
+}
+export declare namespace DeliverConfigSnapshotResponse {
+    
+    const filterSensitiveLog: (obj: DeliverConfigSnapshotResponse) => any;
+}
+
+export interface DeliveryChannel {
+    
+    name?: string;
+    
+    s3BucketName?: string;
+    
+    s3KeyPrefix?: string;
+    
+    s3KmsKeyArn?: string;
+    
+    snsTopicARN?: string;
+    
+    configSnapshotDeliveryProperties?: ConfigSnapshotDeliveryProperties;
+}
+export declare namespace DeliveryChannel {
+    
+    const filterSensitiveLog: (obj: DeliveryChannel) => any;
+}
+
+export interface DeliveryChannelStatus {
+    
+    name?: string;
+    
+    configSnapshotDeliveryInfo?: ConfigExportDeliveryInfo;
+    
+    configHistoryDeliveryInfo?: ConfigExportDeliveryInfo;
+    
+    configStreamDeliveryInfo?: ConfigStreamDeliveryInfo;
+}
+export declare namespace DeliveryChannelStatus {
+    
+    const filterSensitiveLog: (obj: DeliveryChannelStatus) => any;
+}
+export interface DescribeAggregateComplianceByConfigRulesRequest {
+    
+    ConfigurationAggregatorName: string | undefined;
+    
+    Filters?: ConfigRuleComplianceFilters;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAggregateComplianceByConfigRulesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAggregateComplianceByConfigRulesRequest) => any;
+}
+export interface DescribeAggregateComplianceByConfigRulesResponse {
+    
+    AggregateComplianceByConfigRules?: AggregateComplianceByConfigRule[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAggregateComplianceByConfigRulesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAggregateComplianceByConfigRulesResponse) => any;
+}
+
+export declare class InvalidLimitException extends __BaseException {
+    readonly name: "InvalidLimitException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidLimitException, __BaseException>);
+}
+
+export declare class InvalidNextTokenException extends __BaseException {
+    readonly name: "InvalidNextTokenException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidNextTokenException, __BaseException>);
+}
+export interface DescribeAggregateComplianceByConformancePacksRequest {
+    
+    ConfigurationAggregatorName: string | undefined;
+    
+    Filters?: AggregateConformancePackComplianceFilters;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAggregateComplianceByConformancePacksRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAggregateComplianceByConformancePacksRequest) => any;
+}
+export interface DescribeAggregateComplianceByConformancePacksResponse {
+    
+    AggregateComplianceByConformancePacks?: AggregateComplianceByConformancePack[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAggregateComplianceByConformancePacksResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAggregateComplianceByConformancePacksResponse) => any;
+}
+export interface DescribeAggregationAuthorizationsRequest {
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAggregationAuthorizationsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAggregationAuthorizationsRequest) => any;
+}
+export interface DescribeAggregationAuthorizationsResponse {
+    
+    AggregationAuthorizations?: AggregationAuthorization[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAggregationAuthorizationsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAggregationAuthorizationsResponse) => any;
+}
+
+export interface DescribeComplianceByConfigRuleRequest {
+    
+    ConfigRuleNames?: string[];
+    
+    ComplianceTypes?: (ComplianceType | string)[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeComplianceByConfigRuleRequest {
+    
+    const filterSensitiveLog: (obj: DescribeComplianceByConfigRuleRequest) => any;
+}
+
+export interface DescribeComplianceByConfigRuleResponse {
+    
+    ComplianceByConfigRules?: ComplianceByConfigRule[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeComplianceByConfigRuleResponse {
+    
+    const filterSensitiveLog: (obj: DescribeComplianceByConfigRuleResponse) => any;
+}
+
+export interface DescribeComplianceByResourceRequest {
+    
+    ResourceType?: string;
+    
+    ResourceId?: string;
+    
+    ComplianceTypes?: (ComplianceType | string)[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeComplianceByResourceRequest {
+    
+    const filterSensitiveLog: (obj: DescribeComplianceByResourceRequest) => any;
+}
+
+export interface DescribeComplianceByResourceResponse {
+    
+    ComplianceByResources?: ComplianceByResource[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeComplianceByResourceResponse {
+    
+    const filterSensitiveLog: (obj: DescribeComplianceByResourceResponse) => any;
+}
+
+export interface DescribeConfigRuleEvaluationStatusRequest {
+    
+    ConfigRuleNames?: string[];
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace DescribeConfigRuleEvaluationStatusRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConfigRuleEvaluationStatusRequest) => any;
+}
+
+export interface DescribeConfigRuleEvaluationStatusResponse {
+    
+    ConfigRulesEvaluationStatus?: ConfigRuleEvaluationStatus[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConfigRuleEvaluationStatusResponse {
+    
+    const filterSensitiveLog: (obj: DescribeConfigRuleEvaluationStatusResponse) => any;
+}
+
+export interface DescribeConfigRulesRequest {
+    
+    ConfigRuleNames?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConfigRulesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConfigRulesRequest) => any;
+}
+
+export interface DescribeConfigRulesResponse {
+    
+    ConfigRules?: ConfigRule[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConfigRulesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeConfigRulesResponse) => any;
+}
+export interface DescribeConfigurationAggregatorsRequest {
+    
+    ConfigurationAggregatorNames?: string[];
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace DescribeConfigurationAggregatorsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationAggregatorsRequest) => any;
+}
+export interface DescribeConfigurationAggregatorsResponse {
+    
+    ConfigurationAggregators?: ConfigurationAggregator[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConfigurationAggregatorsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationAggregatorsResponse) => any;
+}
+export interface DescribeConfigurationAggregatorSourcesStatusRequest {
+    
+    ConfigurationAggregatorName: string | undefined;
+    
+    UpdateStatus?: (AggregatedSourceStatusType | string)[];
+    
+    NextToken?: string;
+    
+    Limit?: number;
+}
+export declare namespace DescribeConfigurationAggregatorSourcesStatusRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationAggregatorSourcesStatusRequest) => any;
+}
+export interface DescribeConfigurationAggregatorSourcesStatusResponse {
+    
+    AggregatedSourceStatusList?: AggregatedSourceStatus[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConfigurationAggregatorSourcesStatusResponse {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationAggregatorSourcesStatusResponse) => any;
+}
+
+export interface DescribeConfigurationRecordersRequest {
+    
+    ConfigurationRecorderNames?: string[];
+}
+export declare namespace DescribeConfigurationRecordersRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationRecordersRequest) => any;
+}
+
+export interface DescribeConfigurationRecordersResponse {
+    
+    ConfigurationRecorders?: ConfigurationRecorder[];
+}
+export declare namespace DescribeConfigurationRecordersResponse {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationRecordersResponse) => any;
+}
+
+export interface DescribeConfigurationRecorderStatusRequest {
+    
+    ConfigurationRecorderNames?: string[];
+}
+export declare namespace DescribeConfigurationRecorderStatusRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationRecorderStatusRequest) => any;
+}
+
+export interface DescribeConfigurationRecorderStatusResponse {
+    
+    ConfigurationRecordersStatus?: ConfigurationRecorderStatus[];
+}
+export declare namespace DescribeConfigurationRecorderStatusResponse {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationRecorderStatusResponse) => any;
+}
+export interface DescribeConformancePackComplianceRequest {
+    
+    ConformancePackName: string | undefined;
+    
+    Filters?: ConformancePackComplianceFilters;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConformancePackComplianceRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConformancePackComplianceRequest) => any;
+}
+export interface DescribeConformancePackComplianceResponse {
+    
+    ConformancePackName: string | undefined;
+    
+    ConformancePackRuleComplianceList: ConformancePackRuleCompliance[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConformancePackComplianceResponse {
+    
+    const filterSensitiveLog: (obj: DescribeConformancePackComplianceResponse) => any;
+}
+
+export declare class NoSuchConfigRuleInConformancePackException extends __BaseException {
+    readonly name: "NoSuchConfigRuleInConformancePackException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoSuchConfigRuleInConformancePackException, __BaseException>);
+}
+export interface DescribeConformancePacksRequest {
+    
+    ConformancePackNames?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConformancePacksRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConformancePacksRequest) => any;
+}
+export interface DescribeConformancePacksResponse {
+    
+    ConformancePackDetails?: ConformancePackDetail[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConformancePacksResponse {
+    
+    const filterSensitiveLog: (obj: DescribeConformancePacksResponse) => any;
+}
+export interface DescribeConformancePackStatusRequest {
+    
+    ConformancePackNames?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConformancePackStatusRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConformancePackStatusRequest) => any;
+}
+export interface DescribeConformancePackStatusResponse {
+    
+    ConformancePackStatusDetails?: ConformancePackStatusDetail[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConformancePackStatusResponse {
+    
+    const filterSensitiveLog: (obj: DescribeConformancePackStatusResponse) => any;
+}
+
+export interface DescribeDeliveryChannelsRequest {
+    
+    DeliveryChannelNames?: string[];
+}
+export declare namespace DescribeDeliveryChannelsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDeliveryChannelsRequest) => any;
+}
+
+export interface DescribeDeliveryChannelsResponse {
+    
+    DeliveryChannels?: DeliveryChannel[];
+}
+export declare namespace DescribeDeliveryChannelsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDeliveryChannelsResponse) => any;
+}
+
+export interface DescribeDeliveryChannelStatusRequest {
+    
+    DeliveryChannelNames?: string[];
+}
+export declare namespace DescribeDeliveryChannelStatusRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDeliveryChannelStatusRequest) => any;
+}
+
+export interface DescribeDeliveryChannelStatusResponse {
+    
+    DeliveryChannelsStatus?: DeliveryChannelStatus[];
+}
+export declare namespace DescribeDeliveryChannelStatusResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDeliveryChannelStatusResponse) => any;
+}
+export interface DescribeOrganizationConfigRulesRequest {
+    
+    OrganizationConfigRuleNames?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeOrganizationConfigRulesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeOrganizationConfigRulesRequest) => any;
+}
+export declare enum OrganizationConfigRuleTriggerType {
+    CONFIGURATION_ITEM_CHANGE_NOTIFICATION = "ConfigurationItemChangeNotification",
+    OVERSIZED_CONFIGURATION_ITEM_CHANGE_NOTIFCATION = "OversizedConfigurationItemChangeNotification",
+    SCHEDULED_NOTIFICATION = "ScheduledNotification"
+}
+
+export interface OrganizationCustomRuleMetadata {
+    
+    Description?: string;
+    
+    LambdaFunctionArn: string | undefined;
+    
+    OrganizationConfigRuleTriggerTypes: (OrganizationConfigRuleTriggerType | string)[] | undefined;
+    
+    InputParameters?: string;
+    
+    MaximumExecutionFrequency?: MaximumExecutionFrequency | string;
+    
+    ResourceTypesScope?: string[];
+    
+    ResourceIdScope?: string;
+    
+    TagKeyScope?: string;
+    
+    TagValueScope?: string;
+}
+export declare namespace OrganizationCustomRuleMetadata {
+    
+    const filterSensitiveLog: (obj: OrganizationCustomRuleMetadata) => any;
+}
+
+export interface OrganizationManagedRuleMetadata {
+    
+    Description?: string;
+    
+    RuleIdentifier: string | undefined;
+    
+    InputParameters?: string;
+    
+    MaximumExecutionFrequency?: MaximumExecutionFrequency | string;
+    
+    ResourceTypesScope?: string[];
+    
+    ResourceIdScope?: string;
+    
+    TagKeyScope?: string;
+    
+    TagValueScope?: string;
+}
+export declare namespace OrganizationManagedRuleMetadata {
+    
+    const filterSensitiveLog: (obj: OrganizationManagedRuleMetadata) => any;
+}
+
+export interface OrganizationConfigRule {
+    
+    OrganizationConfigRuleName: string | undefined;
+    
+    OrganizationConfigRuleArn: string | undefined;
+    
+    OrganizationManagedRuleMetadata?: OrganizationManagedRuleMetadata;
+    
+    OrganizationCustomRuleMetadata?: OrganizationCustomRuleMetadata;
+    
+    ExcludedAccounts?: string[];
+    
+    LastUpdateTime?: Date;
+}
+export declare namespace OrganizationConfigRule {
+    
+    const filterSensitiveLog: (obj: OrganizationConfigRule) => any;
+}
+export interface DescribeOrganizationConfigRulesResponse {
+    
+    OrganizationConfigRules?: OrganizationConfigRule[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeOrganizationConfigRulesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeOrganizationConfigRulesResponse) => any;
+}
+export interface DescribeOrganizationConfigRuleStatusesRequest {
+    
+    OrganizationConfigRuleNames?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeOrganizationConfigRuleStatusesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeOrganizationConfigRuleStatusesRequest) => any;
+}
+export declare enum OrganizationRuleStatus {
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    CREATE_SUCCESSFUL = "CREATE_SUCCESSFUL",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
+    DELETE_SUCCESSFUL = "DELETE_SUCCESSFUL",
+    UPDATE_FAILED = "UPDATE_FAILED",
+    UPDATE_IN_PROGRESS = "UPDATE_IN_PROGRESS",
+    UPDATE_SUCCESSFUL = "UPDATE_SUCCESSFUL"
+}
+
+export interface OrganizationConfigRuleStatus {
+    
+    OrganizationConfigRuleName: string | undefined;
+    
+    OrganizationRuleStatus: OrganizationRuleStatus | string | undefined;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+    
+    LastUpdateTime?: Date;
+}
+export declare namespace OrganizationConfigRuleStatus {
+    
+    const filterSensitiveLog: (obj: OrganizationConfigRuleStatus) => any;
+}
+export interface DescribeOrganizationConfigRuleStatusesResponse {
+    
+    OrganizationConfigRuleStatuses?: OrganizationConfigRuleStatus[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeOrganizationConfigRuleStatusesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeOrganizationConfigRuleStatusesResponse) => any;
+}
+export interface DescribeOrganizationConformancePacksRequest {
+    
+    OrganizationConformancePackNames?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeOrganizationConformancePacksRequest {
+    
+    const filterSensitiveLog: (obj: DescribeOrganizationConformancePacksRequest) => any;
+}
+
+export interface OrganizationConformancePack {
+    
+    OrganizationConformancePackName: string | undefined;
+    
+    OrganizationConformancePackArn: string | undefined;
+    
+    DeliveryS3Bucket?: string;
+    
+    DeliveryS3KeyPrefix?: string;
+    
+    ConformancePackInputParameters?: ConformancePackInputParameter[];
+    
+    ExcludedAccounts?: string[];
+    
+    LastUpdateTime: Date | undefined;
+}
+export declare namespace OrganizationConformancePack {
+    
+    const filterSensitiveLog: (obj: OrganizationConformancePack) => any;
+}
+export interface DescribeOrganizationConformancePacksResponse {
+    
+    OrganizationConformancePacks?: OrganizationConformancePack[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeOrganizationConformancePacksResponse {
+    
+    const filterSensitiveLog: (obj: DescribeOrganizationConformancePacksResponse) => any;
+}
+export interface DescribeOrganizationConformancePackStatusesRequest {
+    
+    OrganizationConformancePackNames?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeOrganizationConformancePackStatusesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeOrganizationConformancePackStatusesRequest) => any;
+}
+export declare enum OrganizationResourceStatus {
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    CREATE_SUCCESSFUL = "CREATE_SUCCESSFUL",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
+    DELETE_SUCCESSFUL = "DELETE_SUCCESSFUL",
+    UPDATE_FAILED = "UPDATE_FAILED",
+    UPDATE_IN_PROGRESS = "UPDATE_IN_PROGRESS",
+    UPDATE_SUCCESSFUL = "UPDATE_SUCCESSFUL"
+}
+
+export interface OrganizationConformancePackStatus {
+    
+    OrganizationConformancePackName: string | undefined;
+    
+    Status: OrganizationResourceStatus | string | undefined;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+    
+    LastUpdateTime?: Date;
+}
+export declare namespace OrganizationConformancePackStatus {
+    
+    const filterSensitiveLog: (obj: OrganizationConformancePackStatus) => any;
+}
+export interface DescribeOrganizationConformancePackStatusesResponse {
+    
+    OrganizationConformancePackStatuses?: OrganizationConformancePackStatus[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeOrganizationConformancePackStatusesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeOrganizationConformancePackStatusesResponse) => any;
+}
+export interface DescribePendingAggregationRequestsRequest {
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribePendingAggregationRequestsRequest {
+    
+    const filterSensitiveLog: (obj: DescribePendingAggregationRequestsRequest) => any;
+}
+
+export interface PendingAggregationRequest {
+    
+    RequesterAccountId?: string;
+    
+    RequesterAwsRegion?: string;
+}
+export declare namespace PendingAggregationRequest {
+    
+    const filterSensitiveLog: (obj: PendingAggregationRequest) => any;
+}
+export interface DescribePendingAggregationRequestsResponse {
+    
+    PendingAggregationRequests?: PendingAggregationRequest[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribePendingAggregationRequestsResponse {
+    
+    const filterSensitiveLog: (obj: DescribePendingAggregationRequestsResponse) => any;
+}
+export interface DescribeRemediationConfigurationsRequest {
+    
+    ConfigRuleNames: string[] | undefined;
+}
+export declare namespace DescribeRemediationConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeRemediationConfigurationsRequest) => any;
+}
+
+export interface SsmControls {
+    
+    ConcurrentExecutionRatePercentage?: number;
+    
+    ErrorPercentage?: number;
+}
+export declare namespace SsmControls {
+    
+    const filterSensitiveLog: (obj: SsmControls) => any;
+}
+
+export interface ExecutionControls {
+    
+    SsmControls?: SsmControls;
+}
+export declare namespace ExecutionControls {
+    
+    const filterSensitiveLog: (obj: ExecutionControls) => any;
+}
+export declare enum ResourceValueType {
+    RESOURCE_ID = "RESOURCE_ID"
+}
+
+export interface ResourceValue {
+    
+    Value: ResourceValueType | string | undefined;
+}
+export declare namespace ResourceValue {
+    
+    const filterSensitiveLog: (obj: ResourceValue) => any;
+}
+
+export interface StaticValue {
+    
+    Values: string[] | undefined;
+}
+export declare namespace StaticValue {
+    
+    const filterSensitiveLog: (obj: StaticValue) => any;
+}
+
+export interface RemediationParameterValue {
+    
+    ResourceValue?: ResourceValue;
+    
+    StaticValue?: StaticValue;
+}
+export declare namespace RemediationParameterValue {
+    
+    const filterSensitiveLog: (obj: RemediationParameterValue) => any;
+}
+export declare enum RemediationTargetType {
+    SSM_DOCUMENT = "SSM_DOCUMENT"
+}
+
+export interface RemediationConfiguration {
+    
+    ConfigRuleName: string | undefined;
+    
+    TargetType: RemediationTargetType | string | undefined;
+    
+    TargetId: string | undefined;
+    
+    TargetVersion?: string;
+    
+    Parameters?: {
+        [key: string]: RemediationParameterValue;
+    };
+    
+    ResourceType?: string;
+    
+    Automatic?: boolean;
+    
+    ExecutionControls?: ExecutionControls;
+    
+    MaximumAutomaticAttempts?: number;
+    
+    RetryAttemptSeconds?: number;
+    
+    Arn?: string;
+    
+    CreatedByService?: string;
+}
+export declare namespace RemediationConfiguration {
+    
+    const filterSensitiveLog: (obj: RemediationConfiguration) => any;
+}
+export interface DescribeRemediationConfigurationsResponse {
+    
+    RemediationConfigurations?: RemediationConfiguration[];
+}
+export declare namespace DescribeRemediationConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeRemediationConfigurationsResponse) => any;
+}
+export interface DescribeRemediationExceptionsRequest {
+    
+    ConfigRuleName: string | undefined;
+    
+    ResourceKeys?: RemediationExceptionResourceKey[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeRemediationExceptionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeRemediationExceptionsRequest) => any;
+}
+
+export interface RemediationException {
+    
+    ConfigRuleName: string | undefined;
+    
+    ResourceType: string | undefined;
+    
+    ResourceId: string | undefined;
+    
+    Message?: string;
+    
+    ExpirationTime?: Date;
+}
+export declare namespace RemediationException {
+    
+    const filterSensitiveLog: (obj: RemediationException) => any;
+}
+export interface DescribeRemediationExceptionsResponse {
+    
+    RemediationExceptions?: RemediationException[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeRemediationExceptionsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeRemediationExceptionsResponse) => any;
+}
+export interface DescribeRemediationExecutionStatusRequest {
+    
+    ConfigRuleName: string | undefined;
+    
+    ResourceKeys?: ResourceKey[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeRemediationExecutionStatusRequest {
+    
+    const filterSensitiveLog: (obj: DescribeRemediationExecutionStatusRequest) => any;
+}
+export declare enum RemediationExecutionState {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    QUEUED = "QUEUED",
+    SUCCEEDED = "SUCCEEDED"
+}
+export declare enum RemediationExecutionStepState {
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    SUCCEEDED = "SUCCEEDED"
+}
+
+export interface RemediationExecutionStep {
+    
+    Name?: string;
+    
+    State?: RemediationExecutionStepState | string;
+    
+    ErrorMessage?: string;
+    
+    StartTime?: Date;
+    
+    StopTime?: Date;
+}
+export declare namespace RemediationExecutionStep {
+    
+    const filterSensitiveLog: (obj: RemediationExecutionStep) => any;
+}
+
+export interface RemediationExecutionStatus {
+    
+    ResourceKey?: ResourceKey;
+    
+    State?: RemediationExecutionState | string;
+    
+    StepDetails?: RemediationExecutionStep[];
+    
+    InvocationTime?: Date;
+    
+    LastUpdatedTime?: Date;
+}
+export declare namespace RemediationExecutionStatus {
+    
+    const filterSensitiveLog: (obj: RemediationExecutionStatus) => any;
+}
+export interface DescribeRemediationExecutionStatusResponse {
+    
+    RemediationExecutionStatuses?: RemediationExecutionStatus[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeRemediationExecutionStatusResponse {
+    
+    const filterSensitiveLog: (obj: DescribeRemediationExecutionStatusResponse) => any;
+}
+export interface DescribeRetentionConfigurationsRequest {
+    
+    RetentionConfigurationNames?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeRetentionConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeRetentionConfigurationsRequest) => any;
+}
+
+export interface RetentionConfiguration {
+    
+    Name: string | undefined;
+    
+    RetentionPeriodInDays: number | undefined;
+}
+export declare namespace RetentionConfiguration {
+    
+    const filterSensitiveLog: (obj: RetentionConfiguration) => any;
+}
+export interface DescribeRetentionConfigurationsResponse {
+    
+    RetentionConfigurations?: RetentionConfiguration[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeRetentionConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeRetentionConfigurationsResponse) => any;
+}
+
+export interface Evaluation {
+    
+    ComplianceResourceType: string | undefined;
+    
+    ComplianceResourceId: string | undefined;
+    
+    ComplianceType: ComplianceType | string | undefined;
+    
+    Annotation?: string;
+    
+    OrderingTimestamp: Date | undefined;
+}
+export declare namespace Evaluation {
+    
+    const filterSensitiveLog: (obj: Evaluation) => any;
+}
+
+export interface EvaluationResult {
+    
+    EvaluationResultIdentifier?: EvaluationResultIdentifier;
+    
+    ComplianceType?: ComplianceType | string;
+    
+    ResultRecordedTime?: Date;
+    
+    ConfigRuleInvokedTime?: Date;
+    
+    Annotation?: string;
+    
+    ResultToken?: string;
+}
+export declare namespace EvaluationResult {
+    
+    const filterSensitiveLog: (obj: EvaluationResult) => any;
+}
+
+export interface ExternalEvaluation {
+    
+    ComplianceResourceType: string | undefined;
+    
+    ComplianceResourceId: string | undefined;
+    
+    ComplianceType: ComplianceType | string | undefined;
+    
+    Annotation?: string;
+    
+    OrderingTimestamp: Date | undefined;
+}
+export declare namespace ExternalEvaluation {
+    
+    const filterSensitiveLog: (obj: ExternalEvaluation) => any;
+}
+
+export interface FailedRemediationBatch {
+    
+    FailureMessage?: string;
+    
+    FailedItems?: RemediationConfiguration[];
+}
+export declare namespace FailedRemediationBatch {
+    
+    const filterSensitiveLog: (obj: FailedRemediationBatch) => any;
+}
+
+export interface FailedRemediationExceptionBatch {
+    
+    FailureMessage?: string;
+    
+    FailedItems?: RemediationException[];
+}
+export declare namespace FailedRemediationExceptionBatch {
+    
+    const filterSensitiveLog: (obj: FailedRemediationExceptionBatch) => any;
+}
+
+export interface FieldInfo {
+    
+    Name?: string;
+}
+export declare namespace FieldInfo {
+    
+    const filterSensitiveLog: (obj: FieldInfo) => any;
+}
+export interface GetAggregateComplianceDetailsByConfigRuleRequest {
+    
+    ConfigurationAggregatorName: string | undefined;
+    
+    ConfigRuleName: string | undefined;
+    
+    AccountId: string | undefined;
+    
+    AwsRegion: string | undefined;
+    
+    ComplianceType?: ComplianceType | string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetAggregateComplianceDetailsByConfigRuleRequest {
+    
+    const filterSensitiveLog: (obj: GetAggregateComplianceDetailsByConfigRuleRequest) => any;
+}
+export interface GetAggregateComplianceDetailsByConfigRuleResponse {
+    
+    AggregateEvaluationResults?: AggregateEvaluationResult[];
+    
+    NextToken?: string;
+}
+export declare namespace GetAggregateComplianceDetailsByConfigRuleResponse {
+    
+    const filterSensitiveLog: (obj: GetAggregateComplianceDetailsByConfigRuleResponse) => any;
+}
+export interface GetAggregateConfigRuleComplianceSummaryRequest {
+    
+    ConfigurationAggregatorName: string | undefined;
+    
+    Filters?: ConfigRuleComplianceSummaryFilters;
+    
+    GroupByKey?: ConfigRuleComplianceSummaryGroupKey | string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetAggregateConfigRuleComplianceSummaryRequest {
+    
+    const filterSensitiveLog: (obj: GetAggregateConfigRuleComplianceSummaryRequest) => any;
+}
+export interface GetAggregateConfigRuleComplianceSummaryResponse {
+    
+    GroupByKey?: string;
+    
+    AggregateComplianceCounts?: AggregateComplianceCount[];
+    
+    NextToken?: string;
+}
+export declare namespace GetAggregateConfigRuleComplianceSummaryResponse {
+    
+    const filterSensitiveLog: (obj: GetAggregateConfigRuleComplianceSummaryResponse) => any;
+}
+export interface GetAggregateConformancePackComplianceSummaryRequest {
+    
+    ConfigurationAggregatorName: string | undefined;
+    
+    Filters?: AggregateConformancePackComplianceSummaryFilters;
+    
+    GroupByKey?: AggregateConformancePackComplianceSummaryGroupKey | string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetAggregateConformancePackComplianceSummaryRequest {
+    
+    const filterSensitiveLog: (obj: GetAggregateConformancePackComplianceSummaryRequest) => any;
+}
+export interface GetAggregateConformancePackComplianceSummaryResponse {
+    
+    AggregateConformancePackComplianceSummaries?: AggregateConformancePackComplianceSummary[];
+    
+    GroupByKey?: string;
+    
+    NextToken?: string;
+}
+export declare namespace GetAggregateConformancePackComplianceSummaryResponse {
+    
+    const filterSensitiveLog: (obj: GetAggregateConformancePackComplianceSummaryResponse) => any;
+}
+
+export interface ResourceCountFilters {
+    
+    ResourceType?: ResourceType | string;
+    
+    AccountId?: string;
+    
+    Region?: string;
+}
+export declare namespace ResourceCountFilters {
+    
+    const filterSensitiveLog: (obj: ResourceCountFilters) => any;
+}
+export declare enum ResourceCountGroupKey {
+    ACCOUNT_ID = "ACCOUNT_ID",
+    AWS_REGION = "AWS_REGION",
+    RESOURCE_TYPE = "RESOURCE_TYPE"
+}
+export interface GetAggregateDiscoveredResourceCountsRequest {
+    
+    ConfigurationAggregatorName: string | undefined;
+    
+    Filters?: ResourceCountFilters;
+    
+    GroupByKey?: ResourceCountGroupKey | string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetAggregateDiscoveredResourceCountsRequest {
+    
+    const filterSensitiveLog: (obj: GetAggregateDiscoveredResourceCountsRequest) => any;
+}
+
+export interface GroupedResourceCount {
+    
+    GroupName: string | undefined;
+    
+    ResourceCount: number | undefined;
+}
+export declare namespace GroupedResourceCount {
+    
+    const filterSensitiveLog: (obj: GroupedResourceCount) => any;
+}
+export interface GetAggregateDiscoveredResourceCountsResponse {
+    
+    TotalDiscoveredResources: number | undefined;
+    
+    GroupByKey?: string;
+    
+    GroupedResourceCounts?: GroupedResourceCount[];
+    
+    NextToken?: string;
+}
+export declare namespace GetAggregateDiscoveredResourceCountsResponse {
+    
+    const filterSensitiveLog: (obj: GetAggregateDiscoveredResourceCountsResponse) => any;
+}
+export interface GetAggregateResourceConfigRequest {
+    
+    ConfigurationAggregatorName: string | undefined;
+    
+    ResourceIdentifier: AggregateResourceIdentifier | undefined;
+}
+export declare namespace GetAggregateResourceConfigRequest {
+    
+    const filterSensitiveLog: (obj: GetAggregateResourceConfigRequest) => any;
+}
+export interface GetAggregateResourceConfigResponse {
+    
+    ConfigurationItem?: ConfigurationItem;
+}
+export declare namespace GetAggregateResourceConfigResponse {
+    
+    const filterSensitiveLog: (obj: GetAggregateResourceConfigResponse) => any;
+}
+
+export declare class OversizedConfigurationItemException extends __BaseException {
+    readonly name: "OversizedConfigurationItemException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OversizedConfigurationItemException, __BaseException>);
+}
+
+export declare class ResourceNotDiscoveredException extends __BaseException {
+    readonly name: "ResourceNotDiscoveredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotDiscoveredException, __BaseException>);
+}
+
+export interface GetComplianceDetailsByConfigRuleRequest {
+    
+    ConfigRuleName: string | undefined;
+    
+    ComplianceTypes?: (ComplianceType | string)[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetComplianceDetailsByConfigRuleRequest {
+    
+    const filterSensitiveLog: (obj: GetComplianceDetailsByConfigRuleRequest) => any;
+}
+
+export interface GetComplianceDetailsByConfigRuleResponse {
+    
+    EvaluationResults?: EvaluationResult[];
+    
+    NextToken?: string;
+}
+export declare namespace GetComplianceDetailsByConfigRuleResponse {
+    
+    const filterSensitiveLog: (obj: GetComplianceDetailsByConfigRuleResponse) => any;
+}
+
+export interface GetComplianceDetailsByResourceRequest {
+    
+    ResourceType: string | undefined;
+    
+    ResourceId: string | undefined;
+    
+    ComplianceTypes?: (ComplianceType | string)[];
+    
+    NextToken?: string;
+}
+export declare namespace GetComplianceDetailsByResourceRequest {
+    
+    const filterSensitiveLog: (obj: GetComplianceDetailsByResourceRequest) => any;
+}
+
+export interface GetComplianceDetailsByResourceResponse {
+    
+    EvaluationResults?: EvaluationResult[];
+    
+    NextToken?: string;
+}
+export declare namespace GetComplianceDetailsByResourceResponse {
+    
+    const filterSensitiveLog: (obj: GetComplianceDetailsByResourceResponse) => any;
+}
+
+export interface GetComplianceSummaryByConfigRuleResponse {
+    
+    ComplianceSummary?: ComplianceSummary;
+}
+export declare namespace GetComplianceSummaryByConfigRuleResponse {
+    
+    const filterSensitiveLog: (obj: GetComplianceSummaryByConfigRuleResponse) => any;
+}
+
+export interface GetComplianceSummaryByResourceTypeRequest {
+    
+    ResourceTypes?: string[];
+}
+export declare namespace GetComplianceSummaryByResourceTypeRequest {
+    
+    const filterSensitiveLog: (obj: GetComplianceSummaryByResourceTypeRequest) => any;
+}
+
+export interface GetComplianceSummaryByResourceTypeResponse {
+    
+    ComplianceSummariesByResourceType?: ComplianceSummaryByResourceType[];
+}
+export declare namespace GetComplianceSummaryByResourceTypeResponse {
+    
+    const filterSensitiveLog: (obj: GetComplianceSummaryByResourceTypeResponse) => any;
+}
+export interface GetConformancePackComplianceDetailsRequest {
+    
+    ConformancePackName: string | undefined;
+    
+    Filters?: ConformancePackEvaluationFilters;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetConformancePackComplianceDetailsRequest {
+    
+    const filterSensitiveLog: (obj: GetConformancePackComplianceDetailsRequest) => any;
+}
+export interface GetConformancePackComplianceDetailsResponse {
+    
+    ConformancePackName: string | undefined;
+    
+    ConformancePackRuleEvaluationResults?: ConformancePackEvaluationResult[];
+    
+    NextToken?: string;
+}
+export declare namespace GetConformancePackComplianceDetailsResponse {
+    
+    const filterSensitiveLog: (obj: GetConformancePackComplianceDetailsResponse) => any;
+}
+export interface GetConformancePackComplianceSummaryRequest {
+    
+    ConformancePackNames: string[] | undefined;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetConformancePackComplianceSummaryRequest {
+    
+    const filterSensitiveLog: (obj: GetConformancePackComplianceSummaryRequest) => any;
+}
+export interface GetConformancePackComplianceSummaryResponse {
+    
+    ConformancePackComplianceSummaryList?: ConformancePackComplianceSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace GetConformancePackComplianceSummaryResponse {
+    
+    const filterSensitiveLog: (obj: GetConformancePackComplianceSummaryResponse) => any;
+}
+export interface GetDiscoveredResourceCountsRequest {
+    
+    resourceTypes?: string[];
+    
+    limit?: number;
+    
+    nextToken?: string;
+}
+export declare namespace GetDiscoveredResourceCountsRequest {
+    
+    const filterSensitiveLog: (obj: GetDiscoveredResourceCountsRequest) => any;
+}
+
+export interface ResourceCount {
+    
+    resourceType?: ResourceType | string;
+    
+    count?: number;
+}
+export declare namespace ResourceCount {
+    
+    const filterSensitiveLog: (obj: ResourceCount) => any;
+}
+export interface GetDiscoveredResourceCountsResponse {
+    
+    totalDiscoveredResources?: number;
+    
+    resourceCounts?: ResourceCount[];
+    
+    nextToken?: string;
+}
+export declare namespace GetDiscoveredResourceCountsResponse {
+    
+    const filterSensitiveLog: (obj: GetDiscoveredResourceCountsResponse) => any;
+}
+export declare enum MemberAccountRuleStatus {
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    CREATE_SUCCESSFUL = "CREATE_SUCCESSFUL",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
+    DELETE_SUCCESSFUL = "DELETE_SUCCESSFUL",
+    UPDATE_FAILED = "UPDATE_FAILED",
+    UPDATE_IN_PROGRESS = "UPDATE_IN_PROGRESS",
+    UPDATE_SUCCESSFUL = "UPDATE_SUCCESSFUL"
+}
+
+export interface StatusDetailFilters {
+    
+    AccountId?: string;
+    
+    MemberAccountRuleStatus?: MemberAccountRuleStatus | string;
+}
+export declare namespace StatusDetailFilters {
+    
+    const filterSensitiveLog: (obj: StatusDetailFilters) => any;
+}
+export interface GetOrganizationConfigRuleDetailedStatusRequest {
+    
+    OrganizationConfigRuleName: string | undefined;
+    
+    Filters?: StatusDetailFilters;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetOrganizationConfigRuleDetailedStatusRequest {
+    
+    const filterSensitiveLog: (obj: GetOrganizationConfigRuleDetailedStatusRequest) => any;
+}
+
+export interface MemberAccountStatus {
+    
+    AccountId: string | undefined;
+    
+    ConfigRuleName: string | undefined;
+    
+    MemberAccountRuleStatus: MemberAccountRuleStatus | string | undefined;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+    
+    LastUpdateTime?: Date;
+}
+export declare namespace MemberAccountStatus {
+    
+    const filterSensitiveLog: (obj: MemberAccountStatus) => any;
+}
+export interface GetOrganizationConfigRuleDetailedStatusResponse {
+    
+    OrganizationConfigRuleDetailedStatus?: MemberAccountStatus[];
+    
+    NextToken?: string;
+}
+export declare namespace GetOrganizationConfigRuleDetailedStatusResponse {
+    
+    const filterSensitiveLog: (obj: GetOrganizationConfigRuleDetailedStatusResponse) => any;
+}
+export declare enum OrganizationResourceDetailedStatus {
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    CREATE_SUCCESSFUL = "CREATE_SUCCESSFUL",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
+    DELETE_SUCCESSFUL = "DELETE_SUCCESSFUL",
+    UPDATE_FAILED = "UPDATE_FAILED",
+    UPDATE_IN_PROGRESS = "UPDATE_IN_PROGRESS",
+    UPDATE_SUCCESSFUL = "UPDATE_SUCCESSFUL"
+}
+
+export interface OrganizationResourceDetailedStatusFilters {
+    
+    AccountId?: string;
+    
+    Status?: OrganizationResourceDetailedStatus | string;
+}
+export declare namespace OrganizationResourceDetailedStatusFilters {
+    
+    const filterSensitiveLog: (obj: OrganizationResourceDetailedStatusFilters) => any;
+}
+export interface GetOrganizationConformancePackDetailedStatusRequest {
+    
+    OrganizationConformancePackName: string | undefined;
+    
+    Filters?: OrganizationResourceDetailedStatusFilters;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetOrganizationConformancePackDetailedStatusRequest {
+    
+    const filterSensitiveLog: (obj: GetOrganizationConformancePackDetailedStatusRequest) => any;
+}
+
+export interface OrganizationConformancePackDetailedStatus {
+    
+    AccountId: string | undefined;
+    
+    ConformancePackName: string | undefined;
+    
+    Status: OrganizationResourceDetailedStatus | string | undefined;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+    
+    LastUpdateTime?: Date;
+}
+export declare namespace OrganizationConformancePackDetailedStatus {
+    
+    const filterSensitiveLog: (obj: OrganizationConformancePackDetailedStatus) => any;
+}
+export interface GetOrganizationConformancePackDetailedStatusResponse {
+    
+    OrganizationConformancePackDetailedStatuses?: OrganizationConformancePackDetailedStatus[];
+    
+    NextToken?: string;
+}
+export declare namespace GetOrganizationConformancePackDetailedStatusResponse {
+    
+    const filterSensitiveLog: (obj: GetOrganizationConformancePackDetailedStatusResponse) => any;
+}
+
+export interface GetResourceConfigHistoryRequest {
+    
+    resourceType: ResourceType | string | undefined;
+    
+    resourceId: string | undefined;
+    
+    laterTime?: Date;
+    
+    earlierTime?: Date;
+    
+    chronologicalOrder?: ChronologicalOrder | string;
+    
+    limit?: number;
+    
+    nextToken?: string;
+}
+export declare namespace GetResourceConfigHistoryRequest {
+    
+    const filterSensitiveLog: (obj: GetResourceConfigHistoryRequest) => any;
+}
+
+export interface GetResourceConfigHistoryResponse {
+    
+    configurationItems?: ConfigurationItem[];
+    
+    nextToken?: string;
+}
+export declare namespace GetResourceConfigHistoryResponse {
+    
+    const filterSensitiveLog: (obj: GetResourceConfigHistoryResponse) => any;
+}
+
+export declare class InvalidTimeRangeException extends __BaseException {
+    readonly name: "InvalidTimeRangeException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidTimeRangeException, __BaseException>);
+}
+export interface GetStoredQueryRequest {
+    
+    QueryName: string | undefined;
+}
+export declare namespace GetStoredQueryRequest {
+    
+    const filterSensitiveLog: (obj: GetStoredQueryRequest) => any;
+}
+
+export interface StoredQuery {
+    
+    QueryId?: string;
+    
+    QueryArn?: string;
+    
+    QueryName: string | undefined;
+    
+    Description?: string;
+    
+    Expression?: string;
+}
+export declare namespace StoredQuery {
+    
+    const filterSensitiveLog: (obj: StoredQuery) => any;
+}
+export interface GetStoredQueryResponse {
+    
+    StoredQuery?: StoredQuery;
+}
+export declare namespace GetStoredQueryResponse {
+    
+    const filterSensitiveLog: (obj: GetStoredQueryResponse) => any;
+}
+
+export declare class InsufficientDeliveryPolicyException extends __BaseException {
+    readonly name: "InsufficientDeliveryPolicyException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InsufficientDeliveryPolicyException, __BaseException>);
+}
+
+export declare class InvalidConfigurationRecorderNameException extends __BaseException {
+    readonly name: "InvalidConfigurationRecorderNameException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidConfigurationRecorderNameException, __BaseException>);
+}
+
+export declare class InvalidDeliveryChannelNameException extends __BaseException {
+    readonly name: "InvalidDeliveryChannelNameException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDeliveryChannelNameException, __BaseException>);
+}
+
+export declare class InvalidExpressionException extends __BaseException {
+    readonly name: "InvalidExpressionException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidExpressionException, __BaseException>);
+}
+
+export declare class InvalidRecordingGroupException extends __BaseException {
+    readonly name: "InvalidRecordingGroupException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidRecordingGroupException, __BaseException>);
+}
+
+export declare class InvalidResultTokenException extends __BaseException {
+    readonly name: "InvalidResultTokenException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidResultTokenException, __BaseException>);
+}
+
+export declare class InvalidRoleException extends __BaseException {
+    readonly name: "InvalidRoleException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidRoleException, __BaseException>);
+}
+
+export declare class InvalidS3KeyPrefixException extends __BaseException {
+    readonly name: "InvalidS3KeyPrefixException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidS3KeyPrefixException, __BaseException>);
+}
+
+export declare class InvalidS3KmsKeyArnException extends __BaseException {
+    readonly name: "InvalidS3KmsKeyArnException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidS3KmsKeyArnException, __BaseException>);
+}
+
+export declare class InvalidSNSTopicARNException extends __BaseException {
+    readonly name: "InvalidSNSTopicARNException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidSNSTopicARNException, __BaseException>);
+}
+
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+
+export interface ResourceFilters {
+    
+    AccountId?: string;
+    
+    ResourceId?: string;
+    
+    ResourceName?: string;
+    
+    Region?: string;
+}
+export declare namespace ResourceFilters {
+    
+    const filterSensitiveLog: (obj: ResourceFilters) => any;
+}
+export interface ListAggregateDiscoveredResourcesRequest {
+    
+    ConfigurationAggregatorName: string | undefined;
+    
+    ResourceType: ResourceType | string | undefined;
+    
+    Filters?: ResourceFilters;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListAggregateDiscoveredResourcesRequest {
+    
+    const filterSensitiveLog: (obj: ListAggregateDiscoveredResourcesRequest) => any;
+}
+export interface ListAggregateDiscoveredResourcesResponse {
+    
+    ResourceIdentifiers?: AggregateResourceIdentifier[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAggregateDiscoveredResourcesResponse {
+    
+    const filterSensitiveLog: (obj: ListAggregateDiscoveredResourcesResponse) => any;
+}
+
+export interface ListDiscoveredResourcesRequest {
+    
+    resourceType: ResourceType | string | undefined;
+    
+    resourceIds?: string[];
+    
+    resourceName?: string;
+    
+    limit?: number;
+    
+    includeDeletedResources?: boolean;
+    
+    nextToken?: string;
+}
+export declare namespace ListDiscoveredResourcesRequest {
+    
+    const filterSensitiveLog: (obj: ListDiscoveredResourcesRequest) => any;
+}
+
+export interface ResourceIdentifier {
+    
+    resourceType?: ResourceType | string;
+    
+    resourceId?: string;
+    
+    resourceName?: string;
+    
+    resourceDeletionTime?: Date;
+}
+export declare namespace ResourceIdentifier {
+    
+    const filterSensitiveLog: (obj: ResourceIdentifier) => any;
+}
+
+export interface ListDiscoveredResourcesResponse {
+    
+    resourceIdentifiers?: ResourceIdentifier[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDiscoveredResourcesResponse {
+    
+    const filterSensitiveLog: (obj: ListDiscoveredResourcesResponse) => any;
+}
+export interface ListStoredQueriesRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListStoredQueriesRequest {
+    
+    const filterSensitiveLog: (obj: ListStoredQueriesRequest) => any;
+}
+
+export interface StoredQueryMetadata {
+    
+    QueryId: string | undefined;
+    
+    QueryArn: string | undefined;
+    
+    QueryName: string | undefined;
+    
+    Description?: string;
+}
+export declare namespace StoredQueryMetadata {
+    
+    const filterSensitiveLog: (obj: StoredQueryMetadata) => any;
+}
+export interface ListStoredQueriesResponse {
+    
+    StoredQueryMetadata?: StoredQueryMetadata[];
+    
+    NextToken?: string;
+}
+export declare namespace ListStoredQueriesResponse {
+    
+    const filterSensitiveLog: (obj: ListStoredQueriesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+
+export interface Tag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+
+export declare class MaxActiveResourcesExceededException extends __BaseException {
+    readonly name: "MaxActiveResourcesExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaxActiveResourcesExceededException, __BaseException>);
+}
+
+export declare class MaxNumberOfConfigRulesExceededException extends __BaseException {
+    readonly name: "MaxNumberOfConfigRulesExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaxNumberOfConfigRulesExceededException, __BaseException>);
+}
+
+export declare class MaxNumberOfConfigurationRecordersExceededException extends __BaseException {
+    readonly name: "MaxNumberOfConfigurationRecordersExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaxNumberOfConfigurationRecordersExceededException, __BaseException>);
+}
+
+export declare class MaxNumberOfConformancePacksExceededException extends __BaseException {
+    readonly name: "MaxNumberOfConformancePacksExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaxNumberOfConformancePacksExceededException, __BaseException>);
+}
+
+export declare class MaxNumberOfDeliveryChannelsExceededException extends __BaseException {
+    readonly name: "MaxNumberOfDeliveryChannelsExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaxNumberOfDeliveryChannelsExceededException, __BaseException>);
+}
+
+export declare class MaxNumberOfOrganizationConfigRulesExceededException extends __BaseException {
+    readonly name: "MaxNumberOfOrganizationConfigRulesExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaxNumberOfOrganizationConfigRulesExceededException, __BaseException>);
+}
+
+export declare class MaxNumberOfOrganizationConformancePacksExceededException extends __BaseException {
+    readonly name: "MaxNumberOfOrganizationConformancePacksExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaxNumberOfOrganizationConformancePacksExceededException, __BaseException>);
+}
+
+export declare class MaxNumberOfRetentionConfigurationsExceededException extends __BaseException {
+    readonly name: "MaxNumberOfRetentionConfigurationsExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaxNumberOfRetentionConfigurationsExceededException, __BaseException>);
+}
+
+export declare class NoAvailableDeliveryChannelException extends __BaseException {
+    readonly name: "NoAvailableDeliveryChannelException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoAvailableDeliveryChannelException, __BaseException>);
+}
+
+export declare class NoAvailableOrganizationException extends __BaseException {
+    readonly name: "NoAvailableOrganizationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoAvailableOrganizationException, __BaseException>);
+}
+
+export declare class NoSuchBucketException extends __BaseException {
+    readonly name: "NoSuchBucketException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoSuchBucketException, __BaseException>);
+}
+
+export declare class OrganizationAllFeaturesNotEnabledException extends __BaseException {
+    readonly name: "OrganizationAllFeaturesNotEnabledException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OrganizationAllFeaturesNotEnabledException, __BaseException>);
+}
+
+export declare class OrganizationConformancePackTemplateValidationException extends __BaseException {
+    readonly name: "OrganizationConformancePackTemplateValidationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OrganizationConformancePackTemplateValidationException, __BaseException>);
+}
+export interface PutAggregationAuthorizationRequest {
+    
+    AuthorizedAccountId: string | undefined;
+    
+    AuthorizedAwsRegion: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace PutAggregationAuthorizationRequest {
+    
+    const filterSensitiveLog: (obj: PutAggregationAuthorizationRequest) => any;
+}
+export interface PutAggregationAuthorizationResponse {
+    
+    AggregationAuthorization?: AggregationAuthorization;
+}
+export declare namespace PutAggregationAuthorizationResponse {
+    
+    const filterSensitiveLog: (obj: PutAggregationAuthorizationResponse) => any;
+}
+export interface PutConfigRuleRequest {
+    
+    ConfigRule: ConfigRule | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace PutConfigRuleRequest {
+    
+    const filterSensitiveLog: (obj: PutConfigRuleRequest) => any;
+}
+export interface PutConfigurationAggregatorRequest {
+    
+    ConfigurationAggregatorName: string | undefined;
+    
+    AccountAggregationSources?: AccountAggregationSource[];
+    
+    OrganizationAggregationSource?: OrganizationAggregationSource;
+    
+    Tags?: Tag[];
+}
+export declare namespace PutConfigurationAggregatorRequest {
+    
+    const filterSensitiveLog: (obj: PutConfigurationAggregatorRequest) => any;
+}
+export interface PutConfigurationAggregatorResponse {
+    
+    ConfigurationAggregator?: ConfigurationAggregator;
+}
+export declare namespace PutConfigurationAggregatorResponse {
+    
+    const filterSensitiveLog: (obj: PutConfigurationAggregatorResponse) => any;
+}
+
+export interface PutConfigurationRecorderRequest {
+    
+    ConfigurationRecorder: ConfigurationRecorder | undefined;
+}
+export declare namespace PutConfigurationRecorderRequest {
+    
+    const filterSensitiveLog: (obj: PutConfigurationRecorderRequest) => any;
+}
+export interface PutConformancePackRequest {
+    
+    ConformancePackName: string | undefined;
+    
+    TemplateS3Uri?: string;
+    
+    TemplateBody?: string;
+    
+    DeliveryS3Bucket?: string;
+    
+    DeliveryS3KeyPrefix?: string;
+    
+    ConformancePackInputParameters?: ConformancePackInputParameter[];
+}
+export declare namespace PutConformancePackRequest {
+    
+    const filterSensitiveLog: (obj: PutConformancePackRequest) => any;
+}
+export interface PutConformancePackResponse {
+    
+    ConformancePackArn?: string;
+}
+export declare namespace PutConformancePackResponse {
+    
+    const filterSensitiveLog: (obj: PutConformancePackResponse) => any;
+}
+
+export interface PutDeliveryChannelRequest {
+    
+    DeliveryChannel: DeliveryChannel | undefined;
+}
+export declare namespace PutDeliveryChannelRequest {
+    
+    const filterSensitiveLog: (obj: PutDeliveryChannelRequest) => any;
+}
+
+export interface PutEvaluationsRequest {
+    
+    Evaluations?: Evaluation[];
+    
+    ResultToken: string | undefined;
+    
+    TestMode?: boolean;
+}
+export declare namespace PutEvaluationsRequest {
+    
+    const filterSensitiveLog: (obj: PutEvaluationsRequest) => any;
+}
+
+export interface PutEvaluationsResponse {
+    
+    FailedEvaluations?: Evaluation[];
+}
+export declare namespace PutEvaluationsResponse {
+    
+    const filterSensitiveLog: (obj: PutEvaluationsResponse) => any;
+}
+export interface PutExternalEvaluationRequest {
+    
+    ConfigRuleName: string | undefined;
+    
+    ExternalEvaluation: ExternalEvaluation | undefined;
+}
+export declare namespace PutExternalEvaluationRequest {
+    
+    const filterSensitiveLog: (obj: PutExternalEvaluationRequest) => any;
+}
+export interface PutExternalEvaluationResponse {
+}
+export declare namespace PutExternalEvaluationResponse {
+    
+    const filterSensitiveLog: (obj: PutExternalEvaluationResponse) => any;
+}
+export interface PutOrganizationConfigRuleRequest {
+    
+    OrganizationConfigRuleName: string | undefined;
+    
+    OrganizationManagedRuleMetadata?: OrganizationManagedRuleMetadata;
+    
+    OrganizationCustomRuleMetadata?: OrganizationCustomRuleMetadata;
+    
+    ExcludedAccounts?: string[];
+}
+export declare namespace PutOrganizationConfigRuleRequest {
+    
+    const filterSensitiveLog: (obj: PutOrganizationConfigRuleRequest) => any;
+}
+export interface PutOrganizationConfigRuleResponse {
+    
+    OrganizationConfigRuleArn?: string;
+}
+export declare namespace PutOrganizationConfigRuleResponse {
+    
+    const filterSensitiveLog: (obj: PutOrganizationConfigRuleResponse) => any;
+}
+export interface PutOrganizationConformancePackRequest {
+    
+    OrganizationConformancePackName: string | undefined;
+    
+    TemplateS3Uri?: string;
+    
+    TemplateBody?: string;
+    
+    DeliveryS3Bucket?: string;
+    
+    DeliveryS3KeyPrefix?: string;
+    
+    ConformancePackInputParameters?: ConformancePackInputParameter[];
+    
+    ExcludedAccounts?: string[];
+}
+export declare namespace PutOrganizationConformancePackRequest {
+    
+    const filterSensitiveLog: (obj: PutOrganizationConformancePackRequest) => any;
+}
+export interface PutOrganizationConformancePackResponse {
+    
+    OrganizationConformancePackArn?: string;
+}
+export declare namespace PutOrganizationConformancePackResponse {
+    
+    const filterSensitiveLog: (obj: PutOrganizationConformancePackResponse) => any;
+}
+export interface PutRemediationConfigurationsRequest {
+    
+    RemediationConfigurations: RemediationConfiguration[] | undefined;
+}
+export declare namespace PutRemediationConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: PutRemediationConfigurationsRequest) => any;
+}
+export interface PutRemediationConfigurationsResponse {
+    
+    FailedBatches?: FailedRemediationBatch[];
+}
+export declare namespace PutRemediationConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: PutRemediationConfigurationsResponse) => any;
+}
+export interface PutRemediationExceptionsRequest {
+    
+    ConfigRuleName: string | undefined;
+    
+    ResourceKeys: RemediationExceptionResourceKey[] | undefined;
+    
+    Message?: string;
+    
+    ExpirationTime?: Date;
+}
+export declare namespace PutRemediationExceptionsRequest {
+    
+    const filterSensitiveLog: (obj: PutRemediationExceptionsRequest) => any;
+}
+export interface PutRemediationExceptionsResponse {
+    
+    FailedBatches?: FailedRemediationExceptionBatch[];
+}
+export declare namespace PutRemediationExceptionsResponse {
+    
+    const filterSensitiveLog: (obj: PutRemediationExceptionsResponse) => any;
+}