## API Report File for "@azure/arm-recoveryservices-siterecovery"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import * as coreAuth from '@azure/core-auth';
import * as coreClient from '@azure/core-client';
import { OperationState } from '@azure/core-lro';
import { PagedAsyncIterableIterator } from '@azure/core-paging';
import { SimplePollerLike } from '@azure/core-lro';

// @public
export interface A2AAddDisksInput extends AddDisksProviderSpecificInput {
    instanceType: "A2A";
    vmDisks?: A2AVmDiskInputDetails[];
    vmManagedDisks?: A2AVmManagedDiskInputDetails[];
}

// @public
export interface A2AApplyClusterRecoveryPointInput extends ApplyClusterRecoveryPointProviderSpecificInput {
    instanceType: "A2A";
}

// @public
export interface A2AApplyRecoveryPointInput extends ApplyRecoveryPointProviderSpecificInput {
    instanceType: "A2A";
}

// @public
export interface A2AClusterRecoveryPointDetails extends ClusterProviderSpecificRecoveryPointDetails {
    instanceType: "A2A";
    nodes?: string[];
    recoveryPointSyncType?: RecoveryPointSyncType;
}

// @public
export interface A2AClusterTestFailoverInput extends ClusterTestFailoverProviderSpecificInput {
    clusterRecoveryPointId?: string;
    individualNodeRecoveryPoints?: string[];
    instanceType: "A2A";
}

// @public
export interface A2AClusterUnplannedFailoverInput extends ClusterUnplannedFailoverProviderSpecificInput {
    clusterRecoveryPointId?: string;
    individualNodeRecoveryPoints?: string[];
    instanceType: "A2A";
}

// @public
export interface A2AContainerCreationInput extends ReplicationProviderSpecificContainerCreationInput {
    instanceType: "A2A";
}

// @public
export interface A2AContainerMappingInput extends ReplicationProviderSpecificContainerMappingInput {
    agentAutoUpdateStatus?: AgentAutoUpdateStatus;
    automationAccountArmId?: string;
    automationAccountAuthenticationType?: AutomationAccountAuthenticationType;
    instanceType: "A2A";
}

// @public
export interface A2ACreateProtectionIntentInput extends CreateProtectionIntentProviderSpecificDetails {
    agentAutoUpdateStatus?: AgentAutoUpdateStatus;
    automationAccountArmId?: string;
    automationAccountAuthenticationType?: AutomationAccountAuthenticationType;
    autoProtectionOfDataDisk?: AutoProtectionOfDataDisk;
    diskEncryptionInfo?: DiskEncryptionInfo;
    fabricObjectId: string;
    instanceType: "A2A";
    multiVmGroupId?: string;
    multiVmGroupName?: string;
    primaryLocation: string;
    primaryStagingStorageAccountCustomInput?: StorageAccountCustomDetailsUnion;
    protectionProfileCustomInput?: ProtectionProfileCustomDetailsUnion;
    recoveryAvailabilitySetCustomInput?: RecoveryAvailabilitySetCustomDetailsUnion;
    recoveryAvailabilityType: A2ARecoveryAvailabilityType;
    recoveryAvailabilityZone?: string;
    recoveryBootDiagStorageAccount?: StorageAccountCustomDetailsUnion;
    recoveryLocation: string;
    recoveryProximityPlacementGroupCustomInput?: RecoveryProximityPlacementGroupCustomDetailsUnion;
    recoveryResourceGroupId: string;
    recoverySubscriptionId: string;
    recoveryVirtualNetworkCustomInput?: RecoveryVirtualNetworkCustomDetailsUnion;
    vmDisks?: A2AProtectionIntentDiskInputDetails[];
    vmManagedDisks?: A2AProtectionIntentManagedDiskInputDetails[];
}

// @public
export interface A2ACrossClusterMigrationApplyRecoveryPointInput extends ApplyRecoveryPointProviderSpecificInput {
    instanceType: "A2ACrossClusterMigration";
}

// @public
export interface A2ACrossClusterMigrationContainerCreationInput extends ReplicationProviderSpecificContainerCreationInput {
    instanceType: "A2ACrossClusterMigration";
}

// @public
export interface A2ACrossClusterMigrationEnableProtectionInput extends EnableProtectionProviderSpecificInput {
    fabricObjectId?: string;
    instanceType: "A2ACrossClusterMigration";
    recoveryContainerId?: string;
}

// @public
export interface A2ACrossClusterMigrationPolicyCreationInput extends PolicyProviderSpecificInput {
    instanceType: "A2ACrossClusterMigration";
}

// @public
export interface A2ACrossClusterMigrationReplicationDetails extends ReplicationProviderSpecificSettings {
    fabricObjectId?: string;
    instanceType: "A2ACrossClusterMigration";
    lifecycleId?: string;
    osType?: string;
    primaryFabricLocation?: string;
    vmProtectionState?: string;
    vmProtectionStateDescription?: string;
}

// @public
export interface A2AEnableProtectionInput extends EnableProtectionProviderSpecificInput {
    autoProtectionOfDataDisk?: AutoProtectionOfDataDisk;
    diskEncryptionInfo?: DiskEncryptionInfo;
    fabricObjectId: string;
    instanceType: "A2A";
    multiVmGroupId?: string;
    multiVmGroupName?: string;
    protectionClusterId?: string;
    recoveryAvailabilitySetId?: string;
    recoveryAvailabilityZone?: string;
    recoveryAzureNetworkId?: string;
    recoveryBootDiagStorageAccountId?: string;
    recoveryCapacityReservationGroupId?: string;
    recoveryCloudServiceId?: string;
    recoveryContainerId?: string;
    recoveryExtendedLocation?: ExtendedLocation;
    recoveryProximityPlacementGroupId?: string;
    recoveryResourceGroupId?: string;
    recoverySubnetName?: string;
    recoveryVirtualMachineScaleSetId?: string;
    vmDisks?: A2AVmDiskInputDetails[];
    vmManagedDisks?: A2AVmManagedDiskInputDetails[];
}

// @public
export interface A2AEventDetails extends EventProviderSpecificDetails {
    fabricLocation?: string;
    fabricName?: string;
    fabricObjectId?: string;
    instanceType: "A2A";
    protectedItemName?: string;
    remoteFabricLocation?: string;
    remoteFabricName?: string;
}

// @public
export interface A2AExtendedLocationDetails {
    primaryExtendedLocation?: ExtendedLocation;
    recoveryExtendedLocation?: ExtendedLocation;
}

// @public
export interface A2AFabricSpecificLocationDetails {
    initialPrimaryExtendedLocation?: ExtendedLocation;
    initialPrimaryFabricLocation?: string;
    initialPrimaryZone?: string;
    initialRecoveryExtendedLocation?: ExtendedLocation;
    initialRecoveryFabricLocation?: string;
    initialRecoveryZone?: string;
    primaryExtendedLocation?: ExtendedLocation;
    primaryFabricLocation?: string;
    primaryZone?: string;
    recoveryExtendedLocation?: ExtendedLocation;
    recoveryFabricLocation?: string;
    recoveryZone?: string;
}

// @public
export interface A2APolicyCreationInput extends PolicyProviderSpecificInput {
    appConsistentFrequencyInMinutes?: number;
    crashConsistentFrequencyInMinutes?: number;
    instanceType: "A2A";
    multiVmSyncStatus: SetMultiVmSyncStatus;
    recoveryPointHistory?: number;
}

// @public
export interface A2APolicyDetails extends PolicyProviderSpecificDetails {
    appConsistentFrequencyInMinutes?: number;
    crashConsistentFrequencyInMinutes?: number;
    instanceType: "A2A";
    multiVmSyncStatus?: string;
    recoveryPointHistory?: number;
    recoveryPointThresholdInMinutes?: number;
}

// @public
export interface A2AProtectedDiskDetails {
    allowedDiskLevelOperation?: string[];
    dataPendingAtSourceAgentInMB?: number;
    dataPendingInStagingStorageAccountInMB?: number;
    dekKeyVaultArmId?: string;
    diskCapacityInBytes?: number;
    diskName?: string;
    diskState?: string;
    diskType?: string;
    diskUri?: string;
    failoverDiskName?: string;
    isDiskEncrypted?: boolean;
    isDiskKeyEncrypted?: boolean;
    kekKeyVaultArmId?: string;
    keyIdentifier?: string;
    monitoringJobType?: string;
    monitoringPercentageCompletion?: number;
    primaryDiskAzureStorageAccountId?: string;
    primaryStagingAzureStorageAccountId?: string;
    recoveryAzureStorageAccountId?: string;
    recoveryDiskUri?: string;
    resyncRequired?: boolean;
    secretIdentifier?: string;
    tfoDiskName?: string;
}

// @public
export interface A2AProtectedItemDetail {
    diskEncryptionInfo?: DiskEncryptionInfo;
    recoveryAvailabilitySetId?: string;
    recoveryAvailabilityZone?: string;
    recoveryBootDiagStorageAccountId?: string;
    recoveryCapacityReservationGroupId?: string;
    recoveryProximityPlacementGroupId?: string;
    recoveryResourceGroupId?: string;
    recoveryVirtualMachineScaleSetId?: string;
    replicationProtectedItemName?: string;
    vmManagedDisks?: A2AVmManagedDiskInputDetails[];
}

// @public
export interface A2AProtectedManagedDiskDetails {
    allowedDiskLevelOperation?: string[];
    dataPendingAtSourceAgentInMB?: number;
    dataPendingInStagingStorageAccountInMB?: number;
    dekKeyVaultArmId?: string;
    diskCapacityInBytes?: number;
    diskId?: string;
    diskName?: string;
    diskState?: string;
    diskType?: string;
    failoverDiskName?: string;
    isDiskEncrypted?: boolean;
    isDiskKeyEncrypted?: boolean;
    kekKeyVaultArmId?: string;
    keyIdentifier?: string;
    monitoringJobType?: string;
    monitoringPercentageCompletion?: number;
    primaryDiskEncryptionSetId?: string;
    primaryStagingAzureStorageAccountId?: string;
    recoveryDiskEncryptionSetId?: string;
    recoveryOrignalTargetDiskId?: string;
    recoveryReplicaDiskAccountType?: string;
    recoveryReplicaDiskId?: string;
    recoveryResourceGroupId?: string;
    recoveryTargetDiskAccountType?: string;
    recoveryTargetDiskId?: string;
    resyncRequired?: boolean;
    secretIdentifier?: string;
    tfoDiskName?: string;
}

// @public
export interface A2AProtectionContainerMappingDetails extends ProtectionContainerMappingProviderSpecificDetails {
    agentAutoUpdateStatus?: AgentAutoUpdateStatus;
    automationAccountArmId?: string;
    automationAccountAuthenticationType?: AutomationAccountAuthenticationType;
    instanceType: "A2A";
    jobScheduleName?: string;
    scheduleName?: string;
}

// @public
export interface A2AProtectionIntentDiskInputDetails {
    diskUri: string;
    primaryStagingStorageAccountCustomInput?: StorageAccountCustomDetailsUnion;
    recoveryAzureStorageAccountCustomInput?: StorageAccountCustomDetailsUnion;
}

// @public
export interface A2AProtectionIntentManagedDiskInputDetails {
    diskEncryptionInfo?: DiskEncryptionInfo;
    diskId: string;
    primaryStagingStorageAccountCustomInput?: StorageAccountCustomDetailsUnion;
    recoveryDiskEncryptionSetId?: string;
    recoveryReplicaDiskAccountType?: string;
    recoveryResourceGroupCustomInput?: RecoveryResourceGroupCustomDetailsUnion;
    recoveryTargetDiskAccountType?: string;
}

// @public
export type A2ARecoveryAvailabilityType = string;

// @public
export interface A2ARecoveryPointDetails extends ProviderSpecificRecoveryPointDetails {
    disks?: string[];
    instanceType: "A2A";
    recoveryPointSyncType?: RecoveryPointSyncType;
}

// @public
export interface A2ARemoveDisksInput extends RemoveDisksProviderSpecificInput {
    instanceType: "A2A";
    vmDisksUris?: string[];
    vmManagedDisksIds?: string[];
}

// @public
export interface A2AReplicationDetails extends ReplicationProviderSpecificSettings {
    readonly agentCertificateExpiryDate?: Date;
    agentExpiryDate?: Date;
    agentVersion?: string;
    autoProtectionOfDataDisk?: AutoProtectionOfDataDisk;
    readonly churnOptionSelected?: ChurnOptionSelected;
    fabricObjectId?: string;
    initialPrimaryExtendedLocation?: ExtendedLocation;
    readonly initialPrimaryFabricLocation?: string;
    readonly initialPrimaryZone?: string;
    initialRecoveryExtendedLocation?: ExtendedLocation;
    readonly initialRecoveryFabricLocation?: string;
    readonly initialRecoveryZone?: string;
    instanceType: "A2A";
    isClusterInfraReady?: boolean;
    isReplicationAgentCertificateUpdateRequired?: boolean;
    isReplicationAgentUpdateRequired?: boolean;
    lastHeartbeat?: Date;
    lastRpoCalculatedTime?: Date;
    lifecycleId?: string;
    managementId?: string;
    monitoringJobType?: string;
    monitoringPercentageCompletion?: number;
    multiVmGroupCreateOption?: MultiVmGroupCreateOption;
    multiVmGroupId?: string;
    multiVmGroupName?: string;
    osType?: string;
    primaryAvailabilityZone?: string;
    primaryExtendedLocation?: ExtendedLocation;
    primaryFabricLocation?: string;
    protectedDisks?: A2AProtectedDiskDetails[];
    protectedManagedDisks?: A2AProtectedManagedDiskDetails[];
    protectionClusterId?: string;
    recoveryAvailabilitySet?: string;
    recoveryAvailabilityZone?: string;
    readonly recoveryAzureGeneration?: string;
    recoveryAzureResourceGroupId?: string;
    recoveryAzureVMName?: string;
    recoveryAzureVMSize?: string;
    recoveryBootDiagStorageAccountId?: string;
    recoveryCapacityReservationGroupId?: string;
    recoveryCloudService?: string;
    recoveryExtendedLocation?: ExtendedLocation;
    recoveryFabricLocation?: string;
    recoveryFabricObjectId?: string;
    recoveryProximityPlacementGroupId?: string;
    recoveryVirtualMachineScaleSetId?: string;
    rpoInSeconds?: number;
    selectedRecoveryAzureNetworkId?: string;
    selectedTfoAzureNetworkId?: string;
    testFailoverRecoveryFabricObjectId?: string;
    tfoAzureVMName?: string;
    unprotectedDisks?: A2AUnprotectedDiskDetails[];
    readonly vmEncryptionType?: VmEncryptionType;
    vmNics?: VMNicDetails[];
    vmProtectionState?: string;
    vmProtectionStateDescription?: string;
    vmSyncedConfigDetails?: AzureToAzureVmSyncedConfigDetails;
}

// @public
export interface A2AReplicationIntentDetails extends ReplicationProtectionIntentProviderSpecificSettings {
    agentAutoUpdateStatus?: AgentAutoUpdateStatus;
    automationAccountArmId?: string;
    automationAccountAuthenticationType?: AutomationAccountAuthenticationType;
    autoProtectionOfDataDisk?: AutoProtectionOfDataDisk;
    diskEncryptionInfo?: DiskEncryptionInfo;
    fabricObjectId?: string;
    instanceType: "A2A";
    multiVmGroupId?: string;
    multiVmGroupName?: string;
    primaryLocation?: string;
    primaryStagingStorageAccount?: StorageAccountCustomDetailsUnion;
    protectionProfile?: ProtectionProfileCustomDetailsUnion;
    recoveryAvailabilitySet?: RecoveryAvailabilitySetCustomDetailsUnion;
    recoveryAvailabilityType: string;
    recoveryAvailabilityZone?: string;
    recoveryBootDiagStorageAccount?: StorageAccountCustomDetailsUnion;
    recoveryLocation?: string;
    recoveryProximityPlacementGroup?: RecoveryProximityPlacementGroupCustomDetailsUnion;
    recoveryResourceGroupId?: string;
    recoverySubscriptionId?: string;
    recoveryVirtualNetwork?: RecoveryVirtualNetworkCustomDetailsUnion;
    vmDisks?: A2AProtectionIntentDiskInputDetails[];
    vmManagedDisks?: A2AProtectionIntentManagedDiskInputDetails[];
}

// @public
export interface A2AReplicationProtectionClusterDetails extends ReplicationClusterProviderSpecificSettings {
    clusterManagementId?: string;
    failoverRecoveryPointId?: string;
    initialPrimaryExtendedLocation?: ExtendedLocation;
    initialPrimaryFabricLocation?: string;
    initialPrimaryZone?: string;
    initialRecoveryExtendedLocation?: ExtendedLocation;
    initialRecoveryFabricLocation?: string;
    initialRecoveryZone?: string;
    instanceType: "A2A";
    lastRpoCalculatedTime?: Date;
    lifecycleId?: string;
    multiVmGroupCreateOption?: MultiVmGroupCreateOption;
    multiVmGroupId?: string;
    multiVmGroupName?: string;
    primaryAvailabilityZone?: string;
    primaryExtendedLocation?: ExtendedLocation;
    primaryFabricLocation?: string;
    recoveryAvailabilityZone?: string;
    recoveryExtendedLocation?: ExtendedLocation;
    recoveryFabricLocation?: string;
    rpoInSeconds?: number;
}

// @public
export interface A2AReprotectInput extends ReverseReplicationProviderSpecificInput {
    instanceType: "A2A";
    policyId?: string;
    recoveryAvailabilitySetId?: string;
    recoveryCloudServiceId?: string;
    recoveryContainerId?: string;
    recoveryResourceGroupId?: string;
    vmDisks?: A2AVmDiskInputDetails[];
}

// @public
export type A2ARpRecoveryPointType = string;

// @public
export interface A2ASharedDiskIRErrorDetails {
    readonly errorCode?: string;
    readonly errorCodeEnum?: string;
    readonly errorMessage?: string;
    readonly possibleCauses?: string;
    readonly recommendedAction?: string;
}

// @public
export interface A2ASharedDiskReplicationDetails extends SharedDiskReplicationProviderSpecificSettings {
    failoverRecoveryPointId?: string;
    instanceType: "A2A";
    lastRpoCalculatedTime?: Date;
    managementId?: string;
    monitoringJobType?: string;
    monitoringPercentageCompletion?: number;
    primaryFabricLocation?: string;
    protectedManagedDisks?: A2AProtectedManagedDiskDetails[];
    recoveryFabricLocation?: string;
    rpoInSeconds?: number;
    sharedDiskIRErrors?: A2ASharedDiskIRErrorDetails[];
    unprotectedDisks?: A2AUnprotectedDiskDetails[];
}

// @public
export interface A2ASwitchClusterProtectionInput extends SwitchClusterProtectionProviderSpecificInput {
    instanceType: "A2A";
    policyId?: string;
    // (undocumented)
    protectedItemsDetail?: A2AProtectedItemDetail[];
    recoveryContainerId?: string;
}

// @public
export interface A2ASwitchProtectionInput extends SwitchProtectionProviderSpecificInput {
    diskEncryptionInfo?: DiskEncryptionInfo;
    instanceType: "A2A";
    policyId?: string;
    recoveryAvailabilitySetId?: string;
    recoveryAvailabilityZone?: string;
    recoveryBootDiagStorageAccountId?: string;
    recoveryCapacityReservationGroupId?: string;
    recoveryCloudServiceId?: string;
    recoveryContainerId?: string;
    recoveryProximityPlacementGroupId?: string;
    recoveryResourceGroupId?: string;
    recoveryVirtualMachineScaleSetId?: string;
    vmDisks?: A2AVmDiskInputDetails[];
    vmManagedDisks?: A2AVmManagedDiskInputDetails[];
}

// @public
export interface A2ATestFailoverInput extends TestFailoverProviderSpecificInput {
    cloudServiceCreationOption?: string;
    instanceType: "A2A";
    recoveryPointId?: string;
}

// @public
export interface A2AUnplannedFailoverInput extends UnplannedFailoverProviderSpecificInput {
    cloudServiceCreationOption?: string;
    instanceType: "A2A";
    recoveryPointId?: string;
}

// @public
export interface A2AUnprotectedDiskDetails {
    diskAutoProtectionStatus?: AutoProtectionOfDataDisk;
    diskLunId?: number;
}

// @public
export interface A2AUpdateContainerMappingInput extends ReplicationProviderSpecificUpdateContainerMappingInput {
    agentAutoUpdateStatus?: AgentAutoUpdateStatus;
    automationAccountArmId?: string;
    automationAccountAuthenticationType?: AutomationAccountAuthenticationType;
    instanceType: "A2A";
}

// @public
export interface A2AUpdateReplicationProtectedItemInput extends UpdateReplicationProtectedItemProviderInput {
    diskEncryptionInfo?: DiskEncryptionInfo;
    instanceType: "A2A";
    managedDiskUpdateDetails?: A2AVmManagedDiskUpdateDetails[];
    recoveryBootDiagStorageAccountId?: string;
    recoveryCapacityReservationGroupId?: string;
    recoveryCloudServiceId?: string;
    recoveryProximityPlacementGroupId?: string;
    recoveryResourceGroupId?: string;
    recoveryVirtualMachineScaleSetId?: string;
    tfoAzureVMName?: string;
}

// @public
export interface A2AVmDiskInputDetails {
    diskUri: string;
    primaryStagingAzureStorageAccountId: string;
    recoveryAzureStorageAccountId: string;
}

// @public
export interface A2AVmManagedDiskInputDetails {
    diskEncryptionInfo?: DiskEncryptionInfo;
    diskId: string;
    primaryStagingAzureStorageAccountId: string;
    recoveryDiskEncryptionSetId?: string;
    recoveryReplicaDiskAccountType?: string;
    recoveryResourceGroupId: string;
    recoveryTargetDiskAccountType?: string;
}

// @public
export interface A2AVmManagedDiskUpdateDetails {
    diskEncryptionInfo?: DiskEncryptionInfo;
    diskId?: string;
    failoverDiskName?: string;
    recoveryReplicaDiskAccountType?: string;
    recoveryTargetDiskAccountType?: string;
    tfoDiskName?: string;
}

// @public
export interface A2AZoneDetails {
    source?: string;
    target?: string;
}

// @public
export interface AddDisksInput {
    properties?: AddDisksInputProperties;
}

// @public
export interface AddDisksInputProperties {
    providerSpecificDetails: AddDisksProviderSpecificInputUnion;
}

// @public
export interface AddDisksProviderSpecificInput {
    instanceType: "A2A" | "InMageRcm";
}

// @public (undocumented)
export type AddDisksProviderSpecificInputUnion = AddDisksProviderSpecificInput | A2AAddDisksInput | InMageRcmAddDisksInput;

// @public
export interface AddRecoveryServicesProviderInput {
    properties: AddRecoveryServicesProviderInputProperties;
}

// @public
export interface AddRecoveryServicesProviderInputProperties {
    authenticationIdentityInput: IdentityProviderInput;
    biosId?: string;
    dataPlaneAuthenticationIdentityInput?: IdentityProviderInput;
    machineId?: string;
    machineName: string;
    resourceAccessIdentityInput: IdentityProviderInput;
}

// @public
export interface AddVCenterRequest {
    properties?: AddVCenterRequestProperties;
}

// @public
export interface AddVCenterRequestProperties {
    friendlyName?: string;
    ipAddress?: string;
    port?: string;
    processServerId?: string;
    runAsAccountId?: string;
}

// @public
export type AgentAutoUpdateStatus = string;

// @public
export interface AgentDetails {
    readonly agentId?: string;
    readonly biosId?: string;
    readonly disks?: AgentDiskDetails[];
    readonly fqdn?: string;
    readonly machineId?: string;
}

// @public
export interface AgentDiskDetails {
    readonly capacityInBytes?: number;
    readonly diskId?: string;
    readonly diskName?: string;
    readonly isOSDisk?: string;
    readonly lunId?: number;
}

// @public
export type AgentUpgradeBlockedReason = string;

// @public
export type AgentVersionStatus = string;

// @public
export interface Alert extends Resource {
    properties?: AlertProperties;
}

// @public
export interface AlertCollection {
    nextLink?: string;
    value?: Alert[];
}

// @public
export interface AlertProperties {
    customEmailAddresses?: string[];
    locale?: string;
    sendToOwners?: string;
}

// @public
export type AlternateLocationRecoveryOption = string;

// @public
export interface ApplianceCollection {
    nextLink?: string;
    value?: ReplicationAppliance[];
}

// @public
export interface ApplianceMonitoringDetails {
    readonly cpuDetails?: ApplianceResourceDetails;
    readonly datastoreSnapshot?: DataStoreUtilizationDetails[];
    readonly disksReplicationDetails?: ApplianceResourceDetails;
    readonly esxiNfcBuffer?: ApplianceResourceDetails;
    readonly networkBandwidth?: ApplianceResourceDetails;
    readonly ramDetails?: ApplianceResourceDetails;
}

// @public
export interface ApplianceQueryParameter {
    providerType?: string;
}

// @public
export interface ApplianceResourceDetails {
    readonly capacity?: number;
    readonly processUtilization?: number;
    readonly status?: string;
    readonly totalUtilization?: number;
}

// @public
export interface ApplianceSpecificDetails {
    instanceType: "InMageRcm";
}

// @public (undocumented)
export type ApplianceSpecificDetailsUnion = ApplianceSpecificDetails | InMageRcmApplianceSpecificDetails;

// @public
export interface ApplyClusterRecoveryPointInput {
    properties: ApplyClusterRecoveryPointInputProperties;
}

// @public
export interface ApplyClusterRecoveryPointInputProperties {
    clusterRecoveryPointId?: string;
    individualNodeRecoveryPoints?: string[];
    providerSpecificDetails: ApplyClusterRecoveryPointProviderSpecificInputUnion;
}

// @public
export interface ApplyClusterRecoveryPointProviderSpecificInput {
    instanceType: "A2A";
}

// @public (undocumented)
export type ApplyClusterRecoveryPointProviderSpecificInputUnion = ApplyClusterRecoveryPointProviderSpecificInput | A2AApplyClusterRecoveryPointInput;

// @public
export interface ApplyRecoveryPointInput {
    properties: ApplyRecoveryPointInputProperties;
}

// @public
export interface ApplyRecoveryPointInputProperties {
    providerSpecificDetails: ApplyRecoveryPointProviderSpecificInputUnion;
    recoveryPointId?: string;
}

// @public
export interface ApplyRecoveryPointProviderSpecificInput {
    instanceType: "A2A" | "A2ACrossClusterMigration" | "HyperVReplicaAzure" | "InMageAzureV2" | "InMageRcm";
}

// @public (undocumented)
export type ApplyRecoveryPointProviderSpecificInputUnion = ApplyRecoveryPointProviderSpecificInput | A2AApplyRecoveryPointInput | A2ACrossClusterMigrationApplyRecoveryPointInput | HyperVReplicaAzureApplyRecoveryPointInput | InMageAzureV2ApplyRecoveryPointInput | InMageRcmApplyRecoveryPointInput;

// @public
export interface AsrJobDetails extends JobDetails {
    instanceType: "AsrJobDetails";
}

// @public
export interface ASRTask {
    allowedActions?: string[];
    customDetails?: TaskTypeDetailsUnion;
    endTime?: Date;
    errors?: JobErrorDetails[];
    friendlyName?: string;
    groupTaskCustomDetails?: GroupTaskDetailsUnion;
    name?: string;
    startTime?: Date;
    state?: string;
    stateDescription?: string;
    taskId?: string;
    taskType?: string;
}

// @public
export type AutomationAccountAuthenticationType = string;

// @public
export interface AutomationRunbookTaskDetails extends TaskTypeDetails {
    accountName?: string;
    cloudServiceName?: string;
    instanceType: "AutomationRunbookTaskDetails";
    isPrimarySideScript?: boolean;
    jobId?: string;
    jobOutput?: string;
    name?: string;
    runbookId?: string;
    runbookName?: string;
    subscriptionId?: string;
}

// @public
export type AutoProtectionOfDataDisk = string;

// @public
export interface AzureFabricCreationInput extends FabricSpecificCreationInput {
    instanceType: "Azure";
    location?: string;
}

// @public
export interface AzureFabricSpecificDetails extends FabricSpecificDetails {
    containerIds?: string[];
    extendedLocations?: A2AExtendedLocationDetails[];
    instanceType: "Azure";
    location?: string;
    locationDetails?: A2AFabricSpecificLocationDetails[];
    zones?: A2AZoneDetails[];
}

// @public
export interface AzureToAzureCreateNetworkMappingInput extends FabricSpecificCreateNetworkMappingInput {
    instanceType: "AzureToAzure";
    primaryNetworkId: string;
}

// @public
export interface AzureToAzureNetworkMappingSettings extends NetworkMappingFabricSpecificSettings {
    instanceType: "AzureToAzure";
    primaryFabricLocation?: string;
    recoveryFabricLocation?: string;
}

// @public
export interface AzureToAzureUpdateNetworkMappingInput extends FabricSpecificUpdateNetworkMappingInput {
    instanceType: "AzureToAzure";
    primaryNetworkId?: string;
}

// @public
export interface AzureToAzureVmSyncedConfigDetails {
    inputEndpoints?: InputEndpoint[];
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface AzureVmDiskDetails {
    customTargetDiskName?: string;
    diskEncryptionSetId?: string;
    diskId?: string;
    lunId?: string;
    maxSizeMB?: string;
    targetDiskLocation?: string;
    targetDiskName?: string;
    vhdId?: string;
    vhdName?: string;
    vhdType?: string;
}

// @public
export type ChurnOptionSelected = string;

// @public
export interface ClusterFailoverJobDetails extends JobDetails {
    instanceType: "ClusterFailoverJobDetails";
    protectedItemDetails?: FailoverReplicationProtectedItemDetails[];
}

// @public
export interface ClusterProviderSpecificRecoveryPointDetails {
    instanceType: "A2A";
}

// @public (undocumented)
export type ClusterProviderSpecificRecoveryPointDetailsUnion = ClusterProviderSpecificRecoveryPointDetails | A2AClusterRecoveryPointDetails;

// @public
export interface ClusterRecoveryPoint {
    id?: string;
    name?: string;
    properties?: ClusterRecoveryPointProperties;
    type?: string;
}

// @public
export interface ClusterRecoveryPointCollection {
    nextLink?: string;
    value?: ClusterRecoveryPoint[];
}

// @public
export interface ClusterRecoveryPointGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ClusterRecoveryPointGetResponse = ClusterRecoveryPoint;

// @public
export interface ClusterRecoveryPointOperations {
    get(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, recoveryPointName: string, options?: ClusterRecoveryPointGetOptionalParams): Promise<ClusterRecoveryPointGetResponse>;
}

// @public
export interface ClusterRecoveryPointProperties {
    providerSpecificDetails?: ClusterProviderSpecificRecoveryPointDetailsUnion;
    recoveryPointTime?: Date;
    recoveryPointType?: ClusterRecoveryPointType;
}

// @public
export interface ClusterRecoveryPoints {
    listByReplicationProtectionCluster(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, options?: ClusterRecoveryPointsListByReplicationProtectionClusterOptionalParams): PagedAsyncIterableIterator<ClusterRecoveryPoint>;
}

// @public
export interface ClusterRecoveryPointsListByReplicationProtectionClusterNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ClusterRecoveryPointsListByReplicationProtectionClusterNextResponse = ClusterRecoveryPointCollection;

// @public
export interface ClusterRecoveryPointsListByReplicationProtectionClusterOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ClusterRecoveryPointsListByReplicationProtectionClusterResponse = ClusterRecoveryPointCollection;

// @public
export type ClusterRecoveryPointType = string;

// @public
export interface ClusterSwitchProtectionJobDetails extends JobDetails {
    instanceType: "ClusterSwitchProtectionJobDetails";
    newReplicationProtectionClusterId?: string;
}

// @public
export interface ClusterTestFailoverCleanupInput {
    properties: ClusterTestFailoverCleanupInputProperties;
}

// @public
export interface ClusterTestFailoverCleanupInputProperties {
    comments?: string;
}

// @public
export interface ClusterTestFailoverInput {
    properties: ClusterTestFailoverInputProperties;
}

// @public
export interface ClusterTestFailoverInputProperties {
    failoverDirection?: FailoverDirection;
    networkId?: string;
    networkType?: string;
    providerSpecificDetails?: ClusterTestFailoverProviderSpecificInputUnion;
}

// @public
export interface ClusterTestFailoverJobDetails extends JobDetails {
    comments?: string;
    instanceType: "ClusterTestFailoverJobDetails";
    networkFriendlyName?: string;
    networkName?: string;
    networkType?: string;
    protectedItemDetails?: FailoverReplicationProtectedItemDetails[];
    testFailoverStatus?: string;
}

// @public
export interface ClusterTestFailoverProviderSpecificInput {
    instanceType: "A2A";
}

// @public (undocumented)
export type ClusterTestFailoverProviderSpecificInputUnion = ClusterTestFailoverProviderSpecificInput | A2AClusterTestFailoverInput;

// @public
export interface ClusterUnplannedFailoverInput {
    properties: ClusterUnplannedFailoverInputProperties;
}

// @public
export interface ClusterUnplannedFailoverInputProperties {
    failoverDirection?: string;
    providerSpecificDetails?: ClusterUnplannedFailoverProviderSpecificInputUnion;
    sourceSiteOperations?: string;
}

// @public
export interface ClusterUnplannedFailoverProviderSpecificInput {
    instanceType: "A2A";
}

// @public (undocumented)
export type ClusterUnplannedFailoverProviderSpecificInputUnion = ClusterUnplannedFailoverProviderSpecificInput | A2AClusterUnplannedFailoverInput;

// @public
export interface ComputeSizeErrorDetails {
    message?: string;
    severity?: string;
}

// @public
export interface ConfigurationSettings {
    instanceType: "HyperVVirtualMachine" | "ReplicationGroupDetails" | "VmmVirtualMachine" | "VMwareVirtualMachine";
}

// @public (undocumented)
export type ConfigurationSettingsUnion = ConfigurationSettings | HyperVVirtualMachineDetailsUnion | ReplicationGroupDetails | VMwareVirtualMachineDetails;

// @public
export interface ConfigureAlertRequest {
    properties?: ConfigureAlertRequestProperties;
}

// @public
export interface ConfigureAlertRequestProperties {
    customEmailAddresses?: string[];
    locale?: string;
    sendToOwners?: string;
}

// @public
export interface ConsistencyCheckTaskDetails extends TaskTypeDetails {
    instanceType: "ConsistencyCheckTaskDetails";
    vmDetails?: InconsistentVmDetails[];
}

// @public
export interface CreateNetworkMappingInput {
    properties: CreateNetworkMappingInputProperties;
}

// @public
export interface CreateNetworkMappingInputProperties {
    fabricSpecificDetails?: FabricSpecificCreateNetworkMappingInputUnion;
    recoveryFabricName?: string;
    recoveryNetworkId: string;
}

// @public
export interface CreatePolicyInput {
    properties?: CreatePolicyInputProperties;
}

// @public
export interface CreatePolicyInputProperties {
    providerSpecificInput?: PolicyProviderSpecificInputUnion;
}

// @public
export interface CreateProtectionContainerInput {
    properties?: CreateProtectionContainerInputProperties;
}

// @public
export interface CreateProtectionContainerInputProperties {
    providerSpecificInput?: ReplicationProviderSpecificContainerCreationInputUnion[];
}

// @public
export interface CreateProtectionContainerMappingInput {
    properties?: CreateProtectionContainerMappingInputProperties;
}

// @public
export interface CreateProtectionContainerMappingInputProperties {
    policyId?: string;
    providerSpecificInput?: ReplicationProviderSpecificContainerMappingInputUnion;
    targetProtectionContainerId?: string;
}

// @public
export interface CreateProtectionIntentInput {
    properties?: CreateProtectionIntentProperties;
}

// @public
export interface CreateProtectionIntentProperties {
    providerSpecificDetails?: CreateProtectionIntentProviderSpecificDetailsUnion;
}

// @public
export interface CreateProtectionIntentProviderSpecificDetails {
    instanceType: "A2A";
}

// @public (undocumented)
export type CreateProtectionIntentProviderSpecificDetailsUnion = CreateProtectionIntentProviderSpecificDetails | A2ACreateProtectionIntentInput;

// @public
export interface CreateRecoveryPlanInput {
    properties: CreateRecoveryPlanInputProperties;
}

// @public
export interface CreateRecoveryPlanInputProperties {
    failoverDeploymentModel?: FailoverDeploymentModel;
    groups: RecoveryPlanGroup[];
    primaryFabricId: string;
    providerSpecificInput?: RecoveryPlanProviderSpecificInputUnion[];
    recoveryFabricId: string;
}

// @public
export interface CriticalJobHistoryDetails {
    readonly jobId?: string;
    readonly jobName?: string;
    readonly jobStatus?: string;
    readonly startTime?: Date;
}

// @public
export interface CurrentJobDetails {
    readonly jobId?: string;
    readonly jobName?: string;
    readonly startTime?: Date;
}

// @public
export interface CurrentScenarioDetails {
    jobId?: string;
    scenarioName?: string;
    startTime?: Date;
}

// @public
export interface DataStore {
    capacity?: string;
    freeSpace?: string;
    symbolicName?: string;
    type?: string;
    uuid?: string;
}

// @public
export interface DataStoreUtilizationDetails {
    readonly dataStoreName?: string;
    readonly totalSnapshotsCreated?: number;
    readonly totalSnapshotsSupported?: number;
}

// @public
export type DataSyncStatus = string;

// @public
export interface DisableProtectionInput {
    properties: DisableProtectionInputProperties;
}

// @public
export interface DisableProtectionInputProperties {
    disableProtectionReason?: DisableProtectionReason;
    replicationProviderInput?: DisableProtectionProviderSpecificInputUnion;
}

// @public
export interface DisableProtectionProviderSpecificInput {
    instanceType: "InMage";
}

// @public (undocumented)
export type DisableProtectionProviderSpecificInputUnion = DisableProtectionProviderSpecificInput | InMageDisableProtectionProviderSpecificInput;

// @public
export type DisableProtectionReason = string;

// @public
export interface DiscoverProtectableItemRequest {
    properties?: DiscoverProtectableItemRequestProperties;
}

// @public
export interface DiscoverProtectableItemRequestProperties {
    friendlyName?: string;
    ipAddress?: string;
    osType?: string;
}

// @public
export type DiskAccountType = string;

// @public
export interface DiskDetails {
    maxSizeMB?: number;
    vhdId?: string;
    vhdName?: string;
    vhdType?: string;
}

// @public
export interface DiskEncryptionInfo {
    diskEncryptionKeyInfo?: DiskEncryptionKeyInfo;
    keyEncryptionKeyInfo?: KeyEncryptionKeyInfo;
}

// @public
export interface DiskEncryptionKeyInfo {
    keyVaultResourceArmId?: string;
    secretIdentifier?: string;
}

// @public
export type DiskReplicationProgressHealth = string;

// @public
export type DiskState = string;

// @public
export interface DiskVolumeDetails {
    label?: string;
    name?: string;
}

// @public
export interface Display {
    description?: string;
    operation?: string;
    provider?: string;
    resource?: string;
}

// @public
export interface DraDetails {
    readonly biosId?: string;
    readonly forwardProtectedItemCount?: number;
    readonly health?: ProtectionHealth;
    readonly healthErrors?: HealthError[];
    readonly id?: string;
    readonly lastHeartbeatUtc?: Date;
    readonly name?: string;
    readonly reverseProtectedItemCount?: number;
    readonly version?: string;
}

// @public
export interface EnableMigrationInput {
    properties: EnableMigrationInputProperties;
}

// @public
export interface EnableMigrationInputProperties {
    policyId: string;
    providerSpecificDetails: EnableMigrationProviderSpecificInputUnion;
}

// @public
export interface EnableMigrationProviderSpecificInput {
    instanceType: "VMwareCbt";
}

// @public (undocumented)
export type EnableMigrationProviderSpecificInputUnion = EnableMigrationProviderSpecificInput | VMwareCbtEnableMigrationInput;

// @public
export interface EnableProtectionInput {
    properties?: EnableProtectionInputProperties;
}

// @public
export interface EnableProtectionInputProperties {
    policyId?: string;
    protectableItemId?: string;
    providerSpecificDetails?: EnableProtectionProviderSpecificInputUnion;
}

// @public
export interface EnableProtectionProviderSpecificInput {
    instanceType: "A2ACrossClusterMigration" | "A2A" | "HyperVReplicaAzure" | "InMageAzureV2" | "InMage" | "InMageRcm";
}

// @public (undocumented)
export type EnableProtectionProviderSpecificInputUnion = EnableProtectionProviderSpecificInput | A2ACrossClusterMigrationEnableProtectionInput | A2AEnableProtectionInput | HyperVReplicaAzureEnableProtectionInput | InMageAzureV2EnableProtectionInput | InMageEnableProtectionInput | InMageRcmEnableProtectionInput;

// @public
export interface EncryptionDetails {
    kekCertExpiryDate?: Date;
    kekCertThumbprint?: string;
    kekState?: string;
}

// @public
export interface ErrorAdditionalInfo {
    readonly info?: Record<string, unknown>;
    readonly type?: string;
}

// @public
export interface ErrorDetail {
    readonly additionalInfo?: ErrorAdditionalInfo[];
    readonly code?: string;
    readonly details?: ErrorDetail[];
    readonly message?: string;
    readonly target?: string;
}

// @public
export interface ErrorResponse {
    error?: ErrorDetail;
}

// @public
export type EthernetAddressType = string;

// @public
interface Event_2 extends Resource {
    properties?: EventProperties;
}
export { Event_2 as Event }

// @public
export interface EventCollection {
    nextLink?: string;
    value?: Event_2[];
}

// @public
export interface EventProperties {
    affectedObjectCorrelationId?: string;
    affectedObjectFriendlyName?: string;
    description?: string;
    eventCode?: string;
    eventSpecificDetails?: EventSpecificDetailsUnion;
    eventType?: string;
    fabricId?: string;
    healthErrors?: HealthError[];
    providerSpecificDetails?: EventProviderSpecificDetailsUnion;
    severity?: string;
    timeOfOccurrence?: Date;
}

// @public
export interface EventProviderSpecificDetails {
    instanceType: "A2A" | "HyperVReplica2012" | "HyperVReplica2012R2" | "HyperVReplicaAzure" | "HyperVReplicaBaseEventDetails" | "InMageAzureV2" | "InMageRcm" | "InMageRcmFailback" | "VMwareCbt";
}

// @public (undocumented)
export type EventProviderSpecificDetailsUnion = EventProviderSpecificDetails | A2AEventDetails | HyperVReplica2012EventDetails | HyperVReplica2012R2EventDetails | HyperVReplicaAzureEventDetails | HyperVReplicaBaseEventDetails | InMageAzureV2EventDetails | InMageRcmEventDetails | InMageRcmFailbackEventDetails | VMwareCbtEventDetails;

// @public
export interface EventQueryParameter {
    affectedObjectCorrelationId?: string;
    affectedObjectFriendlyName?: string;
    endTime?: Date;
    eventCode?: string;
    eventType?: string;
    fabricName?: string;
    severity?: string;
    startTime?: Date;
}

// @public
export interface EventSpecificDetails {
    instanceType: "JobStatus";
}

// @public (undocumented)
export type EventSpecificDetailsUnion = EventSpecificDetails | JobStatusEventDetails;

// @public
export interface ExistingProtectionProfile extends ProtectionProfileCustomDetails {
    protectionProfileId: string;
    resourceType: "Existing";
}

// @public
export interface ExistingRecoveryAvailabilitySet extends RecoveryAvailabilitySetCustomDetails {
    recoveryAvailabilitySetId?: string;
    resourceType: "Existing";
}

// @public
export interface ExistingRecoveryProximityPlacementGroup extends RecoveryProximityPlacementGroupCustomDetails {
    recoveryProximityPlacementGroupId?: string;
    resourceType: "Existing";
}

// @public
export interface ExistingRecoveryResourceGroup extends RecoveryResourceGroupCustomDetails {
    recoveryResourceGroupId?: string;
    resourceType: "Existing";
}

// @public
export interface ExistingRecoveryVirtualNetwork extends RecoveryVirtualNetworkCustomDetails {
    recoverySubnetName?: string;
    recoveryVirtualNetworkId: string;
    resourceType: "Existing";
}

// @public
export interface ExistingStorageAccount extends StorageAccountCustomDetails {
    azureStorageAccountId: string;
    resourceType: "Existing";
}

// @public
export interface ExportJobDetails extends JobDetails {
    blobUri?: string;
    instanceType: "ExportJobDetails";
    sasToken?: string;
}

// @public
export type ExportJobOutputSerializationType = string;

// @public
export interface ExtendedLocation {
    name: string;
    type: ExtendedLocationType;
}

// @public
export type ExtendedLocationType = string;

// @public
export interface Fabric extends Resource {
    properties?: FabricProperties;
}

// @public
export interface FabricCollection {
    nextLink?: string;
    value?: Fabric[];
}

// @public
export interface FabricCreationInput {
    properties?: FabricCreationInputProperties;
}

// @public
export interface FabricCreationInputProperties {
    customDetails?: FabricSpecificCreationInputUnion;
}

// @public
export interface FabricProperties {
    bcdrState?: string;
    customDetails?: FabricSpecificDetailsUnion;
    encryptionDetails?: EncryptionDetails;
    friendlyName?: string;
    health?: string;
    healthErrorDetails?: HealthError[];
    internalIdentifier?: string;
    rolloverEncryptionDetails?: EncryptionDetails;
}

// @public
export interface FabricQueryParameter {
    biosId?: string;
    discoveryType?: string;
    extendedLocationMappings?: string;
    fetchAgentDetails?: string;
    fqdn?: string;
    locationDetails?: string;
    osType?: string;
    zoneToZoneMappings?: string;
}

// @public
export interface FabricReplicationGroupTaskDetails extends JobTaskDetails {
    instanceType: "FabricReplicationGroupTaskDetails";
    skippedReason?: string;
    skippedReasonString?: string;
}

// @public
export interface FabricSpecificCreateNetworkMappingInput {
    instanceType: "AzureToAzure" | "VmmToAzure" | "VmmToVmm";
}

// @public (undocumented)
export type FabricSpecificCreateNetworkMappingInputUnion = FabricSpecificCreateNetworkMappingInput | AzureToAzureCreateNetworkMappingInput | VmmToAzureCreateNetworkMappingInput | VmmToVmmCreateNetworkMappingInput;

// @public
export interface FabricSpecificCreationInput {
    instanceType: "Azure" | "InMageRcm" | "VMwareV2";
}

// @public (undocumented)
export type FabricSpecificCreationInputUnion = FabricSpecificCreationInput | AzureFabricCreationInput | InMageRcmFabricCreationInput | VMwareV2FabricCreationInput;

// @public
export interface FabricSpecificDetails {
    instanceType: "Azure" | "HyperVSite" | "InMageRcm" | "VMM" | "VMware" | "VMwareV2";
}

// @public (undocumented)
export type FabricSpecificDetailsUnion = FabricSpecificDetails | AzureFabricSpecificDetails | HyperVSiteDetails | InMageRcmFabricSpecificDetails | VmmDetails | VMwareDetails | VMwareV2FabricSpecificDetails;

// @public
export interface FabricSpecificUpdateNetworkMappingInput {
    instanceType: "AzureToAzure" | "VmmToAzure" | "VmmToVmm";
}

// @public (undocumented)
export type FabricSpecificUpdateNetworkMappingInputUnion = FabricSpecificUpdateNetworkMappingInput | AzureToAzureUpdateNetworkMappingInput | VmmToAzureUpdateNetworkMappingInput | VmmToVmmUpdateNetworkMappingInput;

// @public
export type FailoverDeploymentModel = string;

// @public
export type FailoverDirection = string;

// @public
export interface FailoverJobDetails extends JobDetails {
    instanceType: "FailoverJobDetails";
    protectedItemDetails?: FailoverReplicationProtectedItemDetails[];
}

// @public
export interface FailoverProcessServerRequest {
    properties?: FailoverProcessServerRequestProperties;
}

// @public
export interface FailoverProcessServerRequestProperties {
    containerName?: string;
    sourceProcessServerId?: string;
    targetProcessServerId?: string;
    updateType?: string;
    vmsToMigrate?: string[];
}

// @public
export interface FailoverReplicationProtectedItemDetails {
    friendlyName?: string;
    name?: string;
    networkConnectionStatus?: string;
    networkFriendlyName?: string;
    recoveryPointId?: string;
    recoveryPointTime?: Date;
    subnet?: string;
    testVmFriendlyName?: string;
    testVmName?: string;
}

// @public
export interface GatewayOperationDetails {
    readonly dataStores?: string[];
    readonly hostName?: string;
    readonly progressPercentage?: number;
    readonly state?: string;
    readonly timeElapsed?: number;
    readonly timeRemaining?: number;
    readonly uploadSpeed?: number;
    readonly vmwareReadThroughput?: number;
}

// @public
export function getContinuationToken(page: unknown): string | undefined;

// @public
export interface GroupTaskDetails {
    childTasks?: ASRTask[];
    instanceType: "InlineWorkflowTaskDetails" | "RecoveryPlanGroupTaskDetails" | "RecoveryPlanShutdownGroupTaskDetails";
}

// @public (undocumented)
export type GroupTaskDetailsUnion = GroupTaskDetails | InlineWorkflowTaskDetails | RecoveryPlanGroupTaskDetailsUnion;

// @public
export interface HealthError {
    creationTimeUtc?: Date;
    customerResolvability?: HealthErrorCustomerResolvability;
    entityId?: string;
    errorCategory?: string;
    errorCode?: string;
    errorId?: string;
    errorLevel?: string;
    errorMessage?: string;
    errorSource?: string;
    errorType?: string;
    innerHealthErrors?: InnerHealthError[];
    possibleCauses?: string;
    recommendedAction?: string;
    recoveryProviderErrorMessage?: string;
    summaryMessage?: string;
}

// @public
export type HealthErrorCategory = string;

// @public
export type HealthErrorCustomerResolvability = string;

// @public
export interface HealthErrorSummary {
    affectedResourceCorrelationIds?: string[];
    affectedResourceSubtype?: string;
    affectedResourceType?: string;
    category?: HealthErrorCategory;
    severity?: Severity;
    summaryCode?: string;
    summaryMessage?: string;
}

// @public
export interface HyperVHostDetails {
    readonly id?: string;
    readonly marsAgentVersion?: string;
    readonly name?: string;
}

// @public
export interface HyperVReplica2012EventDetails extends EventProviderSpecificDetails {
    containerName?: string;
    fabricName?: string;
    instanceType: "HyperVReplica2012";
    remoteContainerName?: string;
    remoteFabricName?: string;
}

// @public
export interface HyperVReplica2012R2EventDetails extends EventProviderSpecificDetails {
    containerName?: string;
    fabricName?: string;
    instanceType: "HyperVReplica2012R2";
    remoteContainerName?: string;
    remoteFabricName?: string;
}

// @public
export interface HyperVReplicaAzureApplyRecoveryPointInput extends ApplyRecoveryPointProviderSpecificInput {
    instanceType: "HyperVReplicaAzure";
    primaryKekCertificatePfx?: string;
    secondaryKekCertificatePfx?: string;
}

// @public
export interface HyperVReplicaAzureDiskInputDetails {
    diskEncryptionSetId?: string;
    diskId?: string;
    diskType?: DiskAccountType;
    logStorageAccountId?: string;
    sectorSizeInBytes?: number;
}

// @public
export interface HyperVReplicaAzureEnableProtectionInput extends EnableProtectionProviderSpecificInput {
    diskEncryptionSetId?: string;
    disksToInclude?: string[];
    disksToIncludeForManagedDisks?: HyperVReplicaAzureDiskInputDetails[];
    diskType?: DiskAccountType;
    enableRdpOnTargetOption?: string;
    hvHostVmId?: string;
    instanceType: "HyperVReplicaAzure";
    licenseType?: LicenseType;
    linuxLicenseType?: LinuxLicenseType;
    logStorageAccountId?: string;
    osType?: string;
    seedManagedDiskTags?: {
        [propertyName: string]: string;
    };
    sqlServerLicenseType?: SqlServerLicenseType;
    targetAvailabilitySetId?: string;
    targetAvailabilityZone?: string;
    targetAzureNetworkId?: string;
    targetAzureSubnetId?: string;
    targetAzureV1ResourceGroupId?: string;
    targetAzureV2ResourceGroupId?: string;
    targetAzureVmName?: string;
    targetManagedDiskTags?: {
        [propertyName: string]: string;
    };
    targetNicTags?: {
        [propertyName: string]: string;
    };
    targetProximityPlacementGroupId?: string;
    targetStorageAccountId?: string;
    targetVmSecurityProfile?: SecurityProfileProperties;
    targetVmSize?: string;
    targetVmTags?: {
        [propertyName: string]: string;
    };
    useManagedDisks?: string;
    useManagedDisksForReplication?: string;
    userSelectedOSName?: string;
    vhdId?: string;
    vmName?: string;
}

// @public
export interface HyperVReplicaAzureEventDetails extends EventProviderSpecificDetails {
    containerName?: string;
    fabricName?: string;
    instanceType: "HyperVReplicaAzure";
    remoteContainerName?: string;
}

// @public
export interface HyperVReplicaAzureFailbackProviderInput extends PlannedFailoverProviderSpecificFailoverInput {
    dataSyncOption?: string;
    instanceType: "HyperVReplicaAzureFailback";
    providerIdForAlternateRecovery?: string;
    recoveryVmCreationOption?: string;
}

// @public
export interface HyperVReplicaAzureManagedDiskDetails {
    diskEncryptionSetId?: string;
    diskId?: string;
    replicaDiskType?: string;
    sectorSizeInBytes?: number;
    seedManagedDiskId?: string;
    targetDiskAccountType?: DiskAccountType;
}

// @public
export interface HyperVReplicaAzurePlannedFailoverProviderInput extends PlannedFailoverProviderSpecificFailoverInput {
    instanceType: "HyperVReplicaAzure";
    osUpgradeVersion?: string;
    primaryKekCertificatePfx?: string;
    recoveryPointId?: string;
    secondaryKekCertificatePfx?: string;
}

// @public
export interface HyperVReplicaAzurePolicyDetails extends PolicyProviderSpecificDetails {
    activeStorageAccountId?: string;
    applicationConsistentSnapshotFrequencyInHours?: number;
    encryption?: string;
    instanceType: "HyperVReplicaAzure";
    onlineReplicationStartTime?: string;
    recoveryPointHistoryDurationInHours?: number;
    replicationInterval?: number;
}

// @public
export interface HyperVReplicaAzurePolicyInput extends PolicyProviderSpecificInput {
    applicationConsistentSnapshotFrequencyInHours?: number;
    instanceType: "HyperVReplicaAzure";
    onlineReplicationStartTime?: string;
    recoveryPointHistoryDuration?: number;
    replicationInterval?: number;
    storageAccounts?: string[];
}

// @public
export interface HyperVReplicaAzureReplicationDetails extends ReplicationProviderSpecificSettings {
    allAvailableOSUpgradeConfigurations?: OSUpgradeSupportedVersions[];
    azureVmDiskDetails?: AzureVmDiskDetails[];
    enableRdpOnTargetOption?: string;
    encryption?: string;
    initialReplicationDetails?: InitialReplicationDetails;
    instanceType: "HyperVReplicaAzure";
    readonly lastRecoveryPointReceived?: Date;
    lastReplicatedTime?: Date;
    lastRpoCalculatedTime?: Date;
    licenseType?: string;
    linuxLicenseType?: LinuxLicenseType;
    oSDetails?: OSDetails;
    protectedManagedDisks?: HyperVReplicaAzureManagedDiskDetails[];
    recoveryAvailabilitySetId?: string;
    recoveryAzureLogStorageAccountId?: string;
    recoveryAzureResourceGroupId?: string;
    recoveryAzureStorageAccount?: string;
    recoveryAzureVmName?: string;
    recoveryAzureVMSize?: string;
    rpoInSeconds?: number;
    seedManagedDiskTags?: {
        [propertyName: string]: string;
    };
    selectedRecoveryAzureNetworkId?: string;
    selectedSourceNicId?: string;
    sourceVmCpuCount?: number;
    sourceVmRamSizeInMB?: number;
    sqlServerLicenseType?: string;
    targetAvailabilityZone?: string;
    targetManagedDiskTags?: {
        [propertyName: string]: string;
    };
    targetNicTags?: {
        [propertyName: string]: string;
    };
    targetProximityPlacementGroupId?: string;
    targetVmSecurityProfile?: SecurityProfileProperties;
    targetVmTags?: {
        [propertyName: string]: string;
    };
    useManagedDisks?: string;
    vmId?: string;
    vmNics?: VMNicDetails[];
    vmProtectionState?: string;
    vmProtectionStateDescription?: string;
}

// @public
export interface HyperVReplicaAzureReprotectInput extends ReverseReplicationProviderSpecificInput {
    hvHostVmId?: string;
    instanceType: "HyperVReplicaAzure";
    logStorageAccountId?: string;
    osType?: string;
    storageAccountId?: string;
    vHDId?: string;
    vmName?: string;
}

// @public
export type HyperVReplicaAzureRpRecoveryPointType = string;

// @public
export interface HyperVReplicaAzureTestFailoverInput extends TestFailoverProviderSpecificInput {
    instanceType: "HyperVReplicaAzure";
    osUpgradeVersion?: string;
    primaryKekCertificatePfx?: string;
    recoveryPointId?: string;
    secondaryKekCertificatePfx?: string;
}

// @public
export interface HyperVReplicaAzureUnplannedFailoverInput extends UnplannedFailoverProviderSpecificInput {
    instanceType: "HyperVReplicaAzure";
    primaryKekCertificatePfx?: string;
    recoveryPointId?: string;
    secondaryKekCertificatePfx?: string;
}

// @public
export interface HyperVReplicaAzureUpdateReplicationProtectedItemInput extends UpdateReplicationProtectedItemProviderInput {
    diskIdToDiskEncryptionMap?: {
        [propertyName: string]: string;
    };
    instanceType: "HyperVReplicaAzure";
    linuxLicenseType?: LinuxLicenseType;
    recoveryAzureV1ResourceGroupId?: string;
    recoveryAzureV2ResourceGroupId?: string;
    sqlServerLicenseType?: SqlServerLicenseType;
    targetAvailabilityZone?: string;
    targetManagedDiskTags?: {
        [propertyName: string]: string;
    };
    targetNicTags?: {
        [propertyName: string]: string;
    };
    targetProximityPlacementGroupId?: string;
    targetVmTags?: {
        [propertyName: string]: string;
    };
    useManagedDisks?: string;
    userSelectedOSName?: string;
    vmDisks?: UpdateDiskInput[];
}

// @public
export interface HyperVReplicaBaseEventDetails extends EventProviderSpecificDetails {
    containerName?: string;
    fabricName?: string;
    instanceType: "HyperVReplicaBaseEventDetails";
    remoteContainerName?: string;
    remoteFabricName?: string;
}

// @public
export interface HyperVReplicaBasePolicyDetails extends PolicyProviderSpecificDetails {
    allowedAuthenticationType?: number;
    applicationConsistentSnapshotFrequencyInHours?: number;
    compression?: string;
    initialReplicationMethod?: string;
    instanceType: "HyperVReplicaBasePolicyDetails";
    offlineReplicationExportPath?: string;
    offlineReplicationImportPath?: string;
    onlineReplicationStartTime?: string;
    recoveryPoints?: number;
    replicaDeletionOption?: string;
    replicationPort?: number;
}

// @public
export interface HyperVReplicaBaseReplicationDetails extends ReplicationProviderSpecificSettings {
    initialReplicationDetails?: InitialReplicationDetails;
    instanceType: "HyperVReplicaBaseReplicationDetails";
    lastReplicatedTime?: Date;
    vMDiskDetails?: DiskDetails[];
    vmId?: string;
    vmNics?: VMNicDetails[];
    vmProtectionState?: string;
    vmProtectionStateDescription?: string;
}

// @public
export interface HyperVReplicaBluePolicyDetails extends PolicyProviderSpecificDetails {
    allowedAuthenticationType?: number;
    applicationConsistentSnapshotFrequencyInHours?: number;
    compression?: string;
    initialReplicationMethod?: string;
    instanceType: "HyperVReplica2012R2";
    offlineReplicationExportPath?: string;
    offlineReplicationImportPath?: string;
    onlineReplicationStartTime?: string;
    recoveryPoints?: number;
    replicaDeletionOption?: string;
    replicationFrequencyInSeconds?: number;
    replicationPort?: number;
}

// @public
export interface HyperVReplicaBluePolicyInput extends HyperVReplicaPolicyInput {
    instanceType: "HyperVReplica2012R2";
    replicationFrequencyInSeconds?: number;
}

// @public
export interface HyperVReplicaBlueReplicationDetails extends ReplicationProviderSpecificSettings {
    initialReplicationDetails?: InitialReplicationDetails;
    instanceType: "HyperVReplica2012R2";
    lastReplicatedTime?: Date;
    vMDiskDetails?: DiskDetails[];
    vmId?: string;
    vmNics?: VMNicDetails[];
    vmProtectionState?: string;
    vmProtectionStateDescription?: string;
}

// @public
export interface HyperVReplicaPolicyDetails extends PolicyProviderSpecificDetails {
    allowedAuthenticationType?: number;
    applicationConsistentSnapshotFrequencyInHours?: number;
    compression?: string;
    initialReplicationMethod?: string;
    instanceType: "HyperVReplica2012";
    offlineReplicationExportPath?: string;
    offlineReplicationImportPath?: string;
    onlineReplicationStartTime?: string;
    recoveryPoints?: number;
    replicaDeletionOption?: string;
    replicationPort?: number;
}

// @public
export interface HyperVReplicaPolicyInput extends PolicyProviderSpecificInput {
    allowedAuthenticationType?: number;
    applicationConsistentSnapshotFrequencyInHours?: number;
    compression?: string;
    initialReplicationMethod?: string;
    instanceType: "HyperVReplica2012" | "HyperVReplica2012R2";
    offlineReplicationExportPath?: string;
    offlineReplicationImportPath?: string;
    onlineReplicationStartTime?: string;
    recoveryPoints?: number;
    replicaDeletion?: string;
    replicationPort?: number;
}

// @public (undocumented)
export type HyperVReplicaPolicyInputUnion = HyperVReplicaPolicyInput | HyperVReplicaBluePolicyInput;

// @public
export interface HyperVReplicaReplicationDetails extends ReplicationProviderSpecificSettings {
    initialReplicationDetails?: InitialReplicationDetails;
    instanceType: "HyperVReplica2012";
    lastReplicatedTime?: Date;
    vMDiskDetails?: DiskDetails[];
    vmId?: string;
    vmNics?: VMNicDetails[];
    vmProtectionState?: string;
    vmProtectionStateDescription?: string;
}

// @public
export interface HyperVSiteDetails extends FabricSpecificDetails {
    hyperVHosts?: HyperVHostDetails[];
    instanceType: "HyperVSite";
}

// @public
export interface HyperVVirtualMachineDetails extends ConfigurationSettings {
    diskDetails?: DiskDetails[];
    generation?: string;
    hasFibreChannelAdapter?: PresenceStatus;
    hasPhysicalDisk?: PresenceStatus;
    hasSharedVhd?: PresenceStatus;
    hyperVHostId?: string;
    instanceType: "HyperVVirtualMachine" | "VmmVirtualMachine";
    osDetails?: OSDetails;
    sourceItemId?: string;
}

// @public (undocumented)
export type HyperVVirtualMachineDetailsUnion = HyperVVirtualMachineDetails | VmmVirtualMachineDetails;

// @public
export interface IdentityProviderDetails {
    aadAuthority?: string;
    applicationId?: string;
    audience?: string;
    objectId?: string;
    tenantId?: string;
}

// @public
export interface IdentityProviderInput {
    aadAuthority: string;
    applicationId: string;
    audience: string;
    objectId: string;
    tenantId: string;
}

// @public
export interface InconsistentVmDetails {
    cloudName?: string;
    details?: string[];
    errorIds?: string[];
    vmName?: string;
}

// @public
export interface InitialReplicationDetails {
    initialReplicationProgressPercentage?: string;
    initialReplicationType?: string;
}

// @public
export interface InlineWorkflowTaskDetails extends GroupTaskDetails {
    instanceType: "InlineWorkflowTaskDetails";
    workflowIds?: string[];
}

// @public
export interface InMageAgentDetails {
    agentExpiryDate?: Date;
    agentUpdateStatus?: string;
    agentVersion?: string;
    postUpdateRebootStatus?: string;
}

// @public
export interface InMageAzureV2ApplyRecoveryPointInput extends ApplyRecoveryPointProviderSpecificInput {
    instanceType: "InMageAzureV2";
}

// @public
export interface InMageAzureV2DiskInputDetails {
    diskEncryptionSetId?: string;
    diskId?: string;
    diskType?: DiskAccountType;
    logStorageAccountId?: string;
}

// @public
export interface InMageAzureV2EnableProtectionInput extends EnableProtectionProviderSpecificInput {
    diskEncryptionSetId?: string;
    disksToInclude?: InMageAzureV2DiskInputDetails[];
    diskType?: DiskAccountType;
    enableRdpOnTargetOption?: string;
    instanceType: "InMageAzureV2";
    licenseType?: LicenseType;
    logStorageAccountId?: string;
    masterTargetId?: string;
    multiVmGroupId?: string;
    multiVmGroupName?: string;
    processServerId?: string;
    runAsAccountId?: string;
    seedManagedDiskTags?: {
        [propertyName: string]: string;
    };
    sqlServerLicenseType?: SqlServerLicenseType;
    storageAccountId?: string;
    targetAvailabilitySetId?: string;
    targetAvailabilityZone?: string;
    targetAzureNetworkId?: string;
    targetAzureSubnetId?: string;
    targetAzureV1ResourceGroupId?: string;
    targetAzureV2ResourceGroupId?: string;
    targetAzureVmName?: string;
    targetManagedDiskTags?: {
        [propertyName: string]: string;
    };
    targetNicTags?: {
        [propertyName: string]: string;
    };
    targetProximityPlacementGroupId?: string;
    targetVmSize?: string;
    targetVmTags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface InMageAzureV2EventDetails extends EventProviderSpecificDetails {
    category?: string;
    component?: string;
    correctiveAction?: string;
    details?: string;
    eventType?: string;
    instanceType: "InMageAzureV2";
    siteName?: string;
    summary?: string;
}

// @public
export interface InMageAzureV2ManagedDiskDetails {
    diskEncryptionSetId?: string;
    diskId?: string;
    replicaDiskType?: string;
    seedManagedDiskId?: string;
    targetDiskName?: string;
}

// @public
export interface InMageAzureV2PolicyDetails extends PolicyProviderSpecificDetails {
    appConsistentFrequencyInMinutes?: number;
    crashConsistentFrequencyInMinutes?: number;
    instanceType: "InMageAzureV2";
    multiVmSyncStatus?: string;
    recoveryPointHistory?: number;
    recoveryPointThresholdInMinutes?: number;
}

// @public
export interface InMageAzureV2PolicyInput extends PolicyProviderSpecificInput {
    appConsistentFrequencyInMinutes?: number;
    crashConsistentFrequencyInMinutes?: number;
    instanceType: "InMageAzureV2";
    multiVmSyncStatus: SetMultiVmSyncStatus;
    recoveryPointHistory?: number;
    recoveryPointThresholdInMinutes?: number;
}

// @public
export interface InMageAzureV2ProtectedDiskDetails {
    diskCapacityInBytes?: number;
    diskId?: string;
    diskName?: string;
    diskResized?: string;
    fileSystemCapacityInBytes?: number;
    healthErrorCode?: string;
    lastRpoCalculatedTime?: Date;
    progressHealth?: string;
    progressStatus?: string;
    protectionStage?: string;
    psDataInMegaBytes?: number;
    resyncDurationInSeconds?: number;
    resyncLast15MinutesTransferredBytes?: number;
    resyncLastDataTransferTimeUTC?: Date;
    resyncProcessedBytes?: number;
    resyncProgressPercentage?: number;
    resyncRequired?: string;
    resyncStartTime?: Date;
    resyncTotalTransferredBytes?: number;
    rpoInSeconds?: number;
    secondsToTakeSwitchProvider?: number;
    sourceDataInMegaBytes?: number;
    targetDataInMegaBytes?: number;
}

// @public
export interface InMageAzureV2RecoveryPointDetails extends ProviderSpecificRecoveryPointDetails {
    instanceType: "InMageAzureV2";
    isMultiVmSyncPoint?: string;
}

// @public
export interface InMageAzureV2ReplicationDetails extends ReplicationProviderSpecificSettings {
    agentExpiryDate?: Date;
    agentVersion?: string;
    allAvailableOSUpgradeConfigurations?: OSUpgradeSupportedVersions[];
    azureVMDiskDetails?: AzureVmDiskDetails[];
    azureVmGeneration?: string;
    compressedDataRateInMB?: number;
    datastores?: string[];
    discoveryType?: string;
    diskResized?: string;
    enableRdpOnTargetOption?: string;
    firmwareType?: string;
    infrastructureVmId?: string;
    instanceType: "InMageAzureV2";
    ipAddress?: string;
    isAdditionalStatsAvailable?: boolean;
    isAgentUpdateRequired?: string;
    isRebootAfterUpdateRequired?: string;
    lastHeartbeat?: Date;
    readonly lastRecoveryPointReceived?: Date;
    lastRpoCalculatedTime?: Date;
    lastUpdateReceivedTime?: Date;
    licenseType?: string;
    masterTargetId?: string;
    multiVmGroupId?: string;
    multiVmGroupName?: string;
    multiVmSyncStatus?: string;
    osDiskId?: string;
    readonly osName?: string;
    osType?: string;
    osVersion?: string;
    processServerId?: string;
    processServerName?: string;
    protectedDisks?: InMageAzureV2ProtectedDiskDetails[];
    protectedManagedDisks?: InMageAzureV2ManagedDiskDetails[];
    protectionStage?: string;
    recoveryAvailabilitySetId?: string;
    recoveryAzureLogStorageAccountId?: string;
    recoveryAzureResourceGroupId?: string;
    recoveryAzureStorageAccount?: string;
    recoveryAzureVMName?: string;
    recoveryAzureVMSize?: string;
    replicaId?: string;
    resyncProgressPercentage?: number;
    rpoInSeconds?: number;
    seedManagedDiskTags?: {
        [propertyName: string]: string;
    };
    selectedRecoveryAzureNetworkId?: string;
    selectedSourceNicId?: string;
    selectedTfoAzureNetworkId?: string;
    sourceVmCpuCount?: number;
    sourceVmRamSizeInMB?: number;
    sqlServerLicenseType?: string;
    supportedOSVersions?: string[];
    switchProviderBlockingErrorDetails?: InMageAzureV2SwitchProviderBlockingErrorDetails[];
    switchProviderDetails?: InMageAzureV2SwitchProviderDetails;
    targetAvailabilityZone?: string;
    targetManagedDiskTags?: {
        [propertyName: string]: string;
    };
    targetNicTags?: {
        [propertyName: string]: string;
    };
    targetProximityPlacementGroupId?: string;
    targetVmId?: string;
    targetVmTags?: {
        [propertyName: string]: string;
    };
    totalDataTransferred?: number;
    totalProgressHealth?: string;
    uncompressedDataRateInMB?: number;
    useManagedDisks?: string;
    validationErrors?: HealthError[];
    vCenterInfrastructureId?: string;
    vhdName?: string;
    vmId?: string;
    vmNics?: VMNicDetails[];
    vmProtectionState?: string;
    vmProtectionStateDescription?: string;
}

// @public
export interface InMageAzureV2ReprotectInput extends ReverseReplicationProviderSpecificInput {
    disksToInclude?: string[];
    instanceType: "InMageAzureV2";
    logStorageAccountId?: string;
    masterTargetId?: string;
    policyId?: string;
    processServerId?: string;
    runAsAccountId?: string;
    storageAccountId?: string;
}

// @public
export interface InMageAzureV2SwitchProviderBlockingErrorDetails {
    readonly errorCode?: string;
    readonly errorMessage?: string;
    readonly errorMessageParameters?: {
        [propertyName: string]: string;
    };
    readonly errorTags?: {
        [propertyName: string]: string;
    };
    readonly possibleCauses?: string;
    readonly recommendedAction?: string;
}

// @public
export interface InMageAzureV2SwitchProviderDetails {
    readonly targetApplianceId?: string;
    readonly targetFabricId?: string;
    readonly targetResourceId?: string;
    readonly targetVaultId?: string;
}

// @public
export interface InMageAzureV2SwitchProviderInput extends SwitchProviderSpecificInput {
    instanceType: "InMageAzureV2";
    targetApplianceID: string;
    targetFabricID: string;
    targetVaultID: string;
}

// @public
export interface InMageAzureV2TestFailoverInput extends TestFailoverProviderSpecificInput {
    instanceType: "InMageAzureV2";
    osUpgradeVersion?: string;
    recoveryPointId?: string;
}

// @public
export interface InMageAzureV2UnplannedFailoverInput extends UnplannedFailoverProviderSpecificInput {
    instanceType: "InMageAzureV2";
    osUpgradeVersion?: string;
    recoveryPointId?: string;
}

// @public
export interface InMageAzureV2UpdateReplicationProtectedItemInput extends UpdateReplicationProtectedItemProviderInput {
    instanceType: "InMageAzureV2";
    recoveryAzureV1ResourceGroupId?: string;
    recoveryAzureV2ResourceGroupId?: string;
    sqlServerLicenseType?: SqlServerLicenseType;
    targetAvailabilityZone?: string;
    targetManagedDiskTags?: {
        [propertyName: string]: string;
    };
    targetNicTags?: {
        [propertyName: string]: string;
    };
    targetProximityPlacementGroupId?: string;
    targetVmTags?: {
        [propertyName: string]: string;
    };
    useManagedDisks?: string;
    vmDisks?: UpdateDiskInput[];
}

// @public
export interface InMageBasePolicyDetails extends PolicyProviderSpecificDetails {
    appConsistentFrequencyInMinutes?: number;
    instanceType: "InMageBasePolicyDetails";
    multiVmSyncStatus?: string;
    recoveryPointHistory?: number;
    recoveryPointThresholdInMinutes?: number;
}

// @public
export interface InMageDisableProtectionProviderSpecificInput extends DisableProtectionProviderSpecificInput {
    instanceType: "InMage";
    replicaVmDeletionStatus?: string;
}

// @public
export interface InMageDiskDetails {
    diskConfiguration?: string;
    diskId?: string;
    diskName?: string;
    diskSizeInMB?: string;
    diskType?: string;
    volumeList?: DiskVolumeDetails[];
}

// @public
export interface InMageDiskExclusionInput {
    diskSignatureOptions?: InMageDiskSignatureExclusionOptions[];
    volumeOptions?: InMageVolumeExclusionOptions[];
}

// @public
export interface InMageDiskSignatureExclusionOptions {
    diskSignature?: string;
}

// @public
export interface InMageEnableProtectionInput extends EnableProtectionProviderSpecificInput {
    datastoreName?: string;
    diskExclusionInput?: InMageDiskExclusionInput;
    disksToInclude?: string[];
    instanceType: "InMage";
    masterTargetId: string;
    multiVmGroupId: string;
    multiVmGroupName: string;
    processServerId: string;
    retentionDrive: string;
    runAsAccountId?: string;
    vmFriendlyName?: string;
}

// @public
export interface InMageFabricSwitchProviderBlockingErrorDetails {
    readonly errorCode?: string;
    readonly errorMessage?: string;
    readonly errorMessageParameters?: {
        [propertyName: string]: string;
    };
    readonly errorTags?: {
        [propertyName: string]: string;
    };
    readonly possibleCauses?: string;
    readonly recommendedAction?: string;
}

// @public
export interface InMagePolicyDetails extends PolicyProviderSpecificDetails {
    appConsistentFrequencyInMinutes?: number;
    instanceType: "InMage";
    multiVmSyncStatus?: string;
    recoveryPointHistory?: number;
    recoveryPointThresholdInMinutes?: number;
}

// @public
export interface InMagePolicyInput extends PolicyProviderSpecificInput {
    appConsistentFrequencyInMinutes?: number;
    instanceType: "InMage";
    multiVmSyncStatus: SetMultiVmSyncStatus;
    recoveryPointHistory?: number;
    recoveryPointThresholdInMinutes?: number;
}

// @public
export interface InMageProtectedDiskDetails {
    diskCapacityInBytes?: number;
    diskId?: string;
    diskName?: string;
    diskResized?: string;
    fileSystemCapacityInBytes?: number;
    healthErrorCode?: string;
    lastRpoCalculatedTime?: Date;
    progressHealth?: string;
    progressStatus?: string;
    protectionStage?: string;
    psDataInMB?: number;
    resyncDurationInSeconds?: number;
    resyncLast15MinutesTransferredBytes?: number;
    resyncLastDataTransferTimeUTC?: Date;
    resyncProcessedBytes?: number;
    resyncProgressPercentage?: number;
    resyncRequired?: string;
    resyncStartTime?: Date;
    resyncTotalTransferredBytes?: number;
    rpoInSeconds?: number;
    sourceDataInMB?: number;
    targetDataInMB?: number;
}

// @public
export interface InMageRcmAddDisksInput extends AddDisksProviderSpecificInput {
    disks: InMageRcmDiskInput[];
    instanceType: "InMageRcm";
}

// @public
export interface InMageRcmAgentUpgradeBlockingErrorDetails {
    readonly errorCode?: string;
    readonly errorMessage?: string;
    readonly errorMessageParameters?: {
        [propertyName: string]: string;
    };
    readonly errorTags?: {
        [propertyName: string]: string;
    };
    readonly possibleCauses?: string;
    readonly recommendedAction?: string;
}

// @public
export interface InMageRcmApplianceDetails {
    readonly dra?: DraDetails;
    readonly fabricArmId?: string;
    readonly id?: string;
    readonly marsAgent?: MarsAgentDetails;
    readonly name?: string;
    readonly processServer?: ProcessServerDetails;
    readonly pushInstaller?: PushInstallerDetails;
    readonly rcmProxy?: RcmProxyDetails;
    readonly replicationAgent?: ReplicationAgentDetails;
    readonly reprotectAgent?: ReprotectAgentDetails;
    readonly switchProviderBlockingErrorDetails?: InMageRcmFabricSwitchProviderBlockingErrorDetails[];
}

// @public
export interface InMageRcmApplianceSpecificDetails extends ApplianceSpecificDetails {
    readonly appliances?: InMageRcmApplianceDetails[];
    instanceType: "InMageRcm";
}

// @public
export interface InMageRcmApplyRecoveryPointInput extends ApplyRecoveryPointProviderSpecificInput {
    instanceType: "InMageRcm";
    recoveryPointId: string;
}

// @public
export interface InMageRcmDiscoveredProtectedVmDetails {
    readonly createdTimestamp?: Date;
    readonly datastores?: string[];
    readonly ipAddresses?: string[];
    readonly isDeleted?: boolean;
    readonly lastDiscoveryTimeInUtc?: Date;
    readonly osName?: string;
    readonly powerStatus?: string;
    readonly updatedTimestamp?: Date;
    readonly vCenterFqdn?: string;
    readonly vCenterId?: string;
    readonly vmFqdn?: string;
    readonly vmwareToolsStatus?: string;
}

// @public
export interface InMageRcmDiskInput {
    diskEncryptionSetId?: string;
    diskId: string;
    diskType: DiskAccountType;
    logStorageAccountId: string;
    sectorSizeInBytes?: number;
}

// @public
export interface InMageRcmDisksDefaultInput {
    diskEncryptionSetId?: string;
    diskType: DiskAccountType;
    logStorageAccountId: string;
    sectorSizeInBytes?: number;
}

// @public
export interface InMageRcmEnableProtectionInput extends EnableProtectionProviderSpecificInput {
    disksDefault?: InMageRcmDisksDefaultInput;
    disksToInclude?: InMageRcmDiskInput[];
    fabricDiscoveryMachineId: string;
    instanceType: "InMageRcm";
    licenseType?: LicenseType;
    linuxLicenseType?: LinuxLicenseType;
    multiVmGroupName?: string;
    processServerId: string;
    runAsAccountId?: string;
    seedManagedDiskTags?: UserCreatedResourceTag[];
    sqlServerLicenseType?: SqlServerLicenseType;
    targetAvailabilitySetId?: string;
    targetAvailabilityZone?: string;
    targetBootDiagnosticsStorageAccountId?: string;
    targetManagedDiskTags?: UserCreatedResourceTag[];
    targetNetworkId?: string;
    targetNicTags?: UserCreatedResourceTag[];
    targetProximityPlacementGroupId?: string;
    targetResourceGroupId: string;
    targetSubnetName?: string;
    targetVmName?: string;
    targetVmSecurityProfile?: SecurityProfileProperties;
    targetVmSize?: string;
    targetVmTags?: UserCreatedResourceTag[];
    testNetworkId?: string;
    testSubnetName?: string;
    userSelectedOSName?: string;
}

// @public
export interface InMageRcmEventDetails extends EventProviderSpecificDetails {
    readonly applianceName?: string;
    readonly componentDisplayName?: string;
    readonly fabricName?: string;
    instanceType: "InMageRcm";
    readonly jobId?: string;
    readonly latestAgentVersion?: string;
    readonly protectedItemName?: string;
    readonly serverType?: string;
    readonly vmName?: string;
}

// @public
export interface InMageRcmFabricCreationInput extends FabricSpecificCreationInput {
    instanceType: "InMageRcm";
    physicalSiteId: string;
    sourceAgentIdentity: IdentityProviderInput;
    vmwareSiteId: string;
}

// @public
export interface InMageRcmFabricSpecificDetails extends FabricSpecificDetails {
    readonly agentDetails?: AgentDetails[];
    readonly controlPlaneUri?: string;
    readonly dataPlaneUri?: string;
    readonly dras?: DraDetails[];
    instanceType: "InMageRcm";
    readonly marsAgents?: MarsAgentDetails[];
    readonly physicalSiteId?: string;
    readonly processServers?: ProcessServerDetails[];
    readonly pushInstallers?: PushInstallerDetails[];
    readonly rcmProxies?: RcmProxyDetails[];
    readonly replicationAgents?: ReplicationAgentDetails[];
    readonly reprotectAgents?: ReprotectAgentDetails[];
    readonly serviceContainerId?: string;
    readonly serviceEndpoint?: string;
    readonly serviceResourceId?: string;
    sourceAgentIdentityDetails?: IdentityProviderDetails;
    readonly vmwareSiteId?: string;
}

// @public
export interface InMageRcmFabricSwitchProviderBlockingErrorDetails {
    readonly errorCode?: string;
    readonly errorMessage?: string;
    readonly errorMessageParameters?: {
        [propertyName: string]: string;
    };
    readonly errorTags?: {
        [propertyName: string]: string;
    };
    readonly possibleCauses?: string;
    readonly recommendedAction?: string;
}

// @public
export interface InMageRcmFailbackDiscoveredProtectedVmDetails {
    readonly createdTimestamp?: Date;
    readonly datastores?: string[];
    readonly ipAddresses?: string[];
    readonly isDeleted?: boolean;
    readonly lastDiscoveryTimeInUtc?: Date;
    readonly osName?: string;
    readonly powerStatus?: string;
    readonly updatedTimestamp?: Date;
    readonly vCenterFqdn?: string;
    readonly vCenterId?: string;
    readonly vmFqdn?: string;
    readonly vmwareToolsStatus?: string;
}

// @public
export interface InMageRcmFailbackEventDetails extends EventProviderSpecificDetails {
    readonly applianceName?: string;
    readonly componentDisplayName?: string;
    instanceType: "InMageRcmFailback";
    readonly protectedItemName?: string;
    readonly serverType?: string;
    readonly vmName?: string;
}

// @public
export interface InMageRcmFailbackMobilityAgentDetails {
    readonly agentVersionExpiryDate?: Date;
    readonly driverVersion?: string;
    readonly driverVersionExpiryDate?: Date;
    readonly isUpgradeable?: string;
    readonly lastHeartbeatUtc?: Date;
    readonly latestUpgradableVersionWithoutReboot?: string;
    readonly latestVersion?: string;
    readonly reasonsBlockingUpgrade?: AgentUpgradeBlockedReason[];
    readonly version?: string;
}

// @public
export interface InMageRcmFailbackNicDetails {
    readonly adapterType?: string;
    readonly macAddress?: string;
    readonly networkName?: string;
    readonly sourceIpAddress?: string;
}

// @public
export interface InMageRcmFailbackPlannedFailoverProviderInput extends PlannedFailoverProviderSpecificFailoverInput {
    instanceType: "InMageRcmFailback";
    recoveryPointType: InMageRcmFailbackRecoveryPointType;
}

// @public
export interface InMageRcmFailbackPolicyCreationInput extends PolicyProviderSpecificInput {
    appConsistentFrequencyInMinutes?: number;
    crashConsistentFrequencyInMinutes?: number;
    instanceType: "InMageRcmFailback";
}

// @public
export interface InMageRcmFailbackPolicyDetails extends PolicyProviderSpecificDetails {
    appConsistentFrequencyInMinutes?: number;
    crashConsistentFrequencyInMinutes?: number;
    instanceType: "InMageRcmFailback";
}

// @public
export interface InMageRcmFailbackProtectedDiskDetails {
    readonly capacityInBytes?: number;
    readonly dataPendingAtSourceAgentInMB?: number;
    readonly dataPendingInLogDataStoreInMB?: number;
    readonly diskId?: string;
    readonly diskName?: string;
    readonly diskUuid?: string;
    irDetails?: InMageRcmFailbackSyncDetails;
    readonly isInitialReplicationComplete?: string;
    readonly isOSDisk?: string;
    readonly lastSyncTime?: Date;
    resyncDetails?: InMageRcmFailbackSyncDetails;
}

// @public
export type InMageRcmFailbackRecoveryPointType = string;

// @public
export interface InMageRcmFailbackReplicationDetails extends ReplicationProviderSpecificSettings {
    readonly azureVirtualMachineId?: string;
    discoveredVmDetails?: InMageRcmFailbackDiscoveredProtectedVmDetails;
    readonly initialReplicationProcessedBytes?: number;
    readonly initialReplicationProgressHealth?: VmReplicationProgressHealth;
    readonly initialReplicationProgressPercentage?: number;
    readonly initialReplicationTransferredBytes?: number;
    instanceType: "InMageRcmFailback";
    readonly internalIdentifier?: string;
    readonly isAgentRegistrationSuccessfulAfterFailover?: boolean;
    readonly lastPlannedFailoverStartTime?: Date;
    readonly lastPlannedFailoverStatus?: PlannedFailoverStatus;
    readonly lastUsedPolicyFriendlyName?: string;
    readonly lastUsedPolicyId?: string;
    readonly logStorageAccountId?: string;
    mobilityAgentDetails?: InMageRcmFailbackMobilityAgentDetails;
    readonly multiVmGroupName?: string;
    readonly osType?: string;
    protectedDisks?: InMageRcmFailbackProtectedDiskDetails[];
    readonly reprotectAgentId?: string;
    readonly reprotectAgentName?: string;
    readonly resyncProcessedBytes?: number;
    readonly resyncProgressHealth?: VmReplicationProgressHealth;
    readonly resyncProgressPercentage?: number;
    readonly resyncRequired?: string;
    readonly resyncState?: ResyncState;
    readonly resyncTransferredBytes?: number;
    readonly targetDataStoreName?: string;
    readonly targetvCenterId?: string;
    readonly targetVmName?: string;
    vmNics?: InMageRcmFailbackNicDetails[];
}

// @public
export interface InMageRcmFailbackReprotectInput extends ReverseReplicationProviderSpecificInput {
    instanceType: "InMageRcmFailback";
    policyId: string;
    processServerId: string;
    runAsAccountId?: string;
}

// @public
export interface InMageRcmFailbackSyncDetails {
    readonly last15MinutesTransferredBytes?: number;
    readonly lastDataTransferTimeUtc?: string;
    readonly lastRefreshTime?: string;
    readonly processedBytes?: number;
    readonly progressHealth?: DiskReplicationProgressHealth;
    readonly progressPercentage?: number;
    readonly startTime?: string;
    readonly transferredBytes?: number;
}

// @public
export interface InMageRcmLastAgentUpgradeErrorDetails {
    readonly errorCode?: string;
    readonly errorMessage?: string;
    readonly errorMessageParameters?: {
        [propertyName: string]: string;
    };
    readonly errorTags?: {
        [propertyName: string]: string;
    };
    readonly possibleCauses?: string;
    readonly recommendedAction?: string;
}

// @public
export interface InMageRcmMobilityAgentDetails {
    readonly agentVersionExpiryDate?: Date;
    readonly driverVersion?: string;
    readonly driverVersionExpiryDate?: Date;
    readonly isUpgradeable?: string;
    readonly lastHeartbeatUtc?: Date;
    readonly latestAgentReleaseDate?: string;
    readonly latestUpgradableVersionWithoutReboot?: string;
    readonly latestVersion?: string;
    readonly reasonsBlockingUpgrade?: AgentUpgradeBlockedReason[];
    readonly version?: string;
}

// @public
export interface InMageRcmNicDetails {
    isPrimaryNic?: string;
    isSelectedForFailover?: string;
    readonly nicId?: string;
    readonly sourceIPAddress?: string;
    readonly sourceIPAddressType?: EthernetAddressType;
    readonly sourceNetworkId?: string;
    readonly sourceSubnetName?: string;
    targetIPAddress?: string;
    targetIPAddressType?: EthernetAddressType;
    targetNicName?: string;
    targetSubnetName?: string;
    testIPAddress?: string;
    testIPAddressType?: EthernetAddressType;
    testSubnetName?: string;
}

// @public
export interface InMageRcmNicInput {
    isPrimaryNic: string;
    isSelectedForFailover?: string;
    nicId: string;
    targetNicName?: string;
    targetStaticIPAddress?: string;
    targetSubnetName?: string;
    testStaticIPAddress?: string;
    testSubnetName?: string;
}

// @public
export interface InMageRcmPolicyCreationInput extends PolicyProviderSpecificInput {
    appConsistentFrequencyInMinutes?: number;
    crashConsistentFrequencyInMinutes?: number;
    enableMultiVmSync?: string;
    instanceType: "InMageRcm";
    recoveryPointHistoryInMinutes?: number;
}

// @public
export interface InMageRcmPolicyDetails extends PolicyProviderSpecificDetails {
    appConsistentFrequencyInMinutes?: number;
    crashConsistentFrequencyInMinutes?: number;
    enableMultiVmSync?: string;
    instanceType: "InMageRcm";
    recoveryPointHistoryInMinutes?: number;
}

// @public
export interface InMageRcmProtectedDiskDetails {
    readonly capacityInBytes?: number;
    customTargetDiskName?: string;
    readonly dataPendingAtSourceAgentInMB?: number;
    readonly dataPendingInLogDataStoreInMB?: number;
    readonly diskEncryptionSetId?: string;
    readonly diskId?: string;
    readonly diskName?: string;
    readonly diskState?: DiskState;
    diskType?: DiskAccountType;
    irDetails?: InMageRcmSyncDetails;
    readonly isInitialReplicationComplete?: string;
    readonly isOSDisk?: string;
    readonly logStorageAccountId?: string;
    resyncDetails?: InMageRcmSyncDetails;
    sectorSizeInBytes?: number;
    readonly seedBlobUri?: string;
    readonly seedManagedDiskId?: string;
    readonly targetManagedDiskId?: string;
}

// @public
export interface InMageRcmProtectionContainerMappingDetails extends ProtectionContainerMappingProviderSpecificDetails {
    readonly enableAgentAutoUpgrade?: string;
    instanceType: "InMageRcm";
}

// @public
export interface InMageRcmRecoveryPointDetails extends ProviderSpecificRecoveryPointDetails {
    instanceType: "InMageRcm";
    readonly isMultiVmSyncPoint?: string;
}

// @public
export interface InMageRcmReplicationDetails extends ReplicationProviderSpecificSettings {
    readonly agentUpgradeAttemptToVersion?: string;
    agentUpgradeBlockingErrorDetails?: InMageRcmAgentUpgradeBlockingErrorDetails[];
    readonly agentUpgradeJobId?: string;
    readonly agentUpgradeState?: MobilityAgentUpgradeState;
    readonly allocatedMemoryInMB?: number;
    discoveredVmDetails?: InMageRcmDiscoveredProtectedVmDetails;
    readonly discoveryType?: string;
    readonly fabricDiscoveryMachineId?: string;
    readonly failoverRecoveryPointId?: string;
    readonly firmwareType?: string;
    readonly initialReplicationProcessedBytes?: number;
    readonly initialReplicationProgressHealth?: VmReplicationProgressHealth;
    readonly initialReplicationProgressPercentage?: number;
    readonly initialReplicationTransferredBytes?: number;
    instanceType: "InMageRcm";
    readonly internalIdentifier?: string;
    readonly isAgentRegistrationSuccessfulAfterFailover?: boolean;
    readonly isLastUpgradeSuccessful?: string;
    lastAgentUpgradeErrorDetails?: InMageRcmLastAgentUpgradeErrorDetails[];
    readonly lastAgentUpgradeType?: string;
    readonly lastRecoveryPointId?: string;
    readonly lastRecoveryPointReceived?: Date;
    readonly lastRpoCalculatedTime?: Date;
    readonly lastRpoInSeconds?: number;
    licenseType?: string;
    linuxLicenseType?: LinuxLicenseType;
    mobilityAgentDetails?: InMageRcmMobilityAgentDetails;
    readonly multiVmGroupName?: string;
    osName?: string;
    readonly osType?: string;
    readonly primaryNicIpAddress?: string;
    readonly processorCoreCount?: number;
    readonly processServerId?: string;
    readonly processServerName?: string;
    protectedDisks?: InMageRcmProtectedDiskDetails[];
    readonly resyncProcessedBytes?: number;
    readonly resyncProgressHealth?: VmReplicationProgressHealth;
    readonly resyncProgressPercentage?: number;
    readonly resyncRequired?: string;
    readonly resyncState?: ResyncState;
    readonly resyncTransferredBytes?: number;
    readonly runAsAccountId?: string;
    seedManagedDiskTags?: UserCreatedResourceTag[];
    sqlServerLicenseType?: string;
    readonly storageAccountId?: string;
    supportedOSVersions?: string[];
    targetAvailabilitySetId?: string;
    targetAvailabilityZone?: string;
    targetBootDiagnosticsStorageAccountId?: string;
    readonly targetGeneration?: string;
    targetLocation?: string;
    targetManagedDiskTags?: UserCreatedResourceTag[];
    targetNetworkId?: string;
    targetNicTags?: UserCreatedResourceTag[];
    targetProximityPlacementGroupId?: string;
    targetResourceGroupId?: string;
    targetVmName?: string;
    targetVmSecurityProfile?: SecurityProfileProperties;
    targetVmSize?: string;
    targetVmTags?: UserCreatedResourceTag[];
    testNetworkId?: string;
    unprotectedDisks?: InMageRcmUnProtectedDiskDetails[];
    vmNics?: InMageRcmNicDetails[];
}

// @public
export interface InMageRcmReprotectInput extends ReverseReplicationProviderSpecificInput {
    datastoreName: string;
    instanceType: "InMageRcm";
    logStorageAccountId: string;
    policyId?: string;
    reprotectAgentId: string;
}

// @public
export interface InMageRcmSyncDetails {
    readonly last15MinutesTransferredBytes?: number;
    readonly lastDataTransferTimeUtc?: string;
    readonly lastRefreshTime?: string;
    readonly processedBytes?: number;
    readonly progressHealth?: DiskReplicationProgressHealth;
    readonly progressPercentage?: number;
    readonly startTime?: string;
    readonly transferredBytes?: number;
}

// @public
export interface InMageRcmTestFailoverInput extends TestFailoverProviderSpecificInput {
    instanceType: "InMageRcm";
    networkId?: string;
    osUpgradeVersion?: string;
    recoveryPointId?: string;
}

// @public
export interface InMageRcmUnplannedFailoverInput extends UnplannedFailoverProviderSpecificInput {
    instanceType: "InMageRcm";
    osUpgradeVersion?: string;
    performShutdown: string;
    recoveryPointId?: string;
}

// @public
export interface InMageRcmUnProtectedDiskDetails {
    readonly capacityInBytes?: number;
    readonly diskId?: string;
    readonly diskName?: string;
}

// @public
export interface InMageRcmUpdateApplianceForReplicationProtectedItemInput extends UpdateApplianceForReplicationProtectedItemProviderSpecificInput {
    instanceType: "InMageRcm";
    runAsAccountId?: string;
}

// @public
export interface InMageRcmUpdateContainerMappingInput extends ReplicationProviderSpecificUpdateContainerMappingInput {
    enableAgentAutoUpgrade: string;
    instanceType: "InMageRcm";
}

// @public
export interface InMageRcmUpdateReplicationProtectedItemInput extends UpdateReplicationProtectedItemProviderInput {
    instanceType: "InMageRcm";
    licenseType?: LicenseType;
    linuxLicenseType?: LinuxLicenseType;
    sqlServerLicenseType?: SqlServerLicenseType;
    targetAvailabilitySetId?: string;
    targetAvailabilityZone?: string;
    targetBootDiagnosticsStorageAccountId?: string;
    targetManagedDiskTags?: UserCreatedResourceTag[];
    targetNetworkId?: string;
    targetNicTags?: UserCreatedResourceTag[];
    targetProximityPlacementGroupId?: string;
    targetResourceGroupId?: string;
    targetVmName?: string;
    targetVmSize?: string;
    targetVmTags?: UserCreatedResourceTag[];
    testNetworkId?: string;
    userSelectedOSName?: string;
    vmNics?: InMageRcmNicInput[];
}

// @public
export interface InMageReplicationDetails extends ReplicationProviderSpecificSettings {
    activeSiteType?: string;
    agentDetails?: InMageAgentDetails;
    azureStorageAccountId?: string;
    compressedDataRateInMB?: number;
    consistencyPoints?: {
        [propertyName: string]: Date;
    };
    datastores?: string[];
    discoveryType?: string;
    diskResized?: string;
    infrastructureVmId?: string;
    instanceType: "InMage";
    ipAddress?: string;
    isAdditionalStatsAvailable?: boolean;
    lastHeartbeat?: Date;
    lastRpoCalculatedTime?: Date;
    lastUpdateReceivedTime?: Date;
    masterTargetId?: string;
    multiVmGroupId?: string;
    multiVmGroupName?: string;
    multiVmSyncStatus?: string;
    osDetails?: OSDiskDetails;
    osVersion?: string;
    processServerId?: string;
    protectedDisks?: InMageProtectedDiskDetails[];
    protectionStage?: string;
    rebootAfterUpdateStatus?: string;
    replicaId?: string;
    resyncDetails?: InitialReplicationDetails;
    retentionWindowEnd?: Date;
    retentionWindowStart?: Date;
    rpoInSeconds?: number;
    sourceVmCpuCount?: number;
    sourceVmRamSizeInMB?: number;
    totalDataTransferred?: number;
    totalProgressHealth?: string;
    uncompressedDataRateInMB?: number;
    validationErrors?: HealthError[];
    vCenterInfrastructureId?: string;
    vmId?: string;
    vmNics?: VMNicDetails[];
    vmProtectionState?: string;
    vmProtectionStateDescription?: string;
}

// @public
export interface InMageReprotectInput extends ReverseReplicationProviderSpecificInput {
    datastoreName?: string;
    diskExclusionInput?: InMageDiskExclusionInput;
    disksToInclude?: string[];
    instanceType: "InMage";
    masterTargetId: string;
    processServerId: string;
    profileId: string;
    retentionDrive: string;
    runAsAccountId?: string;
}

// @public
export interface InMageTestFailoverInput extends TestFailoverProviderSpecificInput {
    instanceType: "InMage";
    recoveryPointId?: string;
    recoveryPointType?: RecoveryPointType;
}

// @public
export interface InMageUnplannedFailoverInput extends UnplannedFailoverProviderSpecificInput {
    instanceType: "InMage";
    recoveryPointId?: string;
    recoveryPointType?: RecoveryPointType;
}

// @public
export type InMageV2RpRecoveryPointType = string;

// @public
export interface InMageVolumeExclusionOptions {
    onlyExcludeIfSingleVolume?: string;
    volumeLabel?: string;
}

// @public
export interface InnerHealthError {
    creationTimeUtc?: Date;
    customerResolvability?: HealthErrorCustomerResolvability;
    entityId?: string;
    errorCategory?: string;
    errorCode?: string;
    errorId?: string;
    errorLevel?: string;
    errorMessage?: string;
    errorSource?: string;
    errorType?: string;
    possibleCauses?: string;
    recommendedAction?: string;
    recoveryProviderErrorMessage?: string;
    summaryMessage?: string;
}

// @public (undocumented)
export interface InputEndpoint {
    // (undocumented)
    endpointName?: string;
    // (undocumented)
    privatePort?: number;
    // (undocumented)
    protocol?: string;
    // (undocumented)
    publicPort?: number;
}

// @public (undocumented)
export interface IPConfigDetails {
    // (undocumented)
    ipAddressType?: string;
    // (undocumented)
    isPrimary?: boolean;
    // (undocumented)
    isSeletedForFailover?: boolean;
    // (undocumented)
    name?: string;
    // (undocumented)
    recoveryIPAddressType?: string;
    // (undocumented)
    recoveryLBBackendAddressPoolIds?: string[];
    // (undocumented)
    recoveryPublicIPAddressId?: string;
    // (undocumented)
    recoveryStaticIPAddress?: string;
    // (undocumented)
    recoverySubnetName?: string;
    // (undocumented)
    staticIPAddress?: string;
    // (undocumented)
    subnetName?: string;
    // (undocumented)
    tfoLBBackendAddressPoolIds?: string[];
    // (undocumented)
    tfoPublicIPAddressId?: string;
    // (undocumented)
    tfoStaticIPAddress?: string;
    // (undocumented)
    tfoSubnetName?: string;
}

// @public (undocumented)
export interface IPConfigInputDetails {
    // (undocumented)
    ipConfigName?: string;
    // (undocumented)
    isPrimary?: boolean;
    // (undocumented)
    isSeletedForFailover?: boolean;
    // (undocumented)
    recoveryLBBackendAddressPoolIds?: string[];
    // (undocumented)
    recoveryPublicIPAddressId?: string;
    // (undocumented)
    recoveryStaticIPAddress?: string;
    // (undocumented)
    recoverySubnetName?: string;
    // (undocumented)
    tfoLBBackendAddressPoolIds?: string[];
    // (undocumented)
    tfoPublicIPAddressId?: string;
    // (undocumented)
    tfoStaticIPAddress?: string;
    // (undocumented)
    tfoSubnetName?: string;
}

// @public
export interface Job extends Resource {
    properties?: JobProperties;
}

// @public
export interface JobCollection {
    nextLink?: string;
    value?: Job[];
}

// @public
export interface JobDetails {
    affectedObjectDetails?: {
        [propertyName: string]: string;
    };
    instanceType: "AsrJobDetails" | "ClusterFailoverJobDetails" | "ClusterSwitchProtectionJobDetails" | "ClusterTestFailoverJobDetails" | "ExportJobDetails" | "FailoverJobDetails" | "SwitchProtectionJobDetails" | "TestFailoverJobDetails";
}

// @public (undocumented)
export type JobDetailsUnion = JobDetails | AsrJobDetails | ClusterFailoverJobDetails | ClusterSwitchProtectionJobDetails | ClusterTestFailoverJobDetails | ExportJobDetails | FailoverJobDetails | SwitchProtectionJobDetails | TestFailoverJobDetails;

// @public
export interface JobEntity {
    jobFriendlyName?: string;
    jobId?: string;
    jobScenarioName?: string;
    targetInstanceType?: string;
    targetObjectId?: string;
    targetObjectName?: string;
}

// @public
export interface JobErrorDetails {
    creationTime?: Date;
    errorLevel?: string;
    providerErrorDetails?: ProviderError;
    serviceErrorDetails?: ServiceError;
    taskId?: string;
}

// @public
export interface JobProperties {
    activityId?: string;
    allowedActions?: string[];
    customDetails?: JobDetailsUnion;
    endTime?: Date;
    errors?: JobErrorDetails[];
    friendlyName?: string;
    scenarioName?: string;
    startTime?: Date;
    state?: string;
    stateDescription?: string;
    targetInstanceType?: string;
    targetObjectId?: string;
    targetObjectName?: string;
    tasks?: ASRTask[];
}

// @public
export interface JobQueryParameter {
    affectedObjectTypes?: string;
    endTime?: string;
    fabricId?: string;
    jobName?: string;
    jobOutputType?: ExportJobOutputSerializationType;
    jobStatus?: string;
    startTime?: string;
    timezoneOffset?: number;
}

// @public
export interface JobStatusEventDetails extends EventSpecificDetails {
    affectedObjectType?: string;
    instanceType: "JobStatus";
    jobFriendlyName?: string;
    jobId?: string;
    jobStatus?: string;
}

// @public
export interface JobTaskDetails extends TaskTypeDetails {
    instanceType: "JobTaskDetails" | "FabricReplicationGroupTaskDetails" | "VirtualMachineTaskDetails";
    jobTask?: JobEntity;
}

// @public (undocumented)
export type JobTaskDetailsUnion = JobTaskDetails | FabricReplicationGroupTaskDetails | VirtualMachineTaskDetails;

// @public
export interface KeyEncryptionKeyInfo {
    keyIdentifier?: string;
    keyVaultResourceArmId?: string;
}

// @public
export enum KnownA2ARecoveryAvailabilityType {
    AvailabilitySet = "AvailabilitySet",
    AvailabilityZone = "AvailabilityZone",
    Single = "Single"
}

// @public
export enum KnownA2ARpRecoveryPointType {
    Latest = "Latest",
    LatestApplicationConsistent = "LatestApplicationConsistent",
    LatestCrashConsistent = "LatestCrashConsistent",
    LatestProcessed = "LatestProcessed"
}

// @public
export enum KnownAgentAutoUpdateStatus {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownAgentUpgradeBlockedReason {
    AgentNoHeartbeat = "AgentNoHeartbeat",
    AlreadyOnLatestVersion = "AlreadyOnLatestVersion",
    DistroIsNotReported = "DistroIsNotReported",
    DistroNotSupportedForUpgrade = "DistroNotSupportedForUpgrade",
    IncompatibleApplianceVersion = "IncompatibleApplianceVersion",
    InvalidAgentVersion = "InvalidAgentVersion",
    InvalidDriverVersion = "InvalidDriverVersion",
    MissingUpgradePath = "MissingUpgradePath",
    NotProtected = "NotProtected",
    ProcessServerNoHeartbeat = "ProcessServerNoHeartbeat",
    RcmProxyNoHeartbeat = "RcmProxyNoHeartbeat",
    RebootRequired = "RebootRequired",
    Unknown = "Unknown",
    UnsupportedProtectionScenario = "UnsupportedProtectionScenario"
}

// @public
export enum KnownAgentVersionStatus {
    Deprecated = "Deprecated",
    NotSupported = "NotSupported",
    SecurityUpdateRequired = "SecurityUpdateRequired",
    Supported = "Supported",
    UpdateRequired = "UpdateRequired"
}

// @public
export enum KnownAlternateLocationRecoveryOption {
    CreateVmIfNotFound = "CreateVmIfNotFound",
    NoAction = "NoAction"
}

// @public
export enum KnownAutomationAccountAuthenticationType {
    RunAsAccount = "RunAsAccount",
    SystemAssignedIdentity = "SystemAssignedIdentity"
}

// @public
export enum KnownAutoProtectionOfDataDisk {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownChurnOptionSelected {
    High = "High",
    Normal = "Normal"
}

// @public
export enum KnownClusterRecoveryPointType {
    ApplicationConsistent = "ApplicationConsistent",
    CrashConsistent = "CrashConsistent",
    NotSpecified = "NotSpecified"
}

// @public
export enum KnownDataSyncStatus {
    ForDownTime = "ForDownTime",
    ForSynchronization = "ForSynchronization"
}

// @public
export enum KnownDisableProtectionReason {
    MigrationComplete = "MigrationComplete",
    NotSpecified = "NotSpecified"
}

// @public
export enum KnownDiskAccountType {
    PremiumLRS = "Premium_LRS",
    PremiumV2LRS = "PremiumV2_LRS",
    PremiumZRS = "Premium_ZRS",
    StandardLRS = "Standard_LRS",
    StandardSSDLRS = "StandardSSD_LRS",
    StandardSSDZRS = "StandardSSD_ZRS",
    UltraSSDLRS = "UltraSSD_LRS"
}

// @public
export enum KnownDiskReplicationProgressHealth {
    InProgress = "InProgress",
    None = "None",
    NoProgress = "NoProgress",
    Queued = "Queued",
    SlowProgress = "SlowProgress"
}

// @public
export enum KnownDiskState {
    InitialReplicationFailed = "InitialReplicationFailed",
    InitialReplicationPending = "InitialReplicationPending",
    Protected = "Protected",
    Unavailable = "Unavailable"
}

// @public
export enum KnownEthernetAddressType {
    Dynamic = "Dynamic",
    Static = "Static"
}

// @public
export enum KnownExportJobOutputSerializationType {
    Excel = "Excel",
    Json = "Json",
    Xml = "Xml"
}

// @public
export enum KnownExtendedLocationType {
    EdgeZone = "EdgeZone"
}

// @public
export enum KnownFailoverDeploymentModel {
    Classic = "Classic",
    NotApplicable = "NotApplicable",
    ResourceManager = "ResourceManager"
}

// @public
export enum KnownFailoverDirection {
    PrimaryToRecovery = "PrimaryToRecovery",
    RecoveryToPrimary = "RecoveryToPrimary"
}

// @public
export enum KnownHealthErrorCategory {
    AgentAutoUpdateArtifactDeleted = "AgentAutoUpdateArtifactDeleted",
    AgentAutoUpdateInfra = "AgentAutoUpdateInfra",
    AgentAutoUpdateRunAsAccount = "AgentAutoUpdateRunAsAccount",
    AgentAutoUpdateRunAsAccountExpired = "AgentAutoUpdateRunAsAccountExpired",
    AgentAutoUpdateRunAsAccountExpiry = "AgentAutoUpdateRunAsAccountExpiry",
    Configuration = "Configuration",
    FabricInfrastructure = "FabricInfrastructure",
    None = "None",
    Replication = "Replication",
    TestFailover = "TestFailover",
    VersionExpiry = "VersionExpiry"
}

// @public
export enum KnownHealthErrorCustomerResolvability {
    Allowed = "Allowed",
    NotAllowed = "NotAllowed"
}

// @public
export enum KnownHyperVReplicaAzureRpRecoveryPointType {
    Latest = "Latest",
    LatestApplicationConsistent = "LatestApplicationConsistent",
    LatestProcessed = "LatestProcessed"
}

// @public
export enum KnownInMageRcmFailbackRecoveryPointType {
    ApplicationConsistent = "ApplicationConsistent",
    CrashConsistent = "CrashConsistent"
}

// @public
export enum KnownInMageV2RpRecoveryPointType {
    Latest = "Latest",
    LatestApplicationConsistent = "LatestApplicationConsistent",
    LatestCrashConsistent = "LatestCrashConsistent",
    LatestProcessed = "LatestProcessed"
}

// @public
export enum KnownLicenseType {
    NoLicenseType = "NoLicenseType",
    NotSpecified = "NotSpecified",
    WindowsServer = "WindowsServer"
}

// @public
export enum KnownLinuxLicenseType {
    LinuxServer = "LinuxServer",
    NoLicenseType = "NoLicenseType",
    NotSpecified = "NotSpecified"
}

// @public
export enum KnownMigrationItemOperation {
    DisableMigration = "DisableMigration",
    Migrate = "Migrate",
    PauseReplication = "PauseReplication",
    ResumeReplication = "ResumeReplication",
    StartResync = "StartResync",
    TestMigrate = "TestMigrate",
    TestMigrateCleanup = "TestMigrateCleanup"
}

// @public
export enum KnownMigrationRecoveryPointType {
    ApplicationConsistent = "ApplicationConsistent",
    CrashConsistent = "CrashConsistent",
    NotSpecified = "NotSpecified"
}

// @public
export enum KnownMigrationState {
    DisableMigrationFailed = "DisableMigrationFailed",
    DisableMigrationInProgress = "DisableMigrationInProgress",
    EnableMigrationFailed = "EnableMigrationFailed",
    EnableMigrationInProgress = "EnableMigrationInProgress",
    InitialSeedingFailed = "InitialSeedingFailed",
    InitialSeedingInProgress = "InitialSeedingInProgress",
    MigrationCompletedWithInformation = "MigrationCompletedWithInformation",
    MigrationFailed = "MigrationFailed",
    MigrationInProgress = "MigrationInProgress",
    MigrationPartiallySucceeded = "MigrationPartiallySucceeded",
    MigrationSucceeded = "MigrationSucceeded",
    None = "None",
    ProtectionSuspended = "ProtectionSuspended",
    Replicating = "Replicating",
    ResumeInitiated = "ResumeInitiated",
    ResumeInProgress = "ResumeInProgress",
    SuspendingProtection = "SuspendingProtection"
}

// @public
export enum KnownMobilityAgentUpgradeState {
    Commit = "Commit",
    Completed = "Completed",
    None = "None",
    Started = "Started"
}

// @public
export enum KnownMultiVmGroupCreateOption {
    AutoCreated = "AutoCreated",
    UserSpecified = "UserSpecified"
}

// @public
export enum KnownMultiVmSyncPointOption {
    UseMultiVmSyncRecoveryPoint = "UseMultiVmSyncRecoveryPoint",
    UsePerVmRecoveryPoint = "UsePerVmRecoveryPoint"
}

// @public
export enum KnownPlannedFailoverStatus {
    Cancelled = "Cancelled",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Unknown = "Unknown"
}

// @public
export enum KnownPossibleOperationsDirections {
    PrimaryToRecovery = "PrimaryToRecovery",
    RecoveryToPrimary = "RecoveryToPrimary"
}

// @public
export enum KnownPresenceStatus {
    NotPresent = "NotPresent",
    Present = "Present",
    Unknown = "Unknown"
}

// @public
export enum KnownProtectionHealth {
    Critical = "Critical",
    None = "None",
    Normal = "Normal",
    Warning = "Warning"
}

// @public
export enum KnownRcmComponentStatus {
    Critical = "Critical",
    Healthy = "Healthy",
    Unknown = "Unknown",
    Warning = "Warning"
}

// @public
export enum KnownRecoveryPlanActionLocation {
    Primary = "Primary",
    Recovery = "Recovery"
}

// @public
export enum KnownRecoveryPlanGroupType {
    Boot = "Boot",
    Failover = "Failover",
    Shutdown = "Shutdown"
}

// @public
export enum KnownRecoveryPlanPointType {
    Latest = "Latest",
    LatestApplicationConsistent = "LatestApplicationConsistent",
    LatestCrashConsistent = "LatestCrashConsistent",
    LatestProcessed = "LatestProcessed"
}

// @public
export enum KnownRecoveryPointSyncType {
    MultiVmSyncRecoveryPoint = "MultiVmSyncRecoveryPoint",
    PerVmRecoveryPoint = "PerVmRecoveryPoint"
}

// @public
export enum KnownRecoveryPointType {
    Custom = "Custom",
    LatestTag = "LatestTag",
    LatestTime = "LatestTime"
}

// @public
export enum KnownReplicationProtectedItemOperation {
    CancelFailover = "CancelFailover",
    ChangePit = "ChangePit",
    Commit = "Commit",
    CompleteMigration = "CompleteMigration",
    DisableProtection = "DisableProtection",
    Failback = "Failback",
    FinalizeFailback = "FinalizeFailback",
    PlannedFailover = "PlannedFailover",
    RepairReplication = "RepairReplication",
    ReverseReplicate = "ReverseReplicate",
    SwitchProtection = "SwitchProtection",
    TestFailover = "TestFailover",
    TestFailoverCleanup = "TestFailoverCleanup",
    UnplannedFailover = "UnplannedFailover"
}

// @public
export enum KnownResyncState {
    None = "None",
    PreparedForResynchronization = "PreparedForResynchronization",
    StartedResynchronization = "StartedResynchronization"
}

// @public
export enum KnownRpInMageRecoveryPointType {
    Custom = "Custom",
    LatestTag = "LatestTag",
    LatestTime = "LatestTime"
}

// @public
export enum KnownSecurityConfiguration {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownSecurityType {
    ConfidentialVM = "ConfidentialVM",
    None = "None",
    TrustedLaunch = "TrustedLaunch"
}

// @public
export enum KnownSetMultiVmSyncStatus {
    Disable = "Disable",
    Enable = "Enable"
}

// @public
export enum KnownSeverity {
    Error = "Error",
    Info = "Info",
    None = "NONE",
    Warning = "Warning"
}

// @public
export enum KnownSourceSiteOperations {
    NotRequired = "NotRequired",
    Required = "Required"
}

// @public
export enum KnownSqlServerLicenseType {
    Ahub = "AHUB",
    NoLicenseType = "NoLicenseType",
    NotSpecified = "NotSpecified",
    Payg = "PAYG"
}

// @public
export enum KnownTestMigrationState {
    None = "None",
    TestMigrationCleanupInProgress = "TestMigrationCleanupInProgress",
    TestMigrationCompletedWithInformation = "TestMigrationCompletedWithInformation",
    TestMigrationFailed = "TestMigrationFailed",
    TestMigrationInProgress = "TestMigrationInProgress",
    TestMigrationPartiallySucceeded = "TestMigrationPartiallySucceeded",
    TestMigrationSucceeded = "TestMigrationSucceeded"
}

// @public
export enum KnownVmEncryptionType {
    NotEncrypted = "NotEncrypted",
    OnePassEncrypted = "OnePassEncrypted",
    TwoPassEncrypted = "TwoPassEncrypted"
}

// @public
export enum KnownVmReplicationProgressHealth {
    InProgress = "InProgress",
    None = "None",
    NoProgress = "NoProgress",
    SlowProgress = "SlowProgress"
}

// @public
export type LicenseType = string;

// @public
export type LinuxLicenseType = string;

// @public
export interface LogicalNetwork extends Resource {
    properties?: LogicalNetworkProperties;
}

// @public
export interface LogicalNetworkCollection {
    nextLink?: string;
    value?: LogicalNetwork[];
}

// @public
export interface LogicalNetworkProperties {
    friendlyName?: string;
    logicalNetworkDefinitionsStatus?: string;
    logicalNetworkUsage?: string;
    networkVirtualizationStatus?: string;
}

// @public
export interface ManagedRunCommandScriptInput {
    scriptParameters: string;
    scriptUrl: string;
    stepName: string;
}

// @public
export interface ManualActionTaskDetails extends TaskTypeDetails {
    instanceType: "ManualActionTaskDetails";
    instructions?: string;
    name?: string;
    observation?: string;
}

// @public
export interface MarsAgentDetails {
    readonly biosId?: string;
    readonly fabricObjectId?: string;
    readonly fqdn?: string;
    readonly health?: ProtectionHealth;
    readonly healthErrors?: HealthError[];
    readonly id?: string;
    readonly lastHeartbeatUtc?: Date;
    readonly name?: string;
    readonly version?: string;
}

// @public
export interface MasterTargetServer {
    agentExpiryDate?: Date;
    agentVersion?: string;
    agentVersionDetails?: VersionDetails;
    dataStores?: DataStore[];
    diskCount?: number;
    healthErrors?: HealthError[];
    id?: string;
    ipAddress?: string;
    lastHeartbeat?: Date;
    marsAgentExpiryDate?: Date;
    marsAgentVersion?: string;
    marsAgentVersionDetails?: VersionDetails;
    name?: string;
    osType?: string;
    osVersion?: string;
    retentionVolumes?: RetentionVolume[];
    validationErrors?: HealthError[];
    versionStatus?: string;
}

// @public
export interface MigrateInput {
    properties: MigrateInputProperties;
}

// @public
export interface MigrateInputProperties {
    providerSpecificDetails: MigrateProviderSpecificInputUnion;
}

// @public
export interface MigrateProviderSpecificInput {
    instanceType: "VMwareCbt";
}

// @public (undocumented)
export type MigrateProviderSpecificInputUnion = MigrateProviderSpecificInput | VMwareCbtMigrateInput;

// @public
export interface MigrationItem extends Resource {
    properties?: MigrationItemProperties;
}

// @public
export interface MigrationItemCollection {
    nextLink?: string;
    value?: MigrationItem[];
}

// @public
export type MigrationItemOperation = string;

// @public
export interface MigrationItemProperties {
    readonly allowedOperations?: MigrationItemOperation[];
    readonly criticalJobHistory?: CriticalJobHistoryDetails[];
    readonly currentJob?: CurrentJobDetails;
    readonly eventCorrelationId?: string;
    readonly health?: ProtectionHealth;
    readonly healthErrors?: HealthError[];
    readonly lastMigrationStatus?: string;
    readonly lastMigrationTime?: Date;
    readonly lastTestMigrationStatus?: string;
    readonly lastTestMigrationTime?: Date;
    readonly machineName?: string;
    readonly migrationState?: MigrationState;
    readonly migrationStateDescription?: string;
    readonly policyFriendlyName?: string;
    readonly policyId?: string;
    providerSpecificDetails?: MigrationProviderSpecificSettingsUnion;
    readonly recoveryServicesProviderId?: string;
    readonly replicationStatus?: string;
    readonly testMigrateState?: TestMigrationState;
    readonly testMigrateStateDescription?: string;
}

// @public
export interface MigrationItemsQueryParameter {
    instanceType?: string;
    sourceContainerName?: string;
    sourceFabricName?: string;
}

// @public
export interface MigrationProviderSpecificSettings {
    instanceType: "VMwareCbt";
}

// @public (undocumented)
export type MigrationProviderSpecificSettingsUnion = MigrationProviderSpecificSettings | VMwareCbtMigrationDetails;

// @public
export interface MigrationRecoveryPoint extends Resource {
    properties?: MigrationRecoveryPointProperties;
}

// @public
export interface MigrationRecoveryPointCollection {
    nextLink?: string;
    value?: MigrationRecoveryPoint[];
}

// @public
export interface MigrationRecoveryPointProperties {
    readonly recoveryPointTime?: Date;
    readonly recoveryPointType?: MigrationRecoveryPointType;
}

// @public
export interface MigrationRecoveryPoints {
    get(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, migrationRecoveryPointName: string, options?: MigrationRecoveryPointsGetOptionalParams): Promise<MigrationRecoveryPointsGetResponse>;
    listByReplicationMigrationItems(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, options?: MigrationRecoveryPointsListByReplicationMigrationItemsOptionalParams): PagedAsyncIterableIterator<MigrationRecoveryPoint>;
}

// @public
export interface MigrationRecoveryPointsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type MigrationRecoveryPointsGetResponse = MigrationRecoveryPoint;

// @public
export interface MigrationRecoveryPointsListByReplicationMigrationItemsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type MigrationRecoveryPointsListByReplicationMigrationItemsNextResponse = MigrationRecoveryPointCollection;

// @public
export interface MigrationRecoveryPointsListByReplicationMigrationItemsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type MigrationRecoveryPointsListByReplicationMigrationItemsResponse = MigrationRecoveryPointCollection;

// @public
export type MigrationRecoveryPointType = string;

// @public
export type MigrationState = string;

// @public
export type MobilityAgentUpgradeState = string;

// @public
export interface MobilityServiceUpdate {
    osType?: string;
    rebootStatus?: string;
    version?: string;
}

// @public
export type MultiVmGroupCreateOption = string;

// @public
export type MultiVmSyncPointOption = string;

// @public
export interface Network extends Resource {
    properties?: NetworkProperties;
}

// @public
export interface NetworkCollection {
    nextLink?: string;
    value?: Network[];
}

// @public
export interface NetworkMapping extends Resource {
    properties?: NetworkMappingProperties;
}

// @public
export interface NetworkMappingCollection {
    nextLink?: string;
    value?: NetworkMapping[];
}

// @public
export interface NetworkMappingFabricSpecificSettings {
    instanceType: "AzureToAzure" | "VmmToAzure" | "VmmToVmm";
}

// @public (undocumented)
export type NetworkMappingFabricSpecificSettingsUnion = NetworkMappingFabricSpecificSettings | AzureToAzureNetworkMappingSettings | VmmToAzureNetworkMappingSettings | VmmToVmmNetworkMappingSettings;

// @public
export interface NetworkMappingProperties {
    fabricSpecificSettings?: NetworkMappingFabricSpecificSettingsUnion;
    primaryFabricFriendlyName?: string;
    primaryNetworkFriendlyName?: string;
    primaryNetworkId?: string;
    recoveryFabricArmId?: string;
    recoveryFabricFriendlyName?: string;
    recoveryNetworkFriendlyName?: string;
    recoveryNetworkId?: string;
    state?: string;
}

// @public
export interface NetworkProperties {
    fabricType?: string;
    friendlyName?: string;
    networkType?: string;
    subnets?: Subnet[];
}

// @public
export interface NewProtectionProfile extends ProtectionProfileCustomDetails {
    appConsistentFrequencyInMinutes?: number;
    crashConsistentFrequencyInMinutes?: number;
    multiVmSyncStatus: SetMultiVmSyncStatus;
    policyName: string;
    recoveryPointHistory?: number;
    resourceType: "New";
}

// @public
export interface NewRecoveryVirtualNetwork extends RecoveryVirtualNetworkCustomDetails {
    recoveryVirtualNetworkName?: string;
    recoveryVirtualNetworkResourceGroupName?: string;
    resourceType: "New";
}

// @public
export interface Operations {
    list(resourceGroupName: string, options?: OperationsListOptionalParams): PagedAsyncIterableIterator<OperationsDiscovery>;
}

// @public
export interface OperationsDiscovery {
    display?: Display;
    name?: string;
    origin?: string;
    properties?: Record<string, unknown>;
}

// @public
export interface OperationsDiscoveryCollection {
    nextLink?: string;
    value?: OperationsDiscovery[];
}

// @public
export interface OperationsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type OperationsListNextResponse = OperationsDiscoveryCollection;

// @public
export interface OperationsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type OperationsListResponse = OperationsDiscoveryCollection;

// @public
export interface OSDetails {
    osEdition?: string;
    oSMajorVersion?: string;
    oSMinorVersion?: string;
    osType?: string;
    oSVersion?: string;
    productType?: string;
    userSelectedOSName?: string;
}

// @public
export interface OSDiskDetails {
    osType?: string;
    osVhdId?: string;
    vhdName?: string;
}

// @public
export interface OSUpgradeSupportedVersions {
    readonly supportedSourceOsVersion?: string;
    readonly supportedTargetOsVersions?: string[];
}

// @public
export interface OSVersionWrapper {
    servicePack?: string;
    version?: string;
}

// @public
export interface PauseReplicationInput {
    properties: PauseReplicationInputProperties;
}

// @public
export interface PauseReplicationInputProperties {
    instanceType: string;
}

// @public
export interface PlannedFailoverInput {
    properties?: PlannedFailoverInputProperties;
}

// @public
export interface PlannedFailoverInputProperties {
    failoverDirection?: string;
    providerSpecificDetails?: PlannedFailoverProviderSpecificFailoverInputUnion;
}

// @public
export interface PlannedFailoverProviderSpecificFailoverInput {
    instanceType: "HyperVReplicaAzureFailback" | "HyperVReplicaAzure" | "InMageRcmFailback";
}

// @public (undocumented)
export type PlannedFailoverProviderSpecificFailoverInputUnion = PlannedFailoverProviderSpecificFailoverInput | HyperVReplicaAzureFailbackProviderInput | HyperVReplicaAzurePlannedFailoverProviderInput | InMageRcmFailbackPlannedFailoverProviderInput;

// @public
export type PlannedFailoverStatus = string;

// @public
export interface Policy extends Resource {
    properties?: PolicyProperties;
}

// @public
export interface PolicyCollection {
    nextLink?: string;
    value?: Policy[];
}

// @public
export interface PolicyProperties {
    friendlyName?: string;
    providerSpecificDetails?: PolicyProviderSpecificDetailsUnion;
}

// @public
export interface PolicyProviderSpecificDetails {
    instanceType: "A2A" | "HyperVReplicaAzure" | "HyperVReplicaBasePolicyDetails" | "HyperVReplica2012R2" | "HyperVReplica2012" | "InMageAzureV2" | "InMageBasePolicyDetails" | "InMage" | "InMageRcmFailback" | "InMageRcm" | "VMwareCbt";
}

// @public (undocumented)
export type PolicyProviderSpecificDetailsUnion = PolicyProviderSpecificDetails | A2APolicyDetails | HyperVReplicaAzurePolicyDetails | HyperVReplicaBasePolicyDetails | HyperVReplicaBluePolicyDetails | HyperVReplicaPolicyDetails | InMageAzureV2PolicyDetails | InMageBasePolicyDetails | InMagePolicyDetails | InMageRcmFailbackPolicyDetails | InMageRcmPolicyDetails | VmwareCbtPolicyDetails;

// @public
export interface PolicyProviderSpecificInput {
    instanceType: "A2ACrossClusterMigration" | "A2A" | "HyperVReplicaAzure" | "HyperVReplica2012" | "HyperVReplica2012R2" | "InMageAzureV2" | "InMage" | "InMageRcmFailback" | "InMageRcm" | "VMwareCbt";
}

// @public (undocumented)
export type PolicyProviderSpecificInputUnion = PolicyProviderSpecificInput | A2ACrossClusterMigrationPolicyCreationInput | A2APolicyCreationInput | HyperVReplicaAzurePolicyInput | HyperVReplicaPolicyInputUnion | InMageAzureV2PolicyInput | InMagePolicyInput | InMageRcmFailbackPolicyCreationInput | InMageRcmPolicyCreationInput | VMwareCbtPolicyCreationInput;

// @public
export type PossibleOperationsDirections = string;

// @public
export type PresenceStatus = string;

// @public
export interface ProcessServer {
    agentExpiryDate?: Date;
    agentVersion?: string;
    agentVersionDetails?: VersionDetails;
    availableMemoryInBytes?: number;
    availableSpaceInBytes?: number;
    cpuLoad?: string;
    cpuLoadStatus?: string;
    friendlyName?: string;
    readonly health?: ProtectionHealth;
    healthErrors?: HealthError[];
    hostId?: string;
    id?: string;
    ipAddress?: string;
    lastHeartbeat?: Date;
    machineCount?: string;
    readonly marsCommunicationStatus?: string;
    readonly marsRegistrationStatus?: string;
    memoryUsageStatus?: string;
    mobilityServiceUpdates?: MobilityServiceUpdate[];
    osType?: string;
    osVersion?: string;
    psServiceStatus?: string;
    readonly psStatsRefreshTime?: Date;
    replicationPairCount?: string;
    spaceUsageStatus?: string;
    sslCertExpiryDate?: Date;
    sslCertExpiryRemainingDays?: number;
    systemLoad?: string;
    systemLoadStatus?: string;
    readonly throughputInBytes?: number;
    readonly throughputInMBps?: number;
    readonly throughputStatus?: string;
    readonly throughputUploadPendingDataInBytes?: number;
    totalMemoryInBytes?: number;
    totalSpaceInBytes?: number;
    versionStatus?: string;
}

// @public
export interface ProcessServerDetails {
    readonly availableMemoryInBytes?: number;
    readonly availableSpaceInBytes?: number;
    readonly biosId?: string;
    readonly diskUsageStatus?: RcmComponentStatus;
    readonly fabricObjectId?: string;
    readonly fqdn?: string;
    readonly freeSpacePercentage?: number;
    readonly health?: ProtectionHealth;
    readonly healthErrors?: HealthError[];
    readonly historicHealth?: ProtectionHealth;
    readonly id?: string;
    readonly ipAddresses?: string[];
    readonly lastHeartbeatUtc?: Date;
    readonly memoryUsagePercentage?: number;
    readonly memoryUsageStatus?: RcmComponentStatus;
    readonly name?: string;
    readonly processorUsagePercentage?: number;
    readonly processorUsageStatus?: RcmComponentStatus;
    readonly protectedItemCount?: number;
    readonly systemLoad?: number;
    readonly systemLoadStatus?: RcmComponentStatus;
    readonly throughputInBytes?: number;
    readonly throughputStatus?: RcmComponentStatus;
    readonly throughputUploadPendingDataInBytes?: number;
    readonly totalMemoryInBytes?: number;
    readonly totalSpaceInBytes?: number;
    readonly usedMemoryInBytes?: number;
    readonly usedSpaceInBytes?: number;
    readonly version?: string;
}

// @public
export interface ProtectableItem extends Resource {
    properties?: ProtectableItemProperties;
}

// @public
export interface ProtectableItemCollection {
    nextLink?: string;
    value?: ProtectableItem[];
}

// @public
export interface ProtectableItemProperties {
    customDetails?: ConfigurationSettingsUnion;
    friendlyName?: string;
    protectionReadinessErrors?: string[];
    protectionStatus?: string;
    recoveryServicesProviderId?: string;
    replicationProtectedItemId?: string;
    supportedReplicationProviders?: string[];
}

// @public
export interface ProtectableItemQueryParameter {
    state?: string;
}

// @public
export interface ProtectedClustersQueryParameter {
    instanceType?: string;
    sourceFabricLocation?: string;
    sourceFabricName?: string;
}

// @public
export interface ProtectedItemsQueryParameter {
    fabricObjectId?: string;
    instanceType?: string;
    multiVmGroupCreateOption?: MultiVmGroupCreateOption;
    processServerId?: string;
    recoveryPlanName?: string;
    sourceFabricLocation?: string;
    sourceFabricName?: string;
    vCenterName?: string;
}

// @public
export interface ProtectionContainer extends Resource {
    properties?: ProtectionContainerProperties;
}

// @public
export interface ProtectionContainerCollection {
    nextLink?: string;
    value?: ProtectionContainer[];
}

// @public
export interface ProtectionContainerFabricSpecificDetails {
    readonly instanceType?: string;
}

// @public
export interface ProtectionContainerMapping extends Resource {
    properties?: ProtectionContainerMappingProperties;
}

// @public
export interface ProtectionContainerMappingCollection {
    nextLink?: string;
    value?: ProtectionContainerMapping[];
}

// @public
export interface ProtectionContainerMappingProperties {
    health?: string;
    healthErrorDetails?: HealthError[];
    policyFriendlyName?: string;
    policyId?: string;
    providerSpecificDetails?: ProtectionContainerMappingProviderSpecificDetailsUnion;
    sourceFabricFriendlyName?: string;
    sourceProtectionContainerFriendlyName?: string;
    state?: string;
    targetFabricFriendlyName?: string;
    targetProtectionContainerFriendlyName?: string;
    targetProtectionContainerId?: string;
}

// @public
export interface ProtectionContainerMappingProviderSpecificDetails {
    instanceType: "A2A" | "InMageRcm" | "VMwareCbt";
}

// @public (undocumented)
export type ProtectionContainerMappingProviderSpecificDetailsUnion = ProtectionContainerMappingProviderSpecificDetails | A2AProtectionContainerMappingDetails | InMageRcmProtectionContainerMappingDetails | VMwareCbtProtectionContainerMappingDetails;

// @public
export interface ProtectionContainerProperties {
    fabricFriendlyName?: string;
    fabricSpecificDetails?: ProtectionContainerFabricSpecificDetails;
    fabricType?: string;
    friendlyName?: string;
    pairingStatus?: string;
    protectedItemCount?: number;
    role?: string;
}

// @public
export type ProtectionHealth = string;

// @public
export interface ProtectionProfileCustomDetails {
    resourceType: "Existing" | "New";
}

// @public (undocumented)
export type ProtectionProfileCustomDetailsUnion = ProtectionProfileCustomDetails | ExistingProtectionProfile | NewProtectionProfile;

// @public
export interface ProviderError {
    errorCode?: number;
    errorId?: string;
    errorMessage?: string;
    possibleCauses?: string;
    recommendedAction?: string;
}

// @public
export interface ProviderSpecificRecoveryPointDetails {
    instanceType: "A2A" | "InMageAzureV2" | "InMageRcm";
}

// @public (undocumented)
export type ProviderSpecificRecoveryPointDetailsUnion = ProviderSpecificRecoveryPointDetails | A2ARecoveryPointDetails | InMageAzureV2RecoveryPointDetails | InMageRcmRecoveryPointDetails;

// @public
export interface PushInstallerDetails {
    readonly biosId?: string;
    readonly fabricObjectId?: string;
    readonly fqdn?: string;
    readonly health?: ProtectionHealth;
    readonly healthErrors?: HealthError[];
    readonly id?: string;
    readonly lastHeartbeatUtc?: Date;
    readonly name?: string;
    readonly version?: string;
}

// @public
export type RcmComponentStatus = string;

// @public
export interface RcmProxyDetails {
    readonly biosId?: string;
    readonly clientAuthenticationType?: string;
    readonly fabricObjectId?: string;
    readonly fqdn?: string;
    readonly health?: ProtectionHealth;
    readonly healthErrors?: HealthError[];
    readonly id?: string;
    readonly lastHeartbeatUtc?: Date;
    readonly name?: string;
    readonly version?: string;
}

// @public
export interface RecoveryAvailabilitySetCustomDetails {
    resourceType: "Existing";
}

// @public (undocumented)
export type RecoveryAvailabilitySetCustomDetailsUnion = RecoveryAvailabilitySetCustomDetails | ExistingRecoveryAvailabilitySet;

// @public
export interface RecoveryPlan extends Resource {
    properties?: RecoveryPlanProperties;
}

// @public
export interface RecoveryPlanA2ADetails extends RecoveryPlanProviderSpecificDetails {
    instanceType: "A2A";
    primaryExtendedLocation?: ExtendedLocation;
    primaryZone?: string;
    recoveryExtendedLocation?: ExtendedLocation;
    recoveryZone?: string;
}

// @public
export interface RecoveryPlanA2AFailoverInput extends RecoveryPlanProviderSpecificFailoverInput {
    cloudServiceCreationOption?: string;
    instanceType: "A2A";
    multiVmSyncPointOption?: MultiVmSyncPointOption;
    recoveryPointType: A2ARpRecoveryPointType;
}

// @public
export interface RecoveryPlanA2AInput extends RecoveryPlanProviderSpecificInput {
    instanceType: "A2A";
    primaryExtendedLocation?: ExtendedLocation;
    primaryZone?: string;
    recoveryExtendedLocation?: ExtendedLocation;
    recoveryZone?: string;
}

// @public
export interface RecoveryPlanAction {
    actionName: string;
    customDetails: RecoveryPlanActionDetailsUnion;
    failoverDirections: PossibleOperationsDirections[];
    failoverTypes: ReplicationProtectedItemOperation[];
}

// @public
export interface RecoveryPlanActionDetails {
    instanceType: "AutomationRunbookActionDetails" | "ManualActionDetails" | "ScriptActionDetails";
}

// @public (undocumented)
export type RecoveryPlanActionDetailsUnion = RecoveryPlanActionDetails | RecoveryPlanAutomationRunbookActionDetails | RecoveryPlanManualActionDetails | RecoveryPlanScriptActionDetails;

// @public
export type RecoveryPlanActionLocation = string;

// @public
export interface RecoveryPlanAutomationRunbookActionDetails extends RecoveryPlanActionDetails {
    fabricLocation: RecoveryPlanActionLocation;
    instanceType: "AutomationRunbookActionDetails";
    runbookId?: string;
    timeout?: string;
}

// @public
export interface RecoveryPlanCollection {
    nextLink?: string;
    value?: RecoveryPlan[];
}

// @public
export interface RecoveryPlanGroup {
    endGroupActions?: RecoveryPlanAction[];
    groupType: RecoveryPlanGroupType;
    replicationProtectedItems?: RecoveryPlanProtectedItem[];
    startGroupActions?: RecoveryPlanAction[];
}

// @public
export interface RecoveryPlanGroupTaskDetails extends GroupTaskDetails {
    groupId?: string;
    instanceType: "RecoveryPlanGroupTaskDetails" | "RecoveryPlanShutdownGroupTaskDetails";
    name?: string;
    rpGroupType?: string;
}

// @public (undocumented)
export type RecoveryPlanGroupTaskDetailsUnion = RecoveryPlanGroupTaskDetails | RecoveryPlanShutdownGroupTaskDetails;

// @public
export type RecoveryPlanGroupType = string;

// @public
export interface RecoveryPlanHyperVReplicaAzureFailbackInput extends RecoveryPlanProviderSpecificFailoverInput {
    dataSyncOption: DataSyncStatus;
    instanceType: "HyperVReplicaAzureFailback";
    recoveryVmCreationOption: AlternateLocationRecoveryOption;
}

// @public
export interface RecoveryPlanHyperVReplicaAzureFailoverInput extends RecoveryPlanProviderSpecificFailoverInput {
    instanceType: "HyperVReplicaAzure";
    primaryKekCertificatePfx?: string;
    recoveryPointType?: HyperVReplicaAzureRpRecoveryPointType;
    secondaryKekCertificatePfx?: string;
}

// @public
export interface RecoveryPlanInMageAzureV2FailoverInput extends RecoveryPlanProviderSpecificFailoverInput {
    instanceType: "InMageAzureV2";
    recoveryPointType: InMageV2RpRecoveryPointType;
    useMultiVmSyncPoint?: string;
}

// @public
export interface RecoveryPlanInMageFailoverInput extends RecoveryPlanProviderSpecificFailoverInput {
    instanceType: "InMage";
    recoveryPointType: RpInMageRecoveryPointType;
}

// @public
export interface RecoveryPlanInMageRcmFailbackFailoverInput extends RecoveryPlanProviderSpecificFailoverInput {
    instanceType: "InMageRcmFailback";
    recoveryPointType: InMageRcmFailbackRecoveryPointType;
    useMultiVmSyncPoint?: string;
}

// @public
export interface RecoveryPlanInMageRcmFailoverInput extends RecoveryPlanProviderSpecificFailoverInput {
    instanceType: "InMageRcm";
    recoveryPointType: RecoveryPlanPointType;
    useMultiVmSyncPoint?: string;
}

// @public
export interface RecoveryPlanManualActionDetails extends RecoveryPlanActionDetails {
    description?: string;
    instanceType: "ManualActionDetails";
}

// @public
export interface RecoveryPlanPlannedFailoverInput {
    properties: RecoveryPlanPlannedFailoverInputProperties;
}

// @public
export interface RecoveryPlanPlannedFailoverInputProperties {
    failoverDirection: PossibleOperationsDirections;
    providerSpecificDetails?: RecoveryPlanProviderSpecificFailoverInputUnion[];
}

// @public
export type RecoveryPlanPointType = string;

// @public
export interface RecoveryPlanProperties {
    allowedOperations?: string[];
    currentScenario?: CurrentScenarioDetails;
    currentScenarioStatus?: string;
    currentScenarioStatusDescription?: string;
    failoverDeploymentModel?: string;
    friendlyName?: string;
    groups?: RecoveryPlanGroup[];
    lastPlannedFailoverTime?: Date;
    lastTestFailoverTime?: Date;
    lastUnplannedFailoverTime?: Date;
    primaryFabricFriendlyName?: string;
    primaryFabricId?: string;
    providerSpecificDetails?: RecoveryPlanProviderSpecificDetailsUnion[];
    recoveryFabricFriendlyName?: string;
    recoveryFabricId?: string;
    replicationProviders?: string[];
}

// @public
export interface RecoveryPlanProtectedItem {
    id?: string;
    virtualMachineId?: string;
}

// @public
export interface RecoveryPlanProviderSpecificDetails {
    instanceType: "A2A";
}

// @public (undocumented)
export type RecoveryPlanProviderSpecificDetailsUnion = RecoveryPlanProviderSpecificDetails | RecoveryPlanA2ADetails;

// @public
export interface RecoveryPlanProviderSpecificFailoverInput {
    instanceType: "A2A" | "HyperVReplicaAzureFailback" | "HyperVReplicaAzure" | "InMageAzureV2" | "InMage" | "InMageRcmFailback" | "InMageRcm";
}

// @public (undocumented)
export type RecoveryPlanProviderSpecificFailoverInputUnion = RecoveryPlanProviderSpecificFailoverInput | RecoveryPlanA2AFailoverInput | RecoveryPlanHyperVReplicaAzureFailbackInput | RecoveryPlanHyperVReplicaAzureFailoverInput | RecoveryPlanInMageAzureV2FailoverInput | RecoveryPlanInMageFailoverInput | RecoveryPlanInMageRcmFailbackFailoverInput | RecoveryPlanInMageRcmFailoverInput;

// @public
export interface RecoveryPlanProviderSpecificInput {
    instanceType: "A2A";
}

// @public (undocumented)
export type RecoveryPlanProviderSpecificInputUnion = RecoveryPlanProviderSpecificInput | RecoveryPlanA2AInput;

// @public
export interface RecoveryPlanScriptActionDetails extends RecoveryPlanActionDetails {
    fabricLocation: RecoveryPlanActionLocation;
    instanceType: "ScriptActionDetails";
    path: string;
    timeout?: string;
}

// @public
export interface RecoveryPlanShutdownGroupTaskDetails extends RecoveryPlanGroupTaskDetails {
    instanceType: "RecoveryPlanShutdownGroupTaskDetails";
}

// @public
export interface RecoveryPlanTestFailoverCleanupInput {
    properties: RecoveryPlanTestFailoverCleanupInputProperties;
}

// @public
export interface RecoveryPlanTestFailoverCleanupInputProperties {
    comments?: string;
}

// @public
export interface RecoveryPlanTestFailoverInput {
    properties: RecoveryPlanTestFailoverInputProperties;
}

// @public
export interface RecoveryPlanTestFailoverInputProperties {
    failoverDirection: PossibleOperationsDirections;
    networkId?: string;
    networkType: string;
    providerSpecificDetails?: RecoveryPlanProviderSpecificFailoverInputUnion[];
}

// @public
export interface RecoveryPlanUnplannedFailoverInput {
    properties: RecoveryPlanUnplannedFailoverInputProperties;
}

// @public
export interface RecoveryPlanUnplannedFailoverInputProperties {
    failoverDirection: PossibleOperationsDirections;
    providerSpecificDetails?: RecoveryPlanProviderSpecificFailoverInputUnion[];
    sourceSiteOperations: SourceSiteOperations;
}

// @public
export interface RecoveryPoint extends Resource {
    properties?: RecoveryPointProperties;
}

// @public
export interface RecoveryPointCollection {
    nextLink?: string;
    value?: RecoveryPoint[];
}

// @public
export interface RecoveryPointProperties {
    providerSpecificDetails?: ProviderSpecificRecoveryPointDetailsUnion;
    recoveryPointTime?: Date;
    recoveryPointType?: string;
}

// @public
export interface RecoveryPoints {
    get(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, recoveryPointName: string, options?: RecoveryPointsGetOptionalParams): Promise<RecoveryPointsGetResponse>;
    listByReplicationProtectedItems(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, options?: RecoveryPointsListByReplicationProtectedItemsOptionalParams): PagedAsyncIterableIterator<RecoveryPoint>;
}

// @public
export interface RecoveryPointsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RecoveryPointsGetResponse = RecoveryPoint;

// @public
export interface RecoveryPointsListByReplicationProtectedItemsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RecoveryPointsListByReplicationProtectedItemsNextResponse = RecoveryPointCollection;

// @public
export interface RecoveryPointsListByReplicationProtectedItemsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RecoveryPointsListByReplicationProtectedItemsResponse = RecoveryPointCollection;

// @public
export type RecoveryPointSyncType = string;

// @public
export type RecoveryPointType = string;

// @public
export interface RecoveryProximityPlacementGroupCustomDetails {
    resourceType: "Existing";
}

// @public (undocumented)
export type RecoveryProximityPlacementGroupCustomDetailsUnion = RecoveryProximityPlacementGroupCustomDetails | ExistingRecoveryProximityPlacementGroup;

// @public
export interface RecoveryResourceGroupCustomDetails {
    resourceType: "Existing";
}

// @public (undocumented)
export type RecoveryResourceGroupCustomDetailsUnion = RecoveryResourceGroupCustomDetails | ExistingRecoveryResourceGroup;

// @public
export interface RecoveryServicesProvider extends Resource {
    properties?: RecoveryServicesProviderProperties;
}

// @public
export interface RecoveryServicesProviderCollection {
    nextLink?: string;
    value?: RecoveryServicesProvider[];
}

// @public
export interface RecoveryServicesProviderProperties {
    allowedScenarios?: string[];
    authenticationIdentityDetails?: IdentityProviderDetails;
    biosId?: string;
    connectionStatus?: string;
    dataPlaneAuthenticationIdentityDetails?: IdentityProviderDetails;
    draIdentifier?: string;
    fabricFriendlyName?: string;
    fabricType?: string;
    friendlyName?: string;
    healthErrorDetails?: HealthError[];
    lastHeartBeat?: Date;
    machineId?: string;
    machineName?: string;
    protectedItemCount?: number;
    providerVersion?: string;
    providerVersionDetails?: VersionDetails;
    providerVersionExpiryDate?: Date;
    providerVersionState?: string;
    resourceAccessIdentityDetails?: IdentityProviderDetails;
    serverVersion?: string;
}

// @public
export interface RecoveryVirtualNetworkCustomDetails {
    resourceType: "Existing" | "New";
}

// @public (undocumented)
export type RecoveryVirtualNetworkCustomDetailsUnion = RecoveryVirtualNetworkCustomDetails | ExistingRecoveryVirtualNetwork | NewRecoveryVirtualNetwork;

// @public
export interface RegisteredClusterNodes {
    biosId?: string;
    clusterNodeFqdn?: string;
    isSharedDiskVirtualNode?: boolean;
    machineId?: string;
}

// @public
export interface RemoveDisksInput {
    properties?: RemoveDisksInputProperties;
}

// @public
export interface RemoveDisksInputProperties {
    providerSpecificDetails?: RemoveDisksProviderSpecificInputUnion;
}

// @public
export interface RemoveDisksProviderSpecificInput {
    instanceType: "A2A";
}

// @public (undocumented)
export type RemoveDisksProviderSpecificInputUnion = RemoveDisksProviderSpecificInput | A2ARemoveDisksInput;

// @public
export interface RemoveProtectionContainerMappingInput {
    properties?: RemoveProtectionContainerMappingInputProperties;
}

// @public
export interface RemoveProtectionContainerMappingInputProperties {
    providerSpecificInput?: ReplicationProviderContainerUnmappingInput;
}

// @public
export interface RenewCertificateInput {
    properties?: RenewCertificateInputProperties;
}

// @public
export interface RenewCertificateInputProperties {
    renewCertificateType?: string;
}

// @public
export interface ReplicationAgentDetails {
    readonly biosId?: string;
    readonly fabricObjectId?: string;
    readonly fqdn?: string;
    readonly health?: ProtectionHealth;
    readonly healthErrors?: HealthError[];
    readonly id?: string;
    readonly lastHeartbeatUtc?: Date;
    readonly name?: string;
    readonly version?: string;
}

// @public
export interface ReplicationAlertSettings {
    create(resourceGroupName: string, resourceName: string, alertSettingName: string, request: ConfigureAlertRequest, options?: ReplicationAlertSettingsCreateOptionalParams): Promise<ReplicationAlertSettingsCreateResponse>;
    get(resourceGroupName: string, resourceName: string, alertSettingName: string, options?: ReplicationAlertSettingsGetOptionalParams): Promise<ReplicationAlertSettingsGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationAlertSettingsListOptionalParams): PagedAsyncIterableIterator<Alert>;
}

// @public
export interface ReplicationAlertSettingsCreateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationAlertSettingsCreateResponse = Alert;

// @public
export interface ReplicationAlertSettingsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationAlertSettingsGetResponse = Alert;

// @public
export interface ReplicationAlertSettingsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationAlertSettingsListNextResponse = AlertCollection;

// @public
export interface ReplicationAlertSettingsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationAlertSettingsListResponse = AlertCollection;

// @public
export interface ReplicationAppliance {
    properties?: ReplicationApplianceProperties;
}

// @public
export interface ReplicationApplianceProperties {
    providerSpecificDetails?: ApplianceSpecificDetailsUnion;
}

// @public
export interface ReplicationAppliances {
    list(resourceGroupName: string, resourceName: string, options?: ReplicationAppliancesListOptionalParams): PagedAsyncIterableIterator<ReplicationAppliance>;
}

// @public
export interface ReplicationAppliancesListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationAppliancesListNextResponse = ApplianceCollection;

// @public
export interface ReplicationAppliancesListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type ReplicationAppliancesListResponse = ApplianceCollection;

// @public
export interface ReplicationClusterProviderSpecificSettings {
    instanceType: "A2A";
}

// @public (undocumented)
export type ReplicationClusterProviderSpecificSettingsUnion = ReplicationClusterProviderSpecificSettings | A2AReplicationProtectionClusterDetails;

// @public
export interface ReplicationEligibilityResults {
    readonly id?: string;
    readonly name?: string;
    readonly properties?: ReplicationEligibilityResultsProperties;
    readonly type?: string;
}

// @public
export interface ReplicationEligibilityResultsCollection {
    value?: ReplicationEligibilityResults[];
}

// @public
export interface ReplicationEligibilityResultsErrorInfo {
    code?: string;
    message?: string;
    possibleCauses?: string;
    recommendedAction?: string;
    readonly status?: string;
}

// @public
export interface ReplicationEligibilityResultsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationEligibilityResultsGetResponse = ReplicationEligibilityResults;

// @public
export interface ReplicationEligibilityResultsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationEligibilityResultsListResponse = ReplicationEligibilityResultsCollection;

// @public
export interface ReplicationEligibilityResultsOperations {
    get(resourceGroupName: string, virtualMachineName: string, options?: ReplicationEligibilityResultsGetOptionalParams): Promise<ReplicationEligibilityResultsGetResponse>;
    list(resourceGroupName: string, virtualMachineName: string, options?: ReplicationEligibilityResultsListOptionalParams): Promise<ReplicationEligibilityResultsListResponse>;
}

// @public
export interface ReplicationEligibilityResultsProperties {
    readonly clientRequestId?: string;
    errors?: ReplicationEligibilityResultsErrorInfo[];
}

// @public
export interface ReplicationEvents {
    get(resourceGroupName: string, resourceName: string, eventName: string, options?: ReplicationEventsGetOptionalParams): Promise<ReplicationEventsGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationEventsListOptionalParams): PagedAsyncIterableIterator<Event_2>;
}

// @public
export interface ReplicationEventsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationEventsGetResponse = Event_2;

// @public
export interface ReplicationEventsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationEventsListNextResponse = EventCollection;

// @public
export interface ReplicationEventsListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type ReplicationEventsListResponse = EventCollection;

// @public
export interface ReplicationFabrics {
    beginCheckConsistency(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationFabricsCheckConsistencyOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationFabricsCheckConsistencyResponse>, ReplicationFabricsCheckConsistencyResponse>>;
    beginCheckConsistencyAndWait(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationFabricsCheckConsistencyOptionalParams): Promise<ReplicationFabricsCheckConsistencyResponse>;
    beginCreate(resourceGroupName: string, resourceName: string, fabricName: string, input: FabricCreationInput, options?: ReplicationFabricsCreateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationFabricsCreateResponse>, ReplicationFabricsCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, input: FabricCreationInput, options?: ReplicationFabricsCreateOptionalParams): Promise<ReplicationFabricsCreateResponse>;
    beginDelete(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationFabricsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationFabricsDeleteOptionalParams): Promise<void>;
    beginMigrateToAad(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationFabricsMigrateToAadOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginMigrateToAadAndWait(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationFabricsMigrateToAadOptionalParams): Promise<void>;
    beginPurge(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationFabricsPurgeOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginPurgeAndWait(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationFabricsPurgeOptionalParams): Promise<void>;
    beginReassociateGateway(resourceGroupName: string, resourceName: string, fabricName: string, failoverProcessServerRequest: FailoverProcessServerRequest, options?: ReplicationFabricsReassociateGatewayOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationFabricsReassociateGatewayResponse>, ReplicationFabricsReassociateGatewayResponse>>;
    beginReassociateGatewayAndWait(resourceGroupName: string, resourceName: string, fabricName: string, failoverProcessServerRequest: FailoverProcessServerRequest, options?: ReplicationFabricsReassociateGatewayOptionalParams): Promise<ReplicationFabricsReassociateGatewayResponse>;
    beginRemoveInfra(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationFabricsRemoveInfraOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationFabricsRemoveInfraResponse>, ReplicationFabricsRemoveInfraResponse>>;
    beginRemoveInfraAndWait(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationFabricsRemoveInfraOptionalParams): Promise<ReplicationFabricsRemoveInfraResponse>;
    beginRenewCertificate(resourceGroupName: string, resourceName: string, fabricName: string, renewCertificate: RenewCertificateInput, options?: ReplicationFabricsRenewCertificateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationFabricsRenewCertificateResponse>, ReplicationFabricsRenewCertificateResponse>>;
    beginRenewCertificateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, renewCertificate: RenewCertificateInput, options?: ReplicationFabricsRenewCertificateOptionalParams): Promise<ReplicationFabricsRenewCertificateResponse>;
    get(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationFabricsGetOptionalParams): Promise<ReplicationFabricsGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationFabricsListOptionalParams): PagedAsyncIterableIterator<Fabric>;
}

// @public
export interface ReplicationFabricsCheckConsistencyOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationFabricsCheckConsistencyResponse = Fabric;

// @public
export interface ReplicationFabricsCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationFabricsCreateResponse = Fabric;

// @public
export interface ReplicationFabricsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationFabricsGetOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type ReplicationFabricsGetResponse = Fabric;

// @public
export interface ReplicationFabricsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationFabricsListNextResponse = FabricCollection;

// @public
export interface ReplicationFabricsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationFabricsListResponse = FabricCollection;

// @public
export interface ReplicationFabricsMigrateToAadOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationFabricsPurgeOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationFabricsReassociateGatewayOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationFabricsReassociateGatewayResponse = Fabric;

// @public
export interface ReplicationFabricsRemoveInfraHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface ReplicationFabricsRemoveInfraOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationFabricsRemoveInfraResponse = ReplicationFabricsRemoveInfraHeaders;

// @public
export interface ReplicationFabricsRenewCertificateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationFabricsRenewCertificateResponse = Fabric;

// @public
export interface ReplicationGroupDetails extends ConfigurationSettings {
    instanceType: "ReplicationGroupDetails";
}

// @public
export interface ReplicationJobs {
    beginCancel(resourceGroupName: string, resourceName: string, jobName: string, options?: ReplicationJobsCancelOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationJobsCancelResponse>, ReplicationJobsCancelResponse>>;
    beginCancelAndWait(resourceGroupName: string, resourceName: string, jobName: string, options?: ReplicationJobsCancelOptionalParams): Promise<ReplicationJobsCancelResponse>;
    beginExport(resourceGroupName: string, resourceName: string, jobQueryParameter: JobQueryParameter, options?: ReplicationJobsExportOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationJobsExportResponse>, ReplicationJobsExportResponse>>;
    beginExportAndWait(resourceGroupName: string, resourceName: string, jobQueryParameter: JobQueryParameter, options?: ReplicationJobsExportOptionalParams): Promise<ReplicationJobsExportResponse>;
    beginRestart(resourceGroupName: string, resourceName: string, jobName: string, options?: ReplicationJobsRestartOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationJobsRestartResponse>, ReplicationJobsRestartResponse>>;
    beginRestartAndWait(resourceGroupName: string, resourceName: string, jobName: string, options?: ReplicationJobsRestartOptionalParams): Promise<ReplicationJobsRestartResponse>;
    beginResume(resourceGroupName: string, resourceName: string, jobName: string, resumeJobParams: ResumeJobParams, options?: ReplicationJobsResumeOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationJobsResumeResponse>, ReplicationJobsResumeResponse>>;
    beginResumeAndWait(resourceGroupName: string, resourceName: string, jobName: string, resumeJobParams: ResumeJobParams, options?: ReplicationJobsResumeOptionalParams): Promise<ReplicationJobsResumeResponse>;
    get(resourceGroupName: string, resourceName: string, jobName: string, options?: ReplicationJobsGetOptionalParams): Promise<ReplicationJobsGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationJobsListOptionalParams): PagedAsyncIterableIterator<Job>;
}

// @public
export interface ReplicationJobsCancelOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationJobsCancelResponse = Job;

// @public
export interface ReplicationJobsExportOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationJobsExportResponse = Job;

// @public
export interface ReplicationJobsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationJobsGetResponse = Job;

// @public
export interface ReplicationJobsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationJobsListNextResponse = JobCollection;

// @public
export interface ReplicationJobsListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type ReplicationJobsListResponse = JobCollection;

// @public
export interface ReplicationJobsRestartOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationJobsRestartResponse = Job;

// @public
export interface ReplicationJobsResumeOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationJobsResumeResponse = Job;

// @public
export interface ReplicationLogicalNetworks {
    get(resourceGroupName: string, resourceName: string, fabricName: string, logicalNetworkName: string, options?: ReplicationLogicalNetworksGetOptionalParams): Promise<ReplicationLogicalNetworksGetResponse>;
    listByReplicationFabrics(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationLogicalNetworksListByReplicationFabricsOptionalParams): PagedAsyncIterableIterator<LogicalNetwork>;
}

// @public
export interface ReplicationLogicalNetworksGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationLogicalNetworksGetResponse = LogicalNetwork;

// @public
export interface ReplicationLogicalNetworksListByReplicationFabricsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationLogicalNetworksListByReplicationFabricsNextResponse = LogicalNetworkCollection;

// @public
export interface ReplicationLogicalNetworksListByReplicationFabricsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationLogicalNetworksListByReplicationFabricsResponse = LogicalNetworkCollection;

// @public
export interface ReplicationMigrationItems {
    beginCreate(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, input: EnableMigrationInput, options?: ReplicationMigrationItemsCreateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationMigrationItemsCreateResponse>, ReplicationMigrationItemsCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, input: EnableMigrationInput, options?: ReplicationMigrationItemsCreateOptionalParams): Promise<ReplicationMigrationItemsCreateResponse>;
    beginDelete(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, options?: ReplicationMigrationItemsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, options?: ReplicationMigrationItemsDeleteOptionalParams): Promise<void>;
    beginMigrate(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, migrateInput: MigrateInput, options?: ReplicationMigrationItemsMigrateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationMigrationItemsMigrateResponse>, ReplicationMigrationItemsMigrateResponse>>;
    beginMigrateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, migrateInput: MigrateInput, options?: ReplicationMigrationItemsMigrateOptionalParams): Promise<ReplicationMigrationItemsMigrateResponse>;
    beginPauseReplication(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, pauseReplicationInput: PauseReplicationInput, options?: ReplicationMigrationItemsPauseReplicationOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationMigrationItemsPauseReplicationResponse>, ReplicationMigrationItemsPauseReplicationResponse>>;
    beginPauseReplicationAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, pauseReplicationInput: PauseReplicationInput, options?: ReplicationMigrationItemsPauseReplicationOptionalParams): Promise<ReplicationMigrationItemsPauseReplicationResponse>;
    beginResumeReplication(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, resumeReplicationInput: ResumeReplicationInput, options?: ReplicationMigrationItemsResumeReplicationOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationMigrationItemsResumeReplicationResponse>, ReplicationMigrationItemsResumeReplicationResponse>>;
    beginResumeReplicationAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, resumeReplicationInput: ResumeReplicationInput, options?: ReplicationMigrationItemsResumeReplicationOptionalParams): Promise<ReplicationMigrationItemsResumeReplicationResponse>;
    beginResync(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, input: ResyncInput, options?: ReplicationMigrationItemsResyncOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationMigrationItemsResyncResponse>, ReplicationMigrationItemsResyncResponse>>;
    beginResyncAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, input: ResyncInput, options?: ReplicationMigrationItemsResyncOptionalParams): Promise<ReplicationMigrationItemsResyncResponse>;
    beginTestMigrate(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, testMigrateInput: TestMigrateInput, options?: ReplicationMigrationItemsTestMigrateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationMigrationItemsTestMigrateResponse>, ReplicationMigrationItemsTestMigrateResponse>>;
    beginTestMigrateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, testMigrateInput: TestMigrateInput, options?: ReplicationMigrationItemsTestMigrateOptionalParams): Promise<ReplicationMigrationItemsTestMigrateResponse>;
    beginTestMigrateCleanup(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, testMigrateCleanupInput: TestMigrateCleanupInput, options?: ReplicationMigrationItemsTestMigrateCleanupOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationMigrationItemsTestMigrateCleanupResponse>, ReplicationMigrationItemsTestMigrateCleanupResponse>>;
    beginTestMigrateCleanupAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, testMigrateCleanupInput: TestMigrateCleanupInput, options?: ReplicationMigrationItemsTestMigrateCleanupOptionalParams): Promise<ReplicationMigrationItemsTestMigrateCleanupResponse>;
    beginUpdate(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, input: UpdateMigrationItemInput, options?: ReplicationMigrationItemsUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationMigrationItemsUpdateResponse>, ReplicationMigrationItemsUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, input: UpdateMigrationItemInput, options?: ReplicationMigrationItemsUpdateOptionalParams): Promise<ReplicationMigrationItemsUpdateResponse>;
    get(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, migrationItemName: string, options?: ReplicationMigrationItemsGetOptionalParams): Promise<ReplicationMigrationItemsGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationMigrationItemsListOptionalParams): PagedAsyncIterableIterator<MigrationItem>;
    listByReplicationProtectionContainers(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, options?: ReplicationMigrationItemsListByReplicationProtectionContainersOptionalParams): PagedAsyncIterableIterator<MigrationItem>;
}

// @public
export interface ReplicationMigrationItemsCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationMigrationItemsCreateResponse = MigrationItem;

// @public
export interface ReplicationMigrationItemsDeleteOptionalParams extends coreClient.OperationOptions {
    deleteOption?: string;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationMigrationItemsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationMigrationItemsGetResponse = MigrationItem;

// @public
export interface ReplicationMigrationItemsListByReplicationProtectionContainersNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationMigrationItemsListByReplicationProtectionContainersNextResponse = MigrationItemCollection;

// @public
export interface ReplicationMigrationItemsListByReplicationProtectionContainersOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skipToken?: string;
    takeToken?: string;
}

// @public
export type ReplicationMigrationItemsListByReplicationProtectionContainersResponse = MigrationItemCollection;

// @public
export interface ReplicationMigrationItemsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationMigrationItemsListNextResponse = MigrationItemCollection;

// @public
export interface ReplicationMigrationItemsListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skipToken?: string;
    takeToken?: string;
}

// @public
export type ReplicationMigrationItemsListResponse = MigrationItemCollection;

// @public
export interface ReplicationMigrationItemsMigrateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationMigrationItemsMigrateResponse = MigrationItem;

// @public
export interface ReplicationMigrationItemsPauseReplicationOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationMigrationItemsPauseReplicationResponse = MigrationItem;

// @public
export interface ReplicationMigrationItemsResumeReplicationOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationMigrationItemsResumeReplicationResponse = MigrationItem;

// @public
export interface ReplicationMigrationItemsResyncOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationMigrationItemsResyncResponse = MigrationItem;

// @public
export interface ReplicationMigrationItemsTestMigrateCleanupOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationMigrationItemsTestMigrateCleanupResponse = MigrationItem;

// @public
export interface ReplicationMigrationItemsTestMigrateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationMigrationItemsTestMigrateResponse = MigrationItem;

// @public
export interface ReplicationMigrationItemsUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationMigrationItemsUpdateResponse = MigrationItem;

// @public
export interface ReplicationNetworkMappings {
    beginCreate(resourceGroupName: string, resourceName: string, fabricName: string, networkName: string, networkMappingName: string, input: CreateNetworkMappingInput, options?: ReplicationNetworkMappingsCreateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationNetworkMappingsCreateResponse>, ReplicationNetworkMappingsCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, networkName: string, networkMappingName: string, input: CreateNetworkMappingInput, options?: ReplicationNetworkMappingsCreateOptionalParams): Promise<ReplicationNetworkMappingsCreateResponse>;
    beginDelete(resourceGroupName: string, resourceName: string, fabricName: string, networkName: string, networkMappingName: string, options?: ReplicationNetworkMappingsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, resourceName: string, fabricName: string, networkName: string, networkMappingName: string, options?: ReplicationNetworkMappingsDeleteOptionalParams): Promise<void>;
    beginUpdate(resourceGroupName: string, resourceName: string, fabricName: string, networkName: string, networkMappingName: string, input: UpdateNetworkMappingInput, options?: ReplicationNetworkMappingsUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationNetworkMappingsUpdateResponse>, ReplicationNetworkMappingsUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, networkName: string, networkMappingName: string, input: UpdateNetworkMappingInput, options?: ReplicationNetworkMappingsUpdateOptionalParams): Promise<ReplicationNetworkMappingsUpdateResponse>;
    get(resourceGroupName: string, resourceName: string, fabricName: string, networkName: string, networkMappingName: string, options?: ReplicationNetworkMappingsGetOptionalParams): Promise<ReplicationNetworkMappingsGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationNetworkMappingsListOptionalParams): PagedAsyncIterableIterator<NetworkMapping>;
    listByReplicationNetworks(resourceGroupName: string, resourceName: string, fabricName: string, networkName: string, options?: ReplicationNetworkMappingsListByReplicationNetworksOptionalParams): PagedAsyncIterableIterator<NetworkMapping>;
}

// @public
export interface ReplicationNetworkMappingsCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationNetworkMappingsCreateResponse = NetworkMapping;

// @public
export interface ReplicationNetworkMappingsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationNetworkMappingsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationNetworkMappingsGetResponse = NetworkMapping;

// @public
export interface ReplicationNetworkMappingsListByReplicationNetworksNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationNetworkMappingsListByReplicationNetworksNextResponse = NetworkMappingCollection;

// @public
export interface ReplicationNetworkMappingsListByReplicationNetworksOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationNetworkMappingsListByReplicationNetworksResponse = NetworkMappingCollection;

// @public
export interface ReplicationNetworkMappingsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationNetworkMappingsListNextResponse = NetworkMappingCollection;

// @public
export interface ReplicationNetworkMappingsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationNetworkMappingsListResponse = NetworkMappingCollection;

// @public
export interface ReplicationNetworkMappingsUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationNetworkMappingsUpdateResponse = NetworkMapping;

// @public
export interface ReplicationNetworks {
    get(resourceGroupName: string, resourceName: string, fabricName: string, networkName: string, options?: ReplicationNetworksGetOptionalParams): Promise<ReplicationNetworksGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationNetworksListOptionalParams): PagedAsyncIterableIterator<Network>;
    listByReplicationFabrics(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationNetworksListByReplicationFabricsOptionalParams): PagedAsyncIterableIterator<Network>;
}

// @public
export interface ReplicationNetworksGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationNetworksGetResponse = Network;

// @public
export interface ReplicationNetworksListByReplicationFabricsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationNetworksListByReplicationFabricsNextResponse = NetworkCollection;

// @public
export interface ReplicationNetworksListByReplicationFabricsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationNetworksListByReplicationFabricsResponse = NetworkCollection;

// @public
export interface ReplicationNetworksListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationNetworksListNextResponse = NetworkCollection;

// @public
export interface ReplicationNetworksListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationNetworksListResponse = NetworkCollection;

// @public
export interface ReplicationPolicies {
    beginCreate(resourceGroupName: string, resourceName: string, policyName: string, input: CreatePolicyInput, options?: ReplicationPoliciesCreateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationPoliciesCreateResponse>, ReplicationPoliciesCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, resourceName: string, policyName: string, input: CreatePolicyInput, options?: ReplicationPoliciesCreateOptionalParams): Promise<ReplicationPoliciesCreateResponse>;
    beginDelete(resourceGroupName: string, resourceName: string, policyName: string, options?: ReplicationPoliciesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, resourceName: string, policyName: string, options?: ReplicationPoliciesDeleteOptionalParams): Promise<void>;
    beginUpdate(resourceGroupName: string, resourceName: string, policyName: string, input: UpdatePolicyInput, options?: ReplicationPoliciesUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationPoliciesUpdateResponse>, ReplicationPoliciesUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, resourceName: string, policyName: string, input: UpdatePolicyInput, options?: ReplicationPoliciesUpdateOptionalParams): Promise<ReplicationPoliciesUpdateResponse>;
    get(resourceGroupName: string, resourceName: string, policyName: string, options?: ReplicationPoliciesGetOptionalParams): Promise<ReplicationPoliciesGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationPoliciesListOptionalParams): PagedAsyncIterableIterator<Policy>;
}

// @public
export interface ReplicationPoliciesCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationPoliciesCreateResponse = Policy;

// @public
export interface ReplicationPoliciesDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationPoliciesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationPoliciesGetResponse = Policy;

// @public
export interface ReplicationPoliciesListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationPoliciesListNextResponse = PolicyCollection;

// @public
export interface ReplicationPoliciesListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationPoliciesListResponse = PolicyCollection;

// @public
export interface ReplicationPoliciesUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationPoliciesUpdateResponse = Policy;

// @public
export interface ReplicationProtectableItems {
    get(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, protectableItemName: string, options?: ReplicationProtectableItemsGetOptionalParams): Promise<ReplicationProtectableItemsGetResponse>;
    listByReplicationProtectionContainers(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, options?: ReplicationProtectableItemsListByReplicationProtectionContainersOptionalParams): PagedAsyncIterableIterator<ProtectableItem>;
}

// @public
export interface ReplicationProtectableItemsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectableItemsGetResponse = ProtectableItem;

// @public
export interface ReplicationProtectableItemsListByReplicationProtectionContainersNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectableItemsListByReplicationProtectionContainersNextResponse = ProtectableItemCollection;

// @public
export interface ReplicationProtectableItemsListByReplicationProtectionContainersOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skipToken?: string;
    take?: string;
}

// @public
export type ReplicationProtectableItemsListByReplicationProtectionContainersResponse = ProtectableItemCollection;

// @public
export interface ReplicationProtectedItem extends Resource {
    properties?: ReplicationProtectedItemProperties;
}

// @public
export interface ReplicationProtectedItemCollection {
    nextLink?: string;
    value?: ReplicationProtectedItem[];
}

// @public
export type ReplicationProtectedItemOperation = string;

// @public
export interface ReplicationProtectedItemProperties {
    activeLocation?: string;
    allowedOperations?: string[];
    currentScenario?: CurrentScenarioDetails;
    eventCorrelationId?: string;
    failoverHealth?: string;
    failoverRecoveryPointId?: string;
    friendlyName?: string;
    healthErrors?: HealthError[];
    lastSuccessfulFailoverTime?: Date;
    lastSuccessfulTestFailoverTime?: Date;
    policyFriendlyName?: string;
    policyId?: string;
    primaryFabricFriendlyName?: string;
    primaryFabricProvider?: string;
    primaryProtectionContainerFriendlyName?: string;
    protectableItemId?: string;
    protectedItemType?: string;
    protectionState?: string;
    protectionStateDescription?: string;
    providerSpecificDetails?: ReplicationProviderSpecificSettingsUnion;
    recoveryContainerId?: string;
    recoveryFabricFriendlyName?: string;
    recoveryFabricId?: string;
    recoveryProtectionContainerFriendlyName?: string;
    recoveryServicesProviderId?: string;
    replicationHealth?: string;
    switchProviderState?: string;
    switchProviderStateDescription?: string;
    testFailoverState?: string;
    testFailoverStateDescription?: string;
}

// @public
export interface ReplicationProtectedItems {
    beginAddDisks(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, addDisksInput: AddDisksInput, options?: ReplicationProtectedItemsAddDisksOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsAddDisksResponse>, ReplicationProtectedItemsAddDisksResponse>>;
    beginAddDisksAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, addDisksInput: AddDisksInput, options?: ReplicationProtectedItemsAddDisksOptionalParams): Promise<ReplicationProtectedItemsAddDisksResponse>;
    beginApplyRecoveryPoint(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, applyRecoveryPointInput: ApplyRecoveryPointInput, options?: ReplicationProtectedItemsApplyRecoveryPointOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsApplyRecoveryPointResponse>, ReplicationProtectedItemsApplyRecoveryPointResponse>>;
    beginApplyRecoveryPointAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, applyRecoveryPointInput: ApplyRecoveryPointInput, options?: ReplicationProtectedItemsApplyRecoveryPointOptionalParams): Promise<ReplicationProtectedItemsApplyRecoveryPointResponse>;
    beginCreate(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, input: EnableProtectionInput, options?: ReplicationProtectedItemsCreateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsCreateResponse>, ReplicationProtectedItemsCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, input: EnableProtectionInput, options?: ReplicationProtectedItemsCreateOptionalParams): Promise<ReplicationProtectedItemsCreateResponse>;
    beginDelete(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, disableProtectionInput: DisableProtectionInput, options?: ReplicationProtectedItemsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, disableProtectionInput: DisableProtectionInput, options?: ReplicationProtectedItemsDeleteOptionalParams): Promise<void>;
    beginFailoverCancel(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, options?: ReplicationProtectedItemsFailoverCancelOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsFailoverCancelResponse>, ReplicationProtectedItemsFailoverCancelResponse>>;
    beginFailoverCancelAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, options?: ReplicationProtectedItemsFailoverCancelOptionalParams): Promise<ReplicationProtectedItemsFailoverCancelResponse>;
    beginFailoverCommit(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, options?: ReplicationProtectedItemsFailoverCommitOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsFailoverCommitResponse>, ReplicationProtectedItemsFailoverCommitResponse>>;
    beginFailoverCommitAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, options?: ReplicationProtectedItemsFailoverCommitOptionalParams): Promise<ReplicationProtectedItemsFailoverCommitResponse>;
    beginPlannedFailover(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, failoverInput: PlannedFailoverInput, options?: ReplicationProtectedItemsPlannedFailoverOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsPlannedFailoverResponse>, ReplicationProtectedItemsPlannedFailoverResponse>>;
    beginPlannedFailoverAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, failoverInput: PlannedFailoverInput, options?: ReplicationProtectedItemsPlannedFailoverOptionalParams): Promise<ReplicationProtectedItemsPlannedFailoverResponse>;
    beginPurge(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, options?: ReplicationProtectedItemsPurgeOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginPurgeAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, options?: ReplicationProtectedItemsPurgeOptionalParams): Promise<void>;
    beginRemoveDisks(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, removeDisksInput: RemoveDisksInput, options?: ReplicationProtectedItemsRemoveDisksOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsRemoveDisksResponse>, ReplicationProtectedItemsRemoveDisksResponse>>;
    beginRemoveDisksAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, removeDisksInput: RemoveDisksInput, options?: ReplicationProtectedItemsRemoveDisksOptionalParams): Promise<ReplicationProtectedItemsRemoveDisksResponse>;
    beginRepairReplication(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, options?: ReplicationProtectedItemsRepairReplicationOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsRepairReplicationResponse>, ReplicationProtectedItemsRepairReplicationResponse>>;
    beginRepairReplicationAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, options?: ReplicationProtectedItemsRepairReplicationOptionalParams): Promise<ReplicationProtectedItemsRepairReplicationResponse>;
    beginReprotect(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, reprotectInput: ReverseReplicationInput, options?: ReplicationProtectedItemsReprotectOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsReprotectResponse>, ReplicationProtectedItemsReprotectResponse>>;
    beginReprotectAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, reprotectInput: ReverseReplicationInput, options?: ReplicationProtectedItemsReprotectOptionalParams): Promise<ReplicationProtectedItemsReprotectResponse>;
    beginResolveHealthErrors(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, resolveHealthInput: ResolveHealthInput, options?: ReplicationProtectedItemsResolveHealthErrorsOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsResolveHealthErrorsResponse>, ReplicationProtectedItemsResolveHealthErrorsResponse>>;
    beginResolveHealthErrorsAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, resolveHealthInput: ResolveHealthInput, options?: ReplicationProtectedItemsResolveHealthErrorsOptionalParams): Promise<ReplicationProtectedItemsResolveHealthErrorsResponse>;
    beginSwitchProvider(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, switchProviderInput: SwitchProviderInput, options?: ReplicationProtectedItemsSwitchProviderOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsSwitchProviderResponse>, ReplicationProtectedItemsSwitchProviderResponse>>;
    beginSwitchProviderAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, switchProviderInput: SwitchProviderInput, options?: ReplicationProtectedItemsSwitchProviderOptionalParams): Promise<ReplicationProtectedItemsSwitchProviderResponse>;
    beginTestFailover(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, testfailoverInput: TestFailoverInput, options?: ReplicationProtectedItemsTestFailoverOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsTestFailoverResponse>, ReplicationProtectedItemsTestFailoverResponse>>;
    beginTestFailoverAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, testfailoverInput: TestFailoverInput, options?: ReplicationProtectedItemsTestFailoverOptionalParams): Promise<ReplicationProtectedItemsTestFailoverResponse>;
    beginTestFailoverCleanup(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, cleanupInput: TestFailoverCleanupInput, options?: ReplicationProtectedItemsTestFailoverCleanupOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsTestFailoverCleanupResponse>, ReplicationProtectedItemsTestFailoverCleanupResponse>>;
    beginTestFailoverCleanupAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, cleanupInput: TestFailoverCleanupInput, options?: ReplicationProtectedItemsTestFailoverCleanupOptionalParams): Promise<ReplicationProtectedItemsTestFailoverCleanupResponse>;
    beginUnplannedFailover(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, failoverInput: UnplannedFailoverInput, options?: ReplicationProtectedItemsUnplannedFailoverOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsUnplannedFailoverResponse>, ReplicationProtectedItemsUnplannedFailoverResponse>>;
    beginUnplannedFailoverAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, failoverInput: UnplannedFailoverInput, options?: ReplicationProtectedItemsUnplannedFailoverOptionalParams): Promise<ReplicationProtectedItemsUnplannedFailoverResponse>;
    beginUpdate(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, updateProtectionInput: UpdateReplicationProtectedItemInput, options?: ReplicationProtectedItemsUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsUpdateResponse>, ReplicationProtectedItemsUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, updateProtectionInput: UpdateReplicationProtectedItemInput, options?: ReplicationProtectedItemsUpdateOptionalParams): Promise<ReplicationProtectedItemsUpdateResponse>;
    beginUpdateAppliance(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, applianceUpdateInput: UpdateApplianceForReplicationProtectedItemInput, options?: ReplicationProtectedItemsUpdateApplianceOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsUpdateApplianceResponse>, ReplicationProtectedItemsUpdateApplianceResponse>>;
    beginUpdateApplianceAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, applianceUpdateInput: UpdateApplianceForReplicationProtectedItemInput, options?: ReplicationProtectedItemsUpdateApplianceOptionalParams): Promise<ReplicationProtectedItemsUpdateApplianceResponse>;
    beginUpdateMobilityService(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, updateMobilityServiceRequest: UpdateMobilityServiceRequest, options?: ReplicationProtectedItemsUpdateMobilityServiceOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectedItemsUpdateMobilityServiceResponse>, ReplicationProtectedItemsUpdateMobilityServiceResponse>>;
    beginUpdateMobilityServiceAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, updateMobilityServiceRequest: UpdateMobilityServiceRequest, options?: ReplicationProtectedItemsUpdateMobilityServiceOptionalParams): Promise<ReplicationProtectedItemsUpdateMobilityServiceResponse>;
    get(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, options?: ReplicationProtectedItemsGetOptionalParams): Promise<ReplicationProtectedItemsGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationProtectedItemsListOptionalParams): PagedAsyncIterableIterator<ReplicationProtectedItem>;
    listByReplicationProtectionContainers(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, options?: ReplicationProtectedItemsListByReplicationProtectionContainersOptionalParams): PagedAsyncIterableIterator<ReplicationProtectedItem>;
}

// @public
export interface ReplicationProtectedItemsAddDisksOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsAddDisksResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsApplyRecoveryPointOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsApplyRecoveryPointResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsCreateResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationProtectedItemsFailoverCancelOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsFailoverCancelResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsFailoverCommitOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsFailoverCommitResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectedItemsGetResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsListByReplicationProtectionContainersNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectedItemsListByReplicationProtectionContainersNextResponse = ReplicationProtectedItemCollection;

// @public
export interface ReplicationProtectedItemsListByReplicationProtectionContainersOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectedItemsListByReplicationProtectionContainersResponse = ReplicationProtectedItemCollection;

// @public
export interface ReplicationProtectedItemsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectedItemsListNextResponse = ReplicationProtectedItemCollection;

// @public
export interface ReplicationProtectedItemsListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skipToken?: string;
}

// @public
export type ReplicationProtectedItemsListResponse = ReplicationProtectedItemCollection;

// @public
export interface ReplicationProtectedItemsPlannedFailoverOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsPlannedFailoverResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsPurgeOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationProtectedItemsRemoveDisksOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsRemoveDisksResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsRepairReplicationOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsRepairReplicationResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsReprotectOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsReprotectResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsResolveHealthErrorsOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsResolveHealthErrorsResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsSwitchProviderOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsSwitchProviderResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsTestFailoverCleanupOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsTestFailoverCleanupResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsTestFailoverOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsTestFailoverResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsUnplannedFailoverOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsUnplannedFailoverResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsUpdateApplianceOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsUpdateApplianceResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsUpdateMobilityServiceHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface ReplicationProtectedItemsUpdateMobilityServiceOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsUpdateMobilityServiceResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectedItemsUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectedItemsUpdateResponse = ReplicationProtectedItem;

// @public
export interface ReplicationProtectionCluster {
    readonly id?: string;
    readonly name?: string;
    properties?: ReplicationProtectionClusterProperties;
    readonly type?: string;
}

// @public
export interface ReplicationProtectionClusterCollection {
    nextLink?: string;
    value?: ReplicationProtectionCluster[];
}

// @public
export interface ReplicationProtectionClusterProperties {
    activeLocation?: string;
    agentClusterId?: string;
    allowedOperations?: string[];
    areAllClusterNodesRegistered?: boolean;
    clusterFqdn?: string;
    clusterNodeFqdns?: string[];
    clusterProtectedItemIds?: string[];
    clusterRegisteredNodes?: RegisteredClusterNodes[];
    currentScenario?: CurrentScenarioDetails;
    healthErrors?: HealthError[];
    lastSuccessfulFailoverTime?: Date;
    lastSuccessfulTestFailoverTime?: Date;
    policyFriendlyName?: string;
    policyId?: string;
    primaryFabricFriendlyName?: string;
    primaryFabricProvider?: string;
    primaryProtectionContainerFriendlyName?: string;
    protectionClusterType?: string;
    protectionState?: string;
    protectionStateDescription?: string;
    providerSpecificDetails?: ReplicationClusterProviderSpecificSettingsUnion;
    readonly provisioningState?: string;
    recoveryContainerId?: string;
    recoveryFabricFriendlyName?: string;
    recoveryFabricId?: string;
    recoveryProtectionContainerFriendlyName?: string;
    replicationHealth?: string;
    sharedDiskProperties?: SharedDiskReplicationItemProperties;
    testFailoverState?: string;
    testFailoverStateDescription?: string;
}

// @public
export interface ReplicationProtectionClusters {
    beginApplyRecoveryPoint(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, applyClusterRecoveryPointInput: ApplyClusterRecoveryPointInput, options?: ReplicationProtectionClustersApplyRecoveryPointOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionClustersApplyRecoveryPointResponse>, ReplicationProtectionClustersApplyRecoveryPointResponse>>;
    beginApplyRecoveryPointAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, applyClusterRecoveryPointInput: ApplyClusterRecoveryPointInput, options?: ReplicationProtectionClustersApplyRecoveryPointOptionalParams): Promise<ReplicationProtectionClustersApplyRecoveryPointResponse>;
    beginCreate(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, replicationProtectionCluster: ReplicationProtectionCluster, options?: ReplicationProtectionClustersCreateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionClustersCreateResponse>, ReplicationProtectionClustersCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, replicationProtectionCluster: ReplicationProtectionCluster, options?: ReplicationProtectionClustersCreateOptionalParams): Promise<ReplicationProtectionClustersCreateResponse>;
    beginFailoverCommit(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, options?: ReplicationProtectionClustersFailoverCommitOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionClustersFailoverCommitResponse>, ReplicationProtectionClustersFailoverCommitResponse>>;
    beginFailoverCommitAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, options?: ReplicationProtectionClustersFailoverCommitOptionalParams): Promise<ReplicationProtectionClustersFailoverCommitResponse>;
    beginPurge(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, options?: ReplicationProtectionClustersPurgeOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionClustersPurgeResponse>, ReplicationProtectionClustersPurgeResponse>>;
    beginPurgeAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, options?: ReplicationProtectionClustersPurgeOptionalParams): Promise<ReplicationProtectionClustersPurgeResponse>;
    beginRepairReplication(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, options?: ReplicationProtectionClustersRepairReplicationOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionClustersRepairReplicationResponse>, ReplicationProtectionClustersRepairReplicationResponse>>;
    beginRepairReplicationAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, options?: ReplicationProtectionClustersRepairReplicationOptionalParams): Promise<ReplicationProtectionClustersRepairReplicationResponse>;
    beginTestFailover(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, failoverInput: ClusterTestFailoverInput, options?: ReplicationProtectionClustersTestFailoverOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionClustersTestFailoverResponse>, ReplicationProtectionClustersTestFailoverResponse>>;
    beginTestFailoverAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, failoverInput: ClusterTestFailoverInput, options?: ReplicationProtectionClustersTestFailoverOptionalParams): Promise<ReplicationProtectionClustersTestFailoverResponse>;
    beginTestFailoverCleanup(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, cleanupInput: ClusterTestFailoverCleanupInput, options?: ReplicationProtectionClustersTestFailoverCleanupOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionClustersTestFailoverCleanupResponse>, ReplicationProtectionClustersTestFailoverCleanupResponse>>;
    beginTestFailoverCleanupAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, cleanupInput: ClusterTestFailoverCleanupInput, options?: ReplicationProtectionClustersTestFailoverCleanupOptionalParams): Promise<ReplicationProtectionClustersTestFailoverCleanupResponse>;
    beginUnplannedFailover(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, failoverInput: ClusterUnplannedFailoverInput, options?: ReplicationProtectionClustersUnplannedFailoverOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionClustersUnplannedFailoverResponse>, ReplicationProtectionClustersUnplannedFailoverResponse>>;
    beginUnplannedFailoverAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, failoverInput: ClusterUnplannedFailoverInput, options?: ReplicationProtectionClustersUnplannedFailoverOptionalParams): Promise<ReplicationProtectionClustersUnplannedFailoverResponse>;
    get(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, options?: ReplicationProtectionClustersGetOptionalParams): Promise<ReplicationProtectionClustersGetResponse>;
    getOperationResults(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicationProtectionClusterName: string, jobId: string, options?: ReplicationProtectionClustersGetOperationResultsOptionalParams): Promise<ReplicationProtectionClustersGetOperationResultsResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationProtectionClustersListOptionalParams): PagedAsyncIterableIterator<ReplicationProtectionCluster>;
    listByReplicationProtectionContainers(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, options?: ReplicationProtectionClustersListByReplicationProtectionContainersOptionalParams): PagedAsyncIterableIterator<ReplicationProtectionCluster>;
}

// @public
export interface ReplicationProtectionClustersApplyRecoveryPointHeaders {
    // (undocumented)
    azureAsyncOperation?: string;
    // (undocumented)
    location?: string;
    // (undocumented)
    retryAfter?: string;
}

// @public
export interface ReplicationProtectionClustersApplyRecoveryPointOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionClustersApplyRecoveryPointResponse = ReplicationProtectionCluster;

// @public
export interface ReplicationProtectionClustersCreateHeaders {
    // (undocumented)
    azureAsyncOperation?: string;
    // (undocumented)
    location?: string;
    // (undocumented)
    retryAfter?: string;
}

// @public
export interface ReplicationProtectionClustersCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionClustersCreateResponse = ReplicationProtectionCluster;

// @public
export interface ReplicationProtectionClustersFailoverCommitHeaders {
    // (undocumented)
    azureAsyncOperation?: string;
    // (undocumented)
    location?: string;
    // (undocumented)
    retryAfter?: string;
}

// @public
export interface ReplicationProtectionClustersFailoverCommitOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionClustersFailoverCommitResponse = ReplicationProtectionCluster;

// @public
export interface ReplicationProtectionClustersGetOperationResultsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionClustersGetOperationResultsResponse = ReplicationProtectionCluster;

// @public
export interface ReplicationProtectionClustersGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionClustersGetResponse = ReplicationProtectionCluster;

// @public
export interface ReplicationProtectionClustersListByReplicationProtectionContainersNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionClustersListByReplicationProtectionContainersNextResponse = ReplicationProtectionClusterCollection;

// @public
export interface ReplicationProtectionClustersListByReplicationProtectionContainersOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionClustersListByReplicationProtectionContainersResponse = ReplicationProtectionClusterCollection;

// @public
export interface ReplicationProtectionClustersListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionClustersListNextResponse = ReplicationProtectionClusterCollection;

// @public
export interface ReplicationProtectionClustersListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skipToken?: string;
}

// @public
export type ReplicationProtectionClustersListResponse = ReplicationProtectionClusterCollection;

// @public
export interface ReplicationProtectionClustersPurgeHeaders {
    // (undocumented)
    azureAsyncOperation?: string;
    // (undocumented)
    location?: string;
    // (undocumented)
    retryAfter?: string;
}

// @public
export interface ReplicationProtectionClustersPurgeOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionClustersPurgeResponse = ReplicationProtectionClustersPurgeHeaders;

// @public
export interface ReplicationProtectionClustersRepairReplicationHeaders {
    // (undocumented)
    azureAsyncOperation?: string;
    // (undocumented)
    location?: string;
    // (undocumented)
    retryAfter?: string;
}

// @public
export interface ReplicationProtectionClustersRepairReplicationOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionClustersRepairReplicationResponse = ReplicationProtectionCluster;

// @public
export interface ReplicationProtectionClustersTestFailoverCleanupHeaders {
    // (undocumented)
    azureAsyncOperation?: string;
    // (undocumented)
    location?: string;
    // (undocumented)
    retryAfter?: string;
}

// @public
export interface ReplicationProtectionClustersTestFailoverCleanupOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionClustersTestFailoverCleanupResponse = ReplicationProtectionCluster;

// @public
export interface ReplicationProtectionClustersTestFailoverHeaders {
    // (undocumented)
    azureAsyncOperation?: string;
    // (undocumented)
    location?: string;
    // (undocumented)
    retryAfter?: string;
}

// @public
export interface ReplicationProtectionClustersTestFailoverOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionClustersTestFailoverResponse = ReplicationProtectionCluster;

// @public
export interface ReplicationProtectionClustersUnplannedFailoverHeaders {
    // (undocumented)
    azureAsyncOperation?: string;
    // (undocumented)
    location?: string;
    // (undocumented)
    retryAfter?: string;
}

// @public
export interface ReplicationProtectionClustersUnplannedFailoverOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionClustersUnplannedFailoverResponse = ReplicationProtectionCluster;

// @public
export interface ReplicationProtectionContainerMappings {
    beginCreate(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, mappingName: string, creationInput: CreateProtectionContainerMappingInput, options?: ReplicationProtectionContainerMappingsCreateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionContainerMappingsCreateResponse>, ReplicationProtectionContainerMappingsCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, mappingName: string, creationInput: CreateProtectionContainerMappingInput, options?: ReplicationProtectionContainerMappingsCreateOptionalParams): Promise<ReplicationProtectionContainerMappingsCreateResponse>;
    beginDelete(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, mappingName: string, removalInput: RemoveProtectionContainerMappingInput, options?: ReplicationProtectionContainerMappingsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, mappingName: string, removalInput: RemoveProtectionContainerMappingInput, options?: ReplicationProtectionContainerMappingsDeleteOptionalParams): Promise<void>;
    beginPurge(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, mappingName: string, options?: ReplicationProtectionContainerMappingsPurgeOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginPurgeAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, mappingName: string, options?: ReplicationProtectionContainerMappingsPurgeOptionalParams): Promise<void>;
    beginUpdate(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, mappingName: string, updateInput: UpdateProtectionContainerMappingInput, options?: ReplicationProtectionContainerMappingsUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionContainerMappingsUpdateResponse>, ReplicationProtectionContainerMappingsUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, mappingName: string, updateInput: UpdateProtectionContainerMappingInput, options?: ReplicationProtectionContainerMappingsUpdateOptionalParams): Promise<ReplicationProtectionContainerMappingsUpdateResponse>;
    get(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, mappingName: string, options?: ReplicationProtectionContainerMappingsGetOptionalParams): Promise<ReplicationProtectionContainerMappingsGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationProtectionContainerMappingsListOptionalParams): PagedAsyncIterableIterator<ProtectionContainerMapping>;
    listByReplicationProtectionContainers(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, options?: ReplicationProtectionContainerMappingsListByReplicationProtectionContainersOptionalParams): PagedAsyncIterableIterator<ProtectionContainerMapping>;
}

// @public
export interface ReplicationProtectionContainerMappingsCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionContainerMappingsCreateResponse = ProtectionContainerMapping;

// @public
export interface ReplicationProtectionContainerMappingsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationProtectionContainerMappingsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionContainerMappingsGetResponse = ProtectionContainerMapping;

// @public
export interface ReplicationProtectionContainerMappingsListByReplicationProtectionContainersNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionContainerMappingsListByReplicationProtectionContainersNextResponse = ProtectionContainerMappingCollection;

// @public
export interface ReplicationProtectionContainerMappingsListByReplicationProtectionContainersOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionContainerMappingsListByReplicationProtectionContainersResponse = ProtectionContainerMappingCollection;

// @public
export interface ReplicationProtectionContainerMappingsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionContainerMappingsListNextResponse = ProtectionContainerMappingCollection;

// @public
export interface ReplicationProtectionContainerMappingsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionContainerMappingsListResponse = ProtectionContainerMappingCollection;

// @public
export interface ReplicationProtectionContainerMappingsPurgeOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationProtectionContainerMappingsUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionContainerMappingsUpdateResponse = ProtectionContainerMapping;

// @public
export interface ReplicationProtectionContainers {
    beginCreate(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, creationInput: CreateProtectionContainerInput, options?: ReplicationProtectionContainersCreateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionContainersCreateResponse>, ReplicationProtectionContainersCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, creationInput: CreateProtectionContainerInput, options?: ReplicationProtectionContainersCreateOptionalParams): Promise<ReplicationProtectionContainersCreateResponse>;
    beginDelete(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, options?: ReplicationProtectionContainersDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, options?: ReplicationProtectionContainersDeleteOptionalParams): Promise<void>;
    beginDiscoverProtectableItem(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, discoverProtectableItemRequest: DiscoverProtectableItemRequest, options?: ReplicationProtectionContainersDiscoverProtectableItemOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionContainersDiscoverProtectableItemResponse>, ReplicationProtectionContainersDiscoverProtectableItemResponse>>;
    beginDiscoverProtectableItemAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, discoverProtectableItemRequest: DiscoverProtectableItemRequest, options?: ReplicationProtectionContainersDiscoverProtectableItemOptionalParams): Promise<ReplicationProtectionContainersDiscoverProtectableItemResponse>;
    beginSwitchClusterProtection(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, switchInput: SwitchClusterProtectionInput, options?: ReplicationProtectionContainersSwitchClusterProtectionOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionContainersSwitchClusterProtectionResponse>, ReplicationProtectionContainersSwitchClusterProtectionResponse>>;
    beginSwitchClusterProtectionAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, switchInput: SwitchClusterProtectionInput, options?: ReplicationProtectionContainersSwitchClusterProtectionOptionalParams): Promise<ReplicationProtectionContainersSwitchClusterProtectionResponse>;
    beginSwitchProtection(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, switchInput: SwitchProtectionInput, options?: ReplicationProtectionContainersSwitchProtectionOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationProtectionContainersSwitchProtectionResponse>, ReplicationProtectionContainersSwitchProtectionResponse>>;
    beginSwitchProtectionAndWait(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, switchInput: SwitchProtectionInput, options?: ReplicationProtectionContainersSwitchProtectionOptionalParams): Promise<ReplicationProtectionContainersSwitchProtectionResponse>;
    get(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, options?: ReplicationProtectionContainersGetOptionalParams): Promise<ReplicationProtectionContainersGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationProtectionContainersListOptionalParams): PagedAsyncIterableIterator<ProtectionContainer>;
    listByReplicationFabrics(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationProtectionContainersListByReplicationFabricsOptionalParams): PagedAsyncIterableIterator<ProtectionContainer>;
}

// @public
export interface ReplicationProtectionContainersCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionContainersCreateResponse = ProtectionContainer;

// @public
export interface ReplicationProtectionContainersDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationProtectionContainersDiscoverProtectableItemOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionContainersDiscoverProtectableItemResponse = ProtectionContainer;

// @public
export interface ReplicationProtectionContainersGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionContainersGetResponse = ProtectionContainer;

// @public
export interface ReplicationProtectionContainersListByReplicationFabricsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionContainersListByReplicationFabricsNextResponse = ProtectionContainerCollection;

// @public
export interface ReplicationProtectionContainersListByReplicationFabricsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionContainersListByReplicationFabricsResponse = ProtectionContainerCollection;

// @public
export interface ReplicationProtectionContainersListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionContainersListNextResponse = ProtectionContainerCollection;

// @public
export interface ReplicationProtectionContainersListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionContainersListResponse = ProtectionContainerCollection;

// @public
export interface ReplicationProtectionContainersSwitchClusterProtectionHeaders {
    // (undocumented)
    azureAsyncOperation?: string;
    // (undocumented)
    location?: string;
    // (undocumented)
    retryAfter?: string;
}

// @public
export interface ReplicationProtectionContainersSwitchClusterProtectionOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionContainersSwitchClusterProtectionResponse = ProtectionContainer;

// @public
export interface ReplicationProtectionContainersSwitchProtectionHeaders {
    // (undocumented)
    azureAsyncOperation?: string;
    // (undocumented)
    location?: string;
    // (undocumented)
    retryAfter?: string;
}

// @public
export interface ReplicationProtectionContainersSwitchProtectionOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationProtectionContainersSwitchProtectionResponse = ProtectionContainer;

// @public
export interface ReplicationProtectionIntent extends Resource {
    properties?: ReplicationProtectionIntentProperties;
}

// @public
export interface ReplicationProtectionIntentCollection {
    nextLink?: string;
    value?: ReplicationProtectionIntent[];
}

// @public
export interface ReplicationProtectionIntentProperties {
    readonly creationTimeUTC?: string;
    friendlyName?: string;
    readonly isActive?: boolean;
    readonly jobId?: string;
    readonly jobState?: string;
    providerSpecificDetails?: ReplicationProtectionIntentProviderSpecificSettingsUnion;
}

// @public
export interface ReplicationProtectionIntentProviderSpecificSettings {
    instanceType: "A2A";
}

// @public (undocumented)
export type ReplicationProtectionIntentProviderSpecificSettingsUnion = ReplicationProtectionIntentProviderSpecificSettings | A2AReplicationIntentDetails;

// @public
export interface ReplicationProtectionIntents {
    create(resourceGroupName: string, resourceName: string, intentObjectName: string, input: CreateProtectionIntentInput, options?: ReplicationProtectionIntentsCreateOptionalParams): Promise<ReplicationProtectionIntentsCreateResponse>;
    get(resourceGroupName: string, resourceName: string, intentObjectName: string, options?: ReplicationProtectionIntentsGetOptionalParams): Promise<ReplicationProtectionIntentsGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationProtectionIntentsListOptionalParams): PagedAsyncIterableIterator<ReplicationProtectionIntent>;
}

// @public
export interface ReplicationProtectionIntentsCreateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionIntentsCreateResponse = ReplicationProtectionIntent;

// @public
export interface ReplicationProtectionIntentsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionIntentsGetResponse = ReplicationProtectionIntent;

// @public
export interface ReplicationProtectionIntentsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationProtectionIntentsListNextResponse = ReplicationProtectionIntentCollection;

// @public
export interface ReplicationProtectionIntentsListOptionalParams extends coreClient.OperationOptions {
    skipToken?: string;
    takeToken?: string;
}

// @public
export type ReplicationProtectionIntentsListResponse = ReplicationProtectionIntentCollection;

// @public
export interface ReplicationProviderContainerUnmappingInput {
    instanceType?: string;
}

// @public
export interface ReplicationProviderSpecificContainerCreationInput {
    instanceType: "A2A" | "A2ACrossClusterMigration" | "VMwareCbt";
}

// @public (undocumented)
export type ReplicationProviderSpecificContainerCreationInputUnion = ReplicationProviderSpecificContainerCreationInput | A2AContainerCreationInput | A2ACrossClusterMigrationContainerCreationInput | VMwareCbtContainerCreationInput;

// @public
export interface ReplicationProviderSpecificContainerMappingInput {
    instanceType: "A2A" | "VMwareCbt";
}

// @public (undocumented)
export type ReplicationProviderSpecificContainerMappingInputUnion = ReplicationProviderSpecificContainerMappingInput | A2AContainerMappingInput | VMwareCbtContainerMappingInput;

// @public
export interface ReplicationProviderSpecificSettings {
    instanceType: "A2ACrossClusterMigration" | "A2A" | "HyperVReplicaAzure" | "HyperVReplicaBaseReplicationDetails" | "HyperVReplica2012R2" | "HyperVReplica2012" | "InMageAzureV2" | "InMageRcmFailback" | "InMageRcm" | "InMage";
}

// @public (undocumented)
export type ReplicationProviderSpecificSettingsUnion = ReplicationProviderSpecificSettings | A2ACrossClusterMigrationReplicationDetails | A2AReplicationDetails | HyperVReplicaAzureReplicationDetails | HyperVReplicaBaseReplicationDetails | HyperVReplicaBlueReplicationDetails | HyperVReplicaReplicationDetails | InMageAzureV2ReplicationDetails | InMageRcmFailbackReplicationDetails | InMageRcmReplicationDetails | InMageReplicationDetails;

// @public
export interface ReplicationProviderSpecificUpdateContainerMappingInput {
    instanceType: "A2A" | "InMageRcm";
}

// @public (undocumented)
export type ReplicationProviderSpecificUpdateContainerMappingInputUnion = ReplicationProviderSpecificUpdateContainerMappingInput | A2AUpdateContainerMappingInput | InMageRcmUpdateContainerMappingInput;

// @public
export interface ReplicationRecoveryPlans {
    beginCreate(resourceGroupName: string, resourceName: string, recoveryPlanName: string, input: CreateRecoveryPlanInput, options?: ReplicationRecoveryPlansCreateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationRecoveryPlansCreateResponse>, ReplicationRecoveryPlansCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, resourceName: string, recoveryPlanName: string, input: CreateRecoveryPlanInput, options?: ReplicationRecoveryPlansCreateOptionalParams): Promise<ReplicationRecoveryPlansCreateResponse>;
    beginDelete(resourceGroupName: string, resourceName: string, recoveryPlanName: string, options?: ReplicationRecoveryPlansDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, resourceName: string, recoveryPlanName: string, options?: ReplicationRecoveryPlansDeleteOptionalParams): Promise<void>;
    beginFailoverCancel(resourceGroupName: string, resourceName: string, recoveryPlanName: string, options?: ReplicationRecoveryPlansFailoverCancelOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationRecoveryPlansFailoverCancelResponse>, ReplicationRecoveryPlansFailoverCancelResponse>>;
    beginFailoverCancelAndWait(resourceGroupName: string, resourceName: string, recoveryPlanName: string, options?: ReplicationRecoveryPlansFailoverCancelOptionalParams): Promise<ReplicationRecoveryPlansFailoverCancelResponse>;
    beginFailoverCommit(resourceGroupName: string, resourceName: string, recoveryPlanName: string, options?: ReplicationRecoveryPlansFailoverCommitOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationRecoveryPlansFailoverCommitResponse>, ReplicationRecoveryPlansFailoverCommitResponse>>;
    beginFailoverCommitAndWait(resourceGroupName: string, resourceName: string, recoveryPlanName: string, options?: ReplicationRecoveryPlansFailoverCommitOptionalParams): Promise<ReplicationRecoveryPlansFailoverCommitResponse>;
    beginPlannedFailover(resourceGroupName: string, resourceName: string, recoveryPlanName: string, input: RecoveryPlanPlannedFailoverInput, options?: ReplicationRecoveryPlansPlannedFailoverOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationRecoveryPlansPlannedFailoverResponse>, ReplicationRecoveryPlansPlannedFailoverResponse>>;
    beginPlannedFailoverAndWait(resourceGroupName: string, resourceName: string, recoveryPlanName: string, input: RecoveryPlanPlannedFailoverInput, options?: ReplicationRecoveryPlansPlannedFailoverOptionalParams): Promise<ReplicationRecoveryPlansPlannedFailoverResponse>;
    beginReprotect(resourceGroupName: string, resourceName: string, recoveryPlanName: string, options?: ReplicationRecoveryPlansReprotectOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationRecoveryPlansReprotectResponse>, ReplicationRecoveryPlansReprotectResponse>>;
    beginReprotectAndWait(resourceGroupName: string, resourceName: string, recoveryPlanName: string, options?: ReplicationRecoveryPlansReprotectOptionalParams): Promise<ReplicationRecoveryPlansReprotectResponse>;
    beginTestFailover(resourceGroupName: string, resourceName: string, recoveryPlanName: string, input: RecoveryPlanTestFailoverInput, options?: ReplicationRecoveryPlansTestFailoverOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationRecoveryPlansTestFailoverResponse>, ReplicationRecoveryPlansTestFailoverResponse>>;
    beginTestFailoverAndWait(resourceGroupName: string, resourceName: string, recoveryPlanName: string, input: RecoveryPlanTestFailoverInput, options?: ReplicationRecoveryPlansTestFailoverOptionalParams): Promise<ReplicationRecoveryPlansTestFailoverResponse>;
    beginTestFailoverCleanup(resourceGroupName: string, resourceName: string, recoveryPlanName: string, input: RecoveryPlanTestFailoverCleanupInput, options?: ReplicationRecoveryPlansTestFailoverCleanupOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationRecoveryPlansTestFailoverCleanupResponse>, ReplicationRecoveryPlansTestFailoverCleanupResponse>>;
    beginTestFailoverCleanupAndWait(resourceGroupName: string, resourceName: string, recoveryPlanName: string, input: RecoveryPlanTestFailoverCleanupInput, options?: ReplicationRecoveryPlansTestFailoverCleanupOptionalParams): Promise<ReplicationRecoveryPlansTestFailoverCleanupResponse>;
    beginUnplannedFailover(resourceGroupName: string, resourceName: string, recoveryPlanName: string, input: RecoveryPlanUnplannedFailoverInput, options?: ReplicationRecoveryPlansUnplannedFailoverOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationRecoveryPlansUnplannedFailoverResponse>, ReplicationRecoveryPlansUnplannedFailoverResponse>>;
    beginUnplannedFailoverAndWait(resourceGroupName: string, resourceName: string, recoveryPlanName: string, input: RecoveryPlanUnplannedFailoverInput, options?: ReplicationRecoveryPlansUnplannedFailoverOptionalParams): Promise<ReplicationRecoveryPlansUnplannedFailoverResponse>;
    beginUpdate(resourceGroupName: string, resourceName: string, recoveryPlanName: string, input: UpdateRecoveryPlanInput, options?: ReplicationRecoveryPlansUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationRecoveryPlansUpdateResponse>, ReplicationRecoveryPlansUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, resourceName: string, recoveryPlanName: string, input: UpdateRecoveryPlanInput, options?: ReplicationRecoveryPlansUpdateOptionalParams): Promise<ReplicationRecoveryPlansUpdateResponse>;
    get(resourceGroupName: string, resourceName: string, recoveryPlanName: string, options?: ReplicationRecoveryPlansGetOptionalParams): Promise<ReplicationRecoveryPlansGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationRecoveryPlansListOptionalParams): PagedAsyncIterableIterator<RecoveryPlan>;
}

// @public
export interface ReplicationRecoveryPlansCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationRecoveryPlansCreateResponse = RecoveryPlan;

// @public
export interface ReplicationRecoveryPlansDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationRecoveryPlansFailoverCancelOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationRecoveryPlansFailoverCancelResponse = RecoveryPlan;

// @public
export interface ReplicationRecoveryPlansFailoverCommitOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationRecoveryPlansFailoverCommitResponse = RecoveryPlan;

// @public
export interface ReplicationRecoveryPlansGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationRecoveryPlansGetResponse = RecoveryPlan;

// @public
export interface ReplicationRecoveryPlansListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationRecoveryPlansListNextResponse = RecoveryPlanCollection;

// @public
export interface ReplicationRecoveryPlansListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationRecoveryPlansListResponse = RecoveryPlanCollection;

// @public
export interface ReplicationRecoveryPlansPlannedFailoverOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationRecoveryPlansPlannedFailoverResponse = RecoveryPlan;

// @public
export interface ReplicationRecoveryPlansReprotectOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationRecoveryPlansReprotectResponse = RecoveryPlan;

// @public
export interface ReplicationRecoveryPlansTestFailoverCleanupOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationRecoveryPlansTestFailoverCleanupResponse = RecoveryPlan;

// @public
export interface ReplicationRecoveryPlansTestFailoverOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationRecoveryPlansTestFailoverResponse = RecoveryPlan;

// @public
export interface ReplicationRecoveryPlansUnplannedFailoverOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationRecoveryPlansUnplannedFailoverResponse = RecoveryPlan;

// @public
export interface ReplicationRecoveryPlansUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationRecoveryPlansUpdateResponse = RecoveryPlan;

// @public
export interface ReplicationRecoveryServicesProviders {
    beginCreate(resourceGroupName: string, resourceName: string, fabricName: string, providerName: string, addProviderInput: AddRecoveryServicesProviderInput, options?: ReplicationRecoveryServicesProvidersCreateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationRecoveryServicesProvidersCreateResponse>, ReplicationRecoveryServicesProvidersCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, providerName: string, addProviderInput: AddRecoveryServicesProviderInput, options?: ReplicationRecoveryServicesProvidersCreateOptionalParams): Promise<ReplicationRecoveryServicesProvidersCreateResponse>;
    beginDelete(resourceGroupName: string, resourceName: string, fabricName: string, providerName: string, options?: ReplicationRecoveryServicesProvidersDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, resourceName: string, fabricName: string, providerName: string, options?: ReplicationRecoveryServicesProvidersDeleteOptionalParams): Promise<void>;
    beginPurge(resourceGroupName: string, resourceName: string, fabricName: string, providerName: string, options?: ReplicationRecoveryServicesProvidersPurgeOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginPurgeAndWait(resourceGroupName: string, resourceName: string, fabricName: string, providerName: string, options?: ReplicationRecoveryServicesProvidersPurgeOptionalParams): Promise<void>;
    beginRefreshProvider(resourceGroupName: string, resourceName: string, fabricName: string, providerName: string, options?: ReplicationRecoveryServicesProvidersRefreshProviderOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationRecoveryServicesProvidersRefreshProviderResponse>, ReplicationRecoveryServicesProvidersRefreshProviderResponse>>;
    beginRefreshProviderAndWait(resourceGroupName: string, resourceName: string, fabricName: string, providerName: string, options?: ReplicationRecoveryServicesProvidersRefreshProviderOptionalParams): Promise<ReplicationRecoveryServicesProvidersRefreshProviderResponse>;
    get(resourceGroupName: string, resourceName: string, fabricName: string, providerName: string, options?: ReplicationRecoveryServicesProvidersGetOptionalParams): Promise<ReplicationRecoveryServicesProvidersGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationRecoveryServicesProvidersListOptionalParams): PagedAsyncIterableIterator<RecoveryServicesProvider>;
    listByReplicationFabrics(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationRecoveryServicesProvidersListByReplicationFabricsOptionalParams): PagedAsyncIterableIterator<RecoveryServicesProvider>;
}

// @public
export interface ReplicationRecoveryServicesProvidersCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationRecoveryServicesProvidersCreateResponse = RecoveryServicesProvider;

// @public
export interface ReplicationRecoveryServicesProvidersDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationRecoveryServicesProvidersGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationRecoveryServicesProvidersGetResponse = RecoveryServicesProvider;

// @public
export interface ReplicationRecoveryServicesProvidersListByReplicationFabricsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationRecoveryServicesProvidersListByReplicationFabricsNextResponse = RecoveryServicesProviderCollection;

// @public
export interface ReplicationRecoveryServicesProvidersListByReplicationFabricsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationRecoveryServicesProvidersListByReplicationFabricsResponse = RecoveryServicesProviderCollection;

// @public
export interface ReplicationRecoveryServicesProvidersListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationRecoveryServicesProvidersListNextResponse = RecoveryServicesProviderCollection;

// @public
export interface ReplicationRecoveryServicesProvidersListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationRecoveryServicesProvidersListResponse = RecoveryServicesProviderCollection;

// @public
export interface ReplicationRecoveryServicesProvidersPurgeOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationRecoveryServicesProvidersRefreshProviderOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationRecoveryServicesProvidersRefreshProviderResponse = RecoveryServicesProvider;

// @public
export interface ReplicationStorageClassificationMappings {
    beginCreate(resourceGroupName: string, resourceName: string, fabricName: string, storageClassificationName: string, storageClassificationMappingName: string, pairingInput: StorageClassificationMappingInput, options?: ReplicationStorageClassificationMappingsCreateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationStorageClassificationMappingsCreateResponse>, ReplicationStorageClassificationMappingsCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, storageClassificationName: string, storageClassificationMappingName: string, pairingInput: StorageClassificationMappingInput, options?: ReplicationStorageClassificationMappingsCreateOptionalParams): Promise<ReplicationStorageClassificationMappingsCreateResponse>;
    beginDelete(resourceGroupName: string, resourceName: string, fabricName: string, storageClassificationName: string, storageClassificationMappingName: string, options?: ReplicationStorageClassificationMappingsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, resourceName: string, fabricName: string, storageClassificationName: string, storageClassificationMappingName: string, options?: ReplicationStorageClassificationMappingsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, resourceName: string, fabricName: string, storageClassificationName: string, storageClassificationMappingName: string, options?: ReplicationStorageClassificationMappingsGetOptionalParams): Promise<ReplicationStorageClassificationMappingsGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationStorageClassificationMappingsListOptionalParams): PagedAsyncIterableIterator<StorageClassificationMapping>;
    listByReplicationStorageClassifications(resourceGroupName: string, resourceName: string, fabricName: string, storageClassificationName: string, options?: ReplicationStorageClassificationMappingsListByReplicationStorageClassificationsOptionalParams): PagedAsyncIterableIterator<StorageClassificationMapping>;
}

// @public
export interface ReplicationStorageClassificationMappingsCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationStorageClassificationMappingsCreateResponse = StorageClassificationMapping;

// @public
export interface ReplicationStorageClassificationMappingsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationStorageClassificationMappingsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationStorageClassificationMappingsGetResponse = StorageClassificationMapping;

// @public
export interface ReplicationStorageClassificationMappingsListByReplicationStorageClassificationsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationStorageClassificationMappingsListByReplicationStorageClassificationsNextResponse = StorageClassificationMappingCollection;

// @public
export interface ReplicationStorageClassificationMappingsListByReplicationStorageClassificationsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationStorageClassificationMappingsListByReplicationStorageClassificationsResponse = StorageClassificationMappingCollection;

// @public
export interface ReplicationStorageClassificationMappingsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationStorageClassificationMappingsListNextResponse = StorageClassificationMappingCollection;

// @public
export interface ReplicationStorageClassificationMappingsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationStorageClassificationMappingsListResponse = StorageClassificationMappingCollection;

// @public
export interface ReplicationStorageClassifications {
    get(resourceGroupName: string, resourceName: string, fabricName: string, storageClassificationName: string, options?: ReplicationStorageClassificationsGetOptionalParams): Promise<ReplicationStorageClassificationsGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationStorageClassificationsListOptionalParams): PagedAsyncIterableIterator<StorageClassification>;
    listByReplicationFabrics(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationStorageClassificationsListByReplicationFabricsOptionalParams): PagedAsyncIterableIterator<StorageClassification>;
}

// @public
export interface ReplicationStorageClassificationsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationStorageClassificationsGetResponse = StorageClassification;

// @public
export interface ReplicationStorageClassificationsListByReplicationFabricsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationStorageClassificationsListByReplicationFabricsNextResponse = StorageClassificationCollection;

// @public
export interface ReplicationStorageClassificationsListByReplicationFabricsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationStorageClassificationsListByReplicationFabricsResponse = StorageClassificationCollection;

// @public
export interface ReplicationStorageClassificationsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationStorageClassificationsListNextResponse = StorageClassificationCollection;

// @public
export interface ReplicationStorageClassificationsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationStorageClassificationsListResponse = StorageClassificationCollection;

// @public
export interface ReplicationVaultHealth {
    beginRefresh(resourceGroupName: string, resourceName: string, options?: ReplicationVaultHealthRefreshOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationVaultHealthRefreshResponse>, ReplicationVaultHealthRefreshResponse>>;
    beginRefreshAndWait(resourceGroupName: string, resourceName: string, options?: ReplicationVaultHealthRefreshOptionalParams): Promise<ReplicationVaultHealthRefreshResponse>;
    get(resourceGroupName: string, resourceName: string, options?: ReplicationVaultHealthGetOptionalParams): Promise<ReplicationVaultHealthGetResponse>;
}

// @public
export interface ReplicationVaultHealthGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationVaultHealthGetResponse = VaultHealthDetails;

// @public
export interface ReplicationVaultHealthRefreshOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationVaultHealthRefreshResponse = VaultHealthDetails;

// @public
export interface ReplicationVaultSetting {
    beginCreate(resourceGroupName: string, resourceName: string, vaultSettingName: string, input: VaultSettingCreationInput, options?: ReplicationVaultSettingCreateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationVaultSettingCreateResponse>, ReplicationVaultSettingCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, resourceName: string, vaultSettingName: string, input: VaultSettingCreationInput, options?: ReplicationVaultSettingCreateOptionalParams): Promise<ReplicationVaultSettingCreateResponse>;
    get(resourceGroupName: string, resourceName: string, vaultSettingName: string, options?: ReplicationVaultSettingGetOptionalParams): Promise<ReplicationVaultSettingGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationVaultSettingListOptionalParams): PagedAsyncIterableIterator<VaultSetting>;
}

// @public
export interface ReplicationVaultSettingCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationVaultSettingCreateResponse = VaultSetting;

// @public
export interface ReplicationVaultSettingGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationVaultSettingGetResponse = VaultSetting;

// @public
export interface ReplicationVaultSettingListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationVaultSettingListNextResponse = VaultSettingCollection;

// @public
export interface ReplicationVaultSettingListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationVaultSettingListResponse = VaultSettingCollection;

// @public
export interface ReplicationvCenters {
    beginCreate(resourceGroupName: string, resourceName: string, fabricName: string, vcenterName: string, addVCenterRequest: AddVCenterRequest, options?: ReplicationvCentersCreateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationvCentersCreateResponse>, ReplicationvCentersCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, vcenterName: string, addVCenterRequest: AddVCenterRequest, options?: ReplicationvCentersCreateOptionalParams): Promise<ReplicationvCentersCreateResponse>;
    beginDelete(resourceGroupName: string, resourceName: string, fabricName: string, vcenterName: string, options?: ReplicationvCentersDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, resourceName: string, fabricName: string, vcenterName: string, options?: ReplicationvCentersDeleteOptionalParams): Promise<void>;
    beginUpdate(resourceGroupName: string, resourceName: string, fabricName: string, vcenterName: string, updateVCenterRequest: UpdateVCenterRequest, options?: ReplicationvCentersUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ReplicationvCentersUpdateResponse>, ReplicationvCentersUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, resourceName: string, fabricName: string, vcenterName: string, updateVCenterRequest: UpdateVCenterRequest, options?: ReplicationvCentersUpdateOptionalParams): Promise<ReplicationvCentersUpdateResponse>;
    get(resourceGroupName: string, resourceName: string, fabricName: string, vcenterName: string, options?: ReplicationvCentersGetOptionalParams): Promise<ReplicationvCentersGetResponse>;
    list(resourceGroupName: string, resourceName: string, options?: ReplicationvCentersListOptionalParams): PagedAsyncIterableIterator<VCenter>;
    listByReplicationFabrics(resourceGroupName: string, resourceName: string, fabricName: string, options?: ReplicationvCentersListByReplicationFabricsOptionalParams): PagedAsyncIterableIterator<VCenter>;
}

// @public
export interface ReplicationvCentersCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationvCentersCreateResponse = VCenter;

// @public
export interface ReplicationvCentersDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface ReplicationvCentersGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationvCentersGetResponse = VCenter;

// @public
export interface ReplicationvCentersListByReplicationFabricsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationvCentersListByReplicationFabricsNextResponse = VCenterCollection;

// @public
export interface ReplicationvCentersListByReplicationFabricsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationvCentersListByReplicationFabricsResponse = VCenterCollection;

// @public
export interface ReplicationvCentersListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationvCentersListNextResponse = VCenterCollection;

// @public
export interface ReplicationvCentersListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ReplicationvCentersListResponse = VCenterCollection;

// @public
export interface ReplicationvCentersUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ReplicationvCentersUpdateResponse = VCenter;

// @public
export interface ReprotectAgentDetails {
    readonly accessibleDatastores?: string[];
    readonly biosId?: string;
    readonly fabricObjectId?: string;
    readonly fqdn?: string;
    readonly health?: ProtectionHealth;
    readonly healthErrors?: HealthError[];
    readonly id?: string;
    readonly lastDiscoveryInUtc?: Date;
    readonly lastHeartbeatUtc?: Date;
    readonly name?: string;
    readonly protectedItemCount?: number;
    readonly vcenterId?: string;
    readonly version?: string;
}

// @public
export interface ResolveHealthError {
    healthErrorId?: string;
}

// @public
export interface ResolveHealthInput {
    properties?: ResolveHealthInputProperties;
}

// @public
export interface ResolveHealthInputProperties {
    healthErrors?: ResolveHealthError[];
}

// @public
export interface Resource {
    readonly id?: string;
    location?: string;
    readonly name?: string;
    readonly type?: string;
}

// @public
export interface ResourceHealthSummary {
    categorizedResourceCounts?: {
        [propertyName: string]: number;
    };
    issues?: HealthErrorSummary[];
    resourceCount?: number;
}

// @public
export interface ResumeJobParams {
    properties?: ResumeJobParamsProperties;
}

// @public
export interface ResumeJobParamsProperties {
    comments?: string;
}

// @public
export interface ResumeReplicationInput {
    properties: ResumeReplicationInputProperties;
}

// @public
export interface ResumeReplicationInputProperties {
    providerSpecificDetails: ResumeReplicationProviderSpecificInputUnion;
}

// @public
export interface ResumeReplicationProviderSpecificInput {
    instanceType: "VMwareCbt";
}

// @public (undocumented)
export type ResumeReplicationProviderSpecificInputUnion = ResumeReplicationProviderSpecificInput | VMwareCbtResumeReplicationInput;

// @public
export interface ResyncInput {
    properties: ResyncInputProperties;
}

// @public
export interface ResyncInputProperties {
    providerSpecificDetails: ResyncProviderSpecificInputUnion;
}

// @public
export interface ResyncProviderSpecificInput {
    instanceType: "VMwareCbt";
}

// @public (undocumented)
export type ResyncProviderSpecificInputUnion = ResyncProviderSpecificInput | VMwareCbtResyncInput;

// @public
export type ResyncState = string;

// @public
export interface RetentionVolume {
    capacityInBytes?: number;
    freeSpaceInBytes?: number;
    thresholdPercentage?: number;
    volumeName?: string;
}

// @public
export interface ReverseReplicationInput {
    properties?: ReverseReplicationInputProperties;
}

// @public
export interface ReverseReplicationInputProperties {
    failoverDirection?: string;
    providerSpecificDetails?: ReverseReplicationProviderSpecificInputUnion;
}

// @public
export interface ReverseReplicationProviderSpecificInput {
    instanceType: "A2A" | "HyperVReplicaAzure" | "InMageAzureV2" | "InMageRcmFailback" | "InMageRcm" | "InMage";
}

// @public (undocumented)
export type ReverseReplicationProviderSpecificInputUnion = ReverseReplicationProviderSpecificInput | A2AReprotectInput | HyperVReplicaAzureReprotectInput | InMageAzureV2ReprotectInput | InMageRcmFailbackReprotectInput | InMageRcmReprotectInput | InMageReprotectInput;

// @public
export interface RoleAssignment {
    id?: string;
    name?: string;
    principalId?: string;
    roleDefinitionId?: string;
    scope?: string;
}

// @public
export type RpInMageRecoveryPointType = string;

// @public
export interface RunAsAccount {
    accountId?: string;
    accountName?: string;
}

// @public
export interface ScriptActionTaskDetails extends TaskTypeDetails {
    instanceType: "ScriptActionTaskDetails";
    isPrimarySideScript?: boolean;
    name?: string;
    output?: string;
    path?: string;
}

// @public
export type SecurityConfiguration = string;

// @public
export interface SecurityProfileProperties {
    targetVmConfidentialEncryption?: SecurityConfiguration;
    targetVmMonitoring?: SecurityConfiguration;
    targetVmSecureBoot?: SecurityConfiguration;
    targetVmSecurityType?: SecurityType;
    targetVmTpm?: SecurityConfiguration;
}

// @public
export type SecurityType = string;

// @public
export interface ServiceError {
    activityId?: string;
    code?: string;
    message?: string;
    possibleCauses?: string;
    recommendedAction?: string;
}

// @public
export type SetMultiVmSyncStatus = string;

// @public
export type Severity = string;

// @public
export interface SharedDiskReplicationItemProperties {
    activeLocation?: string;
    allowedOperations?: string[];
    currentScenario?: CurrentScenarioDetails;
    healthErrors?: HealthError[];
    protectionState?: string;
    replicationHealth?: string;
    sharedDiskProviderSpecificDetails?: SharedDiskReplicationProviderSpecificSettingsUnion;
    testFailoverState?: string;
}

// @public
export interface SharedDiskReplicationProviderSpecificSettings {
    instanceType: "A2A";
}

// @public (undocumented)
export type SharedDiskReplicationProviderSpecificSettingsUnion = SharedDiskReplicationProviderSpecificSettings | A2ASharedDiskReplicationDetails;

// @public (undocumented)
export class SiteRecoveryManagementClient extends coreClient.ServiceClient {
    // (undocumented)
    $host: string;
    constructor(credentials: coreAuth.TokenCredential, subscriptionId: string, options?: SiteRecoveryManagementClientOptionalParams);
    // (undocumented)
    apiVersion: string;
    // (undocumented)
    clusterRecoveryPointOperations: ClusterRecoveryPointOperations;
    // (undocumented)
    clusterRecoveryPoints: ClusterRecoveryPoints;
    // (undocumented)
    migrationRecoveryPoints: MigrationRecoveryPoints;
    // (undocumented)
    operations: Operations;
    // (undocumented)
    recoveryPoints: RecoveryPoints;
    // (undocumented)
    replicationAlertSettings: ReplicationAlertSettings;
    // (undocumented)
    replicationAppliances: ReplicationAppliances;
    // (undocumented)
    replicationEligibilityResultsOperations: ReplicationEligibilityResultsOperations;
    // (undocumented)
    replicationEvents: ReplicationEvents;
    // (undocumented)
    replicationFabrics: ReplicationFabrics;
    // (undocumented)
    replicationJobs: ReplicationJobs;
    // (undocumented)
    replicationLogicalNetworks: ReplicationLogicalNetworks;
    // (undocumented)
    replicationMigrationItems: ReplicationMigrationItems;
    // (undocumented)
    replicationNetworkMappings: ReplicationNetworkMappings;
    // (undocumented)
    replicationNetworks: ReplicationNetworks;
    // (undocumented)
    replicationPolicies: ReplicationPolicies;
    // (undocumented)
    replicationProtectableItems: ReplicationProtectableItems;
    // (undocumented)
    replicationProtectedItems: ReplicationProtectedItems;
    // (undocumented)
    replicationProtectionClusters: ReplicationProtectionClusters;
    // (undocumented)
    replicationProtectionContainerMappings: ReplicationProtectionContainerMappings;
    // (undocumented)
    replicationProtectionContainers: ReplicationProtectionContainers;
    // (undocumented)
    replicationProtectionIntents: ReplicationProtectionIntents;
    // (undocumented)
    replicationRecoveryPlans: ReplicationRecoveryPlans;
    // (undocumented)
    replicationRecoveryServicesProviders: ReplicationRecoveryServicesProviders;
    // (undocumented)
    replicationStorageClassificationMappings: ReplicationStorageClassificationMappings;
    // (undocumented)
    replicationStorageClassifications: ReplicationStorageClassifications;
    // (undocumented)
    replicationVaultHealth: ReplicationVaultHealth;
    // (undocumented)
    replicationVaultSetting: ReplicationVaultSetting;
    // (undocumented)
    replicationvCenters: ReplicationvCenters;
    // (undocumented)
    subscriptionId: string;
    // (undocumented)
    supportedOperatingSystemsOperations: SupportedOperatingSystemsOperations;
    // (undocumented)
    targetComputeSizes: TargetComputeSizes;
}

// @public
export interface SiteRecoveryManagementClientOptionalParams extends coreClient.ServiceClientOptions {
    $host?: string;
    apiVersion?: string;
    endpoint?: string;
}

// @public
export type SourceSiteOperations = string;

// @public
export type SqlServerLicenseType = string;

// @public
export interface StorageAccountCustomDetails {
    resourceType: "Existing";
}

// @public (undocumented)
export type StorageAccountCustomDetailsUnion = StorageAccountCustomDetails | ExistingStorageAccount;

// @public
export interface StorageClassification extends Resource {
    properties?: StorageClassificationProperties;
}

// @public
export interface StorageClassificationCollection {
    nextLink?: string;
    value?: StorageClassification[];
}

// @public
export interface StorageClassificationMapping extends Resource {
    properties?: StorageClassificationMappingProperties;
}

// @public
export interface StorageClassificationMappingCollection {
    nextLink?: string;
    value?: StorageClassificationMapping[];
}

// @public
export interface StorageClassificationMappingInput {
    properties?: StorageMappingInputProperties;
}

// @public
export interface StorageClassificationMappingProperties {
    targetStorageClassificationId?: string;
}

// @public
export interface StorageClassificationProperties {
    friendlyName?: string;
}

// @public
export interface StorageMappingInputProperties {
    targetStorageClassificationId?: string;
}

// @public
export interface Subnet {
    addressList?: string[];
    friendlyName?: string;
    name?: string;
}

// @public
export interface SupportedOperatingSystems extends Resource {
    properties?: SupportedOSProperties;
}

// @public
export interface SupportedOperatingSystemsGetOptionalParams extends coreClient.OperationOptions {
    instanceType?: string;
}

// @public
export type SupportedOperatingSystemsGetResponse = SupportedOperatingSystems;

// @public
export interface SupportedOperatingSystemsOperations {
    get(resourceGroupName: string, resourceName: string, options?: SupportedOperatingSystemsGetOptionalParams): Promise<SupportedOperatingSystemsGetResponse>;
}

// @public
export interface SupportedOSDetails {
    osName?: string;
    osType?: string;
    osVersions?: OSVersionWrapper[];
}

// @public
export interface SupportedOSProperties {
    supportedOsList?: SupportedOSProperty[];
}

// @public
export interface SupportedOSProperty {
    instanceType?: string;
    supportedOs?: SupportedOSDetails[];
}

// @public
export interface SwitchClusterProtectionInput {
    properties?: SwitchClusterProtectionInputProperties;
}

// @public
export interface SwitchClusterProtectionInputProperties {
    providerSpecificDetails?: SwitchClusterProtectionProviderSpecificInputUnion;
    replicationProtectionClusterName?: string;
}

// @public
export interface SwitchClusterProtectionProviderSpecificInput {
    instanceType: "A2A";
}

// @public (undocumented)
export type SwitchClusterProtectionProviderSpecificInputUnion = SwitchClusterProtectionProviderSpecificInput | A2ASwitchClusterProtectionInput;

// @public
export interface SwitchProtectionInput {
    properties?: SwitchProtectionInputProperties;
}

// @public
export interface SwitchProtectionInputProperties {
    providerSpecificDetails?: SwitchProtectionProviderSpecificInputUnion;
    replicationProtectedItemName?: string;
}

// @public
export interface SwitchProtectionJobDetails extends JobDetails {
    instanceType: "SwitchProtectionJobDetails";
    newReplicationProtectedItemId?: string;
}

// @public
export interface SwitchProtectionProviderSpecificInput {
    instanceType: "A2A";
}

// @public (undocumented)
export type SwitchProtectionProviderSpecificInputUnion = SwitchProtectionProviderSpecificInput | A2ASwitchProtectionInput;

// @public
export interface SwitchProviderInput {
    properties?: SwitchProviderInputProperties;
}

// @public
export interface SwitchProviderInputProperties {
    providerSpecificDetails?: SwitchProviderSpecificInputUnion;
    targetInstanceType?: string;
}

// @public
export interface SwitchProviderSpecificInput {
    instanceType: "InMageAzureV2";
}

// @public (undocumented)
export type SwitchProviderSpecificInputUnion = SwitchProviderSpecificInput | InMageAzureV2SwitchProviderInput;

// @public
export interface TargetComputeSize {
    id?: string;
    name?: string;
    properties?: TargetComputeSizeProperties;
    type?: string;
}

// @public
export interface TargetComputeSizeCollection {
    nextLink?: string;
    value?: TargetComputeSize[];
}

// @public
export interface TargetComputeSizeProperties {
    cpuCoresCount?: number;
    errors?: ComputeSizeErrorDetails[];
    friendlyName?: string;
    highIopsSupported?: string;
    hyperVGenerations?: string[];
    maxDataDiskCount?: number;
    maxNicsCount?: number;
    memoryInGB?: number;
    name?: string;
    readonly vCPUsAvailable?: number;
}

// @public
export interface TargetComputeSizes {
    listByReplicationProtectedItems(resourceGroupName: string, resourceName: string, fabricName: string, protectionContainerName: string, replicatedProtectedItemName: string, options?: TargetComputeSizesListByReplicationProtectedItemsOptionalParams): PagedAsyncIterableIterator<TargetComputeSize>;
}

// @public
export interface TargetComputeSizesListByReplicationProtectedItemsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type TargetComputeSizesListByReplicationProtectedItemsNextResponse = TargetComputeSizeCollection;

// @public
export interface TargetComputeSizesListByReplicationProtectedItemsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type TargetComputeSizesListByReplicationProtectedItemsResponse = TargetComputeSizeCollection;

// @public
export interface TaskTypeDetails {
    instanceType: "AutomationRunbookTaskDetails" | "ConsistencyCheckTaskDetails" | "JobTaskDetails" | "FabricReplicationGroupTaskDetails" | "ManualActionTaskDetails" | "ScriptActionTaskDetails" | "VirtualMachineTaskDetails" | "VmNicUpdatesTaskDetails";
}

// @public (undocumented)
export type TaskTypeDetailsUnion = TaskTypeDetails | AutomationRunbookTaskDetails | ConsistencyCheckTaskDetails | JobTaskDetailsUnion | ManualActionTaskDetails | ScriptActionTaskDetails | VmNicUpdatesTaskDetails;

// @public
export interface TestFailoverCleanupInput {
    properties: TestFailoverCleanupInputProperties;
}

// @public
export interface TestFailoverCleanupInputProperties {
    comments?: string;
}

// @public
export interface TestFailoverInput {
    properties: TestFailoverInputProperties;
}

// @public
export interface TestFailoverInputProperties {
    failoverDirection?: string;
    networkId?: string;
    networkType?: string;
    providerSpecificDetails?: TestFailoverProviderSpecificInputUnion;
}

// @public
export interface TestFailoverJobDetails extends JobDetails {
    comments?: string;
    instanceType: "TestFailoverJobDetails";
    networkFriendlyName?: string;
    networkName?: string;
    networkType?: string;
    protectedItemDetails?: FailoverReplicationProtectedItemDetails[];
    testFailoverStatus?: string;
}

// @public
export interface TestFailoverProviderSpecificInput {
    instanceType: "A2A" | "HyperVReplicaAzure" | "InMageAzureV2" | "InMageRcm" | "InMage";
}

// @public (undocumented)
export type TestFailoverProviderSpecificInputUnion = TestFailoverProviderSpecificInput | A2ATestFailoverInput | HyperVReplicaAzureTestFailoverInput | InMageAzureV2TestFailoverInput | InMageRcmTestFailoverInput | InMageTestFailoverInput;

// @public
export interface TestMigrateCleanupInput {
    properties: TestMigrateCleanupInputProperties;
}

// @public
export interface TestMigrateCleanupInputProperties {
    comments?: string;
}

// @public
export interface TestMigrateInput {
    properties: TestMigrateInputProperties;
}

// @public
export interface TestMigrateInputProperties {
    providerSpecificDetails: TestMigrateProviderSpecificInputUnion;
}

// @public
export interface TestMigrateProviderSpecificInput {
    instanceType: "VMwareCbt";
}

// @public (undocumented)
export type TestMigrateProviderSpecificInputUnion = TestMigrateProviderSpecificInput | VMwareCbtTestMigrateInput;

// @public
export type TestMigrationState = string;

// @public
export interface UnplannedFailoverInput {
    properties: UnplannedFailoverInputProperties;
}

// @public
export interface UnplannedFailoverInputProperties {
    failoverDirection?: string;
    providerSpecificDetails?: UnplannedFailoverProviderSpecificInputUnion;
    sourceSiteOperations?: string;
}

// @public
export interface UnplannedFailoverProviderSpecificInput {
    instanceType: "A2A" | "HyperVReplicaAzure" | "InMageAzureV2" | "InMageRcm" | "InMage";
}

// @public (undocumented)
export type UnplannedFailoverProviderSpecificInputUnion = UnplannedFailoverProviderSpecificInput | A2AUnplannedFailoverInput | HyperVReplicaAzureUnplannedFailoverInput | InMageAzureV2UnplannedFailoverInput | InMageRcmUnplannedFailoverInput | InMageUnplannedFailoverInput;

// @public
export interface UpdateApplianceForReplicationProtectedItemInput {
    properties: UpdateApplianceForReplicationProtectedItemInputProperties;
}

// @public
export interface UpdateApplianceForReplicationProtectedItemInputProperties {
    providerSpecificDetails: UpdateApplianceForReplicationProtectedItemProviderSpecificInputUnion;
    targetApplianceId: string;
}

// @public
export interface UpdateApplianceForReplicationProtectedItemProviderSpecificInput {
    instanceType: "InMageRcm";
}

// @public (undocumented)
export type UpdateApplianceForReplicationProtectedItemProviderSpecificInputUnion = UpdateApplianceForReplicationProtectedItemProviderSpecificInput | InMageRcmUpdateApplianceForReplicationProtectedItemInput;

// @public
export interface UpdateDiskInput {
    diskId: string;
    targetDiskName?: string;
}

// @public
export interface UpdateMigrationItemInput {
    properties?: UpdateMigrationItemInputProperties;
}

// @public
export interface UpdateMigrationItemInputProperties {
    providerSpecificDetails: UpdateMigrationItemProviderSpecificInputUnion;
}

// @public
export interface UpdateMigrationItemProviderSpecificInput {
    instanceType: "VMwareCbt";
}

// @public (undocumented)
export type UpdateMigrationItemProviderSpecificInputUnion = UpdateMigrationItemProviderSpecificInput | VMwareCbtUpdateMigrationItemInput;

// @public
export interface UpdateMobilityServiceRequest {
    properties?: UpdateMobilityServiceRequestProperties;
}

// @public
export interface UpdateMobilityServiceRequestProperties {
    runAsAccountId?: string;
}

// @public
export interface UpdateNetworkMappingInput {
    properties?: UpdateNetworkMappingInputProperties;
}

// @public
export interface UpdateNetworkMappingInputProperties {
    fabricSpecificDetails?: FabricSpecificUpdateNetworkMappingInputUnion;
    recoveryFabricName?: string;
    recoveryNetworkId?: string;
}

// @public
export interface UpdatePolicyInput {
    properties?: UpdatePolicyInputProperties;
}

// @public
export interface UpdatePolicyInputProperties {
    replicationProviderSettings?: PolicyProviderSpecificInputUnion;
}

// @public
export interface UpdateProtectionContainerMappingInput {
    properties?: UpdateProtectionContainerMappingInputProperties;
}

// @public
export interface UpdateProtectionContainerMappingInputProperties {
    providerSpecificInput?: ReplicationProviderSpecificUpdateContainerMappingInputUnion;
}

// @public
export interface UpdateRecoveryPlanInput {
    properties?: UpdateRecoveryPlanInputProperties;
}

// @public
export interface UpdateRecoveryPlanInputProperties {
    groups?: RecoveryPlanGroup[];
}

// @public
export interface UpdateReplicationProtectedItemInput {
    properties?: UpdateReplicationProtectedItemInputProperties;
}

// @public
export interface UpdateReplicationProtectedItemInputProperties {
    enableRdpOnTargetOption?: string;
    licenseType?: LicenseType;
    providerSpecificDetails?: UpdateReplicationProtectedItemProviderInputUnion;
    recoveryAvailabilitySetId?: string;
    recoveryAzureVMName?: string;
    recoveryAzureVMSize?: string;
    selectedRecoveryAzureNetworkId?: string;
    selectedSourceNicId?: string;
    selectedTfoAzureNetworkId?: string;
    vmNics?: VMNicInputDetails[];
}

// @public
export interface UpdateReplicationProtectedItemProviderInput {
    instanceType: "A2A" | "HyperVReplicaAzure" | "InMageAzureV2" | "InMageRcm";
}

// @public (undocumented)
export type UpdateReplicationProtectedItemProviderInputUnion = UpdateReplicationProtectedItemProviderInput | A2AUpdateReplicationProtectedItemInput | HyperVReplicaAzureUpdateReplicationProtectedItemInput | InMageAzureV2UpdateReplicationProtectedItemInput | InMageRcmUpdateReplicationProtectedItemInput;

// @public
export interface UpdateVCenterRequest {
    properties?: UpdateVCenterRequestProperties;
}

// @public
export interface UpdateVCenterRequestProperties {
    friendlyName?: string;
    ipAddress?: string;
    port?: string;
    processServerId?: string;
    runAsAccountId?: string;
}

// @public
export interface UserCreatedResourceTag {
    tagName?: string;
    tagValue?: string;
}

// @public
export interface VaultHealthDetails extends Resource {
    properties?: VaultHealthProperties;
}

// @public
export interface VaultHealthProperties {
    containersHealth?: ResourceHealthSummary;
    fabricsHealth?: ResourceHealthSummary;
    protectedItemsHealth?: ResourceHealthSummary;
    vaultErrors?: HealthError[];
}

// @public
export interface VaultSetting extends Resource {
    properties?: VaultSettingProperties;
}

// @public
export interface VaultSettingCollection {
    nextLink?: string;
    value?: VaultSetting[];
}

// @public
export interface VaultSettingCreationInput {
    properties: VaultSettingCreationInputProperties;
}

// @public
export interface VaultSettingCreationInputProperties {
    migrationSolutionId?: string;
    vmwareToAzureProviderType?: string;
}

// @public
export interface VaultSettingProperties {
    migrationSolutionId?: string;
    vmwareToAzureProviderType?: string;
}

// @public
export interface VCenter extends Resource {
    properties?: VCenterProperties;
}

// @public
export interface VCenterCollection {
    nextLink?: string;
    value?: VCenter[];
}

// @public
export interface VCenterProperties {
    discoveryStatus?: string;
    fabricArmResourceName?: string;
    friendlyName?: string;
    healthErrors?: HealthError[];
    infrastructureId?: string;
    internalId?: string;
    ipAddress?: string;
    lastHeartbeat?: Date;
    port?: string;
    processServerId?: string;
    runAsAccountId?: string;
}

// @public
export interface VersionDetails {
    expiryDate?: Date;
    status?: AgentVersionStatus;
    version?: string;
}

// @public
export interface VirtualMachineTaskDetails extends JobTaskDetails {
    instanceType: "VirtualMachineTaskDetails";
    skippedReason?: string;
    skippedReasonString?: string;
}

// @public
export type VmEncryptionType = string;

// @public
export interface VmmDetails extends FabricSpecificDetails {
    instanceType: "VMM";
}

// @public
export interface VmmToAzureCreateNetworkMappingInput extends FabricSpecificCreateNetworkMappingInput {
    instanceType: "VmmToAzure";
}

// @public
export interface VmmToAzureNetworkMappingSettings extends NetworkMappingFabricSpecificSettings {
    instanceType: "VmmToAzure";
}

// @public
export interface VmmToAzureUpdateNetworkMappingInput extends FabricSpecificUpdateNetworkMappingInput {
    instanceType: "VmmToAzure";
}

// @public
export interface VmmToVmmCreateNetworkMappingInput extends FabricSpecificCreateNetworkMappingInput {
    instanceType: "VmmToVmm";
}

// @public
export interface VmmToVmmNetworkMappingSettings extends NetworkMappingFabricSpecificSettings {
    instanceType: "VmmToVmm";
}

// @public
export interface VmmToVmmUpdateNetworkMappingInput extends FabricSpecificUpdateNetworkMappingInput {
    instanceType: "VmmToVmm";
}

// @public
export interface VmmVirtualMachineDetails extends HyperVVirtualMachineDetails {
    instanceType: "VmmVirtualMachine";
}

// @public
export interface VMNicDetails {
    enableAcceleratedNetworkingOnRecovery?: boolean;
    enableAcceleratedNetworkingOnTfo?: boolean;
    ipConfigs?: IPConfigDetails[];
    nicId?: string;
    recoveryNetworkSecurityGroupId?: string;
    recoveryNicName?: string;
    recoveryNicResourceGroupName?: string;
    recoveryVMNetworkId?: string;
    replicaNicId?: string;
    reuseExistingNic?: boolean;
    selectionType?: string;
    sourceNicArmId?: string;
    targetNicName?: string;
    tfoNetworkSecurityGroupId?: string;
    tfoRecoveryNicName?: string;
    tfoRecoveryNicResourceGroupName?: string;
    tfoReuseExistingNic?: boolean;
    tfoVMNetworkId?: string;
    vMNetworkName?: string;
}

// @public
export interface VMNicInputDetails {
    enableAcceleratedNetworkingOnRecovery?: boolean;
    enableAcceleratedNetworkingOnTfo?: boolean;
    ipConfigs?: IPConfigInputDetails[];
    nicId?: string;
    recoveryNetworkSecurityGroupId?: string;
    recoveryNicName?: string;
    recoveryNicResourceGroupName?: string;
    reuseExistingNic?: boolean;
    selectionType?: string;
    targetNicName?: string;
    tfoNetworkSecurityGroupId?: string;
    tfoNicName?: string;
    tfoNicResourceGroupName?: string;
    tfoReuseExistingNic?: boolean;
}

// @public
export interface VmNicUpdatesTaskDetails extends TaskTypeDetails {
    instanceType: "VmNicUpdatesTaskDetails";
    name?: string;
    nicId?: string;
    vmId?: string;
}

// @public
export type VmReplicationProgressHealth = string;

// @public
export interface VMwareCbtContainerCreationInput extends ReplicationProviderSpecificContainerCreationInput {
    instanceType: "VMwareCbt";
}

// @public
export interface VMwareCbtContainerMappingInput extends ReplicationProviderSpecificContainerMappingInput {
    instanceType: "VMwareCbt";
    keyVaultId?: string;
    keyVaultUri?: string;
    serviceBusConnectionStringSecretName?: string;
    storageAccountId: string;
    storageAccountSasSecretName?: string;
    targetLocation: string;
}

// @public
export interface VMwareCbtDiskInput {
    diskEncryptionSetId?: string;
    diskId: string;
    diskType?: DiskAccountType;
    isOSDisk: string;
    logStorageAccountId: string;
    logStorageAccountSasSecretName: string;
    sectorSizeInBytes?: number;
}

// @public
export interface VMwareCbtEnableMigrationInput extends EnableMigrationProviderSpecificInput {
    confidentialVmKeyVaultId?: string;
    dataMoverRunAsAccountId: string;
    disksToInclude: VMwareCbtDiskInput[];
    instanceType: "VMwareCbt";
    licenseType?: LicenseType;
    linuxLicenseType?: LinuxLicenseType;
    performAutoResync?: string;
    performSqlBulkRegistration?: string;
    seedDiskTags?: {
        [propertyName: string]: string;
    };
    snapshotRunAsAccountId: string;
    sqlServerLicenseType?: SqlServerLicenseType;
    targetAvailabilitySetId?: string;
    targetAvailabilityZone?: string;
    targetBootDiagnosticsStorageAccountId?: string;
    targetDiskTags?: {
        [propertyName: string]: string;
    };
    targetNetworkId: string;
    targetNicTags?: {
        [propertyName: string]: string;
    };
    targetProximityPlacementGroupId?: string;
    targetResourceGroupId: string;
    targetSubnetName?: string;
    targetVmName?: string;
    targetVmSecurityProfile?: VMwareCbtSecurityProfileProperties;
    targetVmSize?: string;
    targetVmTags?: {
        [propertyName: string]: string;
    };
    testNetworkId?: string;
    testSubnetName?: string;
    userSelectedOSName?: string;
    vmwareMachineId: string;
}

// @public
export interface VMwareCbtEventDetails extends EventProviderSpecificDetails {
    instanceType: "VMwareCbt";
    readonly migrationItemName?: string;
}

// @public
export interface VMwareCbtMigrateInput extends MigrateProviderSpecificInput {
    instanceType: "VMwareCbt";
    osUpgradeVersion?: string;
    performShutdown: string;
    postMigrationSteps?: ManagedRunCommandScriptInput[];
}

// @public
export interface VMwareCbtMigrationDetails extends MigrationProviderSpecificSettings {
    readonly applianceMonitoringDetails?: ApplianceMonitoringDetails;
    confidentialVmKeyVaultId?: string;
    readonly dataMoverRunAsAccountId?: string;
    readonly deltaSyncProgressPercentage?: number;
    readonly deltaSyncRetryCount?: number;
    readonly firmwareType?: string;
    readonly gatewayOperationDetails?: GatewayOperationDetails;
    readonly initialSeedingProgressPercentage?: number;
    readonly initialSeedingRetryCount?: number;
    instanceType: "VMwareCbt";
    readonly isCheckSumResyncCycle?: string;
    readonly lastRecoveryPointId?: string;
    readonly lastRecoveryPointReceived?: Date;
    licenseType?: string;
    linuxLicenseType?: LinuxLicenseType;
    readonly migrationProgressPercentage?: number;
    readonly migrationRecoveryPointId?: string;
    readonly operationName?: string;
    readonly osName?: string;
    readonly osType?: string;
    performAutoResync?: string;
    protectedDisks?: VMwareCbtProtectedDiskDetails[];
    readonly resumeProgressPercentage?: number;
    readonly resumeRetryCount?: number;
    readonly resyncProgressPercentage?: number;
    readonly resyncRequired?: string;
    readonly resyncRetryCount?: number;
    readonly resyncState?: ResyncState;
    seedDiskTags?: {
        [propertyName: string]: string;
    };
    readonly snapshotRunAsAccountId?: string;
    sqlServerLicenseType?: string;
    readonly storageAccountId?: string;
    supportedOSVersions?: string[];
    targetAvailabilitySetId?: string;
    targetAvailabilityZone?: string;
    targetBootDiagnosticsStorageAccountId?: string;
    targetDiskTags?: {
        [propertyName: string]: string;
    };
    readonly targetGeneration?: string;
    readonly targetLocation?: string;
    targetNetworkId?: string;
    targetNicTags?: {
        [propertyName: string]: string;
    };
    targetProximityPlacementGroupId?: string;
    targetResourceGroupId?: string;
    targetVmName?: string;
    targetVmSecurityProfile?: VMwareCbtSecurityProfileProperties;
    targetVmSize?: string;
    targetVmTags?: {
        [propertyName: string]: string;
    };
    testNetworkId?: string;
    vmNics?: VMwareCbtNicDetails[];
    readonly vmwareMachineId?: string;
}

// @public
export interface VMwareCbtNicDetails {
    isPrimaryNic?: string;
    isSelectedForMigration?: string;
    readonly nicId?: string;
    readonly sourceIPAddress?: string;
    readonly sourceIPAddressType?: EthernetAddressType;
    readonly sourceNetworkId?: string;
    targetIPAddress?: string;
    targetIPAddressType?: EthernetAddressType;
    targetNicName?: string;
    targetSubnetName?: string;
    testIPAddress?: string;
    testIPAddressType?: EthernetAddressType;
    testNetworkId?: string;
    testSubnetName?: string;
}

// @public
export interface VMwareCbtNicInput {
    isPrimaryNic: string;
    isSelectedForMigration?: string;
    nicId: string;
    targetNicName?: string;
    targetStaticIPAddress?: string;
    targetSubnetName?: string;
    testStaticIPAddress?: string;
    testSubnetName?: string;
}

// @public
export interface VMwareCbtPolicyCreationInput extends PolicyProviderSpecificInput {
    appConsistentFrequencyInMinutes?: number;
    crashConsistentFrequencyInMinutes?: number;
    instanceType: "VMwareCbt";
    recoveryPointHistoryInMinutes?: number;
}

// @public
export interface VmwareCbtPolicyDetails extends PolicyProviderSpecificDetails {
    appConsistentFrequencyInMinutes?: number;
    crashConsistentFrequencyInMinutes?: number;
    instanceType: "VMwareCbt";
    recoveryPointHistoryInMinutes?: number;
}

// @public
export interface VMwareCbtProtectedDiskDetails {
    readonly capacityInBytes?: number;
    readonly diskEncryptionSetId?: string;
    readonly diskId?: string;
    readonly diskName?: string;
    readonly diskPath?: string;
    diskType?: DiskAccountType;
    readonly gatewayOperationDetails?: GatewayOperationDetails;
    readonly isOSDisk?: string;
    readonly logStorageAccountId?: string;
    readonly logStorageAccountSasSecretName?: string;
    sectorSizeInBytes?: number;
    readonly seedBlobUri?: string;
    readonly seedManagedDiskId?: string;
    readonly targetBlobUri?: string;
    targetDiskName?: string;
    readonly targetManagedDiskId?: string;
}

// @public
export interface VMwareCbtProtectionContainerMappingDetails extends ProtectionContainerMappingProviderSpecificDetails {
    excludedSkus?: string[];
    instanceType: "VMwareCbt";
    readonly keyVaultId?: string;
    readonly keyVaultUri?: string;
    readonly roleSizeToNicCountMap?: {
        [propertyName: string]: number;
    };
    readonly serviceBusConnectionStringSecretName?: string;
    readonly storageAccountId?: string;
    readonly storageAccountSasSecretName?: string;
    readonly targetLocation?: string;
}

// @public
export interface VMwareCbtResumeReplicationInput extends ResumeReplicationProviderSpecificInput {
    deleteMigrationResources?: string;
    instanceType: "VMwareCbt";
}

// @public
export interface VMwareCbtResyncInput extends ResyncProviderSpecificInput {
    instanceType: "VMwareCbt";
    skipCbtReset: string;
}

// @public
export interface VMwareCbtSecurityProfileProperties {
    isTargetVmConfidentialEncryptionEnabled?: string;
    isTargetVmIntegrityMonitoringEnabled?: string;
    isTargetVmSecureBootEnabled?: string;
    isTargetVmTpmEnabled?: string;
    targetVmSecurityType?: SecurityType;
}

// @public
export interface VMwareCbtTestMigrateInput extends TestMigrateProviderSpecificInput {
    instanceType: "VMwareCbt";
    networkId: string;
    osUpgradeVersion?: string;
    postMigrationSteps?: ManagedRunCommandScriptInput[];
    recoveryPointId: string;
    vmNics?: VMwareCbtNicInput[];
}

// @public
export interface VMwareCbtUpdateDiskInput {
    diskId: string;
    isOSDisk?: string;
    targetDiskName?: string;
}

// @public
export interface VMwareCbtUpdateMigrationItemInput extends UpdateMigrationItemProviderSpecificInput {
    instanceType: "VMwareCbt";
    licenseType?: LicenseType;
    linuxLicenseType?: LinuxLicenseType;
    performAutoResync?: string;
    sqlServerLicenseType?: SqlServerLicenseType;
    targetAvailabilitySetId?: string;
    targetAvailabilityZone?: string;
    targetBootDiagnosticsStorageAccountId?: string;
    targetDiskTags?: {
        [propertyName: string]: string;
    };
    targetNetworkId?: string;
    targetNicTags?: {
        [propertyName: string]: string;
    };
    targetProximityPlacementGroupId?: string;
    targetResourceGroupId?: string;
    targetVmName?: string;
    targetVmSize?: string;
    targetVmTags?: {
        [propertyName: string]: string;
    };
    testNetworkId?: string;
    userSelectedOSName?: string;
    vmDisks?: VMwareCbtUpdateDiskInput[];
    vmNics?: VMwareCbtNicInput[];
}

// @public
export interface VMwareDetails extends FabricSpecificDetails {
    agentCount?: string;
    agentExpiryDate?: Date;
    agentVersion?: string;
    agentVersionDetails?: VersionDetails;
    availableMemoryInBytes?: number;
    availableSpaceInBytes?: number;
    cpuLoad?: string;
    cpuLoadStatus?: string;
    csServiceStatus?: string;
    databaseServerLoad?: string;
    databaseServerLoadStatus?: string;
    hostName?: string;
    instanceType: "VMware";
    ipAddress?: string;
    lastHeartbeat?: Date;
    masterTargetServers?: MasterTargetServer[];
    memoryUsageStatus?: string;
    processServerCount?: string;
    processServers?: ProcessServer[];
    protectedServers?: string;
    psTemplateVersion?: string;
    replicationPairCount?: string;
    runAsAccounts?: RunAsAccount[];
    spaceUsageStatus?: string;
    sslCertExpiryDate?: Date;
    sslCertExpiryRemainingDays?: number;
    switchProviderBlockingErrorDetails?: InMageFabricSwitchProviderBlockingErrorDetails[];
    systemLoad?: string;
    systemLoadStatus?: string;
    totalMemoryInBytes?: number;
    totalSpaceInBytes?: number;
    versionStatus?: string;
    webLoad?: string;
    webLoadStatus?: string;
}

// @public
export interface VMwareV2FabricCreationInput extends FabricSpecificCreationInput {
    instanceType: "VMwareV2";
    migrationSolutionId: string;
    physicalSiteId?: string;
    vmwareSiteId?: string;
}

// @public
export interface VMwareV2FabricSpecificDetails extends FabricSpecificDetails {
    instanceType: "VMwareV2";
    readonly migrationSolutionId?: string;
    readonly physicalSiteId?: string;
    readonly processServers?: ProcessServerDetails[];
    readonly serviceContainerId?: string;
    readonly serviceEndpoint?: string;
    readonly serviceResourceId?: string;
    readonly vmwareSiteId?: string;
}

// @public
export interface VMwareVirtualMachineDetails extends ConfigurationSettings {
    agentGeneratedId?: string;
    agentInstalled?: string;
    agentVersion?: string;
    discoveryType?: string;
    diskDetails?: InMageDiskDetails[];
    instanceType: "VMwareVirtualMachine";
    ipAddress?: string;
    osType?: string;
    poweredOn?: string;
    validationErrors?: HealthError[];
    vCenterInfrastructureId?: string;
}

// (No @packageDocumentation comment for this package)

```
