@aws-sdk/client-iot/dist-types/ts3.4/models/models_0.d.ts

AWS SDK for JavaScript Iot Client for Node.js, Browser and React Native

import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
import { IoTServiceException as __BaseException } from "./IoTServiceException";
export declare const AbortAction: {
  readonly CANCEL: "CANCEL";
};
export type AbortAction = (typeof AbortAction)[keyof typeof AbortAction];
export declare const JobExecutionFailureType: {
  readonly ALL: "ALL";
  readonly FAILED: "FAILED";
  readonly REJECTED: "REJECTED";
  readonly TIMED_OUT: "TIMED_OUT";
};
export type JobExecutionFailureType =
  (typeof JobExecutionFailureType)[keyof typeof JobExecutionFailureType];
export interface AbortCriteria {
  failureType: JobExecutionFailureType | undefined;
  action: AbortAction | undefined;
  thresholdPercentage: number | undefined;
  minNumberOfExecutedThings: number | undefined;
}
export interface AbortConfig {
  criteriaList: AbortCriteria[] | undefined;
}
export interface AcceptCertificateTransferRequest {
  certificateId: string | undefined;
  setAsActive?: boolean;
}
export declare class InternalFailureException extends __BaseException {
  readonly name: "InternalFailureException";
  readonly $fault: "server";
  constructor(
    opts: __ExceptionOptionType<InternalFailureException, __BaseException>
  );
}
export declare class InvalidRequestException extends __BaseException {
  readonly name: "InvalidRequestException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<InvalidRequestException, __BaseException>
  );
}
export declare class ResourceNotFoundException extends __BaseException {
  readonly name: "ResourceNotFoundException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>
  );
}
export declare class ServiceUnavailableException extends __BaseException {
  readonly name: "ServiceUnavailableException";
  readonly $fault: "server";
  constructor(
    opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>
  );
}
export declare class ThrottlingException extends __BaseException {
  readonly name: "ThrottlingException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<ThrottlingException, __BaseException>
  );
}
export declare class TransferAlreadyCompletedException extends __BaseException {
  readonly name: "TransferAlreadyCompletedException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<
      TransferAlreadyCompletedException,
      __BaseException
    >
  );
}
export declare class UnauthorizedException extends __BaseException {
  readonly name: "UnauthorizedException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<UnauthorizedException, __BaseException>
  );
}
export interface CloudwatchAlarmAction {
  roleArn: string | undefined;
  alarmName: string | undefined;
  stateReason: string | undefined;
  stateValue: string | undefined;
}
export interface CloudwatchLogsAction {
  roleArn: string | undefined;
  logGroupName: string | undefined;
  batchMode?: boolean;
}
export interface CloudwatchMetricAction {
  roleArn: string | undefined;
  metricNamespace: string | undefined;
  metricName: string | undefined;
  metricValue: string | undefined;
  metricUnit: string | undefined;
  metricTimestamp?: string;
}
export declare const DynamoKeyType: {
  readonly NUMBER: "NUMBER";
  readonly STRING: "STRING";
};
export type DynamoKeyType = (typeof DynamoKeyType)[keyof typeof DynamoKeyType];
export interface DynamoDBAction {
  tableName: string | undefined;
  roleArn: string | undefined;
  operation?: string;
  hashKeyField: string | undefined;
  hashKeyValue: string | undefined;
  hashKeyType?: DynamoKeyType;
  rangeKeyField?: string;
  rangeKeyValue?: string;
  rangeKeyType?: DynamoKeyType;
  payloadField?: string;
}
export interface PutItemInput {
  tableName: string | undefined;
}
export interface DynamoDBv2Action {
  roleArn: string | undefined;
  putItem: PutItemInput | undefined;
}
export interface ElasticsearchAction {
  roleArn: string | undefined;
  endpoint: string | undefined;
  index: string | undefined;
  type: string | undefined;
  id: string | undefined;
}
export interface FirehoseAction {
  roleArn: string | undefined;
  deliveryStreamName: string | undefined;
  separator?: string;
  batchMode?: boolean;
}
export interface SigV4Authorization {
  signingRegion: string | undefined;
  serviceName: string | undefined;
  roleArn: string | undefined;
}
export interface HttpAuthorization {
  sigv4?: SigV4Authorization;
}
export interface HttpActionHeader {
  key: string | undefined;
  value: string | undefined;
}
export interface HttpAction {
  url: string | undefined;
  confirmationUrl?: string;
  headers?: HttpActionHeader[];
  auth?: HttpAuthorization;
}
export interface IotAnalyticsAction {
  channelArn?: string;
  channelName?: string;
  batchMode?: boolean;
  roleArn?: string;
}
export interface IotEventsAction {
  inputName: string | undefined;
  messageId?: string;
  batchMode?: boolean;
  roleArn: string | undefined;
}
export interface AssetPropertyTimestamp {
  timeInSeconds: string | undefined;
  offsetInNanos?: string;
}
export type AssetPropertyVariant =
  | AssetPropertyVariant.BooleanValueMember
  | AssetPropertyVariant.DoubleValueMember
  | AssetPropertyVariant.IntegerValueMember
  | AssetPropertyVariant.StringValueMember
  | AssetPropertyVariant.$UnknownMember;
export declare namespace AssetPropertyVariant {
  interface StringValueMember {
    stringValue: string;
    integerValue?: never;
    doubleValue?: never;
    booleanValue?: never;
    $unknown?: never;
  }
  interface IntegerValueMember {
    stringValue?: never;
    integerValue: string;
    doubleValue?: never;
    booleanValue?: never;
    $unknown?: never;
  }
  interface DoubleValueMember {
    stringValue?: never;
    integerValue?: never;
    doubleValue: string;
    booleanValue?: never;
    $unknown?: never;
  }
  interface BooleanValueMember {
    stringValue?: never;
    integerValue?: never;
    doubleValue?: never;
    booleanValue: string;
    $unknown?: never;
  }
  interface $UnknownMember {
    stringValue?: never;
    integerValue?: never;
    doubleValue?: never;
    booleanValue?: never;
    $unknown: [string, any];
  }
  interface Visitor<T> {
    stringValue: (value: string) => T;
    integerValue: (value: string) => T;
    doubleValue: (value: string) => T;
    booleanValue: (value: string) => T;
    _: (name: string, value: any) => T;
  }
  const visit: <T>(value: AssetPropertyVariant, visitor: Visitor<T>) => T;
}
export interface AssetPropertyValue {
  value: AssetPropertyVariant | undefined;
  timestamp: AssetPropertyTimestamp | undefined;
  quality?: string;
}
export interface PutAssetPropertyValueEntry {
  entryId?: string;
  assetId?: string;
  propertyId?: string;
  propertyAlias?: string;
  propertyValues: AssetPropertyValue[] | undefined;
}
export interface IotSiteWiseAction {
  putAssetPropertyValueEntries: PutAssetPropertyValueEntry[] | undefined;
  roleArn: string | undefined;
}
export interface KafkaActionHeader {
  key: string | undefined;
  value: string | undefined;
}
export interface KafkaAction {
  destinationArn: string | undefined;
  topic: string | undefined;
  key?: string;
  partition?: string;
  clientProperties: Record<string, string> | undefined;
  headers?: KafkaActionHeader[];
}
export interface KinesisAction {
  roleArn: string | undefined;
  streamName: string | undefined;
  partitionKey?: string;
}
export interface LambdaAction {
  functionArn: string | undefined;
}
export interface LocationTimestamp {
  value: string | undefined;
  unit?: string;
}
export interface LocationAction {
  roleArn: string | undefined;
  trackerName: string | undefined;
  deviceId: string | undefined;
  timestamp?: LocationTimestamp;
  latitude: string | undefined;
  longitude: string | undefined;
}
export interface OpenSearchAction {
  roleArn: string | undefined;
  endpoint: string | undefined;
  index: string | undefined;
  type: string | undefined;
  id: string | undefined;
}
export interface UserProperty {
  key: string | undefined;
  value: string | undefined;
}
export interface MqttHeaders {
  payloadFormatIndicator?: string;
  contentType?: string;
  responseTopic?: string;
  correlationData?: string;
  messageExpiry?: string;
  userProperties?: UserProperty[];
}
export interface RepublishAction {
  roleArn: string | undefined;
  topic: string | undefined;
  qos?: number;
  headers?: MqttHeaders;
}
export declare const CannedAccessControlList: {
  readonly AuthenticatedRead: "authenticated-read";
  readonly AwsExecRead: "aws-exec-read";
  readonly BucketOwnerFullControl: "bucket-owner-full-control";
  readonly BucketOwnerRead: "bucket-owner-read";
  readonly LogDeliveryWrite: "log-delivery-write";
  readonly Private: "private";
  readonly PublicRead: "public-read";
  readonly PublicReadWrite: "public-read-write";
};
export type CannedAccessControlList =
  (typeof CannedAccessControlList)[keyof typeof CannedAccessControlList];
export interface S3Action {
  roleArn: string | undefined;
  bucketName: string | undefined;
  key: string | undefined;
  cannedAcl?: CannedAccessControlList;
}
export interface SalesforceAction {
  token: string | undefined;
  url: string | undefined;
}
export declare const MessageFormat: {
  readonly JSON: "JSON";
  readonly RAW: "RAW";
};
export type MessageFormat = (typeof MessageFormat)[keyof typeof MessageFormat];
export interface SnsAction {
  targetArn: string | undefined;
  roleArn: string | undefined;
  messageFormat?: MessageFormat;
}
export interface SqsAction {
  roleArn: string | undefined;
  queueUrl: string | undefined;
  useBase64?: boolean;
}
export interface StepFunctionsAction {
  executionNamePrefix?: string;
  stateMachineName: string | undefined;
  roleArn: string | undefined;
}
export interface TimestreamDimension {
  name: string | undefined;
  value: string | undefined;
}
export interface TimestreamTimestamp {
  value: string | undefined;
  unit: string | undefined;
}
export interface TimestreamAction {
  roleArn: string | undefined;
  databaseName: string | undefined;
  tableName: string | undefined;
  dimensions: TimestreamDimension[] | undefined;
  timestamp?: TimestreamTimestamp;
}
export interface Action {
  dynamoDB?: DynamoDBAction;
  dynamoDBv2?: DynamoDBv2Action;
  lambda?: LambdaAction;
  sns?: SnsAction;
  sqs?: SqsAction;
  kinesis?: KinesisAction;
  republish?: RepublishAction;
  s3?: S3Action;
  firehose?: FirehoseAction;
  cloudwatchMetric?: CloudwatchMetricAction;
  cloudwatchAlarm?: CloudwatchAlarmAction;
  cloudwatchLogs?: CloudwatchLogsAction;
  elasticsearch?: ElasticsearchAction;
  salesforce?: SalesforceAction;
  iotAnalytics?: IotAnalyticsAction;
  iotEvents?: IotEventsAction;
  iotSiteWise?: IotSiteWiseAction;
  stepFunctions?: StepFunctionsAction;
  timestream?: TimestreamAction;
  http?: HttpAction;
  kafka?: KafkaAction;
  openSearch?: OpenSearchAction;
  location?: LocationAction;
}
export declare const ActionType: {
  readonly CONNECT: "CONNECT";
  readonly PUBLISH: "PUBLISH";
  readonly RECEIVE: "RECEIVE";
  readonly SUBSCRIBE: "SUBSCRIBE";
};
export type ActionType = (typeof ActionType)[keyof typeof ActionType];
export declare const ComparisonOperator: {
  readonly GREATER_THAN: "greater-than";
  readonly GREATER_THAN_EQUALS: "greater-than-equals";
  readonly IN_CIDR_SET: "in-cidr-set";
  readonly IN_PORT_SET: "in-port-set";
  readonly IN_SET: "in-set";
  readonly LESS_THAN: "less-than";
  readonly LESS_THAN_EQUALS: "less-than-equals";
  readonly NOT_IN_CIDR_SET: "not-in-cidr-set";
  readonly NOT_IN_PORT_SET: "not-in-port-set";
  readonly NOT_IN_SET: "not-in-set";
};
export type ComparisonOperator =
  (typeof ComparisonOperator)[keyof typeof ComparisonOperator];
export declare const ConfidenceLevel: {
  readonly HIGH: "HIGH";
  readonly LOW: "LOW";
  readonly MEDIUM: "MEDIUM";
};
export type ConfidenceLevel =
  (typeof ConfidenceLevel)[keyof typeof ConfidenceLevel];
export interface MachineLearningDetectionConfig {
  confidenceLevel: ConfidenceLevel | undefined;
}
export interface StatisticalThreshold {
  statistic?: string;
}
export interface MetricValue {
  count?: number;
  cidrs?: string[];
  ports?: number[];
  number?: number;
  numbers?: number[];
  strings?: string[];
}
export interface BehaviorCriteria {
  comparisonOperator?: ComparisonOperator;
  value?: MetricValue;
  durationSeconds?: number;
  consecutiveDatapointsToAlarm?: number;
  consecutiveDatapointsToClear?: number;
  statisticalThreshold?: StatisticalThreshold;
  mlDetectionConfig?: MachineLearningDetectionConfig;
}
export declare const DimensionValueOperator: {
  readonly IN: "IN";
  readonly NOT_IN: "NOT_IN";
};
export type DimensionValueOperator =
  (typeof DimensionValueOperator)[keyof typeof DimensionValueOperator];
export interface MetricDimension {
  dimensionName: string | undefined;
  operator?: DimensionValueOperator;
}
export interface Behavior {
  name: string | undefined;
  metric?: string;
  metricDimension?: MetricDimension;
  criteria?: BehaviorCriteria;
  suppressAlerts?: boolean;
  exportMetric?: boolean;
}
export declare const VerificationState: {
  readonly BENIGN_POSITIVE: "BENIGN_POSITIVE";
  readonly FALSE_POSITIVE: "FALSE_POSITIVE";
  readonly TRUE_POSITIVE: "TRUE_POSITIVE";
  readonly UNKNOWN: "UNKNOWN";
};
export type VerificationState =
  (typeof VerificationState)[keyof typeof VerificationState];
export interface ViolationEventAdditionalInfo {
  confidenceLevel?: ConfidenceLevel;
}
export interface ActiveViolation {
  violationId?: string;
  thingName?: string;
  securityProfileName?: string;
  behavior?: Behavior;
  lastViolationValue?: MetricValue;
  violationEventAdditionalInfo?: ViolationEventAdditionalInfo;
  verificationState?: VerificationState;
  verificationStateDescription?: string;
  lastViolationTime?: Date;
  violationStartTime?: Date;
}
export interface MetricToRetain {
  metric: string | undefined;
  metricDimension?: MetricDimension;
  exportMetric?: boolean;
}
export interface AddThingsToThingGroupParams {
  thingGroupNames: string[] | undefined;
  overrideDynamicGroups?: boolean;
}
export interface AddThingToBillingGroupRequest {
  billingGroupName?: string;
  billingGroupArn?: string;
  thingName?: string;
  thingArn?: string;
}
export interface AddThingToBillingGroupResponse {}
export interface AddThingToThingGroupRequest {
  thingGroupName?: string;
  thingGroupArn?: string;
  thingName?: string;
  thingArn?: string;
  overrideDynamicGroups?: boolean;
}
export interface AddThingToThingGroupResponse {}
export declare const AggregationTypeName: {
  readonly CARDINALITY: "Cardinality";
  readonly PERCENTILES: "Percentiles";
  readonly STATISTICS: "Statistics";
};
export type AggregationTypeName =
  (typeof AggregationTypeName)[keyof typeof AggregationTypeName];
export interface AggregationType {
  name: AggregationTypeName | undefined;
  values?: string[];
}
export interface AlertTarget {
  alertTargetArn: string | undefined;
  roleArn: string | undefined;
}
export declare const AlertTargetType: {
  readonly SNS: "SNS";
};
export type AlertTargetType =
  (typeof AlertTargetType)[keyof typeof AlertTargetType];
export interface Policy {
  policyName?: string;
  policyArn?: string;
}
export interface Allowed {
  policies?: Policy[];
}
export interface AssociateTargetsWithJobRequest {
  targets: string[] | undefined;
  jobId: string | undefined;
  comment?: string;
  namespaceId?: string;
}
export interface AssociateTargetsWithJobResponse {
  jobArn?: string;
  jobId?: string;
  description?: string;
}
export declare class LimitExceededException extends __BaseException {
  readonly name: "LimitExceededException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<LimitExceededException, __BaseException>
  );
}
export interface AttachPolicyRequest {
  policyName: string | undefined;
  target: string | undefined;
}
export interface AttachPrincipalPolicyRequest {
  policyName: string | undefined;
  principal: string | undefined;
}
export interface AttachSecurityProfileRequest {
  securityProfileName: string | undefined;
  securityProfileTargetArn: string | undefined;
}
export interface AttachSecurityProfileResponse {}
export declare class VersionConflictException extends __BaseException {
  readonly name: "VersionConflictException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<VersionConflictException, __BaseException>
  );
}
export interface AttachThingPrincipalRequest {
  thingName: string | undefined;
  principal: string | undefined;
}
export interface AttachThingPrincipalResponse {}
export interface AttributePayload {
  attributes?: Record<string, string>;
  merge?: boolean;
}
export interface AuditCheckConfiguration {
  enabled?: boolean;
}
export declare const AuditCheckRunStatus: {
  readonly CANCELED: "CANCELED";
  readonly COMPLETED_COMPLIANT: "COMPLETED_COMPLIANT";
  readonly COMPLETED_NON_COMPLIANT: "COMPLETED_NON_COMPLIANT";
  readonly FAILED: "FAILED";
  readonly IN_PROGRESS: "IN_PROGRESS";
  readonly WAITING_FOR_DATA_COLLECTION: "WAITING_FOR_DATA_COLLECTION";
};
export type AuditCheckRunStatus =
  (typeof AuditCheckRunStatus)[keyof typeof AuditCheckRunStatus];
export interface AuditCheckDetails {
  checkRunStatus?: AuditCheckRunStatus;
  checkCompliant?: boolean;
  totalResourcesCount?: number;
  nonCompliantResourcesCount?: number;
  suppressedNonCompliantResourcesCount?: number;
  errorCode?: string;
  message?: string;
}
export interface IssuerCertificateIdentifier {
  issuerCertificateSubject?: string;
  issuerId?: string;
  issuerCertificateSerialNumber?: string;
}
export interface PolicyVersionIdentifier {
  policyName?: string;
  policyVersionId?: string;
}
export interface ResourceIdentifier {
  deviceCertificateId?: string;
  caCertificateId?: string;
  cognitoIdentityPoolId?: string;
  clientId?: string;
  policyVersionIdentifier?: PolicyVersionIdentifier;
  account?: string;
  iamRoleArn?: string;
  roleAliasArn?: string;
  issuerCertificateIdentifier?: IssuerCertificateIdentifier;
  deviceCertificateArn?: string;
}
export declare const ResourceType: {
  readonly ACCOUNT_SETTINGS: "ACCOUNT_SETTINGS";
  readonly CA_CERTIFICATE: "CA_CERTIFICATE";
  readonly CLIENT_ID: "CLIENT_ID";
  readonly COGNITO_IDENTITY_POOL: "COGNITO_IDENTITY_POOL";
  readonly DEVICE_CERTIFICATE: "DEVICE_CERTIFICATE";
  readonly IAM_ROLE: "IAM_ROLE";
  readonly IOT_POLICY: "IOT_POLICY";
  readonly ISSUER_CERTIFICATE: "ISSUER_CERTIFICATE";
  readonly ROLE_ALIAS: "ROLE_ALIAS";
};
export type ResourceType = (typeof ResourceType)[keyof typeof ResourceType];
export interface NonCompliantResource {
  resourceType?: ResourceType;
  resourceIdentifier?: ResourceIdentifier;
  additionalInfo?: Record<string, string>;
}
export interface RelatedResource {
  resourceType?: ResourceType;
  resourceIdentifier?: ResourceIdentifier;
  additionalInfo?: Record<string, string>;
}
export declare const AuditFindingSeverity: {
  readonly CRITICAL: "CRITICAL";
  readonly HIGH: "HIGH";
  readonly LOW: "LOW";
  readonly MEDIUM: "MEDIUM";
};
export type AuditFindingSeverity =
  (typeof AuditFindingSeverity)[keyof typeof AuditFindingSeverity];
export interface AuditFinding {
  findingId?: string;
  taskId?: string;
  checkName?: string;
  taskStartTime?: Date;
  findingTime?: Date;
  severity?: AuditFindingSeverity;
  nonCompliantResource?: NonCompliantResource;
  relatedResources?: RelatedResource[];
  reasonForNonCompliance?: string;
  reasonForNonComplianceCode?: string;
  isSuppressed?: boolean;
}
export declare const AuditFrequency: {
  readonly BIWEEKLY: "BIWEEKLY";
  readonly DAILY: "DAILY";
  readonly MONTHLY: "MONTHLY";
  readonly WEEKLY: "WEEKLY";
};
export type AuditFrequency =
  (typeof AuditFrequency)[keyof typeof AuditFrequency];
export declare const AuditMitigationActionsExecutionStatus: {
  readonly CANCELED: "CANCELED";
  readonly COMPLETED: "COMPLETED";
  readonly FAILED: "FAILED";
  readonly IN_PROGRESS: "IN_PROGRESS";
  readonly PENDING: "PENDING";
  readonly SKIPPED: "SKIPPED";
};
export type AuditMitigationActionsExecutionStatus =
  (typeof AuditMitigationActionsExecutionStatus)[keyof typeof AuditMitigationActionsExecutionStatus];
export interface AuditMitigationActionExecutionMetadata {
  taskId?: string;
  findingId?: string;
  actionName?: string;
  actionId?: string;
  status?: AuditMitigationActionsExecutionStatus;
  startTime?: Date;
  endTime?: Date;
  errorCode?: string;
  message?: string;
}
export declare const AuditMitigationActionsTaskStatus: {
  readonly CANCELED: "CANCELED";
  readonly COMPLETED: "COMPLETED";
  readonly FAILED: "FAILED";
  readonly IN_PROGRESS: "IN_PROGRESS";
};
export type AuditMitigationActionsTaskStatus =
  (typeof AuditMitigationActionsTaskStatus)[keyof typeof AuditMitigationActionsTaskStatus];
export interface AuditMitigationActionsTaskMetadata {
  taskId?: string;
  startTime?: Date;
  taskStatus?: AuditMitigationActionsTaskStatus;
}
export interface TaskStatisticsForAuditCheck {
  totalFindingsCount?: number;
  failedFindingsCount?: number;
  succeededFindingsCount?: number;
  skippedFindingsCount?: number;
  canceledFindingsCount?: number;
}
export interface AuditMitigationActionsTaskTarget {
  auditTaskId?: string;
  findingIds?: string[];
  auditCheckToReasonCodeFilter?: Record<string, string[]>;
}
export interface AuditNotificationTarget {
  targetArn?: string;
  roleArn?: string;
  enabled?: boolean;
}
export declare const AuditNotificationType: {
  readonly SNS: "SNS";
};
export type AuditNotificationType =
  (typeof AuditNotificationType)[keyof typeof AuditNotificationType];
export interface AuditSuppression {
  checkName: string | undefined;
  resourceIdentifier: ResourceIdentifier | undefined;
  expirationDate?: Date;
  suppressIndefinitely?: boolean;
  description?: string;
}
export declare const AuditTaskStatus: {
  readonly CANCELED: "CANCELED";
  readonly COMPLETED: "COMPLETED";
  readonly FAILED: "FAILED";
  readonly IN_PROGRESS: "IN_PROGRESS";
};
export type AuditTaskStatus =
  (typeof AuditTaskStatus)[keyof typeof AuditTaskStatus];
export declare const AuditTaskType: {
  readonly ON_DEMAND_AUDIT_TASK: "ON_DEMAND_AUDIT_TASK";
  readonly SCHEDULED_AUDIT_TASK: "SCHEDULED_AUDIT_TASK";
};
export type AuditTaskType = (typeof AuditTaskType)[keyof typeof AuditTaskType];
export interface AuditTaskMetadata {
  taskId?: string;
  taskStatus?: AuditTaskStatus;
  taskType?: AuditTaskType;
}
export declare const AuthDecision: {
  readonly ALLOWED: "ALLOWED";
  readonly EXPLICIT_DENY: "EXPLICIT_DENY";
  readonly IMPLICIT_DENY: "IMPLICIT_DENY";
};
export type AuthDecision = (typeof AuthDecision)[keyof typeof AuthDecision];
export interface AuthInfo {
  actionType?: ActionType;
  resources: string[] | undefined;
}
export interface AuthorizerConfig {
  defaultAuthorizerName?: string;
  allowAuthorizerOverride?: boolean;
}
export declare const AuthorizerStatus: {
  readonly ACTIVE: "ACTIVE";
  readonly INACTIVE: "INACTIVE";
};
export type AuthorizerStatus =
  (typeof AuthorizerStatus)[keyof typeof AuthorizerStatus];
export interface AuthorizerDescription {
  authorizerName?: string;
  authorizerArn?: string;
  authorizerFunctionArn?: string;
  tokenKeyName?: string;
  tokenSigningPublicKeys?: Record<string, string>;
  status?: AuthorizerStatus;
  creationDate?: Date;
  lastModifiedDate?: Date;
  signingDisabled?: boolean;
  enableCachingForHttp?: boolean;
}
export interface AuthorizerSummary {
  authorizerName?: string;
  authorizerArn?: string;
}
export interface ExplicitDeny {
  policies?: Policy[];
}
export interface ImplicitDeny {
  policies?: Policy[];
}
export interface Denied {
  implicitDeny?: ImplicitDeny;
  explicitDeny?: ExplicitDeny;
}
export interface AuthResult {
  authInfo?: AuthInfo;
  allowed?: Allowed;
  denied?: Denied;
  authDecision?: AuthDecision;
  missingContextValues?: string[];
}
export declare const AutoRegistrationStatus: {
  readonly DISABLE: "DISABLE";
  readonly ENABLE: "ENABLE";
};
export type AutoRegistrationStatus =
  (typeof AutoRegistrationStatus)[keyof typeof AutoRegistrationStatus];
export interface CancelAuditMitigationActionsTaskRequest {
  taskId: string | undefined;
}
export interface CancelAuditMitigationActionsTaskResponse {}
export interface CancelAuditTaskRequest {
  taskId: string | undefined;
}
export interface CancelAuditTaskResponse {}
export interface CancelCertificateTransferRequest {
  certificateId: string | undefined;
}
export interface CancelDetectMitigationActionsTaskRequest {
  taskId: string | undefined;
}
export interface CancelDetectMitigationActionsTaskResponse {}
export interface CancelJobRequest {
  jobId: string | undefined;
  reasonCode?: string;
  comment?: string;
  force?: boolean;
}
export interface CancelJobResponse {
  jobArn?: string;
  jobId?: string;
  description?: string;
}
export interface CancelJobExecutionRequest {
  jobId: string | undefined;
  thingName: string | undefined;
  force?: boolean;
  expectedVersion?: number;
  statusDetails?: Record<string, string>;
}
export declare class InvalidStateTransitionException extends __BaseException {
  readonly name: "InvalidStateTransitionException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<
      InvalidStateTransitionException,
      __BaseException
    >
  );
}
export interface ClearDefaultAuthorizerRequest {}
export interface ClearDefaultAuthorizerResponse {}
export interface ConfirmTopicRuleDestinationRequest {
  confirmationToken: string | undefined;
}
export interface ConfirmTopicRuleDestinationResponse {}
export declare class ConflictingResourceUpdateException extends __BaseException {
  readonly name: "ConflictingResourceUpdateException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<
      ConflictingResourceUpdateException,
      __BaseException
    >
  );
}
export declare class InternalException extends __BaseException {
  readonly name: "InternalException";
  readonly $fault: "server";
  constructor(opts: __ExceptionOptionType<InternalException, __BaseException>);
}
export interface CreateAuditSuppressionRequest {
  checkName: string | undefined;
  resourceIdentifier: ResourceIdentifier | undefined;
  expirationDate?: Date;
  suppressIndefinitely?: boolean;
  description?: string;
  clientRequestToken?: string;
}
export interface CreateAuditSuppressionResponse {}
export declare class ResourceAlreadyExistsException extends __BaseException {
  readonly name: "ResourceAlreadyExistsException";
  readonly $fault: "client";
  resourceId?: string;
  resourceArn?: string;
  constructor(
    opts: __ExceptionOptionType<ResourceAlreadyExistsException, __BaseException>
  );
}
export interface Tag {
  Key: string | undefined;
  Value?: string;
}
export interface CreateAuthorizerRequest {
  authorizerName: string | undefined;
  authorizerFunctionArn: string | undefined;
  tokenKeyName?: string;
  tokenSigningPublicKeys?: Record<string, string>;
  status?: AuthorizerStatus;
  tags?: Tag[];
  signingDisabled?: boolean;
  enableCachingForHttp?: boolean;
}
export interface CreateAuthorizerResponse {
  authorizerName?: string;
  authorizerArn?: string;
}
export interface BillingGroupProperties {
  billingGroupDescription?: string;
}
export interface CreateBillingGroupRequest {
  billingGroupName: string | undefined;
  billingGroupProperties?: BillingGroupProperties;
  tags?: Tag[];
}
export interface CreateBillingGroupResponse {
  billingGroupName?: string;
  billingGroupArn?: string;
  billingGroupId?: string;
}
export interface CreateCertificateFromCsrRequest {
  certificateSigningRequest: string | undefined;
  setAsActive?: boolean;
}
export interface CreateCertificateFromCsrResponse {
  certificateArn?: string;
  certificateId?: string;
  certificatePem?: string;
}
export declare const CertificateProviderOperation: {
  readonly CreateCertificateFromCsr: "CreateCertificateFromCsr";
};
export type CertificateProviderOperation =
  (typeof CertificateProviderOperation)[keyof typeof CertificateProviderOperation];
export interface CreateCertificateProviderRequest {
  certificateProviderName: string | undefined;
  lambdaFunctionArn: string | undefined;
  accountDefaultForOperations: CertificateProviderOperation[] | undefined;
  clientToken?: string;
  tags?: Tag[];
}
export interface CreateCertificateProviderResponse {
  certificateProviderName?: string;
  certificateProviderArn?: string;
}
export declare const CustomMetricType: {
  readonly IP_ADDRESS_LIST: "ip-address-list";
  readonly NUMBER: "number";
  readonly NUMBER_LIST: "number-list";
  readonly STRING_LIST: "string-list";
};
export type CustomMetricType =
  (typeof CustomMetricType)[keyof typeof CustomMetricType];
export interface CreateCustomMetricRequest {
  metricName: string | undefined;
  displayName?: string;
  metricType: CustomMetricType | undefined;
  tags?: Tag[];
  clientRequestToken?: string;
}
export interface CreateCustomMetricResponse {
  metricName?: string;
  metricArn?: string;
}
export declare const DimensionType: {
  readonly TOPIC_FILTER: "TOPIC_FILTER";
};
export type DimensionType = (typeof DimensionType)[keyof typeof DimensionType];
export interface CreateDimensionRequest {
  name: string | undefined;
  type: DimensionType | undefined;
  stringValues: string[] | undefined;
  tags?: Tag[];
  clientRequestToken?: string;
}
export interface CreateDimensionResponse {
  name?: string;
  arn?: string;
}
export declare class CertificateValidationException extends __BaseException {
  readonly name: "CertificateValidationException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<CertificateValidationException, __BaseException>
  );
}
export interface ServerCertificateConfig {
  enableOCSPCheck?: boolean;
}
export declare const ServiceType: {
  readonly CREDENTIAL_PROVIDER: "CREDENTIAL_PROVIDER";
  readonly DATA: "DATA";
  readonly JOBS: "JOBS";
};
export type ServiceType = (typeof ServiceType)[keyof typeof ServiceType];
export interface TlsConfig {
  securityPolicy?: string;
}
export interface CreateDomainConfigurationRequest {
  domainConfigurationName: string | undefined;
  domainName?: string;
  serverCertificateArns?: string[];
  validationCertificateArn?: string;
  authorizerConfig?: AuthorizerConfig;
  serviceType?: ServiceType;
  tags?: Tag[];
  tlsConfig?: TlsConfig;
  serverCertificateConfig?: ServerCertificateConfig;
}
export interface CreateDomainConfigurationResponse {
  domainConfigurationName?: string;
  domainConfigurationArn?: string;
}
export interface ThingGroupProperties {
  thingGroupDescription?: string;
  attributePayload?: AttributePayload;
}
export interface CreateDynamicThingGroupRequest {
  thingGroupName: string | undefined;
  thingGroupProperties?: ThingGroupProperties;
  indexName?: string;
  queryString: string | undefined;
  queryVersion?: string;
  tags?: Tag[];
}
export interface CreateDynamicThingGroupResponse {
  thingGroupName?: string;
  thingGroupArn?: string;
  thingGroupId?: string;
  indexName?: string;
  queryString?: string;
  queryVersion?: string;
}
export declare class InvalidQueryException extends __BaseException {
  readonly name: "InvalidQueryException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<InvalidQueryException, __BaseException>
  );
}
export declare const FleetMetricUnit: {
  readonly Bits: "Bits";
  readonly BitsSecond: "Bits/Second";
  readonly Bytes: "Bytes";
  readonly BytesSecond: "Bytes/Second";
  readonly Count: "Count";
  readonly CountSecond: "Count/Second";
  readonly Gigabits: "Gigabits";
  readonly GigabitsSecond: "Gigabits/Second";
  readonly Gigabytes: "Gigabytes";
  readonly GigabytesSecond: "Gigabytes/Second";
  readonly Kilobits: "Kilobits";
  readonly KilobitsSecond: "Kilobits/Second";
  readonly Kilobytes: "Kilobytes";
  readonly KilobytesSecond: "Kilobytes/Second";
  readonly Megabits: "Megabits";
  readonly MegabitsSecond: "Megabits/Second";
  readonly Megabytes: "Megabytes";
  readonly MegabytesSecond: "Megabytes/Second";
  readonly Microseconds: "Microseconds";
  readonly Milliseconds: "Milliseconds";
  readonly None: "None";
  readonly Percent: "Percent";
  readonly Seconds: "Seconds";
  readonly Terabits: "Terabits";
  readonly TerabitsSecond: "Terabits/Second";
  readonly Terabytes: "Terabytes";
  readonly TerabytesSecond: "Terabytes/Second";
};
export type FleetMetricUnit =
  (typeof FleetMetricUnit)[keyof typeof FleetMetricUnit];
export interface CreateFleetMetricRequest {
  metricName: string | undefined;
  queryString: string | undefined;
  aggregationType: AggregationType | undefined;
  period: number | undefined;
  aggregationField: string | undefined;
  description?: string;
  queryVersion?: string;
  indexName?: string;
  unit?: FleetMetricUnit;
  tags?: Tag[];
}
export interface CreateFleetMetricResponse {
  metricName?: string;
  metricArn?: string;
}
export declare class IndexNotReadyException extends __BaseException {
  readonly name: "IndexNotReadyException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<IndexNotReadyException, __BaseException>
  );
}
export declare class InvalidAggregationException extends __BaseException {
  readonly name: "InvalidAggregationException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<InvalidAggregationException, __BaseException>
  );
}
export declare const RetryableFailureType: {
  readonly ALL: "ALL";
  readonly FAILED: "FAILED";
  readonly TIMED_OUT: "TIMED_OUT";
};
export type RetryableFailureType =
  (typeof RetryableFailureType)[keyof typeof RetryableFailureType];
export interface RetryCriteria {
  failureType: RetryableFailureType | undefined;
  numberOfRetries: number | undefined;
}
export interface JobExecutionsRetryConfig {
  criteriaList: RetryCriteria[] | undefined;
}
export interface RateIncreaseCriteria {
  numberOfNotifiedThings?: number;
  numberOfSucceededThings?: number;
}
export interface ExponentialRolloutRate {
  baseRatePerMinute: number | undefined;
  incrementFactor: number | undefined;
  rateIncreaseCriteria: RateIncreaseCriteria | undefined;
}
export interface JobExecutionsRolloutConfig {
  maximumPerMinute?: number;
  exponentialRate?: ExponentialRolloutRate;
}
export interface PresignedUrlConfig {
  roleArn?: string;
  expiresInSec?: number;
}
export declare const JobEndBehavior: {
  readonly CANCEL: "CANCEL";
  readonly FORCE_CANCEL: "FORCE_CANCEL";
  readonly STOP_ROLLOUT: "STOP_ROLLOUT";
};
export type JobEndBehavior =
  (typeof JobEndBehavior)[keyof typeof JobEndBehavior];
export interface MaintenanceWindow {
  startTime: string | undefined;
  durationInMinutes: number | undefined;
}
export interface SchedulingConfig {
  startTime?: string;
  endTime?: string;
  endBehavior?: JobEndBehavior;
  maintenanceWindows?: MaintenanceWindow[];
}
export declare const TargetSelection: {
  readonly CONTINUOUS: "CONTINUOUS";
  readonly SNAPSHOT: "SNAPSHOT";
};
export type TargetSelection =
  (typeof TargetSelection)[keyof typeof TargetSelection];
export interface TimeoutConfig {
  inProgressTimeoutInMinutes?: number;
}
export interface CreateJobRequest {
  jobId: string | undefined;
  targets: string[] | undefined;
  documentSource?: string;
  document?: string;
  description?: string;
  presignedUrlConfig?: PresignedUrlConfig;
  targetSelection?: TargetSelection;
  jobExecutionsRolloutConfig?: JobExecutionsRolloutConfig;
  abortConfig?: AbortConfig;
  timeoutConfig?: TimeoutConfig;
  tags?: Tag[];
  namespaceId?: string;
  jobTemplateArn?: string;
  jobExecutionsRetryConfig?: JobExecutionsRetryConfig;
  documentParameters?: Record<string, string>;
  schedulingConfig?: SchedulingConfig;
  destinationPackageVersions?: string[];
}
export interface CreateJobResponse {
  jobArn?: string;
  jobId?: string;
  description?: string;
}
export declare class ConflictException extends __BaseException {
  readonly name: "ConflictException";
  readonly $fault: "client";
  resourceId?: string;
  constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
}
export interface CreateJobTemplateRequest {
  jobTemplateId: string | undefined;
  jobArn?: string;
  documentSource?: string;
  document?: string;
  description: string | undefined;
  presignedUrlConfig?: PresignedUrlConfig;
  jobExecutionsRolloutConfig?: JobExecutionsRolloutConfig;
  abortConfig?: AbortConfig;
  timeoutConfig?: TimeoutConfig;
  tags?: Tag[];
  jobExecutionsRetryConfig?: JobExecutionsRetryConfig;
  maintenanceWindows?: MaintenanceWindow[];
  destinationPackageVersions?: string[];
}
export interface CreateJobTemplateResponse {
  jobTemplateArn?: string;
  jobTemplateId?: string;
}
export interface CreateKeysAndCertificateRequest {
  setAsActive?: boolean;
}
export interface KeyPair {
  PublicKey?: string;
  PrivateKey?: string;
}
export interface CreateKeysAndCertificateResponse {
  certificateArn?: string;
  certificateId?: string;
  certificatePem?: string;
  keyPair?: KeyPair;
}
export declare const LogLevel: {
  readonly DEBUG: "DEBUG";
  readonly DISABLED: "DISABLED";
  readonly ERROR: "ERROR";
  readonly INFO: "INFO";
  readonly WARN: "WARN";
};
export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
export interface EnableIoTLoggingParams {
  roleArnForLogging: string | undefined;
  logLevel: LogLevel | undefined;
}
export interface PublishFindingToSnsParams {
  topicArn: string | undefined;
}
export declare const PolicyTemplateName: {
  readonly BLANK_POLICY: "BLANK_POLICY";
};
export type PolicyTemplateName =
  (typeof PolicyTemplateName)[keyof typeof PolicyTemplateName];
export interface ReplaceDefaultPolicyVersionParams {
  templateName: PolicyTemplateName | undefined;
}
export declare const CACertificateUpdateAction: {
  readonly DEACTIVATE: "DEACTIVATE";
};
export type CACertificateUpdateAction =
  (typeof CACertificateUpdateAction)[keyof typeof CACertificateUpdateAction];
export interface UpdateCACertificateParams {
  action: CACertificateUpdateAction | undefined;
}
export declare const DeviceCertificateUpdateAction: {
  readonly DEACTIVATE: "DEACTIVATE";
};
export type DeviceCertificateUpdateAction =
  (typeof DeviceCertificateUpdateAction)[keyof typeof DeviceCertificateUpdateAction];
export interface UpdateDeviceCertificateParams {
  action: DeviceCertificateUpdateAction | undefined;
}
export interface MitigationActionParams {
  updateDeviceCertificateParams?: UpdateDeviceCertificateParams;
  updateCACertificateParams?: UpdateCACertificateParams;
  addThingsToThingGroupParams?: AddThingsToThingGroupParams;
  replaceDefaultPolicyVersionParams?: ReplaceDefaultPolicyVersionParams;
  enableIoTLoggingParams?: EnableIoTLoggingParams;
  publishFindingToSnsParams?: PublishFindingToSnsParams;
}
export interface CreateMitigationActionRequest {
  actionName: string | undefined;
  roleArn: string | undefined;
  actionParams: MitigationActionParams | undefined;
  tags?: Tag[];
}
export interface CreateMitigationActionResponse {
  actionArn?: string;
  actionId?: string;
}
export declare const AwsJobAbortCriteriaAbortAction: {
  readonly CANCEL: "CANCEL";
};
export type AwsJobAbortCriteriaAbortAction =
  (typeof AwsJobAbortCriteriaAbortAction)[keyof typeof AwsJobAbortCriteriaAbortAction];
export declare const AwsJobAbortCriteriaFailureType: {
  readonly ALL: "ALL";
  readonly FAILED: "FAILED";
  readonly REJECTED: "REJECTED";
  readonly TIMED_OUT: "TIMED_OUT";
};
export type AwsJobAbortCriteriaFailureType =
  (typeof AwsJobAbortCriteriaFailureType)[keyof typeof AwsJobAbortCriteriaFailureType];
export interface AwsJobAbortCriteria {
  failureType: AwsJobAbortCriteriaFailureType | undefined;
  action: AwsJobAbortCriteriaAbortAction | undefined;
  thresholdPercentage: number | undefined;
  minNumberOfExecutedThings: number | undefined;
}
export interface AwsJobAbortConfig {
  abortCriteriaList: AwsJobAbortCriteria[] | undefined;
}
export interface AwsJobRateIncreaseCriteria {
  numberOfNotifiedThings?: number;
  numberOfSucceededThings?: number;
}
export interface AwsJobExponentialRolloutRate {
  baseRatePerMinute: number | undefined;
  incrementFactor: number | undefined;
  rateIncreaseCriteria: AwsJobRateIncreaseCriteria | undefined;
}
export interface AwsJobExecutionsRolloutConfig {
  maximumPerMinute?: number;
  exponentialRate?: AwsJobExponentialRolloutRate;
}
export interface AwsJobPresignedUrlConfig {
  expiresInSec?: number;
}
export interface AwsJobTimeoutConfig {
  inProgressTimeoutInMinutes?: number;
}
export interface CodeSigningCertificateChain {
  certificateName?: string;
  inlineDocument?: string;
}
export interface CodeSigningSignature {
  inlineDocument?: Uint8Array;
}
export interface CustomCodeSigning {
  signature?: CodeSigningSignature;
  certificateChain?: CodeSigningCertificateChain;
  hashAlgorithm?: string;
  signatureAlgorithm?: string;
}
export interface S3Destination {
  bucket?: string;
  prefix?: string;
}
export interface Destination {
  s3Destination?: S3Destination;
}
export interface SigningProfileParameter {
  certificateArn?: string;
  platform?: string;
  certificatePathOnDevice?: string;
}
export interface StartSigningJobParameter {
  signingProfileParameter?: SigningProfileParameter;
  signingProfileName?: string;
  destination?: Destination;
}
export interface CodeSigning {
  awsSignerJobId?: string;
  startSigningJobParameter?: StartSigningJobParameter;
  customCodeSigning?: CustomCodeSigning;
}
export interface S3Location {
  bucket?: string;
  key?: string;
  version?: string;
}
export interface _Stream {
  streamId?: string;
  fileId?: number;
}
export interface FileLocation {
  stream?: _Stream;
  s3Location?: S3Location;
}
export interface OTAUpdateFile {
  fileName?: string;
  fileType?: number;
  fileVersion?: string;
  fileLocation?: FileLocation;
  codeSigning?: CodeSigning;
  attributes?: Record<string, string>;
}
export declare const Protocol: {
  readonly HTTP: "HTTP";
  readonly MQTT: "MQTT";
};
export type Protocol = (typeof Protocol)[keyof typeof Protocol];
export interface CreateOTAUpdateRequest {
  otaUpdateId: string | undefined;
  description?: string;
  targets: string[] | undefined;
  protocols?: Protocol[];
  targetSelection?: TargetSelection;
  awsJobExecutionsRolloutConfig?: AwsJobExecutionsRolloutConfig;
  awsJobPresignedUrlConfig?: AwsJobPresignedUrlConfig;
  awsJobAbortConfig?: AwsJobAbortConfig;
  awsJobTimeoutConfig?: AwsJobTimeoutConfig;
  files: OTAUpdateFile[] | undefined;
  roleArn: string | undefined;
  additionalParameters?: Record<string, string>;
  tags?: Tag[];
}
export declare const OTAUpdateStatus: {
  readonly CREATE_COMPLETE: "CREATE_COMPLETE";
  readonly CREATE_FAILED: "CREATE_FAILED";
  readonly CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS";
  readonly CREATE_PENDING: "CREATE_PENDING";
  readonly DELETE_FAILED: "DELETE_FAILED";
  readonly DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS";
};
export type OTAUpdateStatus =
  (typeof OTAUpdateStatus)[keyof typeof OTAUpdateStatus];
export interface CreateOTAUpdateResponse {
  otaUpdateId?: string;
  awsIotJobId?: string;
  otaUpdateArn?: string;
  awsIotJobArn?: string;
  otaUpdateStatus?: OTAUpdateStatus;
}
export interface CreatePackageRequest {
  packageName: string | undefined;
  description?: string;
  tags?: Record<string, string>;
  clientToken?: string;
}
export interface CreatePackageResponse {
  packageName?: string;
  packageArn?: string;
  description?: string;
}
export declare class InternalServerException extends __BaseException {
  readonly name: "InternalServerException";
  readonly $fault: "server";
  constructor(
    opts: __ExceptionOptionType<InternalServerException, __BaseException>
  );
}
export declare class ServiceQuotaExceededException extends __BaseException {
  readonly name: "ServiceQuotaExceededException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>
  );
}
export declare class ValidationException extends __BaseException {
  readonly name: "ValidationException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<ValidationException, __BaseException>
  );
}
export interface CreatePackageVersionRequest {
  packageName: string | undefined;
  versionName: string | undefined;
  description?: string;
  attributes?: Record<string, string>;
  tags?: Record<string, string>;
  clientToken?: string;
}
export declare const PackageVersionStatus: {
  readonly DEPRECATED: "DEPRECATED";
  readonly DRAFT: "DRAFT";
  readonly PUBLISHED: "PUBLISHED";
};
export type PackageVersionStatus =
  (typeof PackageVersionStatus)[keyof typeof PackageVersionStatus];
export interface CreatePackageVersionResponse {
  packageVersionArn?: string;
  packageName?: string;
  versionName?: string;
  description?: string;
  attributes?: Record<string, string>;
  status?: PackageVersionStatus;
  errorReason?: string;
}
export interface CreatePolicyRequest {
  policyName: string | undefined;
  policyDocument: string | undefined;
  tags?: Tag[];
}
export interface CreatePolicyResponse {
  policyName?: string;
  policyArn?: string;
  policyDocument?: string;
  policyVersionId?: string;
}
export declare class MalformedPolicyException extends __BaseException {
  readonly name: "MalformedPolicyException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<MalformedPolicyException, __BaseException>
  );
}
export interface CreatePolicyVersionRequest {
  policyName: string | undefined;
  policyDocument: string | undefined;
  setAsDefault?: boolean;
}
export interface CreatePolicyVersionResponse {
  policyArn?: string;
  policyDocument?: string;
  policyVersionId?: string;
  isDefaultVersion?: boolean;
}
export declare class VersionsLimitExceededException extends __BaseException {
  readonly name: "VersionsLimitExceededException";
  readonly $fault: "client";
  constructor(
    opts: __ExceptionOptionType<VersionsLimitExceededException, __BaseException>
  );
}
export interface CreateProvisioningClaimRequest {
  templateName: string | undefined;
}
export interface CreateProvisioningClaimResponse {
  certificateId?: string;
  certificatePem?: string;
  keyPair?: KeyPair;
  expiration?: Date;
}
export interface ProvisioningHook {
  payloadVersion?: string;
  targetArn: string | undefined;
}
export declare const TemplateType: {
  readonly FLEET_PROVISIONING: "FLEET_PROVISIONING";
  readonly JITP: "JITP";
};
export type TemplateType = (typeof TemplateType)[keyof typeof TemplateType];
export interface CreateProvisioningTemplateRequest {
  templateName: string | undefined;
  description?: string;
  templateBody: string | undefined;
  enabled?: boolean;
  provisioningRoleArn: string | undefined;
  preProvisioningHook?: ProvisioningHook;
  tags?: Tag[];
  type?: TemplateType;
}
export interface CreateProvisioningTemplateResponse {
  templateArn?: string;
  templateName?: string;
  defaultVersionId?: number;
}
export interface CreateProvisioningTemplateVersionRequest {
  templateName: string | undefined;
  templateBody: string | undefined;
  setAsDefault?: boolean;
}
export interface CreateProvisioningTemplateVersionResponse {
  templateArn?: string;
  templateName?: string;
  versionId?: number;
  isDefaultVersion?: boolean;
}
export interface CreateRoleAliasRequest {
  roleAlias: string | undefined;
  roleArn: string | undefined;
  credentialDurationSeconds?: number;
  tags?: Tag[];
}
export interface CreateRoleAliasResponse {
  roleAlias?: string;
  roleAliasArn?: string;
}
export declare const DayOfWeek: {
  readonly FRI: "FRI";
  readonly MON: "MON";
  readonly SAT: "SAT";
  readonly SUN: "SUN";
  readonly THU: "THU";
  readonly TUE: "TUE";
  readonly WED: "WED";
};
export type DayOfWeek = (typeof DayOfWeek)[keyof typeof DayOfWeek];
export interface CreateScheduledAuditRequest {
  frequency: AuditFrequency | undefined;
  dayOfMonth?: string;
  dayOfWeek?: DayOfWeek;
  targetCheckNames: string[] | undefined;
  scheduledAuditName: string | undefined;
  tags?: Tag[];
}
export interface CreateScheduledAuditResponse {
  scheduledAuditArn?: string;
}
export interface MetricsExportConfig {
  mqttTopic: string | undefined;
  roleArn: string | undefined;
}
export interface CreateSecurityProfileRequest {
  securityProfileName: string | undefined;
  securityProfileDescription?: string;
  behaviors?: Behavior[];
  alertTargets?: Partial<Record<AlertTargetType, AlertTarget>>;
  additionalMetricsToRetain?: string[];
  additionalMetricsToRetainV2?: MetricToRetain[];
  tags?: Tag[];
  metricsExportConfig?: MetricsExportConfig;
}
export interface CreateSecurityProfileResponse {
  securityProfileName?: string;
  securityProfileArn?: string;
}
export interface StreamFile {
  fileId?: number;
  s3Location?: S3Location;
}
export interface CreateStreamRequest {
  streamId: string | undefined;
  description?: string;
  files: StreamFile[] | undefined;
  roleArn: string | undefined;
  tags?: Tag[];
}
export interface CreateStreamResponse {
  streamId?: string;
  streamArn?: string;
  description?: string;
  streamVersion?: number;
}
export interface CreateThingRequest {
  thingName: string | undefined;
  thingTypeName?: string;
  attributePayload?: AttributePayload;
  billingGroupName?: string;
}
export interface CreateThingResponse {
  thingName?: string;
  thingArn?: string;
  thingId?: string;
}
export interface CreateThingGroupRequest {
  thingGroupName: string | undefined;
  parentGroupName?: string;
  thingGroupProperties?: ThingGroupProperties;
  tags?: Tag[];
}
export interface CreateThingGroupResponse {
  thingGroupName?: string;
  thingGroupArn?: string;
  thingGroupId?: string;
}
export interface ThingTypeProperties {
  thingTypeDescription?: string;
  searchableAttributes?: string[];
}
export interface CreateThingTypeRequest {
  thingTypeName: string | undefined;
  thingTypeProperties?: ThingTypeProperties;
  tags?: Tag[];
}
exp