@aws-sdk/client-greengrass 3.50.0 → 3.51.0

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

@@ -0,0 +1,2786 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface ConnectivityInfo {
+    
+    HostAddress?: string;
+    
+    Id?: string;
+    
+    Metadata?: string;
+    
+    PortNumber?: number;
+}
+export declare namespace ConnectivityInfo {
+    
+    const filterSensitiveLog: (obj: ConnectivityInfo) => any;
+}
+
+export interface Connector {
+    
+    ConnectorArn: string | undefined;
+    
+    Id: string | undefined;
+    
+    Parameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Connector {
+    
+    const filterSensitiveLog: (obj: Connector) => any;
+}
+
+export interface Core {
+    
+    CertificateArn: string | undefined;
+    
+    Id: string | undefined;
+    
+    SyncShadow?: boolean;
+    
+    ThingArn: string | undefined;
+}
+export declare namespace Core {
+    
+    const filterSensitiveLog: (obj: Core) => any;
+}
+
+export interface DefinitionInformation {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace DefinitionInformation {
+    
+    const filterSensitiveLog: (obj: DefinitionInformation) => any;
+}
+
+export interface Device {
+    
+    CertificateArn: string | undefined;
+    
+    Id: string | undefined;
+    
+    SyncShadow?: boolean;
+    
+    ThingArn: string | undefined;
+}
+export declare namespace Device {
+    
+    const filterSensitiveLog: (obj: Device) => any;
+}
+export declare enum EncodingType {
+    binary = "binary",
+    json = "json"
+}
+export declare enum FunctionIsolationMode {
+    GreengrassContainer = "GreengrassContainer",
+    NoContainer = "NoContainer"
+}
+
+export interface FunctionRunAsConfig {
+    
+    Gid?: number;
+    
+    Uid?: number;
+}
+export declare namespace FunctionRunAsConfig {
+    
+    const filterSensitiveLog: (obj: FunctionRunAsConfig) => any;
+}
+
+export interface FunctionExecutionConfig {
+    
+    IsolationMode?: FunctionIsolationMode | string;
+    
+    RunAs?: FunctionRunAsConfig;
+}
+export declare namespace FunctionExecutionConfig {
+    
+    const filterSensitiveLog: (obj: FunctionExecutionConfig) => any;
+}
+export declare enum Permission {
+    ro = "ro",
+    rw = "rw"
+}
+
+export interface ResourceAccessPolicy {
+    
+    Permission?: Permission | string;
+    
+    ResourceId: string | undefined;
+}
+export declare namespace ResourceAccessPolicy {
+    
+    const filterSensitiveLog: (obj: ResourceAccessPolicy) => any;
+}
+
+export interface FunctionConfigurationEnvironment {
+    
+    AccessSysfs?: boolean;
+    
+    Execution?: FunctionExecutionConfig;
+    
+    ResourceAccessPolicies?: ResourceAccessPolicy[];
+    
+    Variables?: {
+        [key: string]: string;
+    };
+}
+export declare namespace FunctionConfigurationEnvironment {
+    
+    const filterSensitiveLog: (obj: FunctionConfigurationEnvironment) => any;
+}
+
+export interface FunctionConfiguration {
+    
+    EncodingType?: EncodingType | string;
+    
+    Environment?: FunctionConfigurationEnvironment;
+    
+    ExecArgs?: string;
+    
+    Executable?: string;
+    
+    MemorySize?: number;
+    
+    Pinned?: boolean;
+    
+    Timeout?: number;
+}
+export declare namespace FunctionConfiguration {
+    
+    const filterSensitiveLog: (obj: FunctionConfiguration) => any;
+}
+
+export interface Function {
+    
+    FunctionArn?: string;
+    
+    FunctionConfiguration?: FunctionConfiguration;
+    
+    Id: string | undefined;
+}
+export declare namespace Function {
+    
+    const filterSensitiveLog: (obj: Function) => any;
+}
+
+export interface GroupCertificateAuthorityProperties {
+    
+    GroupCertificateAuthorityArn?: string;
+    
+    GroupCertificateAuthorityId?: string;
+}
+export declare namespace GroupCertificateAuthorityProperties {
+    
+    const filterSensitiveLog: (obj: GroupCertificateAuthorityProperties) => any;
+}
+
+export interface GroupInformation {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+}
+export declare namespace GroupInformation {
+    
+    const filterSensitiveLog: (obj: GroupInformation) => any;
+}
+export declare enum LoggerComponent {
+    GreengrassSystem = "GreengrassSystem",
+    Lambda = "Lambda"
+}
+export declare enum LoggerLevel {
+    DEBUG = "DEBUG",
+    ERROR = "ERROR",
+    FATAL = "FATAL",
+    INFO = "INFO",
+    WARN = "WARN"
+}
+export declare enum LoggerType {
+    AWSCloudWatch = "AWSCloudWatch",
+    FileSystem = "FileSystem"
+}
+
+export interface Logger {
+    
+    Component: LoggerComponent | string | undefined;
+    
+    Id: string | undefined;
+    
+    Level: LoggerLevel | string | undefined;
+    
+    Space?: number;
+    
+    Type: LoggerType | string | undefined;
+}
+export declare namespace Logger {
+    
+    const filterSensitiveLog: (obj: Logger) => any;
+}
+
+export interface GroupOwnerSetting {
+    
+    AutoAddGroupOwner?: boolean;
+    
+    GroupOwner?: string;
+}
+export declare namespace GroupOwnerSetting {
+    
+    const filterSensitiveLog: (obj: GroupOwnerSetting) => any;
+}
+
+export interface LocalDeviceResourceData {
+    
+    GroupOwnerSetting?: GroupOwnerSetting;
+    
+    SourcePath?: string;
+}
+export declare namespace LocalDeviceResourceData {
+    
+    const filterSensitiveLog: (obj: LocalDeviceResourceData) => any;
+}
+
+export interface LocalVolumeResourceData {
+    
+    DestinationPath?: string;
+    
+    GroupOwnerSetting?: GroupOwnerSetting;
+    
+    SourcePath?: string;
+}
+export declare namespace LocalVolumeResourceData {
+    
+    const filterSensitiveLog: (obj: LocalVolumeResourceData) => any;
+}
+
+export interface ResourceDownloadOwnerSetting {
+    
+    GroupOwner: string | undefined;
+    
+    GroupPermission: Permission | string | undefined;
+}
+export declare namespace ResourceDownloadOwnerSetting {
+    
+    const filterSensitiveLog: (obj: ResourceDownloadOwnerSetting) => any;
+}
+
+export interface S3MachineLearningModelResourceData {
+    
+    DestinationPath?: string;
+    
+    OwnerSetting?: ResourceDownloadOwnerSetting;
+    
+    S3Uri?: string;
+}
+export declare namespace S3MachineLearningModelResourceData {
+    
+    const filterSensitiveLog: (obj: S3MachineLearningModelResourceData) => any;
+}
+
+export interface SageMakerMachineLearningModelResourceData {
+    
+    DestinationPath?: string;
+    
+    OwnerSetting?: ResourceDownloadOwnerSetting;
+    
+    SageMakerJobArn?: string;
+}
+export declare namespace SageMakerMachineLearningModelResourceData {
+    
+    const filterSensitiveLog: (obj: SageMakerMachineLearningModelResourceData) => any;
+}
+
+export interface SecretsManagerSecretResourceData {
+    
+    ARN?: string;
+    
+    AdditionalStagingLabelsToDownload?: string[];
+}
+export declare namespace SecretsManagerSecretResourceData {
+    
+    const filterSensitiveLog: (obj: SecretsManagerSecretResourceData) => any;
+}
+
+export interface ResourceDataContainer {
+    
+    LocalDeviceResourceData?: LocalDeviceResourceData;
+    
+    LocalVolumeResourceData?: LocalVolumeResourceData;
+    
+    S3MachineLearningModelResourceData?: S3MachineLearningModelResourceData;
+    
+    SageMakerMachineLearningModelResourceData?: SageMakerMachineLearningModelResourceData;
+    
+    SecretsManagerSecretResourceData?: SecretsManagerSecretResourceData;
+}
+export declare namespace ResourceDataContainer {
+    
+    const filterSensitiveLog: (obj: ResourceDataContainer) => any;
+}
+
+export interface Resource {
+    
+    Id: string | undefined;
+    
+    Name: string | undefined;
+    
+    ResourceDataContainer: ResourceDataContainer | undefined;
+}
+export declare namespace Resource {
+    
+    const filterSensitiveLog: (obj: Resource) => any;
+}
+
+export interface Subscription {
+    
+    Id: string | undefined;
+    
+    Source: string | undefined;
+    
+    Subject: string | undefined;
+    
+    Target: string | undefined;
+}
+export declare namespace Subscription {
+    
+    const filterSensitiveLog: (obj: Subscription) => any;
+}
+
+export interface VersionInformation {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    Version?: string;
+}
+export declare namespace VersionInformation {
+    
+    const filterSensitiveLog: (obj: VersionInformation) => any;
+}
+export interface AssociateRoleToGroupRequest {
+    
+    GroupId: string | undefined;
+    
+    RoleArn: string | undefined;
+}
+export declare namespace AssociateRoleToGroupRequest {
+    
+    const filterSensitiveLog: (obj: AssociateRoleToGroupRequest) => any;
+}
+export interface AssociateRoleToGroupResponse {
+    
+    AssociatedAt?: string;
+}
+export declare namespace AssociateRoleToGroupResponse {
+    
+    const filterSensitiveLog: (obj: AssociateRoleToGroupResponse) => any;
+}
+
+export interface ErrorDetail {
+    
+    DetailedErrorCode?: string;
+    
+    DetailedErrorMessage?: string;
+}
+export declare namespace ErrorDetail {
+    
+    const filterSensitiveLog: (obj: ErrorDetail) => any;
+}
+
+export interface BadRequestException extends __SmithyException, $MetadataBearer {
+    name: "BadRequestException";
+    $fault: "client";
+    
+    ErrorDetails?: ErrorDetail[];
+    
+    Message?: string;
+}
+
+export interface InternalServerErrorException extends __SmithyException, $MetadataBearer {
+    name: "InternalServerErrorException";
+    $fault: "server";
+    
+    ErrorDetails?: ErrorDetail[];
+    
+    Message?: string;
+}
+export interface AssociateServiceRoleToAccountRequest {
+    
+    RoleArn: string | undefined;
+}
+export declare namespace AssociateServiceRoleToAccountRequest {
+    
+    const filterSensitiveLog: (obj: AssociateServiceRoleToAccountRequest) => any;
+}
+export interface AssociateServiceRoleToAccountResponse {
+    
+    AssociatedAt?: string;
+}
+export declare namespace AssociateServiceRoleToAccountResponse {
+    
+    const filterSensitiveLog: (obj: AssociateServiceRoleToAccountResponse) => any;
+}
+
+export interface BulkDeployment {
+    
+    BulkDeploymentArn?: string;
+    
+    BulkDeploymentId?: string;
+    
+    CreatedAt?: string;
+}
+export declare namespace BulkDeployment {
+    
+    const filterSensitiveLog: (obj: BulkDeployment) => any;
+}
+
+export interface BulkDeploymentMetrics {
+    
+    InvalidInputRecords?: number;
+    
+    RecordsProcessed?: number;
+    
+    RetryAttempts?: number;
+}
+export declare namespace BulkDeploymentMetrics {
+    
+    const filterSensitiveLog: (obj: BulkDeploymentMetrics) => any;
+}
+export declare enum DeploymentType {
+    ForceResetDeployment = "ForceResetDeployment",
+    NewDeployment = "NewDeployment",
+    Redeployment = "Redeployment",
+    ResetDeployment = "ResetDeployment"
+}
+
+export interface BulkDeploymentResult {
+    
+    CreatedAt?: string;
+    
+    DeploymentArn?: string;
+    
+    DeploymentId?: string;
+    
+    DeploymentStatus?: string;
+    
+    DeploymentType?: DeploymentType | string;
+    
+    ErrorDetails?: ErrorDetail[];
+    
+    ErrorMessage?: string;
+    
+    GroupArn?: string;
+}
+export declare namespace BulkDeploymentResult {
+    
+    const filterSensitiveLog: (obj: BulkDeploymentResult) => any;
+}
+export declare enum BulkDeploymentStatus {
+    Completed = "Completed",
+    Failed = "Failed",
+    Initializing = "Initializing",
+    Running = "Running",
+    Stopped = "Stopped",
+    Stopping = "Stopping"
+}
+export declare enum ConfigurationSyncStatus {
+    InSync = "InSync",
+    OutOfSync = "OutOfSync"
+}
+
+export interface ConnectorDefinitionVersion {
+    
+    Connectors?: Connector[];
+}
+export declare namespace ConnectorDefinitionVersion {
+    
+    const filterSensitiveLog: (obj: ConnectorDefinitionVersion) => any;
+}
+
+export interface CoreDefinitionVersion {
+    
+    Cores?: Core[];
+}
+export declare namespace CoreDefinitionVersion {
+    
+    const filterSensitiveLog: (obj: CoreDefinitionVersion) => any;
+}
+export interface CreateConnectorDefinitionRequest {
+    
+    AmznClientToken?: string;
+    
+    InitialVersion?: ConnectorDefinitionVersion;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateConnectorDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: CreateConnectorDefinitionRequest) => any;
+}
+export interface CreateConnectorDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+}
+export declare namespace CreateConnectorDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: CreateConnectorDefinitionResponse) => any;
+}
+export interface CreateConnectorDefinitionVersionRequest {
+    
+    AmznClientToken?: string;
+    
+    ConnectorDefinitionId: string | undefined;
+    
+    Connectors?: Connector[];
+}
+export declare namespace CreateConnectorDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateConnectorDefinitionVersionRequest) => any;
+}
+export interface CreateConnectorDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    Version?: string;
+}
+export declare namespace CreateConnectorDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: CreateConnectorDefinitionVersionResponse) => any;
+}
+
+export interface CreateCoreDefinitionRequest {
+    
+    AmznClientToken?: string;
+    
+    InitialVersion?: CoreDefinitionVersion;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateCoreDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: CreateCoreDefinitionRequest) => any;
+}
+export interface CreateCoreDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+}
+export declare namespace CreateCoreDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: CreateCoreDefinitionResponse) => any;
+}
+export interface CreateCoreDefinitionVersionRequest {
+    
+    AmznClientToken?: string;
+    
+    CoreDefinitionId: string | undefined;
+    
+    Cores?: Core[];
+}
+export declare namespace CreateCoreDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateCoreDefinitionVersionRequest) => any;
+}
+export interface CreateCoreDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    Version?: string;
+}
+export declare namespace CreateCoreDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: CreateCoreDefinitionVersionResponse) => any;
+}
+export interface CreateDeploymentRequest {
+    
+    AmznClientToken?: string;
+    
+    DeploymentId?: string;
+    
+    DeploymentType: DeploymentType | string | undefined;
+    
+    GroupId: string | undefined;
+    
+    GroupVersionId?: string;
+}
+export declare namespace CreateDeploymentRequest {
+    
+    const filterSensitiveLog: (obj: CreateDeploymentRequest) => any;
+}
+export interface CreateDeploymentResponse {
+    
+    DeploymentArn?: string;
+    
+    DeploymentId?: string;
+}
+export declare namespace CreateDeploymentResponse {
+    
+    const filterSensitiveLog: (obj: CreateDeploymentResponse) => any;
+}
+
+export interface DeviceDefinitionVersion {
+    
+    Devices?: Device[];
+}
+export declare namespace DeviceDefinitionVersion {
+    
+    const filterSensitiveLog: (obj: DeviceDefinitionVersion) => any;
+}
+export interface CreateDeviceDefinitionRequest {
+    
+    AmznClientToken?: string;
+    
+    InitialVersion?: DeviceDefinitionVersion;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateDeviceDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: CreateDeviceDefinitionRequest) => any;
+}
+export interface CreateDeviceDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+}
+export declare namespace CreateDeviceDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: CreateDeviceDefinitionResponse) => any;
+}
+export interface CreateDeviceDefinitionVersionRequest {
+    
+    AmznClientToken?: string;
+    
+    DeviceDefinitionId: string | undefined;
+    
+    Devices?: Device[];
+}
+export declare namespace CreateDeviceDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateDeviceDefinitionVersionRequest) => any;
+}
+export interface CreateDeviceDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    Version?: string;
+}
+export declare namespace CreateDeviceDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: CreateDeviceDefinitionVersionResponse) => any;
+}
+
+export interface FunctionDefaultExecutionConfig {
+    
+    IsolationMode?: FunctionIsolationMode | string;
+    
+    RunAs?: FunctionRunAsConfig;
+}
+export declare namespace FunctionDefaultExecutionConfig {
+    
+    const filterSensitiveLog: (obj: FunctionDefaultExecutionConfig) => any;
+}
+
+export interface FunctionDefaultConfig {
+    
+    Execution?: FunctionDefaultExecutionConfig;
+}
+export declare namespace FunctionDefaultConfig {
+    
+    const filterSensitiveLog: (obj: FunctionDefaultConfig) => any;
+}
+
+export interface FunctionDefinitionVersion {
+    
+    DefaultConfig?: FunctionDefaultConfig;
+    
+    Functions?: Function[];
+}
+export declare namespace FunctionDefinitionVersion {
+    
+    const filterSensitiveLog: (obj: FunctionDefinitionVersion) => any;
+}
+export interface CreateFunctionDefinitionRequest {
+    
+    AmznClientToken?: string;
+    
+    InitialVersion?: FunctionDefinitionVersion;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateFunctionDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: CreateFunctionDefinitionRequest) => any;
+}
+export interface CreateFunctionDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+}
+export declare namespace CreateFunctionDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: CreateFunctionDefinitionResponse) => any;
+}
+
+export interface CreateFunctionDefinitionVersionRequest {
+    
+    AmznClientToken?: string;
+    
+    DefaultConfig?: FunctionDefaultConfig;
+    
+    FunctionDefinitionId: string | undefined;
+    
+    Functions?: Function[];
+}
+export declare namespace CreateFunctionDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateFunctionDefinitionVersionRequest) => any;
+}
+export interface CreateFunctionDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    Version?: string;
+}
+export declare namespace CreateFunctionDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: CreateFunctionDefinitionVersionResponse) => any;
+}
+
+export interface GroupVersion {
+    
+    ConnectorDefinitionVersionArn?: string;
+    
+    CoreDefinitionVersionArn?: string;
+    
+    DeviceDefinitionVersionArn?: string;
+    
+    FunctionDefinitionVersionArn?: string;
+    
+    LoggerDefinitionVersionArn?: string;
+    
+    ResourceDefinitionVersionArn?: string;
+    
+    SubscriptionDefinitionVersionArn?: string;
+}
+export declare namespace GroupVersion {
+    
+    const filterSensitiveLog: (obj: GroupVersion) => any;
+}
+export interface CreateGroupRequest {
+    
+    AmznClientToken?: string;
+    
+    InitialVersion?: GroupVersion;
+    
+    Name: string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateGroupRequest {
+    
+    const filterSensitiveLog: (obj: CreateGroupRequest) => any;
+}
+export interface CreateGroupResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+}
+export declare namespace CreateGroupResponse {
+    
+    const filterSensitiveLog: (obj: CreateGroupResponse) => any;
+}
+export interface CreateGroupCertificateAuthorityRequest {
+    
+    AmznClientToken?: string;
+    
+    GroupId: string | undefined;
+}
+export declare namespace CreateGroupCertificateAuthorityRequest {
+    
+    const filterSensitiveLog: (obj: CreateGroupCertificateAuthorityRequest) => any;
+}
+export interface CreateGroupCertificateAuthorityResponse {
+    
+    GroupCertificateAuthorityArn?: string;
+}
+export declare namespace CreateGroupCertificateAuthorityResponse {
+    
+    const filterSensitiveLog: (obj: CreateGroupCertificateAuthorityResponse) => any;
+}
+export interface CreateGroupVersionRequest {
+    
+    AmznClientToken?: string;
+    
+    ConnectorDefinitionVersionArn?: string;
+    
+    CoreDefinitionVersionArn?: string;
+    
+    DeviceDefinitionVersionArn?: string;
+    
+    FunctionDefinitionVersionArn?: string;
+    
+    GroupId: string | undefined;
+    
+    LoggerDefinitionVersionArn?: string;
+    
+    ResourceDefinitionVersionArn?: string;
+    
+    SubscriptionDefinitionVersionArn?: string;
+}
+export declare namespace CreateGroupVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateGroupVersionRequest) => any;
+}
+export interface CreateGroupVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    Version?: string;
+}
+export declare namespace CreateGroupVersionResponse {
+    
+    const filterSensitiveLog: (obj: CreateGroupVersionResponse) => any;
+}
+
+export interface LoggerDefinitionVersion {
+    
+    Loggers?: Logger[];
+}
+export declare namespace LoggerDefinitionVersion {
+    
+    const filterSensitiveLog: (obj: LoggerDefinitionVersion) => any;
+}
+export interface CreateLoggerDefinitionRequest {
+    
+    AmznClientToken?: string;
+    
+    InitialVersion?: LoggerDefinitionVersion;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateLoggerDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: CreateLoggerDefinitionRequest) => any;
+}
+export interface CreateLoggerDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+}
+export declare namespace CreateLoggerDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: CreateLoggerDefinitionResponse) => any;
+}
+export interface CreateLoggerDefinitionVersionRequest {
+    
+    AmznClientToken?: string;
+    
+    LoggerDefinitionId: string | undefined;
+    
+    Loggers?: Logger[];
+}
+export declare namespace CreateLoggerDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateLoggerDefinitionVersionRequest) => any;
+}
+export interface CreateLoggerDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    Version?: string;
+}
+export declare namespace CreateLoggerDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: CreateLoggerDefinitionVersionResponse) => any;
+}
+
+export interface ResourceDefinitionVersion {
+    
+    Resources?: Resource[];
+}
+export declare namespace ResourceDefinitionVersion {
+    
+    const filterSensitiveLog: (obj: ResourceDefinitionVersion) => any;
+}
+export interface CreateResourceDefinitionRequest {
+    
+    AmznClientToken?: string;
+    
+    InitialVersion?: ResourceDefinitionVersion;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateResourceDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: CreateResourceDefinitionRequest) => any;
+}
+export interface CreateResourceDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+}
+export declare namespace CreateResourceDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: CreateResourceDefinitionResponse) => any;
+}
+export interface CreateResourceDefinitionVersionRequest {
+    
+    AmznClientToken?: string;
+    
+    ResourceDefinitionId: string | undefined;
+    
+    Resources?: Resource[];
+}
+export declare namespace CreateResourceDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateResourceDefinitionVersionRequest) => any;
+}
+export interface CreateResourceDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    Version?: string;
+}
+export declare namespace CreateResourceDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: CreateResourceDefinitionVersionResponse) => any;
+}
+export declare enum SoftwareToUpdate {
+    core = "core",
+    ota_agent = "ota_agent"
+}
+export declare enum UpdateAgentLogLevel {
+    DEBUG = "DEBUG",
+    ERROR = "ERROR",
+    FATAL = "FATAL",
+    INFO = "INFO",
+    NONE = "NONE",
+    TRACE = "TRACE",
+    VERBOSE = "VERBOSE",
+    WARN = "WARN"
+}
+export declare enum UpdateTargetsArchitecture {
+    aarch64 = "aarch64",
+    armv6l = "armv6l",
+    armv7l = "armv7l",
+    x86_64 = "x86_64"
+}
+export declare enum UpdateTargetsOperatingSystem {
+    amazon_linux = "amazon_linux",
+    openwrt = "openwrt",
+    raspbian = "raspbian",
+    ubuntu = "ubuntu"
+}
+export interface CreateSoftwareUpdateJobRequest {
+    
+    AmznClientToken?: string;
+    
+    S3UrlSignerRole: string | undefined;
+    
+    SoftwareToUpdate: SoftwareToUpdate | string | undefined;
+    
+    UpdateAgentLogLevel?: UpdateAgentLogLevel | string;
+    
+    UpdateTargets: string[] | undefined;
+    
+    UpdateTargetsArchitecture: UpdateTargetsArchitecture | string | undefined;
+    
+    UpdateTargetsOperatingSystem: UpdateTargetsOperatingSystem | string | undefined;
+}
+export declare namespace CreateSoftwareUpdateJobRequest {
+    
+    const filterSensitiveLog: (obj: CreateSoftwareUpdateJobRequest) => any;
+}
+export interface CreateSoftwareUpdateJobResponse {
+    
+    IotJobArn?: string;
+    
+    IotJobId?: string;
+    
+    PlatformSoftwareVersion?: string;
+}
+export declare namespace CreateSoftwareUpdateJobResponse {
+    
+    const filterSensitiveLog: (obj: CreateSoftwareUpdateJobResponse) => any;
+}
+
+export interface SubscriptionDefinitionVersion {
+    
+    Subscriptions?: Subscription[];
+}
+export declare namespace SubscriptionDefinitionVersion {
+    
+    const filterSensitiveLog: (obj: SubscriptionDefinitionVersion) => any;
+}
+export interface CreateSubscriptionDefinitionRequest {
+    
+    AmznClientToken?: string;
+    
+    InitialVersion?: SubscriptionDefinitionVersion;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateSubscriptionDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: CreateSubscriptionDefinitionRequest) => any;
+}
+export interface CreateSubscriptionDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+}
+export declare namespace CreateSubscriptionDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: CreateSubscriptionDefinitionResponse) => any;
+}
+export interface CreateSubscriptionDefinitionVersionRequest {
+    
+    AmznClientToken?: string;
+    
+    SubscriptionDefinitionId: string | undefined;
+    
+    Subscriptions?: Subscription[];
+}
+export declare namespace CreateSubscriptionDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateSubscriptionDefinitionVersionRequest) => any;
+}
+export interface CreateSubscriptionDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    Version?: string;
+}
+export declare namespace CreateSubscriptionDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: CreateSubscriptionDefinitionVersionResponse) => any;
+}
+export interface DeleteConnectorDefinitionRequest {
+    
+    ConnectorDefinitionId: string | undefined;
+}
+export declare namespace DeleteConnectorDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteConnectorDefinitionRequest) => any;
+}
+export interface DeleteConnectorDefinitionResponse {
+}
+export declare namespace DeleteConnectorDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteConnectorDefinitionResponse) => any;
+}
+export interface DeleteCoreDefinitionRequest {
+    
+    CoreDefinitionId: string | undefined;
+}
+export declare namespace DeleteCoreDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteCoreDefinitionRequest) => any;
+}
+export interface DeleteCoreDefinitionResponse {
+}
+export declare namespace DeleteCoreDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteCoreDefinitionResponse) => any;
+}
+export interface DeleteDeviceDefinitionRequest {
+    
+    DeviceDefinitionId: string | undefined;
+}
+export declare namespace DeleteDeviceDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDeviceDefinitionRequest) => any;
+}
+export interface DeleteDeviceDefinitionResponse {
+}
+export declare namespace DeleteDeviceDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDeviceDefinitionResponse) => any;
+}
+export interface DeleteFunctionDefinitionRequest {
+    
+    FunctionDefinitionId: string | undefined;
+}
+export declare namespace DeleteFunctionDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFunctionDefinitionRequest) => any;
+}
+export interface DeleteFunctionDefinitionResponse {
+}
+export declare namespace DeleteFunctionDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFunctionDefinitionResponse) => any;
+}
+export interface DeleteGroupRequest {
+    
+    GroupId: string | undefined;
+}
+export declare namespace DeleteGroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteGroupRequest) => any;
+}
+export interface DeleteGroupResponse {
+}
+export declare namespace DeleteGroupResponse {
+    
+    const filterSensitiveLog: (obj: DeleteGroupResponse) => any;
+}
+export interface DeleteLoggerDefinitionRequest {
+    
+    LoggerDefinitionId: string | undefined;
+}
+export declare namespace DeleteLoggerDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteLoggerDefinitionRequest) => any;
+}
+export interface DeleteLoggerDefinitionResponse {
+}
+export declare namespace DeleteLoggerDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteLoggerDefinitionResponse) => any;
+}
+export interface DeleteResourceDefinitionRequest {
+    
+    ResourceDefinitionId: string | undefined;
+}
+export declare namespace DeleteResourceDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteResourceDefinitionRequest) => any;
+}
+export interface DeleteResourceDefinitionResponse {
+}
+export declare namespace DeleteResourceDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteResourceDefinitionResponse) => any;
+}
+export interface DeleteSubscriptionDefinitionRequest {
+    
+    SubscriptionDefinitionId: string | undefined;
+}
+export declare namespace DeleteSubscriptionDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSubscriptionDefinitionRequest) => any;
+}
+export interface DeleteSubscriptionDefinitionResponse {
+}
+export declare namespace DeleteSubscriptionDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSubscriptionDefinitionResponse) => any;
+}
+
+export interface Deployment {
+    
+    CreatedAt?: string;
+    
+    DeploymentArn?: string;
+    
+    DeploymentId?: string;
+    
+    DeploymentType?: DeploymentType | string;
+    
+    GroupArn?: string;
+}
+export declare namespace Deployment {
+    
+    const filterSensitiveLog: (obj: Deployment) => any;
+}
+export interface DisassociateRoleFromGroupRequest {
+    
+    GroupId: string | undefined;
+}
+export declare namespace DisassociateRoleFromGroupRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateRoleFromGroupRequest) => any;
+}
+export interface DisassociateRoleFromGroupResponse {
+    
+    DisassociatedAt?: string;
+}
+export declare namespace DisassociateRoleFromGroupResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateRoleFromGroupResponse) => any;
+}
+export interface DisassociateServiceRoleFromAccountRequest {
+}
+export declare namespace DisassociateServiceRoleFromAccountRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateServiceRoleFromAccountRequest) => any;
+}
+export interface DisassociateServiceRoleFromAccountResponse {
+    
+    DisassociatedAt?: string;
+}
+export declare namespace DisassociateServiceRoleFromAccountResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateServiceRoleFromAccountResponse) => any;
+}
+export interface GetAssociatedRoleRequest {
+    
+    GroupId: string | undefined;
+}
+export declare namespace GetAssociatedRoleRequest {
+    
+    const filterSensitiveLog: (obj: GetAssociatedRoleRequest) => any;
+}
+export interface GetAssociatedRoleResponse {
+    
+    AssociatedAt?: string;
+    
+    RoleArn?: string;
+}
+export declare namespace GetAssociatedRoleResponse {
+    
+    const filterSensitiveLog: (obj: GetAssociatedRoleResponse) => any;
+}
+export interface GetBulkDeploymentStatusRequest {
+    
+    BulkDeploymentId: string | undefined;
+}
+export declare namespace GetBulkDeploymentStatusRequest {
+    
+    const filterSensitiveLog: (obj: GetBulkDeploymentStatusRequest) => any;
+}
+export interface GetBulkDeploymentStatusResponse {
+    
+    BulkDeploymentMetrics?: BulkDeploymentMetrics;
+    
+    BulkDeploymentStatus?: BulkDeploymentStatus | string;
+    
+    CreatedAt?: string;
+    
+    ErrorDetails?: ErrorDetail[];
+    
+    ErrorMessage?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetBulkDeploymentStatusResponse {
+    
+    const filterSensitiveLog: (obj: GetBulkDeploymentStatusResponse) => any;
+}
+export interface GetConnectivityInfoRequest {
+    
+    ThingName: string | undefined;
+}
+export declare namespace GetConnectivityInfoRequest {
+    
+    const filterSensitiveLog: (obj: GetConnectivityInfoRequest) => any;
+}
+export interface GetConnectivityInfoResponse {
+    
+    ConnectivityInfo?: ConnectivityInfo[];
+    
+    Message?: string;
+}
+export declare namespace GetConnectivityInfoResponse {
+    
+    const filterSensitiveLog: (obj: GetConnectivityInfoResponse) => any;
+}
+export interface GetConnectorDefinitionRequest {
+    
+    ConnectorDefinitionId: string | undefined;
+}
+export declare namespace GetConnectorDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: GetConnectorDefinitionRequest) => any;
+}
+export interface GetConnectorDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetConnectorDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: GetConnectorDefinitionResponse) => any;
+}
+export interface GetConnectorDefinitionVersionRequest {
+    
+    ConnectorDefinitionId: string | undefined;
+    
+    ConnectorDefinitionVersionId: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace GetConnectorDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetConnectorDefinitionVersionRequest) => any;
+}
+export interface GetConnectorDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Definition?: ConnectorDefinitionVersion;
+    
+    Id?: string;
+    
+    NextToken?: string;
+    
+    Version?: string;
+}
+export declare namespace GetConnectorDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: GetConnectorDefinitionVersionResponse) => any;
+}
+export interface GetCoreDefinitionRequest {
+    
+    CoreDefinitionId: string | undefined;
+}
+export declare namespace GetCoreDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: GetCoreDefinitionRequest) => any;
+}
+export interface GetCoreDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetCoreDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: GetCoreDefinitionResponse) => any;
+}
+export interface GetCoreDefinitionVersionRequest {
+    
+    CoreDefinitionId: string | undefined;
+    
+    CoreDefinitionVersionId: string | undefined;
+}
+export declare namespace GetCoreDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetCoreDefinitionVersionRequest) => any;
+}
+export interface GetCoreDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Definition?: CoreDefinitionVersion;
+    
+    Id?: string;
+    
+    NextToken?: string;
+    
+    Version?: string;
+}
+export declare namespace GetCoreDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: GetCoreDefinitionVersionResponse) => any;
+}
+export interface GetDeploymentStatusRequest {
+    
+    DeploymentId: string | undefined;
+    
+    GroupId: string | undefined;
+}
+export declare namespace GetDeploymentStatusRequest {
+    
+    const filterSensitiveLog: (obj: GetDeploymentStatusRequest) => any;
+}
+export interface GetDeploymentStatusResponse {
+    
+    DeploymentStatus?: string;
+    
+    DeploymentType?: DeploymentType | string;
+    
+    ErrorDetails?: ErrorDetail[];
+    
+    ErrorMessage?: string;
+    
+    UpdatedAt?: string;
+}
+export declare namespace GetDeploymentStatusResponse {
+    
+    const filterSensitiveLog: (obj: GetDeploymentStatusResponse) => any;
+}
+export interface GetDeviceDefinitionRequest {
+    
+    DeviceDefinitionId: string | undefined;
+}
+export declare namespace GetDeviceDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: GetDeviceDefinitionRequest) => any;
+}
+export interface GetDeviceDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetDeviceDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: GetDeviceDefinitionResponse) => any;
+}
+export interface GetDeviceDefinitionVersionRequest {
+    
+    DeviceDefinitionId: string | undefined;
+    
+    DeviceDefinitionVersionId: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace GetDeviceDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetDeviceDefinitionVersionRequest) => any;
+}
+export interface GetDeviceDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Definition?: DeviceDefinitionVersion;
+    
+    Id?: string;
+    
+    NextToken?: string;
+    
+    Version?: string;
+}
+export declare namespace GetDeviceDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: GetDeviceDefinitionVersionResponse) => any;
+}
+export interface GetFunctionDefinitionRequest {
+    
+    FunctionDefinitionId: string | undefined;
+}
+export declare namespace GetFunctionDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: GetFunctionDefinitionRequest) => any;
+}
+export interface GetFunctionDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetFunctionDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: GetFunctionDefinitionResponse) => any;
+}
+export interface GetFunctionDefinitionVersionRequest {
+    
+    FunctionDefinitionId: string | undefined;
+    
+    FunctionDefinitionVersionId: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace GetFunctionDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetFunctionDefinitionVersionRequest) => any;
+}
+export interface GetFunctionDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Definition?: FunctionDefinitionVersion;
+    
+    Id?: string;
+    
+    NextToken?: string;
+    
+    Version?: string;
+}
+export declare namespace GetFunctionDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: GetFunctionDefinitionVersionResponse) => any;
+}
+export interface GetGroupRequest {
+    
+    GroupId: string | undefined;
+}
+export declare namespace GetGroupRequest {
+    
+    const filterSensitiveLog: (obj: GetGroupRequest) => any;
+}
+export interface GetGroupResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetGroupResponse {
+    
+    const filterSensitiveLog: (obj: GetGroupResponse) => any;
+}
+export interface GetGroupCertificateAuthorityRequest {
+    
+    CertificateAuthorityId: string | undefined;
+    
+    GroupId: string | undefined;
+}
+export declare namespace GetGroupCertificateAuthorityRequest {
+    
+    const filterSensitiveLog: (obj: GetGroupCertificateAuthorityRequest) => any;
+}
+export interface GetGroupCertificateAuthorityResponse {
+    
+    GroupCertificateAuthorityArn?: string;
+    
+    GroupCertificateAuthorityId?: string;
+    
+    PemEncodedCertificate?: string;
+}
+export declare namespace GetGroupCertificateAuthorityResponse {
+    
+    const filterSensitiveLog: (obj: GetGroupCertificateAuthorityResponse) => any;
+}
+export interface GetGroupCertificateConfigurationRequest {
+    
+    GroupId: string | undefined;
+}
+export declare namespace GetGroupCertificateConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetGroupCertificateConfigurationRequest) => any;
+}
+export interface GetGroupCertificateConfigurationResponse {
+    
+    CertificateAuthorityExpiryInMilliseconds?: string;
+    
+    CertificateExpiryInMilliseconds?: string;
+    
+    GroupId?: string;
+}
+export declare namespace GetGroupCertificateConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: GetGroupCertificateConfigurationResponse) => any;
+}
+export interface GetGroupVersionRequest {
+    
+    GroupId: string | undefined;
+    
+    GroupVersionId: string | undefined;
+}
+export declare namespace GetGroupVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetGroupVersionRequest) => any;
+}
+export interface GetGroupVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Definition?: GroupVersion;
+    
+    Id?: string;
+    
+    Version?: string;
+}
+export declare namespace GetGroupVersionResponse {
+    
+    const filterSensitiveLog: (obj: GetGroupVersionResponse) => any;
+}
+export interface GetLoggerDefinitionRequest {
+    
+    LoggerDefinitionId: string | undefined;
+}
+export declare namespace GetLoggerDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: GetLoggerDefinitionRequest) => any;
+}
+export interface GetLoggerDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetLoggerDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: GetLoggerDefinitionResponse) => any;
+}
+export interface GetLoggerDefinitionVersionRequest {
+    
+    LoggerDefinitionId: string | undefined;
+    
+    LoggerDefinitionVersionId: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace GetLoggerDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetLoggerDefinitionVersionRequest) => any;
+}
+export interface GetLoggerDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Definition?: LoggerDefinitionVersion;
+    
+    Id?: string;
+    
+    Version?: string;
+}
+export declare namespace GetLoggerDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: GetLoggerDefinitionVersionResponse) => any;
+}
+export interface GetResourceDefinitionRequest {
+    
+    ResourceDefinitionId: string | undefined;
+}
+export declare namespace GetResourceDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: GetResourceDefinitionRequest) => any;
+}
+export interface GetResourceDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetResourceDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: GetResourceDefinitionResponse) => any;
+}
+export interface GetResourceDefinitionVersionRequest {
+    
+    ResourceDefinitionId: string | undefined;
+    
+    ResourceDefinitionVersionId: string | undefined;
+}
+export declare namespace GetResourceDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetResourceDefinitionVersionRequest) => any;
+}
+export interface GetResourceDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Definition?: ResourceDefinitionVersion;
+    
+    Id?: string;
+    
+    Version?: string;
+}
+export declare namespace GetResourceDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: GetResourceDefinitionVersionResponse) => any;
+}
+export interface GetServiceRoleForAccountRequest {
+}
+export declare namespace GetServiceRoleForAccountRequest {
+    
+    const filterSensitiveLog: (obj: GetServiceRoleForAccountRequest) => any;
+}
+export interface GetServiceRoleForAccountResponse {
+    
+    AssociatedAt?: string;
+    
+    RoleArn?: string;
+}
+export declare namespace GetServiceRoleForAccountResponse {
+    
+    const filterSensitiveLog: (obj: GetServiceRoleForAccountResponse) => any;
+}
+export interface GetSubscriptionDefinitionRequest {
+    
+    SubscriptionDefinitionId: string | undefined;
+}
+export declare namespace GetSubscriptionDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: GetSubscriptionDefinitionRequest) => any;
+}
+export interface GetSubscriptionDefinitionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Id?: string;
+    
+    LastUpdatedTimestamp?: string;
+    
+    LatestVersion?: string;
+    
+    LatestVersionArn?: string;
+    
+    Name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetSubscriptionDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: GetSubscriptionDefinitionResponse) => any;
+}
+export interface GetSubscriptionDefinitionVersionRequest {
+    
+    NextToken?: string;
+    
+    SubscriptionDefinitionId: string | undefined;
+    
+    SubscriptionDefinitionVersionId: string | undefined;
+}
+export declare namespace GetSubscriptionDefinitionVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetSubscriptionDefinitionVersionRequest) => any;
+}
+export interface GetSubscriptionDefinitionVersionResponse {
+    
+    Arn?: string;
+    
+    CreationTimestamp?: string;
+    
+    Definition?: SubscriptionDefinitionVersion;
+    
+    Id?: string;
+    
+    NextToken?: string;
+    
+    Version?: string;
+}
+export declare namespace GetSubscriptionDefinitionVersionResponse {
+    
+    const filterSensitiveLog: (obj: GetSubscriptionDefinitionVersionResponse) => any;
+}
+export interface GetThingRuntimeConfigurationRequest {
+    
+    ThingName: string | undefined;
+}
+export declare namespace GetThingRuntimeConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetThingRuntimeConfigurationRequest) => any;
+}
+export declare enum Telemetry {
+    Off = "Off",
+    On = "On"
+}
+
+export interface TelemetryConfiguration {
+    
+    ConfigurationSyncStatus?: ConfigurationSyncStatus | string;
+    
+    Telemetry: Telemetry | string | undefined;
+}
+export declare namespace TelemetryConfiguration {
+    
+    const filterSensitiveLog: (obj: TelemetryConfiguration) => any;
+}
+
+export interface RuntimeConfiguration {
+    
+    TelemetryConfiguration?: TelemetryConfiguration;
+}
+export declare namespace RuntimeConfiguration {
+    
+    const filterSensitiveLog: (obj: RuntimeConfiguration) => any;
+}
+export interface GetThingRuntimeConfigurationResponse {
+    
+    RuntimeConfiguration?: RuntimeConfiguration;
+}
+export declare namespace GetThingRuntimeConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: GetThingRuntimeConfigurationResponse) => any;
+}
+export interface ListBulkDeploymentDetailedReportsRequest {
+    
+    BulkDeploymentId: string | undefined;
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListBulkDeploymentDetailedReportsRequest {
+    
+    const filterSensitiveLog: (obj: ListBulkDeploymentDetailedReportsRequest) => any;
+}
+export interface ListBulkDeploymentDetailedReportsResponse {
+    
+    Deployments?: BulkDeploymentResult[];
+    
+    NextToken?: string;
+}
+export declare namespace ListBulkDeploymentDetailedReportsResponse {
+    
+    const filterSensitiveLog: (obj: ListBulkDeploymentDetailedReportsResponse) => any;
+}
+export interface ListBulkDeploymentsRequest {
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListBulkDeploymentsRequest {
+    
+    const filterSensitiveLog: (obj: ListBulkDeploymentsRequest) => any;
+}
+export interface ListBulkDeploymentsResponse {
+    
+    BulkDeployments?: BulkDeployment[];
+    
+    NextToken?: string;
+}
+export declare namespace ListBulkDeploymentsResponse {
+    
+    const filterSensitiveLog: (obj: ListBulkDeploymentsResponse) => any;
+}
+export interface ListConnectorDefinitionsRequest {
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListConnectorDefinitionsRequest {
+    
+    const filterSensitiveLog: (obj: ListConnectorDefinitionsRequest) => any;
+}
+export interface ListConnectorDefinitionsResponse {
+    
+    Definitions?: DefinitionInformation[];
+    
+    NextToken?: string;
+}
+export declare namespace ListConnectorDefinitionsResponse {
+    
+    const filterSensitiveLog: (obj: ListConnectorDefinitionsResponse) => any;
+}
+export interface ListConnectorDefinitionVersionsRequest {
+    
+    ConnectorDefinitionId: string | undefined;
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListConnectorDefinitionVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListConnectorDefinitionVersionsRequest) => any;
+}
+export interface ListConnectorDefinitionVersionsResponse {
+    
+    NextToken?: string;
+    
+    Versions?: VersionInformation[];
+}
+export declare namespace ListConnectorDefinitionVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListConnectorDefinitionVersionsResponse) => any;
+}
+export interface ListCoreDefinitionsRequest {
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListCoreDefinitionsRequest {
+    
+    const filterSensitiveLog: (obj: ListCoreDefinitionsRequest) => any;
+}
+export interface ListCoreDefinitionsResponse {
+    
+    Definitions?: DefinitionInformation[];
+    
+    NextToken?: string;
+}
+export declare namespace ListCoreDefinitionsResponse {
+    
+    const filterSensitiveLog: (obj: ListCoreDefinitionsResponse) => any;
+}
+export interface ListCoreDefinitionVersionsRequest {
+    
+    CoreDefinitionId: string | undefined;
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListCoreDefinitionVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListCoreDefinitionVersionsRequest) => any;
+}
+export interface ListCoreDefinitionVersionsResponse {
+    
+    NextToken?: string;
+    
+    Versions?: VersionInformation[];
+}
+export declare namespace ListCoreDefinitionVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListCoreDefinitionVersionsResponse) => any;
+}
+export interface ListDeploymentsRequest {
+    
+    GroupId: string | undefined;
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListDeploymentsRequest {
+    
+    const filterSensitiveLog: (obj: ListDeploymentsRequest) => any;
+}
+export interface ListDeploymentsResponse {
+    
+    Deployments?: Deployment[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDeploymentsResponse {
+    
+    const filterSensitiveLog: (obj: ListDeploymentsResponse) => any;
+}
+export interface ListDeviceDefinitionsRequest {
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListDeviceDefinitionsRequest {
+    
+    const filterSensitiveLog: (obj: ListDeviceDefinitionsRequest) => any;
+}
+export interface ListDeviceDefinitionsResponse {
+    
+    Definitions?: DefinitionInformation[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDeviceDefinitionsResponse {
+    
+    const filterSensitiveLog: (obj: ListDeviceDefinitionsResponse) => any;
+}
+export interface ListDeviceDefinitionVersionsRequest {
+    
+    DeviceDefinitionId: string | undefined;
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListDeviceDefinitionVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListDeviceDefinitionVersionsRequest) => any;
+}
+export interface ListDeviceDefinitionVersionsResponse {
+    
+    NextToken?: string;
+    
+    Versions?: VersionInformation[];
+}
+export declare namespace ListDeviceDefinitionVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListDeviceDefinitionVersionsResponse) => any;
+}
+export interface ListFunctionDefinitionsRequest {
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListFunctionDefinitionsRequest {
+    
+    const filterSensitiveLog: (obj: ListFunctionDefinitionsRequest) => any;
+}
+export interface ListFunctionDefinitionsResponse {
+    
+    Definitions?: DefinitionInformation[];
+    
+    NextToken?: string;
+}
+export declare namespace ListFunctionDefinitionsResponse {
+    
+    const filterSensitiveLog: (obj: ListFunctionDefinitionsResponse) => any;
+}
+export interface ListFunctionDefinitionVersionsRequest {
+    
+    FunctionDefinitionId: string | undefined;
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListFunctionDefinitionVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListFunctionDefinitionVersionsRequest) => any;
+}
+export interface ListFunctionDefinitionVersionsResponse {
+    
+    NextToken?: string;
+    
+    Versions?: VersionInformation[];
+}
+export declare namespace ListFunctionDefinitionVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListFunctionDefinitionVersionsResponse) => any;
+}
+export interface ListGroupCertificateAuthoritiesRequest {
+    
+    GroupId: string | undefined;
+}
+export declare namespace ListGroupCertificateAuthoritiesRequest {
+    
+    const filterSensitiveLog: (obj: ListGroupCertificateAuthoritiesRequest) => any;
+}
+export interface ListGroupCertificateAuthoritiesResponse {
+    
+    GroupCertificateAuthorities?: GroupCertificateAuthorityProperties[];
+}
+export declare namespace ListGroupCertificateAuthoritiesResponse {
+    
+    const filterSensitiveLog: (obj: ListGroupCertificateAuthoritiesResponse) => any;
+}
+export interface ListGroupsRequest {
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListGroupsRequest {
+    
+    const filterSensitiveLog: (obj: ListGroupsRequest) => any;
+}
+export interface ListGroupsResponse {
+    
+    Groups?: GroupInformation[];
+    
+    NextToken?: string;
+}
+export declare namespace ListGroupsResponse {
+    
+    const filterSensitiveLog: (obj: ListGroupsResponse) => any;
+}
+export interface ListGroupVersionsRequest {
+    
+    GroupId: string | undefined;
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListGroupVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListGroupVersionsRequest) => any;
+}
+export interface ListGroupVersionsResponse {
+    
+    NextToken?: string;
+    
+    Versions?: VersionInformation[];
+}
+export declare namespace ListGroupVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListGroupVersionsResponse) => any;
+}
+export interface ListLoggerDefinitionsRequest {
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListLoggerDefinitionsRequest {
+    
+    const filterSensitiveLog: (obj: ListLoggerDefinitionsRequest) => any;
+}
+export interface ListLoggerDefinitionsResponse {
+    
+    Definitions?: DefinitionInformation[];
+    
+    NextToken?: string;
+}
+export declare namespace ListLoggerDefinitionsResponse {
+    
+    const filterSensitiveLog: (obj: ListLoggerDefinitionsResponse) => any;
+}
+export interface ListLoggerDefinitionVersionsRequest {
+    
+    LoggerDefinitionId: string | undefined;
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListLoggerDefinitionVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListLoggerDefinitionVersionsRequest) => any;
+}
+export interface ListLoggerDefinitionVersionsResponse {
+    
+    NextToken?: string;
+    
+    Versions?: VersionInformation[];
+}
+export declare namespace ListLoggerDefinitionVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListLoggerDefinitionVersionsResponse) => any;
+}
+export interface ListResourceDefinitionsRequest {
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListResourceDefinitionsRequest {
+    
+    const filterSensitiveLog: (obj: ListResourceDefinitionsRequest) => any;
+}
+export interface ListResourceDefinitionsResponse {
+    
+    Definitions?: DefinitionInformation[];
+    
+    NextToken?: string;
+}
+export declare namespace ListResourceDefinitionsResponse {
+    
+    const filterSensitiveLog: (obj: ListResourceDefinitionsResponse) => any;
+}
+export interface ListResourceDefinitionVersionsRequest {
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+    
+    ResourceDefinitionId: string | undefined;
+}
+export declare namespace ListResourceDefinitionVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListResourceDefinitionVersionsRequest) => any;
+}
+export interface ListResourceDefinitionVersionsResponse {
+    
+    NextToken?: string;
+    
+    Versions?: VersionInformation[];
+}
+export declare namespace ListResourceDefinitionVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListResourceDefinitionVersionsResponse) => any;
+}
+export interface ListSubscriptionDefinitionsRequest {
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+}
+export declare namespace ListSubscriptionDefinitionsRequest {
+    
+    const filterSensitiveLog: (obj: ListSubscriptionDefinitionsRequest) => any;
+}
+export interface ListSubscriptionDefinitionsResponse {
+    
+    Definitions?: DefinitionInformation[];
+    
+    NextToken?: string;
+}
+export declare namespace ListSubscriptionDefinitionsResponse {
+    
+    const filterSensitiveLog: (obj: ListSubscriptionDefinitionsResponse) => any;
+}
+export interface ListSubscriptionDefinitionVersionsRequest {
+    
+    MaxResults?: string;
+    
+    NextToken?: string;
+    
+    SubscriptionDefinitionId: string | undefined;
+}
+export declare namespace ListSubscriptionDefinitionVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListSubscriptionDefinitionVersionsRequest) => any;
+}
+export interface ListSubscriptionDefinitionVersionsResponse {
+    
+    NextToken?: string;
+    
+    Versions?: VersionInformation[];
+}
+export declare namespace ListSubscriptionDefinitionVersionsResponse {
+    
+    const filterSensitiveLog: (obj: ListSubscriptionDefinitionVersionsResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+
+export interface ResetDeploymentsRequest {
+    
+    AmznClientToken?: string;
+    
+    Force?: boolean;
+    
+    GroupId: string | undefined;
+}
+export declare namespace ResetDeploymentsRequest {
+    
+    const filterSensitiveLog: (obj: ResetDeploymentsRequest) => any;
+}
+export interface ResetDeploymentsResponse {
+    
+    DeploymentArn?: string;
+    
+    DeploymentId?: string;
+}
+export declare namespace ResetDeploymentsResponse {
+    
+    const filterSensitiveLog: (obj: ResetDeploymentsResponse) => any;
+}
+export interface StartBulkDeploymentRequest {
+    
+    AmznClientToken?: string;
+    
+    ExecutionRoleArn: string | undefined;
+    
+    InputFileUri: string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace StartBulkDeploymentRequest {
+    
+    const filterSensitiveLog: (obj: StartBulkDeploymentRequest) => any;
+}
+export interface StartBulkDeploymentResponse {
+    
+    BulkDeploymentArn?: string;
+    
+    BulkDeploymentId?: string;
+}
+export declare namespace StartBulkDeploymentResponse {
+    
+    const filterSensitiveLog: (obj: StartBulkDeploymentResponse) => any;
+}
+export interface StopBulkDeploymentRequest {
+    
+    BulkDeploymentId: string | undefined;
+}
+export declare namespace StopBulkDeploymentRequest {
+    
+    const filterSensitiveLog: (obj: StopBulkDeploymentRequest) => any;
+}
+export interface StopBulkDeploymentResponse {
+}
+export declare namespace StopBulkDeploymentResponse {
+    
+    const filterSensitiveLog: (obj: StopBulkDeploymentResponse) => any;
+}
+
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+
+export interface UpdateConnectivityInfoRequest {
+    
+    ConnectivityInfo?: ConnectivityInfo[];
+    
+    ThingName: string | undefined;
+}
+export declare namespace UpdateConnectivityInfoRequest {
+    
+    const filterSensitiveLog: (obj: UpdateConnectivityInfoRequest) => any;
+}
+export interface UpdateConnectivityInfoResponse {
+    
+    Message?: string;
+    
+    Version?: string;
+}
+export declare namespace UpdateConnectivityInfoResponse {
+    
+    const filterSensitiveLog: (obj: UpdateConnectivityInfoResponse) => any;
+}
+export interface UpdateConnectorDefinitionRequest {
+    
+    ConnectorDefinitionId: string | undefined;
+    
+    Name?: string;
+}
+export declare namespace UpdateConnectorDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateConnectorDefinitionRequest) => any;
+}
+export interface UpdateConnectorDefinitionResponse {
+}
+export declare namespace UpdateConnectorDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: UpdateConnectorDefinitionResponse) => any;
+}
+export interface UpdateCoreDefinitionRequest {
+    
+    CoreDefinitionId: string | undefined;
+    
+    Name?: string;
+}
+export declare namespace UpdateCoreDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateCoreDefinitionRequest) => any;
+}
+export interface UpdateCoreDefinitionResponse {
+}
+export declare namespace UpdateCoreDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: UpdateCoreDefinitionResponse) => any;
+}
+export interface UpdateDeviceDefinitionRequest {
+    
+    DeviceDefinitionId: string | undefined;
+    
+    Name?: string;
+}
+export declare namespace UpdateDeviceDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDeviceDefinitionRequest) => any;
+}
+export interface UpdateDeviceDefinitionResponse {
+}
+export declare namespace UpdateDeviceDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: UpdateDeviceDefinitionResponse) => any;
+}
+export interface UpdateFunctionDefinitionRequest {
+    
+    FunctionDefinitionId: string | undefined;
+    
+    Name?: string;
+}
+export declare namespace UpdateFunctionDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFunctionDefinitionRequest) => any;
+}
+export interface UpdateFunctionDefinitionResponse {
+}
+export declare namespace UpdateFunctionDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFunctionDefinitionResponse) => any;
+}
+export interface UpdateGroupRequest {
+    
+    GroupId: string | undefined;
+    
+    Name?: string;
+}
+export declare namespace UpdateGroupRequest {
+    
+    const filterSensitiveLog: (obj: UpdateGroupRequest) => any;
+}
+export interface UpdateGroupResponse {
+}
+export declare namespace UpdateGroupResponse {
+    
+    const filterSensitiveLog: (obj: UpdateGroupResponse) => any;
+}
+export interface UpdateGroupCertificateConfigurationRequest {
+    
+    CertificateExpiryInMilliseconds?: string;
+    
+    GroupId: string | undefined;
+}
+export declare namespace UpdateGroupCertificateConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateGroupCertificateConfigurationRequest) => any;
+}
+export interface UpdateGroupCertificateConfigurationResponse {
+    
+    CertificateAuthorityExpiryInMilliseconds?: string;
+    
+    CertificateExpiryInMilliseconds?: string;
+    
+    GroupId?: string;
+}
+export declare namespace UpdateGroupCertificateConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateGroupCertificateConfigurationResponse) => any;
+}
+export interface UpdateLoggerDefinitionRequest {
+    
+    LoggerDefinitionId: string | undefined;
+    
+    Name?: string;
+}
+export declare namespace UpdateLoggerDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateLoggerDefinitionRequest) => any;
+}
+export interface UpdateLoggerDefinitionResponse {
+}
+export declare namespace UpdateLoggerDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: UpdateLoggerDefinitionResponse) => any;
+}
+export interface UpdateResourceDefinitionRequest {
+    
+    Name?: string;
+    
+    ResourceDefinitionId: string | undefined;
+}
+export declare namespace UpdateResourceDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateResourceDefinitionRequest) => any;
+}
+export interface UpdateResourceDefinitionResponse {
+}
+export declare namespace UpdateResourceDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: UpdateResourceDefinitionResponse) => any;
+}
+export interface UpdateSubscriptionDefinitionRequest {
+    
+    Name?: string;
+    
+    SubscriptionDefinitionId: string | undefined;
+}
+export declare namespace UpdateSubscriptionDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateSubscriptionDefinitionRequest) => any;
+}
+export interface UpdateSubscriptionDefinitionResponse {
+}
+export declare namespace UpdateSubscriptionDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: UpdateSubscriptionDefinitionResponse) => any;
+}
+
+export interface TelemetryConfigurationUpdate {
+    
+    Telemetry: Telemetry | string | undefined;
+}
+export declare namespace TelemetryConfigurationUpdate {
+    
+    const filterSensitiveLog: (obj: TelemetryConfigurationUpdate) => any;
+}
+export interface UpdateThingRuntimeConfigurationRequest {
+    
+    TelemetryConfiguration?: TelemetryConfigurationUpdate;
+    
+    ThingName: string | undefined;
+}
+export declare namespace UpdateThingRuntimeConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateThingRuntimeConfigurationRequest) => any;
+}
+export interface UpdateThingRuntimeConfigurationResponse {
+}
+export declare namespace UpdateThingRuntimeConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateThingRuntimeConfigurationResponse) => any;
+}