@aws-sdk/client-iot 3.50.0 → 3.53.0

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

@@ -0,0 +1,3610 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { IoTServiceException as __BaseException } from "./IoTServiceException";
+import { AbortConfig, Action, ActiveViolation, AggregationType, AlertTarget, AuditCheckConfiguration, AuditCheckDetails, AuditFinding, AuditFrequency, AuditMitigationActionExecutionMetadata, AuditMitigationActionsExecutionStatus, AuditMitigationActionsTaskMetadata, AuditMitigationActionsTaskStatus, AuditMitigationActionsTaskTarget, AuditNotificationTarget, AuditSuppression, AuditTaskMetadata, AuditTaskStatus, AuditTaskType, AuthorizerConfig, AuthorizerDescription, AuthorizerStatus, AuthorizerSummary, AutoRegistrationStatus, AwsJobExecutionsRolloutConfig, AwsJobPresignedUrlConfig, Behavior, BillingGroupProperties, CustomMetricType, DayOfWeek, DimensionType, FleetMetricUnit, JobExecutionsRetryConfig, JobExecutionsRolloutConfig, LogLevel, MetricToRetain, MitigationActionParams, OTAUpdateFile, OTAUpdateStatus, Policy, PresignedUrlConfig, Protocol, ProvisioningHook, ResourceIdentifier, ServiceType, StreamFile, Tag, TargetSelection, TaskStatisticsForAuditCheck, ThingGroupProperties, ThingTypeProperties, TimeoutConfig, TopicRuleDestination, VerificationState } from "./models_0";
+export interface DeleteScheduledAuditRequest {
+    
+    scheduledAuditName: string | undefined;
+}
+export declare namespace DeleteScheduledAuditRequest {
+    
+    const filterSensitiveLog: (obj: DeleteScheduledAuditRequest) => any;
+}
+export interface DeleteScheduledAuditResponse {
+}
+export declare namespace DeleteScheduledAuditResponse {
+    
+    const filterSensitiveLog: (obj: DeleteScheduledAuditResponse) => any;
+}
+export interface DeleteSecurityProfileRequest {
+    
+    securityProfileName: string | undefined;
+    
+    expectedVersion?: number;
+}
+export declare namespace DeleteSecurityProfileRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSecurityProfileRequest) => any;
+}
+export interface DeleteSecurityProfileResponse {
+}
+export declare namespace DeleteSecurityProfileResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSecurityProfileResponse) => any;
+}
+export interface DeleteStreamRequest {
+    
+    streamId: string | undefined;
+}
+export declare namespace DeleteStreamRequest {
+    
+    const filterSensitiveLog: (obj: DeleteStreamRequest) => any;
+}
+export interface DeleteStreamResponse {
+}
+export declare namespace DeleteStreamResponse {
+    
+    const filterSensitiveLog: (obj: DeleteStreamResponse) => any;
+}
+
+export interface DeleteThingRequest {
+    
+    thingName: string | undefined;
+    
+    expectedVersion?: number;
+}
+export declare namespace DeleteThingRequest {
+    
+    const filterSensitiveLog: (obj: DeleteThingRequest) => any;
+}
+
+export interface DeleteThingResponse {
+}
+export declare namespace DeleteThingResponse {
+    
+    const filterSensitiveLog: (obj: DeleteThingResponse) => any;
+}
+export interface DeleteThingGroupRequest {
+    
+    thingGroupName: string | undefined;
+    
+    expectedVersion?: number;
+}
+export declare namespace DeleteThingGroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteThingGroupRequest) => any;
+}
+export interface DeleteThingGroupResponse {
+}
+export declare namespace DeleteThingGroupResponse {
+    
+    const filterSensitiveLog: (obj: DeleteThingGroupResponse) => any;
+}
+
+export interface DeleteThingTypeRequest {
+    
+    thingTypeName: string | undefined;
+}
+export declare namespace DeleteThingTypeRequest {
+    
+    const filterSensitiveLog: (obj: DeleteThingTypeRequest) => any;
+}
+
+export interface DeleteThingTypeResponse {
+}
+export declare namespace DeleteThingTypeResponse {
+    
+    const filterSensitiveLog: (obj: DeleteThingTypeResponse) => any;
+}
+
+export interface DeleteTopicRuleRequest {
+    
+    ruleName: string | undefined;
+}
+export declare namespace DeleteTopicRuleRequest {
+    
+    const filterSensitiveLog: (obj: DeleteTopicRuleRequest) => any;
+}
+export interface DeleteTopicRuleDestinationRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeleteTopicRuleDestinationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteTopicRuleDestinationRequest) => any;
+}
+export interface DeleteTopicRuleDestinationResponse {
+}
+export declare namespace DeleteTopicRuleDestinationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteTopicRuleDestinationResponse) => any;
+}
+export declare enum LogTargetType {
+    CLIENT_ID = "CLIENT_ID",
+    DEFAULT = "DEFAULT",
+    PRINCIPAL_ID = "PRINCIPAL_ID",
+    SOURCE_IP = "SOURCE_IP",
+    THING_GROUP = "THING_GROUP"
+}
+export interface DeleteV2LoggingLevelRequest {
+    
+    targetType: LogTargetType | string | undefined;
+    
+    targetName: string | undefined;
+}
+export declare namespace DeleteV2LoggingLevelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteV2LoggingLevelRequest) => any;
+}
+
+export interface DeprecateThingTypeRequest {
+    
+    thingTypeName: string | undefined;
+    
+    undoDeprecate?: boolean;
+}
+export declare namespace DeprecateThingTypeRequest {
+    
+    const filterSensitiveLog: (obj: DeprecateThingTypeRequest) => any;
+}
+
+export interface DeprecateThingTypeResponse {
+}
+export declare namespace DeprecateThingTypeResponse {
+    
+    const filterSensitiveLog: (obj: DeprecateThingTypeResponse) => any;
+}
+export interface DescribeAccountAuditConfigurationRequest {
+}
+export declare namespace DescribeAccountAuditConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAccountAuditConfigurationRequest) => any;
+}
+export interface DescribeAccountAuditConfigurationResponse {
+    
+    roleArn?: string;
+    
+    auditNotificationTargetConfigurations?: {
+        [key: string]: AuditNotificationTarget;
+    };
+    
+    auditCheckConfigurations?: {
+        [key: string]: AuditCheckConfiguration;
+    };
+}
+export declare namespace DescribeAccountAuditConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAccountAuditConfigurationResponse) => any;
+}
+export interface DescribeAuditFindingRequest {
+    
+    findingId: string | undefined;
+}
+export declare namespace DescribeAuditFindingRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAuditFindingRequest) => any;
+}
+export interface DescribeAuditFindingResponse {
+    
+    finding?: AuditFinding;
+}
+export declare namespace DescribeAuditFindingResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAuditFindingResponse) => any;
+}
+export interface DescribeAuditMitigationActionsTaskRequest {
+    
+    taskId: string | undefined;
+}
+export declare namespace DescribeAuditMitigationActionsTaskRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAuditMitigationActionsTaskRequest) => any;
+}
+
+export interface MitigationAction {
+    
+    name?: string;
+    
+    id?: string;
+    
+    roleArn?: string;
+    
+    actionParams?: MitigationActionParams;
+}
+export declare namespace MitigationAction {
+    
+    const filterSensitiveLog: (obj: MitigationAction) => any;
+}
+export interface DescribeAuditMitigationActionsTaskResponse {
+    
+    taskStatus?: AuditMitigationActionsTaskStatus | string;
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+    
+    taskStatistics?: {
+        [key: string]: TaskStatisticsForAuditCheck;
+    };
+    
+    target?: AuditMitigationActionsTaskTarget;
+    
+    auditCheckToActionsMapping?: {
+        [key: string]: string[];
+    };
+    
+    actionsDefinition?: MitigationAction[];
+}
+export declare namespace DescribeAuditMitigationActionsTaskResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAuditMitigationActionsTaskResponse) => any;
+}
+export interface DescribeAuditSuppressionRequest {
+    
+    checkName: string | undefined;
+    
+    resourceIdentifier: ResourceIdentifier | undefined;
+}
+export declare namespace DescribeAuditSuppressionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAuditSuppressionRequest) => any;
+}
+export interface DescribeAuditSuppressionResponse {
+    
+    checkName?: string;
+    
+    resourceIdentifier?: ResourceIdentifier;
+    
+    expirationDate?: Date;
+    
+    suppressIndefinitely?: boolean;
+    
+    description?: string;
+}
+export declare namespace DescribeAuditSuppressionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAuditSuppressionResponse) => any;
+}
+export interface DescribeAuditTaskRequest {
+    
+    taskId: string | undefined;
+}
+export declare namespace DescribeAuditTaskRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAuditTaskRequest) => any;
+}
+
+export interface TaskStatistics {
+    
+    totalChecks?: number;
+    
+    inProgressChecks?: number;
+    
+    waitingForDataCollectionChecks?: number;
+    
+    compliantChecks?: number;
+    
+    nonCompliantChecks?: number;
+    
+    failedChecks?: number;
+    
+    canceledChecks?: number;
+}
+export declare namespace TaskStatistics {
+    
+    const filterSensitiveLog: (obj: TaskStatistics) => any;
+}
+export interface DescribeAuditTaskResponse {
+    
+    taskStatus?: AuditTaskStatus | string;
+    
+    taskType?: AuditTaskType | string;
+    
+    taskStartTime?: Date;
+    
+    taskStatistics?: TaskStatistics;
+    
+    scheduledAuditName?: string;
+    
+    auditDetails?: {
+        [key: string]: AuditCheckDetails;
+    };
+}
+export declare namespace DescribeAuditTaskResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAuditTaskResponse) => any;
+}
+export interface DescribeAuthorizerRequest {
+    
+    authorizerName: string | undefined;
+}
+export declare namespace DescribeAuthorizerRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAuthorizerRequest) => any;
+}
+export interface DescribeAuthorizerResponse {
+    
+    authorizerDescription?: AuthorizerDescription;
+}
+export declare namespace DescribeAuthorizerResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAuthorizerResponse) => any;
+}
+export interface DescribeBillingGroupRequest {
+    
+    billingGroupName: string | undefined;
+}
+export declare namespace DescribeBillingGroupRequest {
+    
+    const filterSensitiveLog: (obj: DescribeBillingGroupRequest) => any;
+}
+
+export interface BillingGroupMetadata {
+    
+    creationDate?: Date;
+}
+export declare namespace BillingGroupMetadata {
+    
+    const filterSensitiveLog: (obj: BillingGroupMetadata) => any;
+}
+export interface DescribeBillingGroupResponse {
+    
+    billingGroupName?: string;
+    
+    billingGroupId?: string;
+    
+    billingGroupArn?: string;
+    
+    version?: number;
+    
+    billingGroupProperties?: BillingGroupProperties;
+    
+    billingGroupMetadata?: BillingGroupMetadata;
+}
+export declare namespace DescribeBillingGroupResponse {
+    
+    const filterSensitiveLog: (obj: DescribeBillingGroupResponse) => any;
+}
+
+export interface DescribeCACertificateRequest {
+    
+    certificateId: string | undefined;
+}
+export declare namespace DescribeCACertificateRequest {
+    
+    const filterSensitiveLog: (obj: DescribeCACertificateRequest) => any;
+}
+export declare enum CACertificateStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
+
+export interface CertificateValidity {
+    
+    notBefore?: Date;
+    
+    notAfter?: Date;
+}
+export declare namespace CertificateValidity {
+    
+    const filterSensitiveLog: (obj: CertificateValidity) => any;
+}
+
+export interface CACertificateDescription {
+    
+    certificateArn?: string;
+    
+    certificateId?: string;
+    
+    status?: CACertificateStatus | string;
+    
+    certificatePem?: string;
+    
+    ownedBy?: string;
+    
+    creationDate?: Date;
+    
+    autoRegistrationStatus?: AutoRegistrationStatus | string;
+    
+    lastModifiedDate?: Date;
+    
+    customerVersion?: number;
+    
+    generationId?: string;
+    
+    validity?: CertificateValidity;
+}
+export declare namespace CACertificateDescription {
+    
+    const filterSensitiveLog: (obj: CACertificateDescription) => any;
+}
+
+export interface RegistrationConfig {
+    
+    templateBody?: string;
+    
+    roleArn?: string;
+}
+export declare namespace RegistrationConfig {
+    
+    const filterSensitiveLog: (obj: RegistrationConfig) => any;
+}
+
+export interface DescribeCACertificateResponse {
+    
+    certificateDescription?: CACertificateDescription;
+    
+    registrationConfig?: RegistrationConfig;
+}
+export declare namespace DescribeCACertificateResponse {
+    
+    const filterSensitiveLog: (obj: DescribeCACertificateResponse) => any;
+}
+
+export interface DescribeCertificateRequest {
+    
+    certificateId: string | undefined;
+}
+export declare namespace DescribeCertificateRequest {
+    
+    const filterSensitiveLog: (obj: DescribeCertificateRequest) => any;
+}
+export declare enum CertificateMode {
+    DEFAULT = "DEFAULT",
+    SNI_ONLY = "SNI_ONLY"
+}
+export declare enum CertificateStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    PENDING_ACTIVATION = "PENDING_ACTIVATION",
+    PENDING_TRANSFER = "PENDING_TRANSFER",
+    REGISTER_INACTIVE = "REGISTER_INACTIVE",
+    REVOKED = "REVOKED"
+}
+
+export interface TransferData {
+    
+    transferMessage?: string;
+    
+    rejectReason?: string;
+    
+    transferDate?: Date;
+    
+    acceptDate?: Date;
+    
+    rejectDate?: Date;
+}
+export declare namespace TransferData {
+    
+    const filterSensitiveLog: (obj: TransferData) => any;
+}
+
+export interface CertificateDescription {
+    
+    certificateArn?: string;
+    
+    certificateId?: string;
+    
+    caCertificateId?: string;
+    
+    status?: CertificateStatus | string;
+    
+    certificatePem?: string;
+    
+    ownedBy?: string;
+    
+    previousOwnedBy?: string;
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+    
+    customerVersion?: number;
+    
+    transferData?: TransferData;
+    
+    generationId?: string;
+    
+    validity?: CertificateValidity;
+    
+    certificateMode?: CertificateMode | string;
+}
+export declare namespace CertificateDescription {
+    
+    const filterSensitiveLog: (obj: CertificateDescription) => any;
+}
+
+export interface DescribeCertificateResponse {
+    
+    certificateDescription?: CertificateDescription;
+}
+export declare namespace DescribeCertificateResponse {
+    
+    const filterSensitiveLog: (obj: DescribeCertificateResponse) => any;
+}
+export interface DescribeCustomMetricRequest {
+    
+    metricName: string | undefined;
+}
+export declare namespace DescribeCustomMetricRequest {
+    
+    const filterSensitiveLog: (obj: DescribeCustomMetricRequest) => any;
+}
+export interface DescribeCustomMetricResponse {
+    
+    metricName?: string;
+    
+    metricArn?: string;
+    
+    metricType?: CustomMetricType | string;
+    
+    displayName?: string;
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+}
+export declare namespace DescribeCustomMetricResponse {
+    
+    const filterSensitiveLog: (obj: DescribeCustomMetricResponse) => any;
+}
+export interface DescribeDefaultAuthorizerRequest {
+}
+export declare namespace DescribeDefaultAuthorizerRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDefaultAuthorizerRequest) => any;
+}
+export interface DescribeDefaultAuthorizerResponse {
+    
+    authorizerDescription?: AuthorizerDescription;
+}
+export declare namespace DescribeDefaultAuthorizerResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDefaultAuthorizerResponse) => any;
+}
+export interface DescribeDetectMitigationActionsTaskRequest {
+    
+    taskId: string | undefined;
+}
+export declare namespace DescribeDetectMitigationActionsTaskRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDetectMitigationActionsTaskRequest) => any;
+}
+
+export interface DetectMitigationActionsTaskTarget {
+    
+    violationIds?: string[];
+    
+    securityProfileName?: string;
+    
+    behaviorName?: string;
+}
+export declare namespace DetectMitigationActionsTaskTarget {
+    
+    const filterSensitiveLog: (obj: DetectMitigationActionsTaskTarget) => any;
+}
+
+export interface DetectMitigationActionsTaskStatistics {
+    
+    actionsExecuted?: number;
+    
+    actionsSkipped?: number;
+    
+    actionsFailed?: number;
+}
+export declare namespace DetectMitigationActionsTaskStatistics {
+    
+    const filterSensitiveLog: (obj: DetectMitigationActionsTaskStatistics) => any;
+}
+export declare enum DetectMitigationActionsTaskStatus {
+    CANCELED = "CANCELED",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCESSFUL = "SUCCESSFUL"
+}
+
+export interface ViolationEventOccurrenceRange {
+    
+    startTime: Date | undefined;
+    
+    endTime: Date | undefined;
+}
+export declare namespace ViolationEventOccurrenceRange {
+    
+    const filterSensitiveLog: (obj: ViolationEventOccurrenceRange) => any;
+}
+
+export interface DetectMitigationActionsTaskSummary {
+    
+    taskId?: string;
+    
+    taskStatus?: DetectMitigationActionsTaskStatus | string;
+    
+    taskStartTime?: Date;
+    
+    taskEndTime?: Date;
+    
+    target?: DetectMitigationActionsTaskTarget;
+    
+    violationEventOccurrenceRange?: ViolationEventOccurrenceRange;
+    
+    onlyActiveViolationsIncluded?: boolean;
+    
+    suppressedAlertsIncluded?: boolean;
+    
+    actionsDefinition?: MitigationAction[];
+    
+    taskStatistics?: DetectMitigationActionsTaskStatistics;
+}
+export declare namespace DetectMitigationActionsTaskSummary {
+    
+    const filterSensitiveLog: (obj: DetectMitigationActionsTaskSummary) => any;
+}
+export interface DescribeDetectMitigationActionsTaskResponse {
+    
+    taskSummary?: DetectMitigationActionsTaskSummary;
+}
+export declare namespace DescribeDetectMitigationActionsTaskResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDetectMitigationActionsTaskResponse) => any;
+}
+export interface DescribeDimensionRequest {
+    
+    name: string | undefined;
+}
+export declare namespace DescribeDimensionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDimensionRequest) => any;
+}
+export interface DescribeDimensionResponse {
+    
+    name?: string;
+    
+    arn?: string;
+    
+    type?: DimensionType | string;
+    
+    stringValues?: string[];
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+}
+export declare namespace DescribeDimensionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDimensionResponse) => any;
+}
+export interface DescribeDomainConfigurationRequest {
+    
+    domainConfigurationName: string | undefined;
+}
+export declare namespace DescribeDomainConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDomainConfigurationRequest) => any;
+}
+export declare enum DomainConfigurationStatus {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum DomainType {
+    AWS_MANAGED = "AWS_MANAGED",
+    CUSTOMER_MANAGED = "CUSTOMER_MANAGED",
+    ENDPOINT = "ENDPOINT"
+}
+export declare enum ServerCertificateStatus {
+    INVALID = "INVALID",
+    VALID = "VALID"
+}
+
+export interface ServerCertificateSummary {
+    
+    serverCertificateArn?: string;
+    
+    serverCertificateStatus?: ServerCertificateStatus | string;
+    
+    serverCertificateStatusDetail?: string;
+}
+export declare namespace ServerCertificateSummary {
+    
+    const filterSensitiveLog: (obj: ServerCertificateSummary) => any;
+}
+export interface DescribeDomainConfigurationResponse {
+    
+    domainConfigurationName?: string;
+    
+    domainConfigurationArn?: string;
+    
+    domainName?: string;
+    
+    serverCertificates?: ServerCertificateSummary[];
+    
+    authorizerConfig?: AuthorizerConfig;
+    
+    domainConfigurationStatus?: DomainConfigurationStatus | string;
+    
+    serviceType?: ServiceType | string;
+    
+    domainType?: DomainType | string;
+    
+    lastStatusChangeDate?: Date;
+}
+export declare namespace DescribeDomainConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDomainConfigurationResponse) => any;
+}
+
+export interface DescribeEndpointRequest {
+    
+    endpointType?: string;
+}
+export declare namespace DescribeEndpointRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointRequest) => any;
+}
+
+export interface DescribeEndpointResponse {
+    
+    endpointAddress?: string;
+}
+export declare namespace DescribeEndpointResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointResponse) => any;
+}
+export interface DescribeEventConfigurationsRequest {
+}
+export declare namespace DescribeEventConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEventConfigurationsRequest) => any;
+}
+export declare enum EventType {
+    CA_CERTIFICATE = "CA_CERTIFICATE",
+    CERTIFICATE = "CERTIFICATE",
+    JOB = "JOB",
+    JOB_EXECUTION = "JOB_EXECUTION",
+    POLICY = "POLICY",
+    THING = "THING",
+    THING_GROUP = "THING_GROUP",
+    THING_GROUP_HIERARCHY = "THING_GROUP_HIERARCHY",
+    THING_GROUP_MEMBERSHIP = "THING_GROUP_MEMBERSHIP",
+    THING_TYPE = "THING_TYPE",
+    THING_TYPE_ASSOCIATION = "THING_TYPE_ASSOCIATION"
+}
+
+export interface Configuration {
+    
+    Enabled?: boolean;
+}
+export declare namespace Configuration {
+    
+    const filterSensitiveLog: (obj: Configuration) => any;
+}
+export interface DescribeEventConfigurationsResponse {
+    
+    eventConfigurations?: {
+        [key: string]: Configuration;
+    };
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+}
+export declare namespace DescribeEventConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEventConfigurationsResponse) => any;
+}
+export interface DescribeFleetMetricRequest {
+    
+    metricName: string | undefined;
+}
+export declare namespace DescribeFleetMetricRequest {
+    
+    const filterSensitiveLog: (obj: DescribeFleetMetricRequest) => any;
+}
+export interface DescribeFleetMetricResponse {
+    
+    metricName?: string;
+    
+    queryString?: string;
+    
+    aggregationType?: AggregationType;
+    
+    period?: number;
+    
+    aggregationField?: string;
+    
+    description?: string;
+    
+    queryVersion?: string;
+    
+    indexName?: string;
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+    
+    unit?: FleetMetricUnit | string;
+    
+    version?: number;
+    
+    metricArn?: string;
+}
+export declare namespace DescribeFleetMetricResponse {
+    
+    const filterSensitiveLog: (obj: DescribeFleetMetricResponse) => any;
+}
+export interface DescribeIndexRequest {
+    
+    indexName: string | undefined;
+}
+export declare namespace DescribeIndexRequest {
+    
+    const filterSensitiveLog: (obj: DescribeIndexRequest) => any;
+}
+export declare enum IndexStatus {
+    ACTIVE = "ACTIVE",
+    BUILDING = "BUILDING",
+    REBUILDING = "REBUILDING"
+}
+export interface DescribeIndexResponse {
+    
+    indexName?: string;
+    
+    indexStatus?: IndexStatus | string;
+    
+    schema?: string;
+}
+export declare namespace DescribeIndexResponse {
+    
+    const filterSensitiveLog: (obj: DescribeIndexResponse) => any;
+}
+export interface DescribeJobRequest {
+    
+    jobId: string | undefined;
+}
+export declare namespace DescribeJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeJobRequest) => any;
+}
+
+export interface JobProcessDetails {
+    
+    processingTargets?: string[];
+    
+    numberOfCanceledThings?: number;
+    
+    numberOfSucceededThings?: number;
+    
+    numberOfFailedThings?: number;
+    
+    numberOfRejectedThings?: number;
+    
+    numberOfQueuedThings?: number;
+    
+    numberOfInProgressThings?: number;
+    
+    numberOfRemovedThings?: number;
+    
+    numberOfTimedOutThings?: number;
+}
+export declare namespace JobProcessDetails {
+    
+    const filterSensitiveLog: (obj: JobProcessDetails) => any;
+}
+export declare enum JobStatus {
+    CANCELED = "CANCELED",
+    COMPLETED = "COMPLETED",
+    DELETION_IN_PROGRESS = "DELETION_IN_PROGRESS",
+    IN_PROGRESS = "IN_PROGRESS"
+}
+
+export interface Job {
+    
+    jobArn?: string;
+    
+    jobId?: string;
+    
+    targetSelection?: TargetSelection | string;
+    
+    status?: JobStatus | string;
+    
+    forceCanceled?: boolean;
+    
+    reasonCode?: string;
+    
+    comment?: string;
+    
+    targets?: string[];
+    
+    description?: string;
+    
+    presignedUrlConfig?: PresignedUrlConfig;
+    
+    jobExecutionsRolloutConfig?: JobExecutionsRolloutConfig;
+    
+    abortConfig?: AbortConfig;
+    
+    createdAt?: Date;
+    
+    lastUpdatedAt?: Date;
+    
+    completedAt?: Date;
+    
+    jobProcessDetails?: JobProcessDetails;
+    
+    timeoutConfig?: TimeoutConfig;
+    
+    namespaceId?: string;
+    
+    jobTemplateArn?: string;
+    
+    jobExecutionsRetryConfig?: JobExecutionsRetryConfig;
+    
+    documentParameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Job {
+    
+    const filterSensitiveLog: (obj: Job) => any;
+}
+export interface DescribeJobResponse {
+    
+    documentSource?: string;
+    
+    job?: Job;
+}
+export declare namespace DescribeJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeJobResponse) => any;
+}
+export interface DescribeJobExecutionRequest {
+    
+    jobId: string | undefined;
+    
+    thingName: string | undefined;
+    
+    executionNumber?: number;
+}
+export declare namespace DescribeJobExecutionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeJobExecutionRequest) => any;
+}
+export declare enum JobExecutionStatus {
+    CANCELED = "CANCELED",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    QUEUED = "QUEUED",
+    REJECTED = "REJECTED",
+    REMOVED = "REMOVED",
+    SUCCEEDED = "SUCCEEDED",
+    TIMED_OUT = "TIMED_OUT"
+}
+
+export interface JobExecutionStatusDetails {
+    
+    detailsMap?: {
+        [key: string]: string;
+    };
+}
+export declare namespace JobExecutionStatusDetails {
+    
+    const filterSensitiveLog: (obj: JobExecutionStatusDetails) => any;
+}
+
+export interface JobExecution {
+    
+    jobId?: string;
+    
+    status?: JobExecutionStatus | string;
+    
+    forceCanceled?: boolean;
+    
+    statusDetails?: JobExecutionStatusDetails;
+    
+    thingArn?: string;
+    
+    queuedAt?: Date;
+    
+    startedAt?: Date;
+    
+    lastUpdatedAt?: Date;
+    
+    executionNumber?: number;
+    
+    versionNumber?: number;
+    
+    approximateSecondsBeforeTimedOut?: number;
+}
+export declare namespace JobExecution {
+    
+    const filterSensitiveLog: (obj: JobExecution) => any;
+}
+export interface DescribeJobExecutionResponse {
+    
+    execution?: JobExecution;
+}
+export declare namespace DescribeJobExecutionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeJobExecutionResponse) => any;
+}
+export interface DescribeJobTemplateRequest {
+    
+    jobTemplateId: string | undefined;
+}
+export declare namespace DescribeJobTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DescribeJobTemplateRequest) => any;
+}
+export interface DescribeJobTemplateResponse {
+    
+    jobTemplateArn?: string;
+    
+    jobTemplateId?: string;
+    
+    description?: string;
+    
+    documentSource?: string;
+    
+    document?: string;
+    
+    createdAt?: Date;
+    
+    presignedUrlConfig?: PresignedUrlConfig;
+    
+    jobExecutionsRolloutConfig?: JobExecutionsRolloutConfig;
+    
+    abortConfig?: AbortConfig;
+    
+    timeoutConfig?: TimeoutConfig;
+    
+    jobExecutionsRetryConfig?: JobExecutionsRetryConfig;
+}
+export declare namespace DescribeJobTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DescribeJobTemplateResponse) => any;
+}
+export interface DescribeManagedJobTemplateRequest {
+    
+    templateName: string | undefined;
+    
+    templateVersion?: string;
+}
+export declare namespace DescribeManagedJobTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DescribeManagedJobTemplateRequest) => any;
+}
+
+export interface DocumentParameter {
+    
+    key?: string;
+    
+    description?: string;
+    
+    regex?: string;
+    
+    example?: string;
+    
+    optional?: boolean;
+}
+export declare namespace DocumentParameter {
+    
+    const filterSensitiveLog: (obj: DocumentParameter) => any;
+}
+export interface DescribeManagedJobTemplateResponse {
+    
+    templateName?: string;
+    
+    templateArn?: string;
+    
+    description?: string;
+    
+    templateVersion?: string;
+    
+    environments?: string[];
+    
+    documentParameters?: DocumentParameter[];
+    
+    document?: string;
+}
+export declare namespace DescribeManagedJobTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DescribeManagedJobTemplateResponse) => any;
+}
+
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+export interface DescribeMitigationActionRequest {
+    
+    actionName: string | undefined;
+}
+export declare namespace DescribeMitigationActionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMitigationActionRequest) => any;
+}
+export declare enum MitigationActionType {
+    ADD_THINGS_TO_THING_GROUP = "ADD_THINGS_TO_THING_GROUP",
+    ENABLE_IOT_LOGGING = "ENABLE_IOT_LOGGING",
+    PUBLISH_FINDING_TO_SNS = "PUBLISH_FINDING_TO_SNS",
+    REPLACE_DEFAULT_POLICY_VERSION = "REPLACE_DEFAULT_POLICY_VERSION",
+    UPDATE_CA_CERTIFICATE = "UPDATE_CA_CERTIFICATE",
+    UPDATE_DEVICE_CERTIFICATE = "UPDATE_DEVICE_CERTIFICATE"
+}
+export interface DescribeMitigationActionResponse {
+    
+    actionName?: string;
+    
+    actionType?: MitigationActionType | string;
+    
+    actionArn?: string;
+    
+    actionId?: string;
+    
+    roleArn?: string;
+    
+    actionParams?: MitigationActionParams;
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+}
+export declare namespace DescribeMitigationActionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeMitigationActionResponse) => any;
+}
+export interface DescribeProvisioningTemplateRequest {
+    
+    templateName: string | undefined;
+}
+export declare namespace DescribeProvisioningTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DescribeProvisioningTemplateRequest) => any;
+}
+export interface DescribeProvisioningTemplateResponse {
+    
+    templateArn?: string;
+    
+    templateName?: string;
+    
+    description?: string;
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+    
+    defaultVersionId?: number;
+    
+    templateBody?: string;
+    
+    enabled?: boolean;
+    
+    provisioningRoleArn?: string;
+    
+    preProvisioningHook?: ProvisioningHook;
+}
+export declare namespace DescribeProvisioningTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DescribeProvisioningTemplateResponse) => any;
+}
+export interface DescribeProvisioningTemplateVersionRequest {
+    
+    templateName: string | undefined;
+    
+    versionId: number | undefined;
+}
+export declare namespace DescribeProvisioningTemplateVersionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeProvisioningTemplateVersionRequest) => any;
+}
+export interface DescribeProvisioningTemplateVersionResponse {
+    
+    versionId?: number;
+    
+    creationDate?: Date;
+    
+    templateBody?: string;
+    
+    isDefaultVersion?: boolean;
+}
+export declare namespace DescribeProvisioningTemplateVersionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeProvisioningTemplateVersionResponse) => any;
+}
+export interface DescribeRoleAliasRequest {
+    
+    roleAlias: string | undefined;
+}
+export declare namespace DescribeRoleAliasRequest {
+    
+    const filterSensitiveLog: (obj: DescribeRoleAliasRequest) => any;
+}
+
+export interface RoleAliasDescription {
+    
+    roleAlias?: string;
+    
+    roleAliasArn?: string;
+    
+    roleArn?: string;
+    
+    owner?: string;
+    
+    credentialDurationSeconds?: number;
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+}
+export declare namespace RoleAliasDescription {
+    
+    const filterSensitiveLog: (obj: RoleAliasDescription) => any;
+}
+export interface DescribeRoleAliasResponse {
+    
+    roleAliasDescription?: RoleAliasDescription;
+}
+export declare namespace DescribeRoleAliasResponse {
+    
+    const filterSensitiveLog: (obj: DescribeRoleAliasResponse) => any;
+}
+export interface DescribeScheduledAuditRequest {
+    
+    scheduledAuditName: string | undefined;
+}
+export declare namespace DescribeScheduledAuditRequest {
+    
+    const filterSensitiveLog: (obj: DescribeScheduledAuditRequest) => any;
+}
+export interface DescribeScheduledAuditResponse {
+    
+    frequency?: AuditFrequency | string;
+    
+    dayOfMonth?: string;
+    
+    dayOfWeek?: DayOfWeek | string;
+    
+    targetCheckNames?: string[];
+    
+    scheduledAuditName?: string;
+    
+    scheduledAuditArn?: string;
+}
+export declare namespace DescribeScheduledAuditResponse {
+    
+    const filterSensitiveLog: (obj: DescribeScheduledAuditResponse) => any;
+}
+export interface DescribeSecurityProfileRequest {
+    
+    securityProfileName: string | undefined;
+}
+export declare namespace DescribeSecurityProfileRequest {
+    
+    const filterSensitiveLog: (obj: DescribeSecurityProfileRequest) => any;
+}
+export interface DescribeSecurityProfileResponse {
+    
+    securityProfileName?: string;
+    
+    securityProfileArn?: string;
+    
+    securityProfileDescription?: string;
+    
+    behaviors?: Behavior[];
+    
+    alertTargets?: {
+        [key: string]: AlertTarget;
+    };
+    
+    additionalMetricsToRetain?: string[];
+    
+    additionalMetricsToRetainV2?: MetricToRetain[];
+    
+    version?: number;
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+}
+export declare namespace DescribeSecurityProfileResponse {
+    
+    const filterSensitiveLog: (obj: DescribeSecurityProfileResponse) => any;
+}
+export interface DescribeStreamRequest {
+    
+    streamId: string | undefined;
+}
+export declare namespace DescribeStreamRequest {
+    
+    const filterSensitiveLog: (obj: DescribeStreamRequest) => any;
+}
+
+export interface StreamInfo {
+    
+    streamId?: string;
+    
+    streamArn?: string;
+    
+    streamVersion?: number;
+    
+    description?: string;
+    
+    files?: StreamFile[];
+    
+    createdAt?: Date;
+    
+    lastUpdatedAt?: Date;
+    
+    roleArn?: string;
+}
+export declare namespace StreamInfo {
+    
+    const filterSensitiveLog: (obj: StreamInfo) => any;
+}
+export interface DescribeStreamResponse {
+    
+    streamInfo?: StreamInfo;
+}
+export declare namespace DescribeStreamResponse {
+    
+    const filterSensitiveLog: (obj: DescribeStreamResponse) => any;
+}
+
+export interface DescribeThingRequest {
+    
+    thingName: string | undefined;
+}
+export declare namespace DescribeThingRequest {
+    
+    const filterSensitiveLog: (obj: DescribeThingRequest) => any;
+}
+
+export interface DescribeThingResponse {
+    
+    defaultClientId?: string;
+    
+    thingName?: string;
+    
+    thingId?: string;
+    
+    thingArn?: string;
+    
+    thingTypeName?: string;
+    
+    attributes?: {
+        [key: string]: string;
+    };
+    
+    version?: number;
+    
+    billingGroupName?: string;
+}
+export declare namespace DescribeThingResponse {
+    
+    const filterSensitiveLog: (obj: DescribeThingResponse) => any;
+}
+export interface DescribeThingGroupRequest {
+    
+    thingGroupName: string | undefined;
+}
+export declare namespace DescribeThingGroupRequest {
+    
+    const filterSensitiveLog: (obj: DescribeThingGroupRequest) => any;
+}
+export declare enum DynamicGroupStatus {
+    ACTIVE = "ACTIVE",
+    BUILDING = "BUILDING",
+    REBUILDING = "REBUILDING"
+}
+
+export interface GroupNameAndArn {
+    
+    groupName?: string;
+    
+    groupArn?: string;
+}
+export declare namespace GroupNameAndArn {
+    
+    const filterSensitiveLog: (obj: GroupNameAndArn) => any;
+}
+
+export interface ThingGroupMetadata {
+    
+    parentGroupName?: string;
+    
+    rootToParentThingGroups?: GroupNameAndArn[];
+    
+    creationDate?: Date;
+}
+export declare namespace ThingGroupMetadata {
+    
+    const filterSensitiveLog: (obj: ThingGroupMetadata) => any;
+}
+export interface DescribeThingGroupResponse {
+    
+    thingGroupName?: string;
+    
+    thingGroupId?: string;
+    
+    thingGroupArn?: string;
+    
+    version?: number;
+    
+    thingGroupProperties?: ThingGroupProperties;
+    
+    thingGroupMetadata?: ThingGroupMetadata;
+    
+    indexName?: string;
+    
+    queryString?: string;
+    
+    queryVersion?: string;
+    
+    status?: DynamicGroupStatus | string;
+}
+export declare namespace DescribeThingGroupResponse {
+    
+    const filterSensitiveLog: (obj: DescribeThingGroupResponse) => any;
+}
+export interface DescribeThingRegistrationTaskRequest {
+    
+    taskId: string | undefined;
+}
+export declare namespace DescribeThingRegistrationTaskRequest {
+    
+    const filterSensitiveLog: (obj: DescribeThingRegistrationTaskRequest) => any;
+}
+export declare enum Status {
+    Cancelled = "Cancelled",
+    Cancelling = "Cancelling",
+    Completed = "Completed",
+    Failed = "Failed",
+    InProgress = "InProgress"
+}
+export interface DescribeThingRegistrationTaskResponse {
+    
+    taskId?: string;
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+    
+    templateBody?: string;
+    
+    inputFileBucket?: string;
+    
+    inputFileKey?: string;
+    
+    roleArn?: string;
+    
+    status?: Status | string;
+    
+    message?: string;
+    
+    successCount?: number;
+    
+    failureCount?: number;
+    
+    percentageProgress?: number;
+}
+export declare namespace DescribeThingRegistrationTaskResponse {
+    
+    const filterSensitiveLog: (obj: DescribeThingRegistrationTaskResponse) => any;
+}
+
+export interface DescribeThingTypeRequest {
+    
+    thingTypeName: string | undefined;
+}
+export declare namespace DescribeThingTypeRequest {
+    
+    const filterSensitiveLog: (obj: DescribeThingTypeRequest) => any;
+}
+
+export interface ThingTypeMetadata {
+    
+    deprecated?: boolean;
+    
+    deprecationDate?: Date;
+    
+    creationDate?: Date;
+}
+export declare namespace ThingTypeMetadata {
+    
+    const filterSensitiveLog: (obj: ThingTypeMetadata) => any;
+}
+
+export interface DescribeThingTypeResponse {
+    
+    thingTypeName?: string;
+    
+    thingTypeId?: string;
+    
+    thingTypeArn?: string;
+    
+    thingTypeProperties?: ThingTypeProperties;
+    
+    thingTypeMetadata?: ThingTypeMetadata;
+}
+export declare namespace DescribeThingTypeResponse {
+    
+    const filterSensitiveLog: (obj: DescribeThingTypeResponse) => any;
+}
+export interface DetachPolicyRequest {
+    
+    policyName: string | undefined;
+    
+    target: string | undefined;
+}
+export declare namespace DetachPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DetachPolicyRequest) => any;
+}
+
+export interface DetachPrincipalPolicyRequest {
+    
+    policyName: string | undefined;
+    
+    principal: string | undefined;
+}
+export declare namespace DetachPrincipalPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DetachPrincipalPolicyRequest) => any;
+}
+export interface DetachSecurityProfileRequest {
+    
+    securityProfileName: string | undefined;
+    
+    securityProfileTargetArn: string | undefined;
+}
+export declare namespace DetachSecurityProfileRequest {
+    
+    const filterSensitiveLog: (obj: DetachSecurityProfileRequest) => any;
+}
+export interface DetachSecurityProfileResponse {
+}
+export declare namespace DetachSecurityProfileResponse {
+    
+    const filterSensitiveLog: (obj: DetachSecurityProfileResponse) => any;
+}
+
+export interface DetachThingPrincipalRequest {
+    
+    thingName: string | undefined;
+    
+    principal: string | undefined;
+}
+export declare namespace DetachThingPrincipalRequest {
+    
+    const filterSensitiveLog: (obj: DetachThingPrincipalRequest) => any;
+}
+
+export interface DetachThingPrincipalResponse {
+}
+export declare namespace DetachThingPrincipalResponse {
+    
+    const filterSensitiveLog: (obj: DetachThingPrincipalResponse) => any;
+}
+
+export interface DisableTopicRuleRequest {
+    
+    ruleName: string | undefined;
+}
+export declare namespace DisableTopicRuleRequest {
+    
+    const filterSensitiveLog: (obj: DisableTopicRuleRequest) => any;
+}
+
+export interface EnableTopicRuleRequest {
+    
+    ruleName: string | undefined;
+}
+export declare namespace EnableTopicRuleRequest {
+    
+    const filterSensitiveLog: (obj: EnableTopicRuleRequest) => any;
+}
+export interface GetBehaviorModelTrainingSummariesRequest {
+    
+    securityProfileName?: string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace GetBehaviorModelTrainingSummariesRequest {
+    
+    const filterSensitiveLog: (obj: GetBehaviorModelTrainingSummariesRequest) => any;
+}
+export declare enum ModelStatus {
+    ACTIVE = "ACTIVE",
+    EXPIRED = "EXPIRED",
+    PENDING_BUILD = "PENDING_BUILD"
+}
+
+export interface BehaviorModelTrainingSummary {
+    
+    securityProfileName?: string;
+    
+    behaviorName?: string;
+    
+    trainingDataCollectionStartDate?: Date;
+    
+    modelStatus?: ModelStatus | string;
+    
+    datapointsCollectionPercentage?: number;
+    
+    lastModelRefreshDate?: Date;
+}
+export declare namespace BehaviorModelTrainingSummary {
+    
+    const filterSensitiveLog: (obj: BehaviorModelTrainingSummary) => any;
+}
+export interface GetBehaviorModelTrainingSummariesResponse {
+    
+    summaries?: BehaviorModelTrainingSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace GetBehaviorModelTrainingSummariesResponse {
+    
+    const filterSensitiveLog: (obj: GetBehaviorModelTrainingSummariesResponse) => any;
+}
+
+export interface TermsAggregation {
+    
+    maxBuckets?: number;
+}
+export declare namespace TermsAggregation {
+    
+    const filterSensitiveLog: (obj: TermsAggregation) => any;
+}
+
+export interface BucketsAggregationType {
+    
+    termsAggregation?: TermsAggregation;
+}
+export declare namespace BucketsAggregationType {
+    
+    const filterSensitiveLog: (obj: BucketsAggregationType) => any;
+}
+export interface GetBucketsAggregationRequest {
+    
+    indexName?: string;
+    
+    queryString: string | undefined;
+    
+    aggregationField: string | undefined;
+    
+    queryVersion?: string;
+    
+    bucketsAggregationType: BucketsAggregationType | undefined;
+}
+export declare namespace GetBucketsAggregationRequest {
+    
+    const filterSensitiveLog: (obj: GetBucketsAggregationRequest) => any;
+}
+
+export interface Bucket {
+    
+    keyValue?: string;
+    
+    count?: number;
+}
+export declare namespace Bucket {
+    
+    const filterSensitiveLog: (obj: Bucket) => any;
+}
+export interface GetBucketsAggregationResponse {
+    
+    totalCount?: number;
+    
+    buckets?: Bucket[];
+}
+export declare namespace GetBucketsAggregationResponse {
+    
+    const filterSensitiveLog: (obj: GetBucketsAggregationResponse) => any;
+}
+export interface GetCardinalityRequest {
+    
+    indexName?: string;
+    
+    queryString: string | undefined;
+    
+    aggregationField?: string;
+    
+    queryVersion?: string;
+}
+export declare namespace GetCardinalityRequest {
+    
+    const filterSensitiveLog: (obj: GetCardinalityRequest) => any;
+}
+export interface GetCardinalityResponse {
+    
+    cardinality?: number;
+}
+export declare namespace GetCardinalityResponse {
+    
+    const filterSensitiveLog: (obj: GetCardinalityResponse) => any;
+}
+export interface GetEffectivePoliciesRequest {
+    
+    principal?: string;
+    
+    cognitoIdentityPoolId?: string;
+    
+    thingName?: string;
+}
+export declare namespace GetEffectivePoliciesRequest {
+    
+    const filterSensitiveLog: (obj: GetEffectivePoliciesRequest) => any;
+}
+
+export interface EffectivePolicy {
+    
+    policyName?: string;
+    
+    policyArn?: string;
+    
+    policyDocument?: string;
+}
+export declare namespace EffectivePolicy {
+    
+    const filterSensitiveLog: (obj: EffectivePolicy) => any;
+}
+export interface GetEffectivePoliciesResponse {
+    
+    effectivePolicies?: EffectivePolicy[];
+}
+export declare namespace GetEffectivePoliciesResponse {
+    
+    const filterSensitiveLog: (obj: GetEffectivePoliciesResponse) => any;
+}
+export interface GetIndexingConfigurationRequest {
+}
+export declare namespace GetIndexingConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetIndexingConfigurationRequest) => any;
+}
+export declare enum FieldType {
+    BOOLEAN = "Boolean",
+    NUMBER = "Number",
+    STRING = "String"
+}
+
+export interface Field {
+    
+    name?: string;
+    
+    type?: FieldType | string;
+}
+export declare namespace Field {
+    
+    const filterSensitiveLog: (obj: Field) => any;
+}
+export declare enum ThingGroupIndexingMode {
+    OFF = "OFF",
+    ON = "ON"
+}
+
+export interface ThingGroupIndexingConfiguration {
+    
+    thingGroupIndexingMode: ThingGroupIndexingMode | string | undefined;
+    
+    managedFields?: Field[];
+    
+    customFields?: Field[];
+}
+export declare namespace ThingGroupIndexingConfiguration {
+    
+    const filterSensitiveLog: (obj: ThingGroupIndexingConfiguration) => any;
+}
+export declare enum DeviceDefenderIndexingMode {
+    OFF = "OFF",
+    VIOLATIONS = "VIOLATIONS"
+}
+export declare enum NamedShadowIndexingMode {
+    OFF = "OFF",
+    ON = "ON"
+}
+export declare enum ThingConnectivityIndexingMode {
+    OFF = "OFF",
+    STATUS = "STATUS"
+}
+export declare enum ThingIndexingMode {
+    OFF = "OFF",
+    REGISTRY = "REGISTRY",
+    REGISTRY_AND_SHADOW = "REGISTRY_AND_SHADOW"
+}
+
+export interface ThingIndexingConfiguration {
+    
+    thingIndexingMode: ThingIndexingMode | string | undefined;
+    
+    thingConnectivityIndexingMode?: ThingConnectivityIndexingMode | string;
+    
+    deviceDefenderIndexingMode?: DeviceDefenderIndexingMode | string;
+    
+    namedShadowIndexingMode?: NamedShadowIndexingMode | string;
+    
+    managedFields?: Field[];
+    
+    customFields?: Field[];
+}
+export declare namespace ThingIndexingConfiguration {
+    
+    const filterSensitiveLog: (obj: ThingIndexingConfiguration) => any;
+}
+export interface GetIndexingConfigurationResponse {
+    
+    thingIndexingConfiguration?: ThingIndexingConfiguration;
+    
+    thingGroupIndexingConfiguration?: ThingGroupIndexingConfiguration;
+}
+export declare namespace GetIndexingConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: GetIndexingConfigurationResponse) => any;
+}
+export interface GetJobDocumentRequest {
+    
+    jobId: string | undefined;
+}
+export declare namespace GetJobDocumentRequest {
+    
+    const filterSensitiveLog: (obj: GetJobDocumentRequest) => any;
+}
+export interface GetJobDocumentResponse {
+    
+    document?: string;
+}
+export declare namespace GetJobDocumentResponse {
+    
+    const filterSensitiveLog: (obj: GetJobDocumentResponse) => any;
+}
+
+export interface GetLoggingOptionsRequest {
+}
+export declare namespace GetLoggingOptionsRequest {
+    
+    const filterSensitiveLog: (obj: GetLoggingOptionsRequest) => any;
+}
+
+export interface GetLoggingOptionsResponse {
+    
+    roleArn?: string;
+    
+    logLevel?: LogLevel | string;
+}
+export declare namespace GetLoggingOptionsResponse {
+    
+    const filterSensitiveLog: (obj: GetLoggingOptionsResponse) => any;
+}
+export interface GetOTAUpdateRequest {
+    
+    otaUpdateId: string | undefined;
+}
+export declare namespace GetOTAUpdateRequest {
+    
+    const filterSensitiveLog: (obj: GetOTAUpdateRequest) => any;
+}
+
+export interface ErrorInfo {
+    
+    code?: string;
+    
+    message?: string;
+}
+export declare namespace ErrorInfo {
+    
+    const filterSensitiveLog: (obj: ErrorInfo) => any;
+}
+
+export interface OTAUpdateInfo {
+    
+    otaUpdateId?: string;
+    
+    otaUpdateArn?: string;
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+    
+    description?: string;
+    
+    targets?: string[];
+    
+    protocols?: (Protocol | string)[];
+    
+    awsJobExecutionsRolloutConfig?: AwsJobExecutionsRolloutConfig;
+    
+    awsJobPresignedUrlConfig?: AwsJobPresignedUrlConfig;
+    
+    targetSelection?: TargetSelection | string;
+    
+    otaUpdateFiles?: OTAUpdateFile[];
+    
+    otaUpdateStatus?: OTAUpdateStatus | string;
+    
+    awsIotJobId?: string;
+    
+    awsIotJobArn?: string;
+    
+    errorInfo?: ErrorInfo;
+    
+    additionalParameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace OTAUpdateInfo {
+    
+    const filterSensitiveLog: (obj: OTAUpdateInfo) => any;
+}
+export interface GetOTAUpdateResponse {
+    
+    otaUpdateInfo?: OTAUpdateInfo;
+}
+export declare namespace GetOTAUpdateResponse {
+    
+    const filterSensitiveLog: (obj: GetOTAUpdateResponse) => any;
+}
+export interface GetPercentilesRequest {
+    
+    indexName?: string;
+    
+    queryString: string | undefined;
+    
+    aggregationField?: string;
+    
+    queryVersion?: string;
+    
+    percents?: number[];
+}
+export declare namespace GetPercentilesRequest {
+    
+    const filterSensitiveLog: (obj: GetPercentilesRequest) => any;
+}
+
+export interface PercentPair {
+    
+    percent?: number;
+    
+    value?: number;
+}
+export declare namespace PercentPair {
+    
+    const filterSensitiveLog: (obj: PercentPair) => any;
+}
+export interface GetPercentilesResponse {
+    
+    percentiles?: PercentPair[];
+}
+export declare namespace GetPercentilesResponse {
+    
+    const filterSensitiveLog: (obj: GetPercentilesResponse) => any;
+}
+
+export interface GetPolicyRequest {
+    
+    policyName: string | undefined;
+}
+export declare namespace GetPolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetPolicyRequest) => any;
+}
+
+export interface GetPolicyResponse {
+    
+    policyName?: string;
+    
+    policyArn?: string;
+    
+    policyDocument?: string;
+    
+    defaultVersionId?: string;
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+    
+    generationId?: string;
+}
+export declare namespace GetPolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetPolicyResponse) => any;
+}
+
+export interface GetPolicyVersionRequest {
+    
+    policyName: string | undefined;
+    
+    policyVersionId: string | undefined;
+}
+export declare namespace GetPolicyVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetPolicyVersionRequest) => any;
+}
+
+export interface GetPolicyVersionResponse {
+    
+    policyArn?: string;
+    
+    policyName?: string;
+    
+    policyDocument?: string;
+    
+    policyVersionId?: string;
+    
+    isDefaultVersion?: boolean;
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+    
+    generationId?: string;
+}
+export declare namespace GetPolicyVersionResponse {
+    
+    const filterSensitiveLog: (obj: GetPolicyVersionResponse) => any;
+}
+
+export interface GetRegistrationCodeRequest {
+}
+export declare namespace GetRegistrationCodeRequest {
+    
+    const filterSensitiveLog: (obj: GetRegistrationCodeRequest) => any;
+}
+
+export interface GetRegistrationCodeResponse {
+    
+    registrationCode?: string;
+}
+export declare namespace GetRegistrationCodeResponse {
+    
+    const filterSensitiveLog: (obj: GetRegistrationCodeResponse) => any;
+}
+export interface GetStatisticsRequest {
+    
+    indexName?: string;
+    
+    queryString: string | undefined;
+    
+    aggregationField?: string;
+    
+    queryVersion?: string;
+}
+export declare namespace GetStatisticsRequest {
+    
+    const filterSensitiveLog: (obj: GetStatisticsRequest) => any;
+}
+
+export interface Statistics {
+    
+    count?: number;
+    
+    average?: number;
+    
+    sum?: number;
+    
+    minimum?: number;
+    
+    maximum?: number;
+    
+    sumOfSquares?: number;
+    
+    variance?: number;
+    
+    stdDeviation?: number;
+}
+export declare namespace Statistics {
+    
+    const filterSensitiveLog: (obj: Statistics) => any;
+}
+export interface GetStatisticsResponse {
+    
+    statistics?: Statistics;
+}
+export declare namespace GetStatisticsResponse {
+    
+    const filterSensitiveLog: (obj: GetStatisticsResponse) => any;
+}
+
+export interface GetTopicRuleRequest {
+    
+    ruleName: string | undefined;
+}
+export declare namespace GetTopicRuleRequest {
+    
+    const filterSensitiveLog: (obj: GetTopicRuleRequest) => any;
+}
+
+export interface TopicRule {
+    
+    ruleName?: string;
+    
+    sql?: string;
+    
+    description?: string;
+    
+    createdAt?: Date;
+    
+    actions?: Action[];
+    
+    ruleDisabled?: boolean;
+    
+    awsIotSqlVersion?: string;
+    
+    errorAction?: Action;
+}
+export declare namespace TopicRule {
+    
+    const filterSensitiveLog: (obj: TopicRule) => any;
+}
+
+export interface GetTopicRuleResponse {
+    
+    ruleArn?: string;
+    
+    rule?: TopicRule;
+}
+export declare namespace GetTopicRuleResponse {
+    
+    const filterSensitiveLog: (obj: GetTopicRuleResponse) => any;
+}
+export interface GetTopicRuleDestinationRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetTopicRuleDestinationRequest {
+    
+    const filterSensitiveLog: (obj: GetTopicRuleDestinationRequest) => any;
+}
+export interface GetTopicRuleDestinationResponse {
+    
+    topicRuleDestination?: TopicRuleDestination;
+}
+export declare namespace GetTopicRuleDestinationResponse {
+    
+    const filterSensitiveLog: (obj: GetTopicRuleDestinationResponse) => any;
+}
+export interface GetV2LoggingOptionsRequest {
+}
+export declare namespace GetV2LoggingOptionsRequest {
+    
+    const filterSensitiveLog: (obj: GetV2LoggingOptionsRequest) => any;
+}
+export interface GetV2LoggingOptionsResponse {
+    
+    roleArn?: string;
+    
+    defaultLogLevel?: LogLevel | string;
+    
+    disableAllLogs?: boolean;
+}
+export declare namespace GetV2LoggingOptionsResponse {
+    
+    const filterSensitiveLog: (obj: GetV2LoggingOptionsResponse) => any;
+}
+
+export declare class NotConfiguredException extends __BaseException {
+    readonly name: "NotConfiguredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NotConfiguredException, __BaseException>);
+}
+export declare enum BehaviorCriteriaType {
+    MACHINE_LEARNING = "MACHINE_LEARNING",
+    STATIC = "STATIC",
+    STATISTICAL = "STATISTICAL"
+}
+export interface ListActiveViolationsRequest {
+    
+    thingName?: string;
+    
+    securityProfileName?: string;
+    
+    behaviorCriteriaType?: BehaviorCriteriaType | string;
+    
+    listSuppressedAlerts?: boolean;
+    
+    verificationState?: VerificationState | string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListActiveViolationsRequest {
+    
+    const filterSensitiveLog: (obj: ListActiveViolationsRequest) => any;
+}
+export interface ListActiveViolationsResponse {
+    
+    activeViolations?: ActiveViolation[];
+    
+    nextToken?: string;
+}
+export declare namespace ListActiveViolationsResponse {
+    
+    const filterSensitiveLog: (obj: ListActiveViolationsResponse) => any;
+}
+export interface ListAttachedPoliciesRequest {
+    
+    target: string | undefined;
+    
+    recursive?: boolean;
+    
+    marker?: string;
+    
+    pageSize?: number;
+}
+export declare namespace ListAttachedPoliciesRequest {
+    
+    const filterSensitiveLog: (obj: ListAttachedPoliciesRequest) => any;
+}
+export interface ListAttachedPoliciesResponse {
+    
+    policies?: Policy[];
+    
+    nextMarker?: string;
+}
+export declare namespace ListAttachedPoliciesResponse {
+    
+    const filterSensitiveLog: (obj: ListAttachedPoliciesResponse) => any;
+}
+export interface ListAuditFindingsRequest {
+    
+    taskId?: string;
+    
+    checkName?: string;
+    
+    resourceIdentifier?: ResourceIdentifier;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+    
+    listSuppressedFindings?: boolean;
+}
+export declare namespace ListAuditFindingsRequest {
+    
+    const filterSensitiveLog: (obj: ListAuditFindingsRequest) => any;
+}
+export interface ListAuditFindingsResponse {
+    
+    findings?: AuditFinding[];
+    
+    nextToken?: string;
+}
+export declare namespace ListAuditFindingsResponse {
+    
+    const filterSensitiveLog: (obj: ListAuditFindingsResponse) => any;
+}
+export interface ListAuditMitigationActionsExecutionsRequest {
+    
+    taskId: string | undefined;
+    
+    actionStatus?: AuditMitigationActionsExecutionStatus | string;
+    
+    findingId: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListAuditMitigationActionsExecutionsRequest {
+    
+    const filterSensitiveLog: (obj: ListAuditMitigationActionsExecutionsRequest) => any;
+}
+export interface ListAuditMitigationActionsExecutionsResponse {
+    
+    actionsExecutions?: AuditMitigationActionExecutionMetadata[];
+    
+    nextToken?: string;
+}
+export declare namespace ListAuditMitigationActionsExecutionsResponse {
+    
+    const filterSensitiveLog: (obj: ListAuditMitigationActionsExecutionsResponse) => any;
+}
+export interface ListAuditMitigationActionsTasksRequest {
+    
+    auditTaskId?: string;
+    
+    findingId?: string;
+    
+    taskStatus?: AuditMitigationActionsTaskStatus | string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+    
+    startTime: Date | undefined;
+    
+    endTime: Date | undefined;
+}
+export declare namespace ListAuditMitigationActionsTasksRequest {
+    
+    const filterSensitiveLog: (obj: ListAuditMitigationActionsTasksRequest) => any;
+}
+export interface ListAuditMitigationActionsTasksResponse {
+    
+    tasks?: AuditMitigationActionsTaskMetadata[];
+    
+    nextToken?: string;
+}
+export declare namespace ListAuditMitigationActionsTasksResponse {
+    
+    const filterSensitiveLog: (obj: ListAuditMitigationActionsTasksResponse) => any;
+}
+export interface ListAuditSuppressionsRequest {
+    
+    checkName?: string;
+    
+    resourceIdentifier?: ResourceIdentifier;
+    
+    ascendingOrder?: boolean;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListAuditSuppressionsRequest {
+    
+    const filterSensitiveLog: (obj: ListAuditSuppressionsRequest) => any;
+}
+export interface ListAuditSuppressionsResponse {
+    
+    suppressions?: AuditSuppression[];
+    
+    nextToken?: string;
+}
+export declare namespace ListAuditSuppressionsResponse {
+    
+    const filterSensitiveLog: (obj: ListAuditSuppressionsResponse) => any;
+}
+export interface ListAuditTasksRequest {
+    
+    startTime: Date | undefined;
+    
+    endTime: Date | undefined;
+    
+    taskType?: AuditTaskType | string;
+    
+    taskStatus?: AuditTaskStatus | string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListAuditTasksRequest {
+    
+    const filterSensitiveLog: (obj: ListAuditTasksRequest) => any;
+}
+export interface ListAuditTasksResponse {
+    
+    tasks?: AuditTaskMetadata[];
+    
+    nextToken?: string;
+}
+export declare namespace ListAuditTasksResponse {
+    
+    const filterSensitiveLog: (obj: ListAuditTasksResponse) => any;
+}
+export interface ListAuthorizersRequest {
+    
+    pageSize?: number;
+    
+    marker?: string;
+    
+    ascendingOrder?: boolean;
+    
+    status?: AuthorizerStatus | string;
+}
+export declare namespace ListAuthorizersRequest {
+    
+    const filterSensitiveLog: (obj: ListAuthorizersRequest) => any;
+}
+export interface ListAuthorizersResponse {
+    
+    authorizers?: AuthorizerSummary[];
+    
+    nextMarker?: string;
+}
+export declare namespace ListAuthorizersResponse {
+    
+    const filterSensitiveLog: (obj: ListAuthorizersResponse) => any;
+}
+export interface ListBillingGroupsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    namePrefixFilter?: string;
+}
+export declare namespace ListBillingGroupsRequest {
+    
+    const filterSensitiveLog: (obj: ListBillingGroupsRequest) => any;
+}
+export interface ListBillingGroupsResponse {
+    
+    billingGroups?: GroupNameAndArn[];
+    
+    nextToken?: string;
+}
+export declare namespace ListBillingGroupsResponse {
+    
+    const filterSensitiveLog: (obj: ListBillingGroupsResponse) => any;
+}
+
+export interface ListCACertificatesRequest {
+    
+    pageSize?: number;
+    
+    marker?: string;
+    
+    ascendingOrder?: boolean;
+}
+export declare namespace ListCACertificatesRequest {
+    
+    const filterSensitiveLog: (obj: ListCACertificatesRequest) => any;
+}
+
+export interface CACertificate {
+    
+    certificateArn?: string;
+    
+    certificateId?: string;
+    
+    status?: CACertificateStatus | string;
+    
+    creationDate?: Date;
+}
+export declare namespace CACertificate {
+    
+    const filterSensitiveLog: (obj: CACertificate) => any;
+}
+
+export interface ListCACertificatesResponse {
+    
+    certificates?: CACertificate[];
+    
+    nextMarker?: string;
+}
+export declare namespace ListCACertificatesResponse {
+    
+    const filterSensitiveLog: (obj: ListCACertificatesResponse) => any;
+}
+
+export interface ListCertificatesRequest {
+    
+    pageSize?: number;
+    
+    marker?: string;
+    
+    ascendingOrder?: boolean;
+}
+export declare namespace ListCertificatesRequest {
+    
+    const filterSensitiveLog: (obj: ListCertificatesRequest) => any;
+}
+
+export interface Certificate {
+    
+    certificateArn?: string;
+    
+    certificateId?: string;
+    
+    status?: CertificateStatus | string;
+    
+    certificateMode?: CertificateMode | string;
+    
+    creationDate?: Date;
+}
+export declare namespace Certificate {
+    
+    const filterSensitiveLog: (obj: Certificate) => any;
+}
+
+export interface ListCertificatesResponse {
+    
+    certificates?: Certificate[];
+    
+    nextMarker?: string;
+}
+export declare namespace ListCertificatesResponse {
+    
+    const filterSensitiveLog: (obj: ListCertificatesResponse) => any;
+}
+
+export interface ListCertificatesByCARequest {
+    
+    caCertificateId: string | undefined;
+    
+    pageSize?: number;
+    
+    marker?: string;
+    
+    ascendingOrder?: boolean;
+}
+export declare namespace ListCertificatesByCARequest {
+    
+    const filterSensitiveLog: (obj: ListCertificatesByCARequest) => any;
+}
+
+export interface ListCertificatesByCAResponse {
+    
+    certificates?: Certificate[];
+    
+    nextMarker?: string;
+}
+export declare namespace ListCertificatesByCAResponse {
+    
+    const filterSensitiveLog: (obj: ListCertificatesByCAResponse) => any;
+}
+export interface ListCustomMetricsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListCustomMetricsRequest {
+    
+    const filterSensitiveLog: (obj: ListCustomMetricsRequest) => any;
+}
+export interface ListCustomMetricsResponse {
+    
+    metricNames?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListCustomMetricsResponse {
+    
+    const filterSensitiveLog: (obj: ListCustomMetricsResponse) => any;
+}
+export interface ListDetectMitigationActionsExecutionsRequest {
+    
+    taskId?: string;
+    
+    violationId?: string;
+    
+    thingName?: string;
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListDetectMitigationActionsExecutionsRequest {
+    
+    const filterSensitiveLog: (obj: ListDetectMitigationActionsExecutionsRequest) => any;
+}
+export declare enum DetectMitigationActionExecutionStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    SKIPPED = "SKIPPED",
+    SUCCESSFUL = "SUCCESSFUL"
+}
+
+export interface DetectMitigationActionExecution {
+    
+    taskId?: string;
+    
+    violationId?: string;
+    
+    actionName?: string;
+    
+    thingName?: string;
+    
+    executionStartDate?: Date;
+    
+    executionEndDate?: Date;
+    
+    status?: DetectMitigationActionExecutionStatus | string;
+    
+    errorCode?: string;
+    
+    message?: string;
+}
+export declare namespace DetectMitigationActionExecution {
+    
+    const filterSensitiveLog: (obj: DetectMitigationActionExecution) => any;
+}
+export interface ListDetectMitigationActionsExecutionsResponse {
+    
+    actionsExecutions?: DetectMitigationActionExecution[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDetectMitigationActionsExecutionsResponse {
+    
+    const filterSensitiveLog: (obj: ListDetectMitigationActionsExecutionsResponse) => any;
+}
+export interface ListDetectMitigationActionsTasksRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+    
+    startTime: Date | undefined;
+    
+    endTime: Date | undefined;
+}
+export declare namespace ListDetectMitigationActionsTasksRequest {
+    
+    const filterSensitiveLog: (obj: ListDetectMitigationActionsTasksRequest) => any;
+}
+export interface ListDetectMitigationActionsTasksResponse {
+    
+    tasks?: DetectMitigationActionsTaskSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDetectMitigationActionsTasksResponse {
+    
+    const filterSensitiveLog: (obj: ListDetectMitigationActionsTasksResponse) => any;
+}
+export interface ListDimensionsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListDimensionsRequest {
+    
+    const filterSensitiveLog: (obj: ListDimensionsRequest) => any;
+}
+export interface ListDimensionsResponse {
+    
+    dimensionNames?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDimensionsResponse {
+    
+    const filterSensitiveLog: (obj: ListDimensionsResponse) => any;
+}
+export interface ListDomainConfigurationsRequest {
+    
+    marker?: string;
+    
+    pageSize?: number;
+    
+    serviceType?: ServiceType | string;
+}
+export declare namespace ListDomainConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: ListDomainConfigurationsRequest) => any;
+}
+
+export interface DomainConfigurationSummary {
+    
+    domainConfigurationName?: string;
+    
+    domainConfigurationArn?: string;
+    
+    serviceType?: ServiceType | string;
+}
+export declare namespace DomainConfigurationSummary {
+    
+    const filterSensitiveLog: (obj: DomainConfigurationSummary) => any;
+}
+export interface ListDomainConfigurationsResponse {
+    
+    domainConfigurations?: DomainConfigurationSummary[];
+    
+    nextMarker?: string;
+}
+export declare namespace ListDomainConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: ListDomainConfigurationsResponse) => any;
+}
+export interface ListFleetMetricsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListFleetMetricsRequest {
+    
+    const filterSensitiveLog: (obj: ListFleetMetricsRequest) => any;
+}
+
+export interface FleetMetricNameAndArn {
+    
+    metricName?: string;
+    
+    metricArn?: string;
+}
+export declare namespace FleetMetricNameAndArn {
+    
+    const filterSensitiveLog: (obj: FleetMetricNameAndArn) => any;
+}
+export interface ListFleetMetricsResponse {
+    
+    fleetMetrics?: FleetMetricNameAndArn[];
+    
+    nextToken?: string;
+}
+export declare namespace ListFleetMetricsResponse {
+    
+    const filterSensitiveLog: (obj: ListFleetMetricsResponse) => any;
+}
+export interface ListIndicesRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListIndicesRequest {
+    
+    const filterSensitiveLog: (obj: ListIndicesRequest) => any;
+}
+export interface ListIndicesResponse {
+    
+    indexNames?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListIndicesResponse {
+    
+    const filterSensitiveLog: (obj: ListIndicesResponse) => any;
+}
+export interface ListJobExecutionsForJobRequest {
+    
+    jobId: string | undefined;
+    
+    status?: JobExecutionStatus | string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListJobExecutionsForJobRequest {
+    
+    const filterSensitiveLog: (obj: ListJobExecutionsForJobRequest) => any;
+}
+
+export interface JobExecutionSummary {
+    
+    status?: JobExecutionStatus | string;
+    
+    queuedAt?: Date;
+    
+    startedAt?: Date;
+    
+    lastUpdatedAt?: Date;
+    
+    executionNumber?: number;
+    
+    retryAttempt?: number;
+}
+export declare namespace JobExecutionSummary {
+    
+    const filterSensitiveLog: (obj: JobExecutionSummary) => any;
+}
+
+export interface JobExecutionSummaryForJob {
+    
+    thingArn?: string;
+    
+    jobExecutionSummary?: JobExecutionSummary;
+}
+export declare namespace JobExecutionSummaryForJob {
+    
+    const filterSensitiveLog: (obj: JobExecutionSummaryForJob) => any;
+}
+export interface ListJobExecutionsForJobResponse {
+    
+    executionSummaries?: JobExecutionSummaryForJob[];
+    
+    nextToken?: string;
+}
+export declare namespace ListJobExecutionsForJobResponse {
+    
+    const filterSensitiveLog: (obj: ListJobExecutionsForJobResponse) => any;
+}
+export interface ListJobExecutionsForThingRequest {
+    
+    thingName: string | undefined;
+    
+    status?: JobExecutionStatus | string;
+    
+    namespaceId?: string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+    
+    jobId?: string;
+}
+export declare namespace ListJobExecutionsForThingRequest {
+    
+    const filterSensitiveLog: (obj: ListJobExecutionsForThingRequest) => any;
+}
+
+export interface JobExecutionSummaryForThing {
+    
+    jobId?: string;
+    
+    jobExecutionSummary?: JobExecutionSummary;
+}
+export declare namespace JobExecutionSummaryForThing {
+    
+    const filterSensitiveLog: (obj: JobExecutionSummaryForThing) => any;
+}
+export interface ListJobExecutionsForThingResponse {
+    
+    executionSummaries?: JobExecutionSummaryForThing[];
+    
+    nextToken?: string;
+}
+export declare namespace ListJobExecutionsForThingResponse {
+    
+    const filterSensitiveLog: (obj: ListJobExecutionsForThingResponse) => any;
+}
+export interface ListJobsRequest {
+    
+    status?: JobStatus | string;
+    
+    targetSelection?: TargetSelection | string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+    
+    thingGroupName?: string;
+    
+    thingGroupId?: string;
+    
+    namespaceId?: string;
+}
+export declare namespace ListJobsRequest {
+    
+    const filterSensitiveLog: (obj: ListJobsRequest) => any;
+}
+
+export interface JobSummary {
+    
+    jobArn?: string;
+    
+    jobId?: string;
+    
+    thingGroupId?: string;
+    
+    targetSelection?: TargetSelection | string;
+    
+    status?: JobStatus | string;
+    
+    createdAt?: Date;
+    
+    lastUpdatedAt?: Date;
+    
+    completedAt?: Date;
+}
+export declare namespace JobSummary {
+    
+    const filterSensitiveLog: (obj: JobSummary) => any;
+}
+export interface ListJobsResponse {
+    
+    jobs?: JobSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListJobsResponse {
+    
+    const filterSensitiveLog: (obj: ListJobsResponse) => any;
+}
+export interface ListJobTemplatesRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListJobTemplatesRequest {
+    
+    const filterSensitiveLog: (obj: ListJobTemplatesRequest) => any;
+}
+
+export interface JobTemplateSummary {
+    
+    jobTemplateArn?: string;
+    
+    jobTemplateId?: string;
+    
+    description?: string;
+    
+    createdAt?: Date;
+}
+export declare namespace JobTemplateSummary {
+    
+    const filterSensitiveLog: (obj: JobTemplateSummary) => any;
+}
+export interface ListJobTemplatesResponse {
+    
+    jobTemplates?: JobTemplateSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListJobTemplatesResponse {
+    
+    const filterSensitiveLog: (obj: ListJobTemplatesResponse) => any;
+}
+export interface ListManagedJobTemplatesRequest {
+    
+    templateName?: string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListManagedJobTemplatesRequest {
+    
+    const filterSensitiveLog: (obj: ListManagedJobTemplatesRequest) => any;
+}
+
+export interface ManagedJobTemplateSummary {
+    
+    templateArn?: string;
+    
+    templateName?: string;
+    
+    description?: string;
+    
+    environments?: string[];
+    
+    templateVersion?: string;
+}
+export declare namespace ManagedJobTemplateSummary {
+    
+    const filterSensitiveLog: (obj: ManagedJobTemplateSummary) => any;
+}
+export interface ListManagedJobTemplatesResponse {
+    
+    managedJobTemplates?: ManagedJobTemplateSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListManagedJobTemplatesResponse {
+    
+    const filterSensitiveLog: (obj: ListManagedJobTemplatesResponse) => any;
+}
+export interface ListMitigationActionsRequest {
+    
+    actionType?: MitigationActionType | string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListMitigationActionsRequest {
+    
+    const filterSensitiveLog: (obj: ListMitigationActionsRequest) => any;
+}
+
+export interface MitigationActionIdentifier {
+    
+    actionName?: string;
+    
+    actionArn?: string;
+    
+    creationDate?: Date;
+}
+export declare namespace MitigationActionIdentifier {
+    
+    const filterSensitiveLog: (obj: MitigationActionIdentifier) => any;
+}
+export interface ListMitigationActionsResponse {
+    
+    actionIdentifiers?: MitigationActionIdentifier[];
+    
+    nextToken?: string;
+}
+export declare namespace ListMitigationActionsResponse {
+    
+    const filterSensitiveLog: (obj: ListMitigationActionsResponse) => any;
+}
+export interface ListOTAUpdatesRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+    
+    otaUpdateStatus?: OTAUpdateStatus | string;
+}
+export declare namespace ListOTAUpdatesRequest {
+    
+    const filterSensitiveLog: (obj: ListOTAUpdatesRequest) => any;
+}
+
+export interface OTAUpdateSummary {
+    
+    otaUpdateId?: string;
+    
+    otaUpdateArn?: string;
+    
+    creationDate?: Date;
+}
+export declare namespace OTAUpdateSummary {
+    
+    const filterSensitiveLog: (obj: OTAUpdateSummary) => any;
+}
+export interface ListOTAUpdatesResponse {
+    
+    otaUpdates?: OTAUpdateSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListOTAUpdatesResponse {
+    
+    const filterSensitiveLog: (obj: ListOTAUpdatesResponse) => any;
+}
+
+export interface ListOutgoingCertificatesRequest {
+    
+    pageSize?: number;
+    
+    marker?: string;
+    
+    ascendingOrder?: boolean;
+}
+export declare namespace ListOutgoingCertificatesRequest {
+    
+    const filterSensitiveLog: (obj: ListOutgoingCertificatesRequest) => any;
+}
+
+export interface OutgoingCertificate {
+    
+    certificateArn?: string;
+    
+    certificateId?: string;
+    
+    transferredTo?: string;
+    
+    transferDate?: Date;
+    
+    transferMessage?: string;
+    
+    creationDate?: Date;
+}
+export declare namespace OutgoingCertificate {
+    
+    const filterSensitiveLog: (obj: OutgoingCertificate) => any;
+}
+
+export interface ListOutgoingCertificatesResponse {
+    
+    outgoingCertificates?: OutgoingCertificate[];
+    
+    nextMarker?: string;
+}
+export declare namespace ListOutgoingCertificatesResponse {
+    
+    const filterSensitiveLog: (obj: ListOutgoingCertificatesResponse) => any;
+}
+
+export interface ListPoliciesRequest {
+    
+    marker?: string;
+    
+    pageSize?: number;
+    
+    ascendingOrder?: boolean;
+}
+export declare namespace ListPoliciesRequest {
+    
+    const filterSensitiveLog: (obj: ListPoliciesRequest) => any;
+}
+
+export interface ListPoliciesResponse {
+    
+    policies?: Policy[];
+    
+    nextMarker?: string;
+}
+export declare namespace ListPoliciesResponse {
+    
+    const filterSensitiveLog: (obj: ListPoliciesResponse) => any;
+}
+
+export interface ListPolicyPrincipalsRequest {
+    
+    policyName: string | undefined;
+    
+    marker?: string;
+    
+    pageSize?: number;
+    
+    ascendingOrder?: boolean;
+}
+export declare namespace ListPolicyPrincipalsRequest {
+    
+    const filterSensitiveLog: (obj: ListPolicyPrincipalsRequest) => any;
+}
+
+export interface ListPolicyPrincipalsResponse {
+    
+    principals?: string[];
+    
+    nextMarker?: string;
+}
+export declare namespace ListPolicyPrincipalsResponse {
+    
+    const filterSensitiveLog: (obj: ListPolicyPrincipalsResponse) => any;
+}
+
+export interface ListPolicyVersionsRequest {
+    
+    policyName: string | undefined;
+}
+export declare namespace ListPolicyVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListPolicyVersionsRequest) => any;
+}
+
+export interface PolicyVersion {
+    
+    versionId?: string;
+    
+    isDefaultVersion?: boolean;
+    
+    createDate?: Date;
+}
+export declare namespace PolicyVersion {
+    
+    const filterSensitiveLog: (obj: PolicyVersion) => any;
+}
+
+export interface ListPolicyVersionsResponse {
+    
+    policyVersions?: PolicyVersion[];
+}
+export declare namespace ListPolicyVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListPolicyVersionsResponse) => any;
+}
+
+export interface ListPrincipalPoliciesRequest {
+    
+    principal: string | undefined;
+    
+    marker?: string;
+    
+    pageSize?: number;
+    
+    ascendingOrder?: boolean;
+}
+export declare namespace ListPrincipalPoliciesRequest {
+    
+    const filterSensitiveLog: (obj: ListPrincipalPoliciesRequest) => any;
+}
+
+export interface ListPrincipalPoliciesResponse {
+    
+    policies?: Policy[];
+    
+    nextMarker?: string;
+}
+export declare namespace ListPrincipalPoliciesResponse {
+    
+    const filterSensitiveLog: (obj: ListPrincipalPoliciesResponse) => any;
+}
+
+export interface ListPrincipalThingsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    principal: string | undefined;
+}
+export declare namespace ListPrincipalThingsRequest {
+    
+    const filterSensitiveLog: (obj: ListPrincipalThingsRequest) => any;
+}
+
+export interface ListPrincipalThingsResponse {
+    
+    things?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListPrincipalThingsResponse {
+    
+    const filterSensitiveLog: (obj: ListPrincipalThingsResponse) => any;
+}
+export interface ListProvisioningTemplatesRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListProvisioningTemplatesRequest {
+    
+    const filterSensitiveLog: (obj: ListProvisioningTemplatesRequest) => any;
+}
+
+export interface ProvisioningTemplateSummary {
+    
+    templateArn?: string;
+    
+    templateName?: string;
+    
+    description?: string;
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+    
+    enabled?: boolean;
+}
+export declare namespace ProvisioningTemplateSummary {
+    
+    const filterSensitiveLog: (obj: ProvisioningTemplateSummary) => any;
+}
+export interface ListProvisioningTemplatesResponse {
+    
+    templates?: ProvisioningTemplateSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListProvisioningTemplatesResponse {
+    
+    const filterSensitiveLog: (obj: ListProvisioningTemplatesResponse) => any;
+}
+export interface ListProvisioningTemplateVersionsRequest {
+    
+    templateName: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListProvisioningTemplateVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListProvisioningTemplateVersionsRequest) => any;
+}
+
+export interface ProvisioningTemplateVersionSummary {
+    
+    versionId?: number;
+    
+    creationDate?: Date;
+    
+    isDefaultVersion?: boolean;
+}
+export declare namespace ProvisioningTemplateVersionSummary {
+    
+    const filterSensitiveLog: (obj: ProvisioningTemplateVersionSummary) => any;
+}
+export interface ListProvisioningTemplateVersionsResponse {
+    
+    versions?: ProvisioningTemplateVersionSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListProvisioningTemplateVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListProvisioningTemplateVersionsResponse) => any;
+}
+export interface ListRoleAliasesRequest {
+    
+    pageSize?: number;
+    
+    marker?: string;
+    
+    ascendingOrder?: boolean;
+}
+export declare namespace ListRoleAliasesRequest {
+    
+    const filterSensitiveLog: (obj: ListRoleAliasesRequest) => any;
+}
+export interface ListRoleAliasesResponse {
+    
+    roleAliases?: string[];
+    
+    nextMarker?: string;
+}
+export declare namespace ListRoleAliasesResponse {
+    
+    const filterSensitiveLog: (obj: ListRoleAliasesResponse) => any;
+}
+export interface ListScheduledAuditsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListScheduledAuditsRequest {
+    
+    const filterSensitiveLog: (obj: ListScheduledAuditsRequest) => any;
+}
+
+export interface ScheduledAuditMetadata {
+    
+    scheduledAuditName?: string;
+    
+    scheduledAuditArn?: string;
+    
+    frequency?: AuditFrequency | string;
+    
+    dayOfMonth?: string;
+    
+    dayOfWeek?: DayOfWeek | string;
+}
+export declare namespace ScheduledAuditMetadata {
+    
+    const filterSensitiveLog: (obj: ScheduledAuditMetadata) => any;
+}
+export interface ListScheduledAuditsResponse {
+    
+    scheduledAudits?: ScheduledAuditMetadata[];
+    
+    nextToken?: string;
+}
+export declare namespace ListScheduledAuditsResponse {
+    
+    const filterSensitiveLog: (obj: ListScheduledAuditsResponse) => any;
+}
+export interface ListSecurityProfilesRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    dimensionName?: string;
+    
+    metricName?: string;
+}
+export declare namespace ListSecurityProfilesRequest {
+    
+    const filterSensitiveLog: (obj: ListSecurityProfilesRequest) => any;
+}
+
+export interface SecurityProfileIdentifier {
+    
+    name: string | undefined;
+    
+    arn: string | undefined;
+}
+export declare namespace SecurityProfileIdentifier {
+    
+    const filterSensitiveLog: (obj: SecurityProfileIdentifier) => any;
+}
+export interface ListSecurityProfilesResponse {
+    
+    securityProfileIdentifiers?: SecurityProfileIdentifier[];
+    
+    nextToken?: string;
+}
+export declare namespace ListSecurityProfilesResponse {
+    
+    const filterSensitiveLog: (obj: ListSecurityProfilesResponse) => any;
+}
+export interface ListSecurityProfilesForTargetRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    recursive?: boolean;
+    
+    securityProfileTargetArn: string | undefined;
+}
+export declare namespace ListSecurityProfilesForTargetRequest {
+    
+    const filterSensitiveLog: (obj: ListSecurityProfilesForTargetRequest) => any;
+}
+
+export interface SecurityProfileTarget {
+    
+    arn: string | undefined;
+}
+export declare namespace SecurityProfileTarget {
+    
+    const filterSensitiveLog: (obj: SecurityProfileTarget) => any;
+}
+
+export interface SecurityProfileTargetMapping {
+    
+    securityProfileIdentifier?: SecurityProfileIdentifier;
+    
+    target?: SecurityProfileTarget;
+}
+export declare namespace SecurityProfileTargetMapping {
+    
+    const filterSensitiveLog: (obj: SecurityProfileTargetMapping) => any;
+}
+export interface ListSecurityProfilesForTargetResponse {
+    
+    securityProfileTargetMappings?: SecurityProfileTargetMapping[];
+    
+    nextToken?: string;
+}
+export declare namespace ListSecurityProfilesForTargetResponse {
+    
+    const filterSensitiveLog: (obj: ListSecurityProfilesForTargetResponse) => any;
+}
+export interface ListStreamsRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+    
+    ascendingOrder?: boolean;
+}
+export declare namespace ListStreamsRequest {
+    
+    const filterSensitiveLog: (obj: ListStreamsRequest) => any;
+}
+
+export interface StreamSummary {
+    
+    streamId?: string;
+    
+    streamArn?: string;
+    
+    streamVersion?: number;
+    
+    description?: string;
+}
+export declare namespace StreamSummary {
+    
+    const filterSensitiveLog: (obj: StreamSummary) => any;
+}
+export interface ListStreamsResponse {
+    
+    streams?: StreamSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListStreamsResponse {
+    
+    const filterSensitiveLog: (obj: ListStreamsResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags?: Tag[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ListTargetsForPolicyRequest {
+    
+    policyName: string | undefined;
+    
+    marker?: string;
+    
+    pageSize?: number;
+}
+export declare namespace ListTargetsForPolicyRequest {
+    
+    const filterSensitiveLog: (obj: ListTargetsForPolicyRequest) => any;
+}
+export interface ListTargetsForPolicyResponse {
+    
+    targets?: string[];
+    
+    nextMarker?: string;
+}
+export declare namespace ListTargetsForPolicyResponse {
+    
+    const filterSensitiveLog: (obj: ListTargetsForPolicyResponse) => any;
+}
+export interface ListTargetsForSecurityProfileRequest {
+    
+    securityProfileName: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListTargetsForSecurityProfileRequest {
+    
+    const filterSensitiveLog: (obj: ListTargetsForSecurityProfileRequest) => any;
+}
+export interface ListTargetsForSecurityProfileResponse {
+    
+    securityProfileTargets?: SecurityProfileTarget[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTargetsForSecurityProfileResponse {
+    
+    const filterSensitiveLog: (obj: ListTargetsForSecurityProfileResponse) => any;
+}
+export interface ListThingGroupsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    parentGroup?: string;
+    
+    namePrefixFilter?: string;
+    
+    recursive?: boolean;
+}
+export declare namespace ListThingGroupsRequest {
+    
+    const filterSensitiveLog: (obj: ListThingGroupsRequest) => any;
+}
+export interface ListThingGroupsResponse {
+    
+    thingGroups?: GroupNameAndArn[];
+    
+    nextToken?: string;
+}
+export declare namespace ListThingGroupsResponse {
+    
+    const filterSensitiveLog: (obj: ListThingGroupsResponse) => any;
+}
+export interface ListThingGroupsForThingRequest {
+    
+    thingName: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListThingGroupsForThingRequest {
+    
+    const filterSensitiveLog: (obj: ListThingGroupsForThingRequest) => any;
+}
+export interface ListThingGroupsForThingResponse {
+    
+    thingGroups?: GroupNameAndArn[];
+    
+    nextToken?: string;
+}
+export declare namespace ListThingGroupsForThingResponse {
+    
+    const filterSensitiveLog: (obj: ListThingGroupsForThingResponse) => any;
+}
+
+export interface ListThingPrincipalsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    thingName: string | undefined;
+}
+export declare namespace ListThingPrincipalsRequest {
+    
+    const filterSensitiveLog: (obj: ListThingPrincipalsRequest) => any;
+}
+
+export interface ListThingPrincipalsResponse {
+    
+    principals?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListThingPrincipalsResponse {
+    
+    const filterSensitiveLog: (obj: ListThingPrincipalsResponse) => any;
+}
+export declare enum ReportType {
+    ERRORS = "ERRORS",
+    RESULTS = "RESULTS"
+}