@aws-sdk/client-mgn 3.50.0 → 3.51.0

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

@@ -0,0 +1,1279 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    message?: string;
+    code?: string;
+}
+export interface InitializeServiceRequest {
+}
+export declare namespace InitializeServiceRequest {
+    
+    const filterSensitiveLog: (obj: InitializeServiceRequest) => any;
+}
+export interface InitializeServiceResponse {
+}
+export declare namespace InitializeServiceResponse {
+    
+    const filterSensitiveLog: (obj: InitializeServiceResponse) => any;
+}
+
+export interface ValidationExceptionField {
+    
+    name?: string;
+    
+    message?: string;
+}
+export declare namespace ValidationExceptionField {
+    
+    const filterSensitiveLog: (obj: ValidationExceptionField) => any;
+}
+export declare enum ValidationExceptionReason {
+    CANNOT_PARSE = "cannotParse",
+    FIELD_VALIDATION_FAILED = "fieldValidationFailed",
+    OTHER = "other",
+    UNKNOWN_OPERATION = "unknownOperation"
+}
+
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    message?: string;
+    code?: string;
+    
+    reason?: ValidationExceptionReason | string;
+    
+    fieldList?: ValidationExceptionField[];
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    message?: string;
+    code?: string;
+    
+    resourceId?: string;
+    
+    resourceType?: string;
+}
+export interface DeleteJobRequest {
+    
+    jobID: string | undefined;
+}
+export declare namespace DeleteJobRequest {
+    
+    const filterSensitiveLog: (obj: DeleteJobRequest) => any;
+}
+export interface DeleteJobResponse {
+}
+export declare namespace DeleteJobResponse {
+    
+    const filterSensitiveLog: (obj: DeleteJobResponse) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    message?: string;
+    code?: string;
+    
+    resourceId?: string;
+    
+    resourceType?: string;
+}
+
+export interface UninitializedAccountException extends __SmithyException, $MetadataBearer {
+    name: "UninitializedAccountException";
+    $fault: "client";
+    message?: string;
+    code?: string;
+}
+export interface DescribeJobLogItemsRequest {
+    
+    jobID: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeJobLogItemsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeJobLogItemsRequest) => any;
+}
+export declare enum JobLogEvent {
+    CLEANUP_END = "CLEANUP_END",
+    CLEANUP_FAIL = "CLEANUP_FAIL",
+    CLEANUP_START = "CLEANUP_START",
+    CONVERSION_END = "CONVERSION_END",
+    CONVERSION_FAIL = "CONVERSION_FAIL",
+    CONVERSION_START = "CONVERSION_START",
+    JOB_CANCEL = "JOB_CANCEL",
+    JOB_END = "JOB_END",
+    JOB_START = "JOB_START",
+    LAUNCH_FAILED = "LAUNCH_FAILED",
+    LAUNCH_START = "LAUNCH_START",
+    SERVER_SKIPPED = "SERVER_SKIPPED",
+    SNAPSHOT_END = "SNAPSHOT_END",
+    SNAPSHOT_FAIL = "SNAPSHOT_FAIL",
+    SNAPSHOT_START = "SNAPSHOT_START",
+    USING_PREVIOUS_SNAPSHOT = "USING_PREVIOUS_SNAPSHOT"
+}
+
+export interface JobLogEventData {
+    
+    sourceServerID?: string;
+    
+    conversionServerID?: string;
+    
+    targetInstanceID?: string;
+    
+    rawError?: string;
+}
+export declare namespace JobLogEventData {
+    
+    const filterSensitiveLog: (obj: JobLogEventData) => any;
+}
+
+export interface JobLog {
+    
+    logDateTime?: string;
+    
+    event?: JobLogEvent | string;
+    
+    eventData?: JobLogEventData;
+}
+export declare namespace JobLog {
+    
+    const filterSensitiveLog: (obj: JobLog) => any;
+}
+export interface DescribeJobLogItemsResponse {
+    
+    items?: JobLog[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeJobLogItemsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeJobLogItemsResponse) => any;
+}
+
+export interface DescribeJobsRequestFilters {
+    
+    jobIDs?: string[];
+    
+    fromDate?: string;
+    
+    toDate?: string;
+}
+export declare namespace DescribeJobsRequestFilters {
+    
+    const filterSensitiveLog: (obj: DescribeJobsRequestFilters) => any;
+}
+export interface DescribeJobsRequest {
+    
+    filters: DescribeJobsRequestFilters | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeJobsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeJobsRequest) => any;
+}
+export declare enum InitiatedBy {
+    DIAGNOSTIC = "DIAGNOSTIC",
+    START_CUTOVER = "START_CUTOVER",
+    START_TEST = "START_TEST",
+    TERMINATE = "TERMINATE"
+}
+export declare enum LaunchStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    LAUNCHED = "LAUNCHED",
+    PENDING = "PENDING",
+    TERMINATED = "TERMINATED"
+}
+
+export interface ParticipatingServer {
+    
+    sourceServerID?: string;
+    
+    launchStatus?: LaunchStatus | string;
+}
+export declare namespace ParticipatingServer {
+    
+    const filterSensitiveLog: (obj: ParticipatingServer) => any;
+}
+export declare enum JobStatus {
+    COMPLETED = "COMPLETED",
+    PENDING = "PENDING",
+    STARTED = "STARTED"
+}
+export declare enum JobType {
+    LAUNCH = "LAUNCH",
+    TERMINATE = "TERMINATE"
+}
+
+export interface Job {
+    
+    jobID: string | undefined;
+    
+    arn?: string;
+    
+    type?: JobType | string;
+    
+    initiatedBy?: InitiatedBy | string;
+    
+    creationDateTime?: string;
+    
+    endDateTime?: string;
+    
+    status?: JobStatus | string;
+    
+    participatingServers?: ParticipatingServer[];
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Job {
+    
+    const filterSensitiveLog: (obj: Job) => any;
+}
+export interface DescribeJobsResponse {
+    
+    items?: Job[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeJobsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeJobsResponse) => any;
+}
+
+export interface InternalServerException extends __SmithyException, $MetadataBearer {
+    name: "InternalServerException";
+    $fault: "server";
+    message: string | undefined;
+    
+    retryAfterSeconds?: number;
+}
+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 ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+    message: string | undefined;
+    
+    serviceCode?: string;
+    
+    quotaCode?: string;
+    
+    retryAfterSeconds?: string;
+}
+export declare enum ReplicationConfigurationDataPlaneRouting {
+    PRIVATE_IP = "PRIVATE_IP",
+    PUBLIC_IP = "PUBLIC_IP"
+}
+export declare enum ReplicationConfigurationDefaultLargeStagingDiskType {
+    GP2 = "GP2",
+    ST1 = "ST1"
+}
+export declare enum ReplicationConfigurationEbsEncryption {
+    CUSTOM = "CUSTOM",
+    DEFAULT = "DEFAULT"
+}
+export interface CreateReplicationConfigurationTemplateRequest {
+    
+    stagingAreaSubnetId: string | undefined;
+    
+    associateDefaultSecurityGroup: boolean | undefined;
+    
+    replicationServersSecurityGroupsIDs: string[] | undefined;
+    
+    replicationServerInstanceType: string | undefined;
+    
+    useDedicatedReplicationServer: boolean | undefined;
+    
+    defaultLargeStagingDiskType: ReplicationConfigurationDefaultLargeStagingDiskType | string | undefined;
+    
+    ebsEncryption: ReplicationConfigurationEbsEncryption | string | undefined;
+    
+    ebsEncryptionKeyArn?: string;
+    
+    bandwidthThrottling: number | undefined;
+    
+    dataPlaneRouting: ReplicationConfigurationDataPlaneRouting | string | undefined;
+    
+    createPublicIP: boolean | undefined;
+    
+    stagingAreaTags: {
+        [key: string]: string;
+    } | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateReplicationConfigurationTemplateRequest {
+    
+    const filterSensitiveLog: (obj: CreateReplicationConfigurationTemplateRequest) => any;
+}
+export interface ReplicationConfigurationTemplate {
+    
+    replicationConfigurationTemplateID: string | undefined;
+    
+    arn?: string;
+    
+    stagingAreaSubnetId?: string;
+    
+    associateDefaultSecurityGroup?: boolean;
+    
+    replicationServersSecurityGroupsIDs?: string[];
+    
+    replicationServerInstanceType?: string;
+    
+    useDedicatedReplicationServer?: boolean;
+    
+    defaultLargeStagingDiskType?: ReplicationConfigurationDefaultLargeStagingDiskType | string;
+    
+    ebsEncryption?: ReplicationConfigurationEbsEncryption | string;
+    
+    ebsEncryptionKeyArn?: string;
+    
+    bandwidthThrottling?: number;
+    
+    dataPlaneRouting?: ReplicationConfigurationDataPlaneRouting | string;
+    
+    createPublicIP?: boolean;
+    
+    stagingAreaTags?: {
+        [key: string]: string;
+    };
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ReplicationConfigurationTemplate {
+    
+    const filterSensitiveLog: (obj: ReplicationConfigurationTemplate) => any;
+}
+export interface DeleteReplicationConfigurationTemplateRequest {
+    
+    replicationConfigurationTemplateID: string | undefined;
+}
+export declare namespace DeleteReplicationConfigurationTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DeleteReplicationConfigurationTemplateRequest) => any;
+}
+export interface DeleteReplicationConfigurationTemplateResponse {
+}
+export declare namespace DeleteReplicationConfigurationTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DeleteReplicationConfigurationTemplateResponse) => any;
+}
+export interface DescribeReplicationConfigurationTemplatesRequest {
+    
+    replicationConfigurationTemplateIDs: string[] | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeReplicationConfigurationTemplatesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeReplicationConfigurationTemplatesRequest) => any;
+}
+export interface DescribeReplicationConfigurationTemplatesResponse {
+    
+    items?: ReplicationConfigurationTemplate[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeReplicationConfigurationTemplatesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeReplicationConfigurationTemplatesResponse) => any;
+}
+export interface UpdateReplicationConfigurationTemplateRequest {
+    
+    replicationConfigurationTemplateID: string | undefined;
+    
+    arn?: string;
+    
+    stagingAreaSubnetId?: string;
+    
+    associateDefaultSecurityGroup?: boolean;
+    
+    replicationServersSecurityGroupsIDs?: string[];
+    
+    replicationServerInstanceType?: string;
+    
+    useDedicatedReplicationServer?: boolean;
+    
+    defaultLargeStagingDiskType?: ReplicationConfigurationDefaultLargeStagingDiskType | string;
+    
+    ebsEncryption?: ReplicationConfigurationEbsEncryption | string;
+    
+    ebsEncryptionKeyArn?: string;
+    
+    bandwidthThrottling?: number;
+    
+    dataPlaneRouting?: ReplicationConfigurationDataPlaneRouting | string;
+    
+    createPublicIP?: boolean;
+    
+    stagingAreaTags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace UpdateReplicationConfigurationTemplateRequest {
+    
+    const filterSensitiveLog: (obj: UpdateReplicationConfigurationTemplateRequest) => any;
+}
+export declare enum ChangeServerLifeCycleStateSourceServerLifecycleState {
+    CUTOVER = "CUTOVER",
+    READY_FOR_CUTOVER = "READY_FOR_CUTOVER",
+    READY_FOR_TEST = "READY_FOR_TEST"
+}
+
+export interface ChangeServerLifeCycleStateSourceServerLifecycle {
+    
+    state: ChangeServerLifeCycleStateSourceServerLifecycleState | string | undefined;
+}
+export declare namespace ChangeServerLifeCycleStateSourceServerLifecycle {
+    
+    const filterSensitiveLog: (obj: ChangeServerLifeCycleStateSourceServerLifecycle) => any;
+}
+export interface ChangeServerLifeCycleStateRequest {
+    
+    sourceServerID: string | undefined;
+    
+    lifeCycle: ChangeServerLifeCycleStateSourceServerLifecycle | undefined;
+}
+export declare namespace ChangeServerLifeCycleStateRequest {
+    
+    const filterSensitiveLog: (obj: ChangeServerLifeCycleStateRequest) => any;
+}
+export declare enum DataReplicationErrorString {
+    AGENT_NOT_SEEN = "AGENT_NOT_SEEN",
+    FAILED_TO_ATTACH_STAGING_DISKS = "FAILED_TO_ATTACH_STAGING_DISKS",
+    FAILED_TO_AUTHENTICATE_WITH_SERVICE = "FAILED_TO_AUTHENTICATE_WITH_SERVICE",
+    FAILED_TO_BOOT_REPLICATION_SERVER = "FAILED_TO_BOOT_REPLICATION_SERVER",
+    FAILED_TO_CONNECT_AGENT_TO_REPLICATION_SERVER = "FAILED_TO_CONNECT_AGENT_TO_REPLICATION_SERVER",
+    FAILED_TO_CREATE_SECURITY_GROUP = "FAILED_TO_CREATE_SECURITY_GROUP",
+    FAILED_TO_CREATE_STAGING_DISKS = "FAILED_TO_CREATE_STAGING_DISKS",
+    FAILED_TO_DOWNLOAD_REPLICATION_SOFTWARE = "FAILED_TO_DOWNLOAD_REPLICATION_SOFTWARE",
+    FAILED_TO_LAUNCH_REPLICATION_SERVER = "FAILED_TO_LAUNCH_REPLICATION_SERVER",
+    FAILED_TO_PAIR_REPLICATION_SERVER_WITH_AGENT = "FAILED_TO_PAIR_REPLICATION_SERVER_WITH_AGENT",
+    FAILED_TO_START_DATA_TRANSFER = "FAILED_TO_START_DATA_TRANSFER",
+    LAST_SNAPSHOT_JOB_FAILED = "LAST_SNAPSHOT_JOB_FAILED",
+    NOT_CONVERGING = "NOT_CONVERGING",
+    SNAPSHOTS_FAILURE = "SNAPSHOTS_FAILURE",
+    UNSTABLE_NETWORK = "UNSTABLE_NETWORK",
+    UNSUPPORTED_VM_CONFIGURATION = "UNSUPPORTED_VM_CONFIGURATION"
+}
+
+export interface DataReplicationError {
+    
+    error?: DataReplicationErrorString | string;
+    
+    rawError?: string;
+}
+export declare namespace DataReplicationError {
+    
+    const filterSensitiveLog: (obj: DataReplicationError) => any;
+}
+export declare enum DataReplicationInitiationStepName {
+    ATTACH_STAGING_DISKS = "ATTACH_STAGING_DISKS",
+    AUTHENTICATE_WITH_SERVICE = "AUTHENTICATE_WITH_SERVICE",
+    BOOT_REPLICATION_SERVER = "BOOT_REPLICATION_SERVER",
+    CONNECT_AGENT_TO_REPLICATION_SERVER = "CONNECT_AGENT_TO_REPLICATION_SERVER",
+    CREATE_SECURITY_GROUP = "CREATE_SECURITY_GROUP",
+    CREATE_STAGING_DISKS = "CREATE_STAGING_DISKS",
+    DOWNLOAD_REPLICATION_SOFTWARE = "DOWNLOAD_REPLICATION_SOFTWARE",
+    LAUNCH_REPLICATION_SERVER = "LAUNCH_REPLICATION_SERVER",
+    PAIR_REPLICATION_SERVER_WITH_AGENT = "PAIR_REPLICATION_SERVER_WITH_AGENT",
+    START_DATA_TRANSFER = "START_DATA_TRANSFER",
+    WAIT = "WAIT"
+}
+export declare enum DataReplicationInitiationStepStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    NOT_STARTED = "NOT_STARTED",
+    SKIPPED = "SKIPPED",
+    SUCCEEDED = "SUCCEEDED"
+}
+
+export interface DataReplicationInitiationStep {
+    
+    name?: DataReplicationInitiationStepName | string;
+    
+    status?: DataReplicationInitiationStepStatus | string;
+}
+export declare namespace DataReplicationInitiationStep {
+    
+    const filterSensitiveLog: (obj: DataReplicationInitiationStep) => any;
+}
+
+export interface DataReplicationInitiation {
+    
+    startDateTime?: string;
+    
+    nextAttemptDateTime?: string;
+    
+    steps?: DataReplicationInitiationStep[];
+}
+export declare namespace DataReplicationInitiation {
+    
+    const filterSensitiveLog: (obj: DataReplicationInitiation) => any;
+}
+export declare enum DataReplicationState {
+    BACKLOG = "BACKLOG",
+    CONTINUOUS = "CONTINUOUS",
+    CREATING_SNAPSHOT = "CREATING_SNAPSHOT",
+    DISCONNECTED = "DISCONNECTED",
+    INITIAL_SYNC = "INITIAL_SYNC",
+    INITIATING = "INITIATING",
+    PAUSED = "PAUSED",
+    PENDING_SNAPSHOT_SHIPPING = "PENDING_SNAPSHOT_SHIPPING",
+    RESCAN = "RESCAN",
+    SHIPPING_SNAPSHOT = "SHIPPING_SNAPSHOT",
+    STALLED = "STALLED",
+    STOPPED = "STOPPED"
+}
+
+export interface DataReplicationInfoReplicatedDisk {
+    
+    deviceName?: string;
+    
+    totalStorageBytes?: number;
+    
+    replicatedStorageBytes?: number;
+    
+    rescannedStorageBytes?: number;
+    
+    backloggedStorageBytes?: number;
+}
+export declare namespace DataReplicationInfoReplicatedDisk {
+    
+    const filterSensitiveLog: (obj: DataReplicationInfoReplicatedDisk) => any;
+}
+
+export interface DataReplicationInfo {
+    
+    lagDuration?: string;
+    
+    etaDateTime?: string;
+    
+    replicatedDisks?: DataReplicationInfoReplicatedDisk[];
+    
+    dataReplicationState?: DataReplicationState | string;
+    
+    dataReplicationInitiation?: DataReplicationInitiation;
+    
+    dataReplicationError?: DataReplicationError;
+    
+    lastSnapshotDateTime?: string;
+}
+export declare namespace DataReplicationInfo {
+    
+    const filterSensitiveLog: (obj: DataReplicationInfo) => any;
+}
+export declare enum FirstBoot {
+    STOPPED = "STOPPED",
+    SUCCEEDED = "SUCCEEDED",
+    UNKNOWN = "UNKNOWN",
+    WAITING = "WAITING"
+}
+
+export interface LaunchedInstance {
+    
+    ec2InstanceID?: string;
+    
+    jobID?: string;
+    
+    firstBoot?: FirstBoot | string;
+}
+export declare namespace LaunchedInstance {
+    
+    const filterSensitiveLog: (obj: LaunchedInstance) => any;
+}
+
+export interface LifeCycleLastCutoverFinalized {
+    
+    apiCallDateTime?: string;
+}
+export declare namespace LifeCycleLastCutoverFinalized {
+    
+    const filterSensitiveLog: (obj: LifeCycleLastCutoverFinalized) => any;
+}
+
+export interface LifeCycleLastCutoverInitiated {
+    
+    apiCallDateTime?: string;
+    
+    jobID?: string;
+}
+export declare namespace LifeCycleLastCutoverInitiated {
+    
+    const filterSensitiveLog: (obj: LifeCycleLastCutoverInitiated) => any;
+}
+
+export interface LifeCycleLastCutoverReverted {
+    
+    apiCallDateTime?: string;
+}
+export declare namespace LifeCycleLastCutoverReverted {
+    
+    const filterSensitiveLog: (obj: LifeCycleLastCutoverReverted) => any;
+}
+
+export interface LifeCycleLastCutover {
+    
+    initiated?: LifeCycleLastCutoverInitiated;
+    
+    reverted?: LifeCycleLastCutoverReverted;
+    
+    finalized?: LifeCycleLastCutoverFinalized;
+}
+export declare namespace LifeCycleLastCutover {
+    
+    const filterSensitiveLog: (obj: LifeCycleLastCutover) => any;
+}
+
+export interface LifeCycleLastTestFinalized {
+    
+    apiCallDateTime?: string;
+}
+export declare namespace LifeCycleLastTestFinalized {
+    
+    const filterSensitiveLog: (obj: LifeCycleLastTestFinalized) => any;
+}
+
+export interface LifeCycleLastTestInitiated {
+    
+    apiCallDateTime?: string;
+    
+    jobID?: string;
+}
+export declare namespace LifeCycleLastTestInitiated {
+    
+    const filterSensitiveLog: (obj: LifeCycleLastTestInitiated) => any;
+}
+
+export interface LifeCycleLastTestReverted {
+    
+    apiCallDateTime?: string;
+}
+export declare namespace LifeCycleLastTestReverted {
+    
+    const filterSensitiveLog: (obj: LifeCycleLastTestReverted) => any;
+}
+
+export interface LifeCycleLastTest {
+    
+    initiated?: LifeCycleLastTestInitiated;
+    
+    reverted?: LifeCycleLastTestReverted;
+    
+    finalized?: LifeCycleLastTestFinalized;
+}
+export declare namespace LifeCycleLastTest {
+    
+    const filterSensitiveLog: (obj: LifeCycleLastTest) => any;
+}
+export declare enum LifeCycleState {
+    CUTOVER = "CUTOVER",
+    CUTTING_OVER = "CUTTING_OVER",
+    DISCONNECTED = "DISCONNECTED",
+    DISCOVERED = "DISCOVERED",
+    NOT_READY = "NOT_READY",
+    READY_FOR_CUTOVER = "READY_FOR_CUTOVER",
+    READY_FOR_TEST = "READY_FOR_TEST",
+    STOPPED = "STOPPED",
+    TESTING = "TESTING"
+}
+
+export interface LifeCycle {
+    
+    addedToServiceDateTime?: string;
+    
+    firstByteDateTime?: string;
+    
+    elapsedReplicationDuration?: string;
+    
+    lastSeenByServiceDateTime?: string;
+    
+    lastTest?: LifeCycleLastTest;
+    
+    lastCutover?: LifeCycleLastCutover;
+    
+    state?: LifeCycleState | string;
+}
+export declare namespace LifeCycle {
+    
+    const filterSensitiveLog: (obj: LifeCycle) => any;
+}
+export declare enum ReplicationType {
+    AGENT_BASED = "AGENT_BASED",
+    SNAPSHOT_SHIPPING = "SNAPSHOT_SHIPPING"
+}
+
+export interface CPU {
+    
+    cores?: number;
+    
+    modelName?: string;
+}
+export declare namespace CPU {
+    
+    const filterSensitiveLog: (obj: CPU) => any;
+}
+
+export interface Disk {
+    
+    deviceName?: string;
+    
+    bytes?: number;
+}
+export declare namespace Disk {
+    
+    const filterSensitiveLog: (obj: Disk) => any;
+}
+
+export interface IdentificationHints {
+    
+    fqdn?: string;
+    
+    hostname?: string;
+    
+    vmWareUuid?: string;
+    
+    awsInstanceID?: string;
+    
+    vmPath?: string;
+}
+export declare namespace IdentificationHints {
+    
+    const filterSensitiveLog: (obj: IdentificationHints) => any;
+}
+
+export interface NetworkInterface {
+    
+    macAddress?: string;
+    
+    ips?: string[];
+    
+    isPrimary?: boolean;
+}
+export declare namespace NetworkInterface {
+    
+    const filterSensitiveLog: (obj: NetworkInterface) => any;
+}
+
+export interface OS {
+    
+    fullString?: string;
+}
+export declare namespace OS {
+    
+    const filterSensitiveLog: (obj: OS) => any;
+}
+
+export interface SourceProperties {
+    
+    lastUpdatedDateTime?: string;
+    
+    recommendedInstanceType?: string;
+    
+    identificationHints?: IdentificationHints;
+    
+    networkInterfaces?: NetworkInterface[];
+    
+    disks?: Disk[];
+    
+    cpus?: CPU[];
+    
+    ramBytes?: number;
+    
+    os?: OS;
+}
+export declare namespace SourceProperties {
+    
+    const filterSensitiveLog: (obj: SourceProperties) => any;
+}
+export interface SourceServer {
+    
+    sourceServerID?: string;
+    
+    arn?: string;
+    
+    isArchived?: boolean;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    launchedInstance?: LaunchedInstance;
+    
+    dataReplicationInfo?: DataReplicationInfo;
+    
+    lifeCycle?: LifeCycle;
+    
+    sourceProperties?: SourceProperties;
+    
+    replicationType?: ReplicationType | string;
+    
+    vcenterClientID?: string;
+}
+export declare namespace SourceServer {
+    
+    const filterSensitiveLog: (obj: SourceServer) => any;
+}
+export interface DeleteSourceServerRequest {
+    
+    sourceServerID: string | undefined;
+}
+export declare namespace DeleteSourceServerRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSourceServerRequest) => any;
+}
+export interface DeleteSourceServerResponse {
+}
+export declare namespace DeleteSourceServerResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSourceServerResponse) => any;
+}
+
+export interface DescribeSourceServersRequestFilters {
+    
+    sourceServerIDs?: string[];
+    
+    isArchived?: boolean;
+    
+    replicationTypes?: (ReplicationType | string)[];
+    
+    lifeCycleStates?: (LifeCycleState | string)[];
+}
+export declare namespace DescribeSourceServersRequestFilters {
+    
+    const filterSensitiveLog: (obj: DescribeSourceServersRequestFilters) => any;
+}
+export interface DescribeSourceServersRequest {
+    
+    filters: DescribeSourceServersRequestFilters | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeSourceServersRequest {
+    
+    const filterSensitiveLog: (obj: DescribeSourceServersRequest) => any;
+}
+export interface DescribeSourceServersResponse {
+    
+    items?: SourceServer[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeSourceServersResponse {
+    
+    const filterSensitiveLog: (obj: DescribeSourceServersResponse) => any;
+}
+export interface DisconnectFromServiceRequest {
+    
+    sourceServerID: string | undefined;
+}
+export declare namespace DisconnectFromServiceRequest {
+    
+    const filterSensitiveLog: (obj: DisconnectFromServiceRequest) => any;
+}
+export interface FinalizeCutoverRequest {
+    
+    sourceServerID: string | undefined;
+}
+export declare namespace FinalizeCutoverRequest {
+    
+    const filterSensitiveLog: (obj: FinalizeCutoverRequest) => any;
+}
+export interface GetLaunchConfigurationRequest {
+    
+    sourceServerID: string | undefined;
+}
+export declare namespace GetLaunchConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetLaunchConfigurationRequest) => any;
+}
+export declare enum LaunchDisposition {
+    STARTED = "STARTED",
+    STOPPED = "STOPPED"
+}
+
+export interface Licensing {
+    
+    osByol?: boolean;
+}
+export declare namespace Licensing {
+    
+    const filterSensitiveLog: (obj: Licensing) => any;
+}
+export declare enum TargetInstanceTypeRightSizingMethod {
+    BASIC = "BASIC",
+    NONE = "NONE"
+}
+export interface LaunchConfiguration {
+    
+    sourceServerID?: string;
+    
+    name?: string;
+    
+    ec2LaunchTemplateID?: string;
+    
+    launchDisposition?: LaunchDisposition | string;
+    
+    targetInstanceTypeRightSizingMethod?: TargetInstanceTypeRightSizingMethod | string;
+    
+    copyPrivateIp?: boolean;
+    
+    copyTags?: boolean;
+    
+    licensing?: Licensing;
+}
+export declare namespace LaunchConfiguration {
+    
+    const filterSensitiveLog: (obj: LaunchConfiguration) => any;
+}
+export interface GetReplicationConfigurationRequest {
+    
+    sourceServerID: string | undefined;
+}
+export declare namespace GetReplicationConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetReplicationConfigurationRequest) => any;
+}
+export declare enum ReplicationConfigurationReplicatedDiskStagingDiskType {
+    AUTO = "AUTO",
+    GP2 = "GP2",
+    IO1 = "IO1",
+    SC1 = "SC1",
+    ST1 = "ST1",
+    STANDARD = "STANDARD"
+}
+
+export interface ReplicationConfigurationReplicatedDisk {
+    
+    deviceName?: string;
+    
+    isBootDisk?: boolean;
+    
+    stagingDiskType?: ReplicationConfigurationReplicatedDiskStagingDiskType | string;
+    
+    iops?: number;
+}
+export declare namespace ReplicationConfigurationReplicatedDisk {
+    
+    const filterSensitiveLog: (obj: ReplicationConfigurationReplicatedDisk) => any;
+}
+export interface ReplicationConfiguration {
+    
+    sourceServerID?: string;
+    
+    name?: string;
+    
+    stagingAreaSubnetId?: string;
+    
+    associateDefaultSecurityGroup?: boolean;
+    
+    replicationServersSecurityGroupsIDs?: string[];
+    
+    replicationServerInstanceType?: string;
+    
+    useDedicatedReplicationServer?: boolean;
+    
+    defaultLargeStagingDiskType?: ReplicationConfigurationDefaultLargeStagingDiskType | string;
+    
+    replicatedDisks?: ReplicationConfigurationReplicatedDisk[];
+    
+    ebsEncryption?: ReplicationConfigurationEbsEncryption | string;
+    
+    ebsEncryptionKeyArn?: string;
+    
+    bandwidthThrottling?: number;
+    
+    dataPlaneRouting?: ReplicationConfigurationDataPlaneRouting | string;
+    
+    createPublicIP?: boolean;
+    
+    stagingAreaTags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ReplicationConfiguration {
+    
+    const filterSensitiveLog: (obj: ReplicationConfiguration) => any;
+}
+export interface MarkAsArchivedRequest {
+    
+    sourceServerID: string | undefined;
+}
+export declare namespace MarkAsArchivedRequest {
+    
+    const filterSensitiveLog: (obj: MarkAsArchivedRequest) => any;
+}
+export interface RetryDataReplicationRequest {
+    
+    sourceServerID: string | undefined;
+}
+export declare namespace RetryDataReplicationRequest {
+    
+    const filterSensitiveLog: (obj: RetryDataReplicationRequest) => any;
+}
+export interface StartCutoverRequest {
+    
+    sourceServerIDs: string[] | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace StartCutoverRequest {
+    
+    const filterSensitiveLog: (obj: StartCutoverRequest) => any;
+}
+export interface StartCutoverResponse {
+    
+    job?: Job;
+}
+export declare namespace StartCutoverResponse {
+    
+    const filterSensitiveLog: (obj: StartCutoverResponse) => any;
+}
+
+export interface ServiceQuotaExceededException extends __SmithyException, $MetadataBearer {
+    name: "ServiceQuotaExceededException";
+    $fault: "client";
+    message?: string;
+    code?: string;
+    
+    resourceId?: string;
+    
+    resourceType?: string;
+    
+    serviceCode?: string;
+    
+    quotaCode?: string;
+}
+export interface StartReplicationRequest {
+    
+    sourceServerID: string | undefined;
+}
+export declare namespace StartReplicationRequest {
+    
+    const filterSensitiveLog: (obj: StartReplicationRequest) => any;
+}
+export interface StartTestRequest {
+    
+    sourceServerIDs: string[] | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace StartTestRequest {
+    
+    const filterSensitiveLog: (obj: StartTestRequest) => any;
+}
+export interface StartTestResponse {
+    
+    job?: Job;
+}
+export declare namespace StartTestResponse {
+    
+    const filterSensitiveLog: (obj: StartTestResponse) => any;
+}
+export interface TerminateTargetInstancesRequest {
+    
+    sourceServerIDs: string[] | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace TerminateTargetInstancesRequest {
+    
+    const filterSensitiveLog: (obj: TerminateTargetInstancesRequest) => any;
+}
+export interface TerminateTargetInstancesResponse {
+    
+    job?: Job;
+}
+export declare namespace TerminateTargetInstancesResponse {
+    
+    const filterSensitiveLog: (obj: TerminateTargetInstancesResponse) => any;
+}
+export interface UpdateLaunchConfigurationRequest {
+    
+    sourceServerID: string | undefined;
+    
+    name?: string;
+    
+    launchDisposition?: LaunchDisposition | string;
+    
+    targetInstanceTypeRightSizingMethod?: TargetInstanceTypeRightSizingMethod | string;
+    
+    copyPrivateIp?: boolean;
+    
+    copyTags?: boolean;
+    
+    licensing?: Licensing;
+}
+export declare namespace UpdateLaunchConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateLaunchConfigurationRequest) => any;
+}
+export interface UpdateReplicationConfigurationRequest {
+    
+    sourceServerID: string | undefined;
+    
+    name?: string;
+    
+    stagingAreaSubnetId?: string;
+    
+    associateDefaultSecurityGroup?: boolean;
+    
+    replicationServersSecurityGroupsIDs?: string[];
+    
+    replicationServerInstanceType?: string;
+    
+    useDedicatedReplicationServer?: boolean;
+    
+    defaultLargeStagingDiskType?: ReplicationConfigurationDefaultLargeStagingDiskType | string;
+    
+    replicatedDisks?: ReplicationConfigurationReplicatedDisk[];
+    
+    ebsEncryption?: ReplicationConfigurationEbsEncryption | string;
+    
+    ebsEncryptionKeyArn?: string;
+    
+    bandwidthThrottling?: number;
+    
+    dataPlaneRouting?: ReplicationConfigurationDataPlaneRouting | string;
+    
+    createPublicIP?: boolean;
+    
+    stagingAreaTags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace UpdateReplicationConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateReplicationConfigurationRequest) => any;
+}
+export interface UpdateSourceServerReplicationTypeRequest {
+    
+    sourceServerID: string | undefined;
+    
+    replicationType: ReplicationType | string | undefined;
+}
+export declare namespace UpdateSourceServerReplicationTypeRequest {
+    
+    const filterSensitiveLog: (obj: UpdateSourceServerReplicationTypeRequest) => any;
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+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 DeleteVcenterClientRequest {
+    
+    vcenterClientID: string | undefined;
+}
+export declare namespace DeleteVcenterClientRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVcenterClientRequest) => any;
+}
+export interface DescribeVcenterClientsRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeVcenterClientsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeVcenterClientsRequest) => any;
+}
+
+export interface VcenterClient {
+    
+    vcenterClientID?: string;
+    
+    arn?: string;
+    
+    hostname?: string;
+    
+    vcenterUUID?: string;
+    
+    datacenterName?: string;
+    
+    lastSeenDatetime?: string;
+    
+    sourceServerTags?: {
+        [key: string]: string;
+    };
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace VcenterClient {
+    
+    const filterSensitiveLog: (obj: VcenterClient) => any;
+}
+export interface DescribeVcenterClientsResponse {
+    
+    items?: VcenterClient[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeVcenterClientsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeVcenterClientsResponse) => any;
+}