pulumi-azure-native 3.8.0a1756942349__py3-none-any.whl → 3.11.0a1761334446__py3-none-any.whl

pulumi_azure_native/datamigration/outputs.py

@@ -19,6 +19,8 @@ from ._enums import *
 
 __all__ = [
     'AzureActiveDirectoryAppResponse',
+    'AzureBlobResponse',
+    'BackupConfigurationResponse',
     'BackupFileInfoResponse',
     'BackupSetInfoResponse',
     'BlobShareResponse',
@@ -67,6 +69,8 @@ __all__ = [
     'DatabaseFileInfoResponse',
     'DatabaseInfoResponse',
     'DatabaseMigrationPropertiesSqlDbResponse',
+    'DatabaseMigrationPropertiesSqlMiResponse',
+    'DatabaseMigrationPropertiesSqlVmResponse',
     'DatabaseSummaryResultResponse',
     'DatabaseTableResponse',
     'ErrorInfoResponse',
@@ -90,6 +94,7 @@ __all__ = [
     'GetUserTablesSqlTaskInputResponse',
     'GetUserTablesSqlTaskOutputResponse',
     'GetUserTablesSqlTaskPropertiesResponse',
+    'ManagedServiceIdentityResponse',
     'MiSqlConnectionInfoResponse',
     'MigrateMISyncCompleteCommandInputResponse',
     'MigrateMISyncCompleteCommandOutputResponse',
@@ -166,6 +171,7 @@ __all__ = [
     'MigrateSyncCompleteCommandPropertiesResponse',
     'MigrationEligibilityInfoResponse',
     'MigrationReportResultResponse',
+    'MigrationStatusDetailsResponse',
     'MigrationValidationDatabaseSummaryResultResponse',
     'MigrationValidationOptionsResponse',
     'MigrationValidationResultResponse',
@@ -190,6 +196,7 @@ __all__ = [
     'MySqlConnectionInfoResponse',
     'NodeMonitoringDataResponse',
     'ODataErrorResponse',
+    'OfflineConfigurationResponse',
     'OracleConnectionInfoResponse',
     'OrphanedUserInfoResponse',
     'PostgreSqlConnectionInfoResponse',
@@ -202,14 +209,20 @@ __all__ = [
     'SelectedCertificateInputResponse',
     'ServerPropertiesResponse',
     'ServiceSkuResponse',
+    'SourceLocationResponse',
+    'SqlBackupFileInfoResponse',
+    'SqlBackupSetInfoResponse',
     'SqlConnectionInfoResponse',
     'SqlConnectionInformationResponse',
     'SqlDbMigrationStatusDetailsResponse',
     'SqlDbOfflineConfigurationResponse',
+    'SqlFileShareResponse',
     'SsisMigrationInfoResponse',
     'StartMigrationScenarioServerRoleResultResponse',
     'SyncMigrationDatabaseErrorEventResponse',
     'SystemDataResponse',
+    'TargetLocationResponse',
+    'UserAssignedIdentityResponse',
     'ValidateMigrationInputSqlServerSqlDbSyncTaskPropertiesResponse',
     'ValidateMigrationInputSqlServerSqlMISyncTaskInputResponse',
     'ValidateMigrationInputSqlServerSqlMISyncTaskOutputResponse',
@@ -308,6 +321,154 @@ class AzureActiveDirectoryAppResponse(dict):
         return pulumi.get(self, "tenant_id")
 
 
+@pulumi.output_type
+class AzureBlobResponse(dict):
+    """
+    Azure Blob Details
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "accountKey":
+            suggest = "account_key"
+        elif key == "authType":
+            suggest = "auth_type"
+        elif key == "blobContainerName":
+            suggest = "blob_container_name"
+        elif key == "storageAccountResourceId":
+            suggest = "storage_account_resource_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AzureBlobResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AzureBlobResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AzureBlobResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 account_key: Optional[builtins.str] = None,
+                 auth_type: Optional[builtins.str] = None,
+                 blob_container_name: Optional[builtins.str] = None,
+                 identity: Optional['outputs.ManagedServiceIdentityResponse'] = None,
+                 storage_account_resource_id: Optional[builtins.str] = None):
+        """
+        Azure Blob Details
+        :param builtins.str account_key: Storage Account Key.
+        :param builtins.str auth_type: Authentication type used for accessing Azure Blob Storage.
+        :param builtins.str blob_container_name: Blob container name where backups are stored.
+        :param 'ManagedServiceIdentityResponse' identity: Identity details for authentication using a Managed Identity.
+        :param builtins.str storage_account_resource_id: Resource Id of the storage account where backups are stored.
+        """
+        if account_key is not None:
+            pulumi.set(__self__, "account_key", account_key)
+        if auth_type is not None:
+            pulumi.set(__self__, "auth_type", auth_type)
+        if blob_container_name is not None:
+            pulumi.set(__self__, "blob_container_name", blob_container_name)
+        if identity is not None:
+            pulumi.set(__self__, "identity", identity)
+        if storage_account_resource_id is not None:
+            pulumi.set(__self__, "storage_account_resource_id", storage_account_resource_id)
+
+    @property
+    @pulumi.getter(name="accountKey")
+    def account_key(self) -> Optional[builtins.str]:
+        """
+        Storage Account Key.
+        """
+        return pulumi.get(self, "account_key")
+
+    @property
+    @pulumi.getter(name="authType")
+    def auth_type(self) -> Optional[builtins.str]:
+        """
+        Authentication type used for accessing Azure Blob Storage.
+        """
+        return pulumi.get(self, "auth_type")
+
+    @property
+    @pulumi.getter(name="blobContainerName")
+    def blob_container_name(self) -> Optional[builtins.str]:
+        """
+        Blob container name where backups are stored.
+        """
+        return pulumi.get(self, "blob_container_name")
+
+    @property
+    @pulumi.getter
+    def identity(self) -> Optional['outputs.ManagedServiceIdentityResponse']:
+        """
+        Identity details for authentication using a Managed Identity.
+        """
+        return pulumi.get(self, "identity")
+
+    @property
+    @pulumi.getter(name="storageAccountResourceId")
+    def storage_account_resource_id(self) -> Optional[builtins.str]:
+        """
+        Resource Id of the storage account where backups are stored.
+        """
+        return pulumi.get(self, "storage_account_resource_id")
+
+
+@pulumi.output_type
+class BackupConfigurationResponse(dict):
+    """
+    Backup Configuration
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "sourceLocation":
+            suggest = "source_location"
+        elif key == "targetLocation":
+            suggest = "target_location"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BackupConfigurationResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BackupConfigurationResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BackupConfigurationResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 source_location: Optional['outputs.SourceLocationResponse'] = None,
+                 target_location: Optional['outputs.TargetLocationResponse'] = None):
+        """
+        Backup Configuration
+        :param 'SourceLocationResponse' source_location: Source location of backups.
+        :param 'TargetLocationResponse' target_location: Target location for copying backups.
+        """
+        if source_location is not None:
+            pulumi.set(__self__, "source_location", source_location)
+        if target_location is not None:
+            pulumi.set(__self__, "target_location", target_location)
+
+    @property
+    @pulumi.getter(name="sourceLocation")
+    def source_location(self) -> Optional['outputs.SourceLocationResponse']:
+        """
+        Source location of backups.
+        """
+        return pulumi.get(self, "source_location")
+
+    @property
+    @pulumi.getter(name="targetLocation")
+    def target_location(self) -> Optional['outputs.TargetLocationResponse']:
+        """
+        Target location for copying backups.
+        """
+        return pulumi.get(self, "target_location")
+
+
 @pulumi.output_type
 class BackupFileInfoResponse(dict):
     """
@@ -4963,356 +5124,864 @@ class DatabaseMigrationPropertiesSqlDbResponse(dict):
 
 
 @pulumi.output_type
-class DatabaseSummaryResultResponse(dict):
+class DatabaseMigrationPropertiesSqlMiResponse(dict):
     """
-    Summary of database results in the migration
+    Database Migration Resource properties for SQL Managed Instance.
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
         if key == "endedOn":
             suggest = "ended_on"
-        elif key == "errorPrefix":
-            suggest = "error_prefix"
-        elif key == "itemsCompletedCount":
-            suggest = "items_completed_count"
-        elif key == "itemsCount":
-            suggest = "items_count"
-        elif key == "resultPrefix":
-            suggest = "result_prefix"
-        elif key == "sizeMB":
-            suggest = "size_mb"
+        elif key == "migrationFailureError":
+            suggest = "migration_failure_error"
+        elif key == "migrationStatus":
+            suggest = "migration_status"
+        elif key == "migrationStatusDetails":
+            suggest = "migration_status_details"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "sourceServerName":
+            suggest = "source_server_name"
         elif key == "startedOn":
             suggest = "started_on"
-        elif key == "statusMessage":
-            suggest = "status_message"
+        elif key == "backupConfiguration":
+            suggest = "backup_configuration"
+        elif key == "migrationOperationId":
+            suggest = "migration_operation_id"
+        elif key == "migrationService":
+            suggest = "migration_service"
+        elif key == "offlineConfiguration":
+            suggest = "offline_configuration"
+        elif key == "provisioningError":
+            suggest = "provisioning_error"
+        elif key == "sourceDatabaseName":
+            suggest = "source_database_name"
+        elif key == "sourceSqlConnection":
+            suggest = "source_sql_connection"
+        elif key == "targetDatabaseCollation":
+            suggest = "target_database_collation"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in DatabaseSummaryResultResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in DatabaseMigrationPropertiesSqlMiResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        DatabaseSummaryResultResponse.__key_warning(key)
+        DatabaseMigrationPropertiesSqlMiResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        DatabaseSummaryResultResponse.__key_warning(key)
+        DatabaseMigrationPropertiesSqlMiResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
                  ended_on: builtins.str,
-                 error_prefix: builtins.str,
-                 items_completed_count: builtins.float,
-                 items_count: builtins.float,
-                 name: builtins.str,
-                 result_prefix: builtins.str,
-                 size_mb: builtins.float,
+                 kind: builtins.str,
+                 migration_failure_error: 'outputs.ErrorInfoResponse',
+                 migration_status: builtins.str,
+                 migration_status_details: 'outputs.MigrationStatusDetailsResponse',
+                 provisioning_state: builtins.str,
+                 source_server_name: builtins.str,
                  started_on: builtins.str,
-                 state: builtins.str,
-                 status_message: builtins.str):
+                 backup_configuration: Optional['outputs.BackupConfigurationResponse'] = None,
+                 migration_operation_id: Optional[builtins.str] = None,
+                 migration_service: Optional[builtins.str] = None,
+                 offline_configuration: Optional['outputs.OfflineConfigurationResponse'] = None,
+                 provisioning_error: Optional[builtins.str] = None,
+                 scope: Optional[builtins.str] = None,
+                 source_database_name: Optional[builtins.str] = None,
+                 source_sql_connection: Optional['outputs.SqlConnectionInformationResponse'] = None,
+                 target_database_collation: Optional[builtins.str] = None):
         """
-        Summary of database results in the migration
-        :param builtins.str ended_on: Migration end time
-        :param builtins.str error_prefix: Wildcard string prefix to use for querying all errors of the item
-        :param builtins.float items_completed_count: Number of successfully completed items
-        :param builtins.float items_count: Number of items
-        :param builtins.str name: Name of the item
-        :param builtins.str result_prefix: Wildcard string prefix to use for querying all sub-tem results of the item
-        :param builtins.float size_mb: Size of the database in megabytes
-        :param builtins.str started_on: Migration start time
-        :param builtins.str state: Current state of migration
-        :param builtins.str status_message: Status message
+        Database Migration Resource properties for SQL Managed Instance.
+        :param builtins.str ended_on: Database migration end time.
+        :param builtins.str kind: 
+               Expected value is 'SqlMi'.
+        :param 'ErrorInfoResponse' migration_failure_error: Error details in case of migration failure.
+        :param builtins.str migration_status: Migration status.
+        :param 'MigrationStatusDetailsResponse' migration_status_details: Detailed migration status. Not included by default.
+        :param builtins.str provisioning_state: Provisioning State of migration. ProvisioningState as Succeeded implies that validations have been performed and migration has started.
+        :param builtins.str source_server_name: Name of the source sql server.
+        :param builtins.str started_on: Database migration start time.
+        :param 'BackupConfigurationResponse' backup_configuration: Backup configuration info.
+        :param builtins.str migration_operation_id: ID for current migration operation.
+        :param builtins.str migration_service: Resource Id of the Migration Service.
+        :param 'OfflineConfigurationResponse' offline_configuration: Offline configuration.
+        :param builtins.str provisioning_error: Error message for migration provisioning failure, if any.
+        :param builtins.str scope: Resource Id of the target resource.
+        :param builtins.str source_database_name: Name of the source database.
+        :param 'SqlConnectionInformationResponse' source_sql_connection: Source SQL Server connection details.
+        :param builtins.str target_database_collation: Database collation to be used for the target database.
         """
         pulumi.set(__self__, "ended_on", ended_on)
-        pulumi.set(__self__, "error_prefix", error_prefix)
-        pulumi.set(__self__, "items_completed_count", items_completed_count)
-        pulumi.set(__self__, "items_count", items_count)
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "result_prefix", result_prefix)
-        pulumi.set(__self__, "size_mb", size_mb)
+        pulumi.set(__self__, "kind", 'SqlMi')
+        pulumi.set(__self__, "migration_failure_error", migration_failure_error)
+        pulumi.set(__self__, "migration_status", migration_status)
+        pulumi.set(__self__, "migration_status_details", migration_status_details)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "source_server_name", source_server_name)
         pulumi.set(__self__, "started_on", started_on)
-        pulumi.set(__self__, "state", state)
-        pulumi.set(__self__, "status_message", status_message)
+        if backup_configuration is not None:
+            pulumi.set(__self__, "backup_configuration", backup_configuration)
+        if migration_operation_id is not None:
+            pulumi.set(__self__, "migration_operation_id", migration_operation_id)
+        if migration_service is not None:
+            pulumi.set(__self__, "migration_service", migration_service)
+        if offline_configuration is not None:
+            pulumi.set(__self__, "offline_configuration", offline_configuration)
+        if provisioning_error is not None:
+            pulumi.set(__self__, "provisioning_error", provisioning_error)
+        if scope is not None:
+            pulumi.set(__self__, "scope", scope)
+        if source_database_name is not None:
+            pulumi.set(__self__, "source_database_name", source_database_name)
+        if source_sql_connection is not None:
+            pulumi.set(__self__, "source_sql_connection", source_sql_connection)
+        if target_database_collation is not None:
+            pulumi.set(__self__, "target_database_collation", target_database_collation)
 
     @property
     @pulumi.getter(name="endedOn")
     def ended_on(self) -> builtins.str:
         """
-        Migration end time
+        Database migration end time.
         """
         return pulumi.get(self, "ended_on")
 
     @property
-    @pulumi.getter(name="errorPrefix")
-    def error_prefix(self) -> builtins.str:
+    @pulumi.getter
+    def kind(self) -> builtins.str:
         """
-        Wildcard string prefix to use for querying all errors of the item
+
+        Expected value is 'SqlMi'.
         """
-        return pulumi.get(self, "error_prefix")
+        return pulumi.get(self, "kind")
 
     @property
-    @pulumi.getter(name="itemsCompletedCount")
-    def items_completed_count(self) -> builtins.float:
+    @pulumi.getter(name="migrationFailureError")
+    def migration_failure_error(self) -> 'outputs.ErrorInfoResponse':
         """
-        Number of successfully completed items
+        Error details in case of migration failure.
         """
-        return pulumi.get(self, "items_completed_count")
+        return pulumi.get(self, "migration_failure_error")
 
     @property
-    @pulumi.getter(name="itemsCount")
-    def items_count(self) -> builtins.float:
+    @pulumi.getter(name="migrationStatus")
+    def migration_status(self) -> builtins.str:
         """
-        Number of items
+        Migration status.
         """
-        return pulumi.get(self, "items_count")
+        return pulumi.get(self, "migration_status")
 
     @property
-    @pulumi.getter
-    def name(self) -> builtins.str:
+    @pulumi.getter(name="migrationStatusDetails")
+    def migration_status_details(self) -> 'outputs.MigrationStatusDetailsResponse':
         """
-        Name of the item
+        Detailed migration status. Not included by default.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "migration_status_details")
 
     @property
-    @pulumi.getter(name="resultPrefix")
-    def result_prefix(self) -> builtins.str:
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
         """
-        Wildcard string prefix to use for querying all sub-tem results of the item
+        Provisioning State of migration. ProvisioningState as Succeeded implies that validations have been performed and migration has started.
         """
-        return pulumi.get(self, "result_prefix")
+        return pulumi.get(self, "provisioning_state")
 
     @property
-    @pulumi.getter(name="sizeMB")
-    def size_mb(self) -> builtins.float:
+    @pulumi.getter(name="sourceServerName")
+    def source_server_name(self) -> builtins.str:
         """
-        Size of the database in megabytes
+        Name of the source sql server.
         """
-        return pulumi.get(self, "size_mb")
+        return pulumi.get(self, "source_server_name")
 
     @property
     @pulumi.getter(name="startedOn")
     def started_on(self) -> builtins.str:
         """
-        Migration start time
+        Database migration start time.
         """
         return pulumi.get(self, "started_on")
 
     @property
-    @pulumi.getter
-    def state(self) -> builtins.str:
+    @pulumi.getter(name="backupConfiguration")
+    def backup_configuration(self) -> Optional['outputs.BackupConfigurationResponse']:
         """
-        Current state of migration
+        Backup configuration info.
         """
-        return pulumi.get(self, "state")
+        return pulumi.get(self, "backup_configuration")
 
     @property
-    @pulumi.getter(name="statusMessage")
-    def status_message(self) -> builtins.str:
+    @pulumi.getter(name="migrationOperationId")
+    def migration_operation_id(self) -> Optional[builtins.str]:
         """
-        Status message
+        ID for current migration operation.
         """
-        return pulumi.get(self, "status_message")
+        return pulumi.get(self, "migration_operation_id")
 
+    @property
+    @pulumi.getter(name="migrationService")
+    def migration_service(self) -> Optional[builtins.str]:
+        """
+        Resource Id of the Migration Service.
+        """
+        return pulumi.get(self, "migration_service")
 
-@pulumi.output_type
-class DatabaseTableResponse(dict):
-    """
-    Table properties
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "hasRows":
-            suggest = "has_rows"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in DatabaseTableResponse. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        DatabaseTableResponse.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        DatabaseTableResponse.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 has_rows: builtins.bool,
-                 name: builtins.str):
+    @property
+    @pulumi.getter(name="offlineConfiguration")
+    def offline_configuration(self) -> Optional['outputs.OfflineConfigurationResponse']:
         """
-        Table properties
-        :param builtins.bool has_rows: Indicates whether table is empty or not
-        :param builtins.str name: Schema-qualified name of the table
+        Offline configuration.
         """
-        pulumi.set(__self__, "has_rows", has_rows)
-        pulumi.set(__self__, "name", name)
+        return pulumi.get(self, "offline_configuration")
 
     @property
-    @pulumi.getter(name="hasRows")
-    def has_rows(self) -> builtins.bool:
+    @pulumi.getter(name="provisioningError")
+    def provisioning_error(self) -> Optional[builtins.str]:
         """
-        Indicates whether table is empty or not
+        Error message for migration provisioning failure, if any.
         """
-        return pulumi.get(self, "has_rows")
+        return pulumi.get(self, "provisioning_error")
 
     @property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def scope(self) -> Optional[builtins.str]:
         """
-        Schema-qualified name of the table
+        Resource Id of the target resource.
         """
-        return pulumi.get(self, "name")
-
+        return pulumi.get(self, "scope")
 
-@pulumi.output_type
-class ErrorInfoResponse(dict):
-    """
-    Error details
-    """
-    def __init__(__self__, *,
-                 code: builtins.str,
-                 message: builtins.str):
+    @property
+    @pulumi.getter(name="sourceDatabaseName")
+    def source_database_name(self) -> Optional[builtins.str]:
         """
-        Error details
-        :param builtins.str code: Error code.
-        :param builtins.str message: Error message.
+        Name of the source database.
         """
-        pulumi.set(__self__, "code", code)
-        pulumi.set(__self__, "message", message)
+        return pulumi.get(self, "source_database_name")
 
     @property
-    @pulumi.getter
-    def code(self) -> builtins.str:
+    @pulumi.getter(name="sourceSqlConnection")
+    def source_sql_connection(self) -> Optional['outputs.SqlConnectionInformationResponse']:
         """
-        Error code.
+        Source SQL Server connection details.
         """
-        return pulumi.get(self, "code")
+        return pulumi.get(self, "source_sql_connection")
 
     @property
-    @pulumi.getter
-    def message(self) -> builtins.str:
+    @pulumi.getter(name="targetDatabaseCollation")
+    def target_database_collation(self) -> Optional[builtins.str]:
         """
-        Error message.
+        Database collation to be used for the target database.
         """
-        return pulumi.get(self, "message")
+        return pulumi.get(self, "target_database_collation")
 
 
 @pulumi.output_type
-class ExecutionStatisticsResponse(dict):
+class DatabaseMigrationPropertiesSqlVmResponse(dict):
     """
-    Description about the errors happen while performing migration validation
+    Database Migration Resource properties for SQL Virtual Machine.
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "cpuTimeMs":
-            suggest = "cpu_time_ms"
-        elif key == "elapsedTimeMs":
-            suggest = "elapsed_time_ms"
-        elif key == "executionCount":
-            suggest = "execution_count"
-        elif key == "hasErrors":
-            suggest = "has_errors"
-        elif key == "sqlErrors":
-            suggest = "sql_errors"
-        elif key == "waitStats":
-            suggest = "wait_stats"
+        if key == "endedOn":
+            suggest = "ended_on"
+        elif key == "migrationFailureError":
+            suggest = "migration_failure_error"
+        elif key == "migrationStatus":
+            suggest = "migration_status"
+        elif key == "migrationStatusDetails":
+            suggest = "migration_status_details"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "sourceServerName":
+            suggest = "source_server_name"
+        elif key == "startedOn":
+            suggest = "started_on"
+        elif key == "backupConfiguration":
+            suggest = "backup_configuration"
+        elif key == "migrationOperationId":
+            suggest = "migration_operation_id"
+        elif key == "migrationService":
+            suggest = "migration_service"
+        elif key == "offlineConfiguration":
+            suggest = "offline_configuration"
+        elif key == "provisioningError":
+            suggest = "provisioning_error"
+        elif key == "sourceDatabaseName":
+            suggest = "source_database_name"
+        elif key == "sourceSqlConnection":
+            suggest = "source_sql_connection"
+        elif key == "targetDatabaseCollation":
+            suggest = "target_database_collation"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ExecutionStatisticsResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in DatabaseMigrationPropertiesSqlVmResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        ExecutionStatisticsResponse.__key_warning(key)
+        DatabaseMigrationPropertiesSqlVmResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        ExecutionStatisticsResponse.__key_warning(key)
+        DatabaseMigrationPropertiesSqlVmResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 cpu_time_ms: Optional[builtins.float] = None,
-                 elapsed_time_ms: Optional[builtins.float] = None,
-                 execution_count: Optional[builtins.float] = None,
-                 has_errors: Optional[builtins.bool] = None,
-                 sql_errors: Optional[Sequence[builtins.str]] = None,
-                 wait_stats: Optional[Mapping[str, 'outputs.WaitStatisticsResponse']] = None):
+                 ended_on: builtins.str,
+                 kind: builtins.str,
+                 migration_failure_error: 'outputs.ErrorInfoResponse',
+                 migration_status: builtins.str,
+                 migration_status_details: 'outputs.MigrationStatusDetailsResponse',
+                 provisioning_state: builtins.str,
+                 source_server_name: builtins.str,
+                 started_on: builtins.str,
+                 backup_configuration: Optional['outputs.BackupConfigurationResponse'] = None,
+                 migration_operation_id: Optional[builtins.str] = None,
+                 migration_service: Optional[builtins.str] = None,
+                 offline_configuration: Optional['outputs.OfflineConfigurationResponse'] = None,
+                 provisioning_error: Optional[builtins.str] = None,
+                 scope: Optional[builtins.str] = None,
+                 source_database_name: Optional[builtins.str] = None,
+                 source_sql_connection: Optional['outputs.SqlConnectionInformationResponse'] = None,
+                 target_database_collation: Optional[builtins.str] = None):
         """
-        Description about the errors happen while performing migration validation
-        :param builtins.float cpu_time_ms: CPU Time in millisecond(s) for the query execution
-        :param builtins.float elapsed_time_ms: Time taken in millisecond(s) for executing the query
-        :param builtins.float execution_count: No. of query executions
-        :param builtins.bool has_errors: Indicates whether the query resulted in an error
-        :param Sequence[builtins.str] sql_errors: List of sql Errors
-        :param Mapping[str, 'WaitStatisticsResponse'] wait_stats: Dictionary of sql query execution wait types and the respective statistics
+        Database Migration Resource properties for SQL Virtual Machine.
+        :param builtins.str ended_on: Database migration end time.
+        :param builtins.str kind: 
+               Expected value is 'SqlVm'.
+        :param 'ErrorInfoResponse' migration_failure_error: Error details in case of migration failure.
+        :param builtins.str migration_status: Migration status.
+        :param 'MigrationStatusDetailsResponse' migration_status_details: Detailed migration status. Not included by default.
+        :param builtins.str provisioning_state: Provisioning State of migration. ProvisioningState as Succeeded implies that validations have been performed and migration has started.
+        :param builtins.str source_server_name: Name of the source sql server.
+        :param builtins.str started_on: Database migration start time.
+        :param 'BackupConfigurationResponse' backup_configuration: Backup configuration info.
+        :param builtins.str migration_operation_id: ID for current migration operation.
+        :param builtins.str migration_service: Resource Id of the Migration Service.
+        :param 'OfflineConfigurationResponse' offline_configuration: Offline configuration.
+        :param builtins.str provisioning_error: Error message for migration provisioning failure, if any.
+        :param builtins.str scope: Resource Id of the target resource.
+        :param builtins.str source_database_name: Name of the source database.
+        :param 'SqlConnectionInformationResponse' source_sql_connection: Source SQL Server connection details.
+        :param builtins.str target_database_collation: Database collation to be used for the target database.
         """
-        if cpu_time_ms is not None:
-            pulumi.set(__self__, "cpu_time_ms", cpu_time_ms)
-        if elapsed_time_ms is not None:
-            pulumi.set(__self__, "elapsed_time_ms", elapsed_time_ms)
-        if execution_count is not None:
-            pulumi.set(__self__, "execution_count", execution_count)
-        if has_errors is not None:
-            pulumi.set(__self__, "has_errors", has_errors)
-        if sql_errors is not None:
-            pulumi.set(__self__, "sql_errors", sql_errors)
-        if wait_stats is not None:
-            pulumi.set(__self__, "wait_stats", wait_stats)
+        pulumi.set(__self__, "ended_on", ended_on)
+        pulumi.set(__self__, "kind", 'SqlVm')
+        pulumi.set(__self__, "migration_failure_error", migration_failure_error)
+        pulumi.set(__self__, "migration_status", migration_status)
+        pulumi.set(__self__, "migration_status_details", migration_status_details)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "source_server_name", source_server_name)
+        pulumi.set(__self__, "started_on", started_on)
+        if backup_configuration is not None:
+            pulumi.set(__self__, "backup_configuration", backup_configuration)
+        if migration_operation_id is not None:
+            pulumi.set(__self__, "migration_operation_id", migration_operation_id)
+        if migration_service is not None:
+            pulumi.set(__self__, "migration_service", migration_service)
+        if offline_configuration is not None:
+            pulumi.set(__self__, "offline_configuration", offline_configuration)
+        if provisioning_error is not None:
+            pulumi.set(__self__, "provisioning_error", provisioning_error)
+        if scope is not None:
+            pulumi.set(__self__, "scope", scope)
+        if source_database_name is not None:
+            pulumi.set(__self__, "source_database_name", source_database_name)
+        if source_sql_connection is not None:
+            pulumi.set(__self__, "source_sql_connection", source_sql_connection)
+        if target_database_collation is not None:
+            pulumi.set(__self__, "target_database_collation", target_database_collation)
 
     @property
-    @pulumi.getter(name="cpuTimeMs")
-    def cpu_time_ms(self) -> Optional[builtins.float]:
+    @pulumi.getter(name="endedOn")
+    def ended_on(self) -> builtins.str:
         """
-        CPU Time in millisecond(s) for the query execution
+        Database migration end time.
         """
-        return pulumi.get(self, "cpu_time_ms")
+        return pulumi.get(self, "ended_on")
 
     @property
-    @pulumi.getter(name="elapsedTimeMs")
-    def elapsed_time_ms(self) -> Optional[builtins.float]:
+    @pulumi.getter
+    def kind(self) -> builtins.str:
         """
-        Time taken in millisecond(s) for executing the query
+
+        Expected value is 'SqlVm'.
         """
-        return pulumi.get(self, "elapsed_time_ms")
+        return pulumi.get(self, "kind")
 
     @property
-    @pulumi.getter(name="executionCount")
-    def execution_count(self) -> Optional[builtins.float]:
+    @pulumi.getter(name="migrationFailureError")
+    def migration_failure_error(self) -> 'outputs.ErrorInfoResponse':
         """
-        No. of query executions
+        Error details in case of migration failure.
         """
-        return pulumi.get(self, "execution_count")
+        return pulumi.get(self, "migration_failure_error")
 
     @property
-    @pulumi.getter(name="hasErrors")
-    def has_errors(self) -> Optional[builtins.bool]:
+    @pulumi.getter(name="migrationStatus")
+    def migration_status(self) -> builtins.str:
         """
-        Indicates whether the query resulted in an error
+        Migration status.
         """
-        return pulumi.get(self, "has_errors")
+        return pulumi.get(self, "migration_status")
 
     @property
-    @pulumi.getter(name="sqlErrors")
-    def sql_errors(self) -> Optional[Sequence[builtins.str]]:
+    @pulumi.getter(name="migrationStatusDetails")
+    def migration_status_details(self) -> 'outputs.MigrationStatusDetailsResponse':
         """
-        List of sql Errors
+        Detailed migration status. Not included by default.
         """
-        return pulumi.get(self, "sql_errors")
+        return pulumi.get(self, "migration_status_details")
 
     @property
-    @pulumi.getter(name="waitStats")
-    def wait_stats(self) -> Optional[Mapping[str, 'outputs.WaitStatisticsResponse']]:
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> builtins.str:
         """
-        Dictionary of sql query execution wait types and the respective statistics
+        Provisioning State of migration. ProvisioningState as Succeeded implies that validations have been performed and migration has started.
         """
-        return pulumi.get(self, "wait_stats")
+        return pulumi.get(self, "provisioning_state")
 
+    @property
+    @pulumi.getter(name="sourceServerName")
+    def source_server_name(self) -> builtins.str:
+        """
+        Name of the source sql server.
+        """
+        return pulumi.get(self, "source_server_name")
 
-@pulumi.output_type
-class FileShareResponse(dict):
-    """
-    File share information with Path, Username, and Password.
-    """
-    @staticmethod
+    @property
+    @pulumi.getter(name="startedOn")
+    def started_on(self) -> builtins.str:
+        """
+        Database migration start time.
+        """
+        return pulumi.get(self, "started_on")
+
+    @property
+    @pulumi.getter(name="backupConfiguration")
+    def backup_configuration(self) -> Optional['outputs.BackupConfigurationResponse']:
+        """
+        Backup configuration info.
+        """
+        return pulumi.get(self, "backup_configuration")
+
+    @property
+    @pulumi.getter(name="migrationOperationId")
+    def migration_operation_id(self) -> Optional[builtins.str]:
+        """
+        ID for current migration operation.
+        """
+        return pulumi.get(self, "migration_operation_id")
+
+    @property
+    @pulumi.getter(name="migrationService")
+    def migration_service(self) -> Optional[builtins.str]:
+        """
+        Resource Id of the Migration Service.
+        """
+        return pulumi.get(self, "migration_service")
+
+    @property
+    @pulumi.getter(name="offlineConfiguration")
+    def offline_configuration(self) -> Optional['outputs.OfflineConfigurationResponse']:
+        """
+        Offline configuration.
+        """
+        return pulumi.get(self, "offline_configuration")
+
+    @property
+    @pulumi.getter(name="provisioningError")
+    def provisioning_error(self) -> Optional[builtins.str]:
+        """
+        Error message for migration provisioning failure, if any.
+        """
+        return pulumi.get(self, "provisioning_error")
+
+    @property
+    @pulumi.getter
+    def scope(self) -> Optional[builtins.str]:
+        """
+        Resource Id of the target resource.
+        """
+        return pulumi.get(self, "scope")
+
+    @property
+    @pulumi.getter(name="sourceDatabaseName")
+    def source_database_name(self) -> Optional[builtins.str]:
+        """
+        Name of the source database.
+        """
+        return pulumi.get(self, "source_database_name")
+
+    @property
+    @pulumi.getter(name="sourceSqlConnection")
+    def source_sql_connection(self) -> Optional['outputs.SqlConnectionInformationResponse']:
+        """
+        Source SQL Server connection details.
+        """
+        return pulumi.get(self, "source_sql_connection")
+
+    @property
+    @pulumi.getter(name="targetDatabaseCollation")
+    def target_database_collation(self) -> Optional[builtins.str]:
+        """
+        Database collation to be used for the target database.
+        """
+        return pulumi.get(self, "target_database_collation")
+
+
+@pulumi.output_type
+class DatabaseSummaryResultResponse(dict):
+    """
+    Summary of database results in the migration
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "endedOn":
+            suggest = "ended_on"
+        elif key == "errorPrefix":
+            suggest = "error_prefix"
+        elif key == "itemsCompletedCount":
+            suggest = "items_completed_count"
+        elif key == "itemsCount":
+            suggest = "items_count"
+        elif key == "resultPrefix":
+            suggest = "result_prefix"
+        elif key == "sizeMB":
+            suggest = "size_mb"
+        elif key == "startedOn":
+            suggest = "started_on"
+        elif key == "statusMessage":
+            suggest = "status_message"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DatabaseSummaryResultResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DatabaseSummaryResultResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DatabaseSummaryResultResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 ended_on: builtins.str,
+                 error_prefix: builtins.str,
+                 items_completed_count: builtins.float,
+                 items_count: builtins.float,
+                 name: builtins.str,
+                 result_prefix: builtins.str,
+                 size_mb: builtins.float,
+                 started_on: builtins.str,
+                 state: builtins.str,
+                 status_message: builtins.str):
+        """
+        Summary of database results in the migration
+        :param builtins.str ended_on: Migration end time
+        :param builtins.str error_prefix: Wildcard string prefix to use for querying all errors of the item
+        :param builtins.float items_completed_count: Number of successfully completed items
+        :param builtins.float items_count: Number of items
+        :param builtins.str name: Name of the item
+        :param builtins.str result_prefix: Wildcard string prefix to use for querying all sub-tem results of the item
+        :param builtins.float size_mb: Size of the database in megabytes
+        :param builtins.str started_on: Migration start time
+        :param builtins.str state: Current state of migration
+        :param builtins.str status_message: Status message
+        """
+        pulumi.set(__self__, "ended_on", ended_on)
+        pulumi.set(__self__, "error_prefix", error_prefix)
+        pulumi.set(__self__, "items_completed_count", items_completed_count)
+        pulumi.set(__self__, "items_count", items_count)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "result_prefix", result_prefix)
+        pulumi.set(__self__, "size_mb", size_mb)
+        pulumi.set(__self__, "started_on", started_on)
+        pulumi.set(__self__, "state", state)
+        pulumi.set(__self__, "status_message", status_message)
+
+    @property
+    @pulumi.getter(name="endedOn")
+    def ended_on(self) -> builtins.str:
+        """
+        Migration end time
+        """
+        return pulumi.get(self, "ended_on")
+
+    @property
+    @pulumi.getter(name="errorPrefix")
+    def error_prefix(self) -> builtins.str:
+        """
+        Wildcard string prefix to use for querying all errors of the item
+        """
+        return pulumi.get(self, "error_prefix")
+
+    @property
+    @pulumi.getter(name="itemsCompletedCount")
+    def items_completed_count(self) -> builtins.float:
+        """
+        Number of successfully completed items
+        """
+        return pulumi.get(self, "items_completed_count")
+
+    @property
+    @pulumi.getter(name="itemsCount")
+    def items_count(self) -> builtins.float:
+        """
+        Number of items
+        """
+        return pulumi.get(self, "items_count")
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        Name of the item
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="resultPrefix")
+    def result_prefix(self) -> builtins.str:
+        """
+        Wildcard string prefix to use for querying all sub-tem results of the item
+        """
+        return pulumi.get(self, "result_prefix")
+
+    @property
+    @pulumi.getter(name="sizeMB")
+    def size_mb(self) -> builtins.float:
+        """
+        Size of the database in megabytes
+        """
+        return pulumi.get(self, "size_mb")
+
+    @property
+    @pulumi.getter(name="startedOn")
+    def started_on(self) -> builtins.str:
+        """
+        Migration start time
+        """
+        return pulumi.get(self, "started_on")
+
+    @property
+    @pulumi.getter
+    def state(self) -> builtins.str:
+        """
+        Current state of migration
+        """
+        return pulumi.get(self, "state")
+
+    @property
+    @pulumi.getter(name="statusMessage")
+    def status_message(self) -> builtins.str:
+        """
+        Status message
+        """
+        return pulumi.get(self, "status_message")
+
+
+@pulumi.output_type
+class DatabaseTableResponse(dict):
+    """
+    Table properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "hasRows":
+            suggest = "has_rows"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DatabaseTableResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DatabaseTableResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DatabaseTableResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 has_rows: builtins.bool,
+                 name: builtins.str):
+        """
+        Table properties
+        :param builtins.bool has_rows: Indicates whether table is empty or not
+        :param builtins.str name: Schema-qualified name of the table
+        """
+        pulumi.set(__self__, "has_rows", has_rows)
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter(name="hasRows")
+    def has_rows(self) -> builtins.bool:
+        """
+        Indicates whether table is empty or not
+        """
+        return pulumi.get(self, "has_rows")
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        Schema-qualified name of the table
+        """
+        return pulumi.get(self, "name")
+
+
+@pulumi.output_type
+class ErrorInfoResponse(dict):
+    """
+    Error details
+    """
+    def __init__(__self__, *,
+                 code: builtins.str,
+                 message: builtins.str):
+        """
+        Error details
+        :param builtins.str code: Error code.
+        :param builtins.str message: Error message.
+        """
+        pulumi.set(__self__, "code", code)
+        pulumi.set(__self__, "message", message)
+
+    @property
+    @pulumi.getter
+    def code(self) -> builtins.str:
+        """
+        Error code.
+        """
+        return pulumi.get(self, "code")
+
+    @property
+    @pulumi.getter
+    def message(self) -> builtins.str:
+        """
+        Error message.
+        """
+        return pulumi.get(self, "message")
+
+
+@pulumi.output_type
+class ExecutionStatisticsResponse(dict):
+    """
+    Description about the errors happen while performing migration validation
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "cpuTimeMs":
+            suggest = "cpu_time_ms"
+        elif key == "elapsedTimeMs":
+            suggest = "elapsed_time_ms"
+        elif key == "executionCount":
+            suggest = "execution_count"
+        elif key == "hasErrors":
+            suggest = "has_errors"
+        elif key == "sqlErrors":
+            suggest = "sql_errors"
+        elif key == "waitStats":
+            suggest = "wait_stats"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ExecutionStatisticsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ExecutionStatisticsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ExecutionStatisticsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cpu_time_ms: Optional[builtins.float] = None,
+                 elapsed_time_ms: Optional[builtins.float] = None,
+                 execution_count: Optional[builtins.float] = None,
+                 has_errors: Optional[builtins.bool] = None,
+                 sql_errors: Optional[Sequence[builtins.str]] = None,
+                 wait_stats: Optional[Mapping[str, 'outputs.WaitStatisticsResponse']] = None):
+        """
+        Description about the errors happen while performing migration validation
+        :param builtins.float cpu_time_ms: CPU Time in millisecond(s) for the query execution
+        :param builtins.float elapsed_time_ms: Time taken in millisecond(s) for executing the query
+        :param builtins.float execution_count: No. of query executions
+        :param builtins.bool has_errors: Indicates whether the query resulted in an error
+        :param Sequence[builtins.str] sql_errors: List of sql Errors
+        :param Mapping[str, 'WaitStatisticsResponse'] wait_stats: Dictionary of sql query execution wait types and the respective statistics
+        """
+        if cpu_time_ms is not None:
+            pulumi.set(__self__, "cpu_time_ms", cpu_time_ms)
+        if elapsed_time_ms is not None:
+            pulumi.set(__self__, "elapsed_time_ms", elapsed_time_ms)
+        if execution_count is not None:
+            pulumi.set(__self__, "execution_count", execution_count)
+        if has_errors is not None:
+            pulumi.set(__self__, "has_errors", has_errors)
+        if sql_errors is not None:
+            pulumi.set(__self__, "sql_errors", sql_errors)
+        if wait_stats is not None:
+            pulumi.set(__self__, "wait_stats", wait_stats)
+
+    @property
+    @pulumi.getter(name="cpuTimeMs")
+    def cpu_time_ms(self) -> Optional[builtins.float]:
+        """
+        CPU Time in millisecond(s) for the query execution
+        """
+        return pulumi.get(self, "cpu_time_ms")
+
+    @property
+    @pulumi.getter(name="elapsedTimeMs")
+    def elapsed_time_ms(self) -> Optional[builtins.float]:
+        """
+        Time taken in millisecond(s) for executing the query
+        """
+        return pulumi.get(self, "elapsed_time_ms")
+
+    @property
+    @pulumi.getter(name="executionCount")
+    def execution_count(self) -> Optional[builtins.float]:
+        """
+        No. of query executions
+        """
+        return pulumi.get(self, "execution_count")
+
+    @property
+    @pulumi.getter(name="hasErrors")
+    def has_errors(self) -> Optional[builtins.bool]:
+        """
+        Indicates whether the query resulted in an error
+        """
+        return pulumi.get(self, "has_errors")
+
+    @property
+    @pulumi.getter(name="sqlErrors")
+    def sql_errors(self) -> Optional[Sequence[builtins.str]]:
+        """
+        List of sql Errors
+        """
+        return pulumi.get(self, "sql_errors")
+
+    @property
+    @pulumi.getter(name="waitStats")
+    def wait_stats(self) -> Optional[Mapping[str, 'outputs.WaitStatisticsResponse']]:
+        """
+        Dictionary of sql query execution wait types and the respective statistics
+        """
+        return pulumi.get(self, "wait_stats")
+
+
+@pulumi.output_type
+class FileShareResponse(dict):
+    """
+    File share information with Path, Username, and Password.
+    """
+    @staticmethod
     def __key_warning(key: str):
         suggest = None
         if key == "userName":
@@ -6797,6 +7466,83 @@ class GetUserTablesSqlTaskPropertiesResponse(dict):
         return pulumi.get(self, "task_id")
 
 
+@pulumi.output_type
+class ManagedServiceIdentityResponse(dict):
+    """
+    Managed service identity (system assigned and/or user assigned identities)
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "principalId":
+            suggest = "principal_id"
+        elif key == "tenantId":
+            suggest = "tenant_id"
+        elif key == "userAssignedIdentities":
+            suggest = "user_assigned_identities"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ManagedServiceIdentityResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ManagedServiceIdentityResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ManagedServiceIdentityResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 principal_id: builtins.str,
+                 tenant_id: builtins.str,
+                 type: builtins.str,
+                 user_assigned_identities: Optional[Mapping[str, 'outputs.UserAssignedIdentityResponse']] = None):
+        """
+        Managed service identity (system assigned and/or user assigned identities)
+        :param builtins.str principal_id: The service principal ID of the system assigned identity. This property will only be provided for a system assigned identity.
+        :param builtins.str tenant_id: The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
+        :param builtins.str type: Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
+        :param Mapping[str, 'UserAssignedIdentityResponse'] user_assigned_identities: The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests.
+        """
+        pulumi.set(__self__, "principal_id", principal_id)
+        pulumi.set(__self__, "tenant_id", tenant_id)
+        pulumi.set(__self__, "type", type)
+        if user_assigned_identities is not None:
+            pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
+
+    @property
+    @pulumi.getter(name="principalId")
+    def principal_id(self) -> builtins.str:
+        """
+        The service principal ID of the system assigned identity. This property will only be provided for a system assigned identity.
+        """
+        return pulumi.get(self, "principal_id")
+
+    @property
+    @pulumi.getter(name="tenantId")
+    def tenant_id(self) -> builtins.str:
+        """
+        The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
+        """
+        return pulumi.get(self, "tenant_id")
+
+    @property
+    @pulumi.getter
+    def type(self) -> builtins.str:
+        """
+        Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="userAssignedIdentities")
+    def user_assigned_identities(self) -> Optional[Mapping[str, 'outputs.UserAssignedIdentityResponse']]:
+        """
+        The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests.
+        """
+        return pulumi.get(self, "user_assigned_identities")
+
+
 @pulumi.output_type
 class MiSqlConnectionInfoResponse(dict):
     """
@@ -16320,6 +17066,201 @@ class MigrationReportResultResponse(dict):
         return pulumi.get(self, "report_url")
 
 
+@pulumi.output_type
+class MigrationStatusDetailsResponse(dict):
+    """
+    Detailed status of current migration.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "activeBackupSets":
+            suggest = "active_backup_sets"
+        elif key == "blobContainerName":
+            suggest = "blob_container_name"
+        elif key == "completeRestoreErrorMessage":
+            suggest = "complete_restore_error_message"
+        elif key == "currentRestoringFilename":
+            suggest = "current_restoring_filename"
+        elif key == "fileUploadBlockingErrors":
+            suggest = "file_upload_blocking_errors"
+        elif key == "fullBackupSetInfo":
+            suggest = "full_backup_set_info"
+        elif key == "invalidFiles":
+            suggest = "invalid_files"
+        elif key == "isFullBackupRestored":
+            suggest = "is_full_backup_restored"
+        elif key == "lastRestoredBackupSetInfo":
+            suggest = "last_restored_backup_set_info"
+        elif key == "lastRestoredFilename":
+            suggest = "last_restored_filename"
+        elif key == "migrationState":
+            suggest = "migration_state"
+        elif key == "pendingLogBackupsCount":
+            suggest = "pending_log_backups_count"
+        elif key == "restoreBlockingReason":
+            suggest = "restore_blocking_reason"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in MigrationStatusDetailsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        MigrationStatusDetailsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        MigrationStatusDetailsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 active_backup_sets: Sequence['outputs.SqlBackupSetInfoResponse'],
+                 blob_container_name: builtins.str,
+                 complete_restore_error_message: builtins.str,
+                 current_restoring_filename: builtins.str,
+                 file_upload_blocking_errors: Sequence[builtins.str],
+                 full_backup_set_info: 'outputs.SqlBackupSetInfoResponse',
+                 invalid_files: Sequence[builtins.str],
+                 is_full_backup_restored: builtins.bool,
+                 last_restored_backup_set_info: 'outputs.SqlBackupSetInfoResponse',
+                 last_restored_filename: builtins.str,
+                 migration_state: builtins.str,
+                 pending_log_backups_count: builtins.int,
+                 restore_blocking_reason: builtins.str):
+        """
+        Detailed status of current migration.
+        :param Sequence['SqlBackupSetInfoResponse'] active_backup_sets: Backup sets that are currently active.
+        :param builtins.str blob_container_name: Name of blob container.
+        :param builtins.str complete_restore_error_message: Complete restore error message, if any
+        :param builtins.str current_restoring_filename: File name that is currently being restored.
+        :param Sequence[builtins.str] file_upload_blocking_errors: File upload blocking errors, if any.
+        :param 'SqlBackupSetInfoResponse' full_backup_set_info: Details of full backup set.
+        :param Sequence[builtins.str] invalid_files: Files that are not valid backup files.
+        :param builtins.bool is_full_backup_restored: Whether full backup has been applied to the target database or not.
+        :param 'SqlBackupSetInfoResponse' last_restored_backup_set_info: Last applied backup set information.
+        :param builtins.str last_restored_filename: Last restored file name.
+        :param builtins.str migration_state: Current State of Migration.
+        :param builtins.int pending_log_backups_count: Total pending log backups.
+        :param builtins.str restore_blocking_reason: Restore blocking reason, if any
+        """
+        pulumi.set(__self__, "active_backup_sets", active_backup_sets)
+        pulumi.set(__self__, "blob_container_name", blob_container_name)
+        pulumi.set(__self__, "complete_restore_error_message", complete_restore_error_message)
+        pulumi.set(__self__, "current_restoring_filename", current_restoring_filename)
+        pulumi.set(__self__, "file_upload_blocking_errors", file_upload_blocking_errors)
+        pulumi.set(__self__, "full_backup_set_info", full_backup_set_info)
+        pulumi.set(__self__, "invalid_files", invalid_files)
+        pulumi.set(__self__, "is_full_backup_restored", is_full_backup_restored)
+        pulumi.set(__self__, "last_restored_backup_set_info", last_restored_backup_set_info)
+        pulumi.set(__self__, "last_restored_filename", last_restored_filename)
+        pulumi.set(__self__, "migration_state", migration_state)
+        pulumi.set(__self__, "pending_log_backups_count", pending_log_backups_count)
+        pulumi.set(__self__, "restore_blocking_reason", restore_blocking_reason)
+
+    @property
+    @pulumi.getter(name="activeBackupSets")
+    def active_backup_sets(self) -> Sequence['outputs.SqlBackupSetInfoResponse']:
+        """
+        Backup sets that are currently active.
+        """
+        return pulumi.get(self, "active_backup_sets")
+
+    @property
+    @pulumi.getter(name="blobContainerName")
+    def blob_container_name(self) -> builtins.str:
+        """
+        Name of blob container.
+        """
+        return pulumi.get(self, "blob_container_name")
+
+    @property
+    @pulumi.getter(name="completeRestoreErrorMessage")
+    def complete_restore_error_message(self) -> builtins.str:
+        """
+        Complete restore error message, if any
+        """
+        return pulumi.get(self, "complete_restore_error_message")
+
+    @property
+    @pulumi.getter(name="currentRestoringFilename")
+    def current_restoring_filename(self) -> builtins.str:
+        """
+        File name that is currently being restored.
+        """
+        return pulumi.get(self, "current_restoring_filename")
+
+    @property
+    @pulumi.getter(name="fileUploadBlockingErrors")
+    def file_upload_blocking_errors(self) -> Sequence[builtins.str]:
+        """
+        File upload blocking errors, if any.
+        """
+        return pulumi.get(self, "file_upload_blocking_errors")
+
+    @property
+    @pulumi.getter(name="fullBackupSetInfo")
+    def full_backup_set_info(self) -> 'outputs.SqlBackupSetInfoResponse':
+        """
+        Details of full backup set.
+        """
+        return pulumi.get(self, "full_backup_set_info")
+
+    @property
+    @pulumi.getter(name="invalidFiles")
+    def invalid_files(self) -> Sequence[builtins.str]:
+        """
+        Files that are not valid backup files.
+        """
+        return pulumi.get(self, "invalid_files")
+
+    @property
+    @pulumi.getter(name="isFullBackupRestored")
+    def is_full_backup_restored(self) -> builtins.bool:
+        """
+        Whether full backup has been applied to the target database or not.
+        """
+        return pulumi.get(self, "is_full_backup_restored")
+
+    @property
+    @pulumi.getter(name="lastRestoredBackupSetInfo")
+    def last_restored_backup_set_info(self) -> 'outputs.SqlBackupSetInfoResponse':
+        """
+        Last applied backup set information.
+        """
+        return pulumi.get(self, "last_restored_backup_set_info")
+
+    @property
+    @pulumi.getter(name="lastRestoredFilename")
+    def last_restored_filename(self) -> builtins.str:
+        """
+        Last restored file name.
+        """
+        return pulumi.get(self, "last_restored_filename")
+
+    @property
+    @pulumi.getter(name="migrationState")
+    def migration_state(self) -> builtins.str:
+        """
+        Current State of Migration.
+        """
+        return pulumi.get(self, "migration_state")
+
+    @property
+    @pulumi.getter(name="pendingLogBackupsCount")
+    def pending_log_backups_count(self) -> builtins.int:
+        """
+        Total pending log backups.
+        """
+        return pulumi.get(self, "pending_log_backups_count")
+
+    @property
+    @pulumi.getter(name="restoreBlockingReason")
+    def restore_blocking_reason(self) -> builtins.str:
+        """
+        Restore blocking reason, if any
+        """
+        return pulumi.get(self, "restore_blocking_reason")
+
+
 @pulumi.output_type
 class MigrationValidationDatabaseSummaryResultResponse(dict):
     """
@@ -18766,25 +19707,77 @@ class ODataErrorResponse(dict):
     @pulumi.getter
     def code(self) -> Optional[builtins.str]:
         """
-        The machine-readable description of the error, such as 'InvalidRequest' or 'InternalServerError'
+        The machine-readable description of the error, such as 'InvalidRequest' or 'InternalServerError'
+        """
+        return pulumi.get(self, "code")
+
+    @property
+    @pulumi.getter
+    def details(self) -> Optional[Sequence['outputs.ODataErrorResponse']]:
+        """
+        Inner errors that caused this error
+        """
+        return pulumi.get(self, "details")
+
+    @property
+    @pulumi.getter
+    def message(self) -> Optional[builtins.str]:
+        """
+        The human-readable description of the error
+        """
+        return pulumi.get(self, "message")
+
+
+@pulumi.output_type
+class OfflineConfigurationResponse(dict):
+    """
+    Offline configuration
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "lastBackupName":
+            suggest = "last_backup_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OfflineConfigurationResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OfflineConfigurationResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OfflineConfigurationResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 last_backup_name: Optional[builtins.str] = None,
+                 offline: Optional[builtins.bool] = None):
+        """
+        Offline configuration
+        :param builtins.str last_backup_name: Last backup name for offline migration. This is optional for migrations from file share. If it is not provided, then the service will determine the last backup file name based on latest backup files present in file share.
+        :param builtins.bool offline: Offline migration
         """
-        return pulumi.get(self, "code")
+        if last_backup_name is not None:
+            pulumi.set(__self__, "last_backup_name", last_backup_name)
+        if offline is not None:
+            pulumi.set(__self__, "offline", offline)
 
     @property
-    @pulumi.getter
-    def details(self) -> Optional[Sequence['outputs.ODataErrorResponse']]:
+    @pulumi.getter(name="lastBackupName")
+    def last_backup_name(self) -> Optional[builtins.str]:
         """
-        Inner errors that caused this error
+        Last backup name for offline migration. This is optional for migrations from file share. If it is not provided, then the service will determine the last backup file name based on latest backup files present in file share.
         """
-        return pulumi.get(self, "details")
+        return pulumi.get(self, "last_backup_name")
 
     @property
     @pulumi.getter
-    def message(self) -> Optional[builtins.str]:
+    def offline(self) -> Optional[builtins.bool]:
         """
-        The human-readable description of the error
+        Offline migration
         """
-        return pulumi.get(self, "message")
+        return pulumi.get(self, "offline")
 
 
 @pulumi.output_type
@@ -19070,815 +20063,1179 @@ class PostgreSqlConnectionInfoResponse(dict):
     @pulumi.getter
     def port(self) -> builtins.int:
         """
-        Port for Server
+        Port for Server
+        """
+        return pulumi.get(self, "port")
+
+    @property
+    @pulumi.getter(name="serverName")
+    def server_name(self) -> builtins.str:
+        """
+        Name of the server
+        """
+        return pulumi.get(self, "server_name")
+
+    @property
+    @pulumi.getter
+    def type(self) -> builtins.str:
+        """
+        Type of connection info
+        Expected value is 'PostgreSqlConnectionInfo'.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="additionalSettings")
+    def additional_settings(self) -> Optional[builtins.str]:
+        """
+        Additional connection settings
+        """
+        return pulumi.get(self, "additional_settings")
+
+    @property
+    @pulumi.getter
+    def authentication(self) -> Optional[builtins.str]:
+        """
+        Authentication type to use for connection
+        """
+        return pulumi.get(self, "authentication")
+
+    @property
+    @pulumi.getter(name="dataSource")
+    def data_source(self) -> Optional[builtins.str]:
+        """
+        Data source 
+        """
+        return pulumi.get(self, "data_source")
+
+    @property
+    @pulumi.getter(name="databaseName")
+    def database_name(self) -> Optional[builtins.str]:
+        """
+        Name of the database
+        """
+        return pulumi.get(self, "database_name")
+
+    @property
+    @pulumi.getter(name="encryptConnection")
+    def encrypt_connection(self) -> Optional[builtins.bool]:
+        """
+        Whether to encrypt the connection
+        """
+        return pulumi.get(self, "encrypt_connection")
+
+    @property
+    @pulumi.getter
+    def password(self) -> Optional[builtins.str]:
+        """
+        Password credential.
+        """
+        return pulumi.get(self, "password")
+
+    @property
+    @pulumi.getter(name="serverBrandVersion")
+    def server_brand_version(self) -> Optional[builtins.str]:
+        """
+        server brand version
+        """
+        return pulumi.get(self, "server_brand_version")
+
+    @property
+    @pulumi.getter(name="serverVersion")
+    def server_version(self) -> Optional[builtins.str]:
+        """
+        server version
+        """
+        return pulumi.get(self, "server_version")
+
+    @property
+    @pulumi.getter(name="trustServerCertificate")
+    def trust_server_certificate(self) -> Optional[builtins.bool]:
+        """
+        Whether to trust the server certificate
+        """
+        return pulumi.get(self, "trust_server_certificate")
+
+    @property
+    @pulumi.getter(name="userName")
+    def user_name(self) -> Optional[builtins.str]:
+        """
+        User name
+        """
+        return pulumi.get(self, "user_name")
+
+
+@pulumi.output_type
+class ProjectFilePropertiesResponse(dict):
+    """
+    Base class for file properties.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "lastModified":
+            suggest = "last_modified"
+        elif key == "filePath":
+            suggest = "file_path"
+        elif key == "mediaType":
+            suggest = "media_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ProjectFilePropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ProjectFilePropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ProjectFilePropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 last_modified: builtins.str,
+                 size: builtins.float,
+                 extension: Optional[builtins.str] = None,
+                 file_path: Optional[builtins.str] = None,
+                 media_type: Optional[builtins.str] = None):
+        """
+        Base class for file properties.
+        :param builtins.str last_modified: Modification DateTime.
+        :param builtins.float size: File size.
+        :param builtins.str extension: Optional File extension. If submitted it should not have a leading period and must match the extension from filePath.
+        :param builtins.str file_path: Relative path of this file resource. This property can be set when creating or updating the file resource.
+        :param builtins.str media_type: File content type. This property can be modified to reflect the file content type.
+        """
+        pulumi.set(__self__, "last_modified", last_modified)
+        pulumi.set(__self__, "size", size)
+        if extension is not None:
+            pulumi.set(__self__, "extension", extension)
+        if file_path is not None:
+            pulumi.set(__self__, "file_path", file_path)
+        if media_type is not None:
+            pulumi.set(__self__, "media_type", media_type)
+
+    @property
+    @pulumi.getter(name="lastModified")
+    def last_modified(self) -> builtins.str:
+        """
+        Modification DateTime.
+        """
+        return pulumi.get(self, "last_modified")
+
+    @property
+    @pulumi.getter
+    def size(self) -> builtins.float:
+        """
+        File size.
+        """
+        return pulumi.get(self, "size")
+
+    @property
+    @pulumi.getter
+    def extension(self) -> Optional[builtins.str]:
+        """
+        Optional File extension. If submitted it should not have a leading period and must match the extension from filePath.
+        """
+        return pulumi.get(self, "extension")
+
+    @property
+    @pulumi.getter(name="filePath")
+    def file_path(self) -> Optional[builtins.str]:
+        """
+        Relative path of this file resource. This property can be set when creating or updating the file resource.
+        """
+        return pulumi.get(self, "file_path")
+
+    @property
+    @pulumi.getter(name="mediaType")
+    def media_type(self) -> Optional[builtins.str]:
+        """
+        File content type. This property can be modified to reflect the file content type.
+        """
+        return pulumi.get(self, "media_type")
+
+
+@pulumi.output_type
+class QueryAnalysisValidationResultResponse(dict):
+    """
+    Results for query analysis comparison between the source and target
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "queryResults":
+            suggest = "query_results"
+        elif key == "validationErrors":
+            suggest = "validation_errors"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in QueryAnalysisValidationResultResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        QueryAnalysisValidationResultResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        QueryAnalysisValidationResultResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 query_results: Optional['outputs.QueryExecutionResultResponse'] = None,
+                 validation_errors: Optional['outputs.ValidationErrorResponse'] = None):
+        """
+        Results for query analysis comparison between the source and target
+        :param 'QueryExecutionResultResponse' query_results: List of queries executed and it's execution results in source and target
+        :param 'ValidationErrorResponse' validation_errors: Errors that are part of the execution
+        """
+        if query_results is not None:
+            pulumi.set(__self__, "query_results", query_results)
+        if validation_errors is not None:
+            pulumi.set(__self__, "validation_errors", validation_errors)
+
+    @property
+    @pulumi.getter(name="queryResults")
+    def query_results(self) -> Optional['outputs.QueryExecutionResultResponse']:
+        """
+        List of queries executed and it's execution results in source and target
+        """
+        return pulumi.get(self, "query_results")
+
+    @property
+    @pulumi.getter(name="validationErrors")
+    def validation_errors(self) -> Optional['outputs.ValidationErrorResponse']:
+        """
+        Errors that are part of the execution
         """
-        return pulumi.get(self, "port")
+        return pulumi.get(self, "validation_errors")
 
-    @property
-    @pulumi.getter(name="serverName")
-    def server_name(self) -> builtins.str:
+
+@pulumi.output_type
+class QueryExecutionResultResponse(dict):
+    """
+    Describes query analysis results for execution in source and target
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "queryText":
+            suggest = "query_text"
+        elif key == "sourceResult":
+            suggest = "source_result"
+        elif key == "statementsInBatch":
+            suggest = "statements_in_batch"
+        elif key == "targetResult":
+            suggest = "target_result"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in QueryExecutionResultResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        QueryExecutionResultResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        QueryExecutionResultResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 query_text: Optional[builtins.str] = None,
+                 source_result: Optional['outputs.ExecutionStatisticsResponse'] = None,
+                 statements_in_batch: Optional[builtins.float] = None,
+                 target_result: Optional['outputs.ExecutionStatisticsResponse'] = None):
         """
-        Name of the server
+        Describes query analysis results for execution in source and target
+        :param builtins.str query_text: Query text retrieved from the source server
+        :param 'ExecutionStatisticsResponse' source_result: Query analysis result from the source
+        :param builtins.float statements_in_batch: Total no. of statements in the batch
+        :param 'ExecutionStatisticsResponse' target_result: Query analysis result from the target
         """
-        return pulumi.get(self, "server_name")
+        if query_text is not None:
+            pulumi.set(__self__, "query_text", query_text)
+        if source_result is not None:
+            pulumi.set(__self__, "source_result", source_result)
+        if statements_in_batch is not None:
+            pulumi.set(__self__, "statements_in_batch", statements_in_batch)
+        if target_result is not None:
+            pulumi.set(__self__, "target_result", target_result)
 
     @property
-    @pulumi.getter
-    def type(self) -> builtins.str:
+    @pulumi.getter(name="queryText")
+    def query_text(self) -> Optional[builtins.str]:
         """
-        Type of connection info
-        Expected value is 'PostgreSqlConnectionInfo'.
+        Query text retrieved from the source server
         """
-        return pulumi.get(self, "type")
+        return pulumi.get(self, "query_text")
 
     @property
-    @pulumi.getter(name="additionalSettings")
-    def additional_settings(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="sourceResult")
+    def source_result(self) -> Optional['outputs.ExecutionStatisticsResponse']:
         """
-        Additional connection settings
+        Query analysis result from the source
         """
-        return pulumi.get(self, "additional_settings")
+        return pulumi.get(self, "source_result")
 
     @property
-    @pulumi.getter
-    def authentication(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="statementsInBatch")
+    def statements_in_batch(self) -> Optional[builtins.float]:
         """
-        Authentication type to use for connection
+        Total no. of statements in the batch
         """
-        return pulumi.get(self, "authentication")
+        return pulumi.get(self, "statements_in_batch")
 
     @property
-    @pulumi.getter(name="dataSource")
-    def data_source(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="targetResult")
+    def target_result(self) -> Optional['outputs.ExecutionStatisticsResponse']:
         """
-        Data source 
+        Query analysis result from the target
         """
-        return pulumi.get(self, "data_source")
+        return pulumi.get(self, "target_result")
 
-    @property
-    @pulumi.getter(name="databaseName")
-    def database_name(self) -> Optional[builtins.str]:
+
+@pulumi.output_type
+class ReportableExceptionResponse(dict):
+    """
+    Exception object for all custom exceptions
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "actionableMessage":
+            suggest = "actionable_message"
+        elif key == "filePath":
+            suggest = "file_path"
+        elif key == "hResult":
+            suggest = "h_result"
+        elif key == "lineNumber":
+            suggest = "line_number"
+        elif key == "stackTrace":
+            suggest = "stack_trace"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ReportableExceptionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ReportableExceptionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ReportableExceptionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 actionable_message: Optional[builtins.str] = None,
+                 file_path: Optional[builtins.str] = None,
+                 h_result: Optional[builtins.int] = None,
+                 line_number: Optional[builtins.str] = None,
+                 message: Optional[builtins.str] = None,
+                 stack_trace: Optional[builtins.str] = None):
         """
-        Name of the database
+        Exception object for all custom exceptions
+        :param builtins.str actionable_message: Actionable steps for this exception
+        :param builtins.str file_path: The path to the file where exception occurred
+        :param builtins.int h_result: Coded numerical value that is assigned to a specific exception
+        :param builtins.str line_number: The line number where exception occurred
+        :param builtins.str message: Error message
+        :param builtins.str stack_trace: Stack trace
         """
-        return pulumi.get(self, "database_name")
+        if actionable_message is not None:
+            pulumi.set(__self__, "actionable_message", actionable_message)
+        if file_path is not None:
+            pulumi.set(__self__, "file_path", file_path)
+        if h_result is not None:
+            pulumi.set(__self__, "h_result", h_result)
+        if line_number is not None:
+            pulumi.set(__self__, "line_number", line_number)
+        if message is not None:
+            pulumi.set(__self__, "message", message)
+        if stack_trace is not None:
+            pulumi.set(__self__, "stack_trace", stack_trace)
 
     @property
-    @pulumi.getter(name="encryptConnection")
-    def encrypt_connection(self) -> Optional[builtins.bool]:
+    @pulumi.getter(name="actionableMessage")
+    def actionable_message(self) -> Optional[builtins.str]:
         """
-        Whether to encrypt the connection
+        Actionable steps for this exception
         """
-        return pulumi.get(self, "encrypt_connection")
+        return pulumi.get(self, "actionable_message")
 
     @property
-    @pulumi.getter
-    def password(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="filePath")
+    def file_path(self) -> Optional[builtins.str]:
         """
-        Password credential.
+        The path to the file where exception occurred
         """
-        return pulumi.get(self, "password")
+        return pulumi.get(self, "file_path")
 
     @property
-    @pulumi.getter(name="serverBrandVersion")
-    def server_brand_version(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="hResult")
+    def h_result(self) -> Optional[builtins.int]:
         """
-        server brand version
+        Coded numerical value that is assigned to a specific exception
         """
-        return pulumi.get(self, "server_brand_version")
+        return pulumi.get(self, "h_result")
 
     @property
-    @pulumi.getter(name="serverVersion")
-    def server_version(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="lineNumber")
+    def line_number(self) -> Optional[builtins.str]:
         """
-        server version
+        The line number where exception occurred
         """
-        return pulumi.get(self, "server_version")
+        return pulumi.get(self, "line_number")
 
     @property
-    @pulumi.getter(name="trustServerCertificate")
-    def trust_server_certificate(self) -> Optional[builtins.bool]:
+    @pulumi.getter
+    def message(self) -> Optional[builtins.str]:
         """
-        Whether to trust the server certificate
+        Error message
         """
-        return pulumi.get(self, "trust_server_certificate")
+        return pulumi.get(self, "message")
 
     @property
-    @pulumi.getter(name="userName")
-    def user_name(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="stackTrace")
+    def stack_trace(self) -> Optional[builtins.str]:
         """
-        User name
+        Stack trace
         """
-        return pulumi.get(self, "user_name")
+        return pulumi.get(self, "stack_trace")
 
 
 @pulumi.output_type
-class ProjectFilePropertiesResponse(dict):
+class SchemaComparisonValidationResultResponse(dict):
     """
-    Base class for file properties.
+    Results for schema comparison between the source and target
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "lastModified":
-            suggest = "last_modified"
-        elif key == "filePath":
-            suggest = "file_path"
-        elif key == "mediaType":
-            suggest = "media_type"
+        if key == "schemaDifferences":
+            suggest = "schema_differences"
+        elif key == "sourceDatabaseObjectCount":
+            suggest = "source_database_object_count"
+        elif key == "targetDatabaseObjectCount":
+            suggest = "target_database_object_count"
+        elif key == "validationErrors":
+            suggest = "validation_errors"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ProjectFilePropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in SchemaComparisonValidationResultResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        ProjectFilePropertiesResponse.__key_warning(key)
+        SchemaComparisonValidationResultResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        ProjectFilePropertiesResponse.__key_warning(key)
+        SchemaComparisonValidationResultResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 last_modified: builtins.str,
-                 size: builtins.float,
-                 extension: Optional[builtins.str] = None,
-                 file_path: Optional[builtins.str] = None,
-                 media_type: Optional[builtins.str] = None):
-        """
-        Base class for file properties.
-        :param builtins.str last_modified: Modification DateTime.
-        :param builtins.float size: File size.
-        :param builtins.str extension: Optional File extension. If submitted it should not have a leading period and must match the extension from filePath.
-        :param builtins.str file_path: Relative path of this file resource. This property can be set when creating or updating the file resource.
-        :param builtins.str media_type: File content type. This property can be modified to reflect the file content type.
-        """
-        pulumi.set(__self__, "last_modified", last_modified)
-        pulumi.set(__self__, "size", size)
-        if extension is not None:
-            pulumi.set(__self__, "extension", extension)
-        if file_path is not None:
-            pulumi.set(__self__, "file_path", file_path)
-        if media_type is not None:
-            pulumi.set(__self__, "media_type", media_type)
-
-    @property
-    @pulumi.getter(name="lastModified")
-    def last_modified(self) -> builtins.str:
+                 schema_differences: Optional['outputs.SchemaComparisonValidationResultTypeResponse'] = None,
+                 source_database_object_count: Optional[Mapping[str, builtins.float]] = None,
+                 target_database_object_count: Optional[Mapping[str, builtins.float]] = None,
+                 validation_errors: Optional['outputs.ValidationErrorResponse'] = None):
         """
-        Modification DateTime.
+        Results for schema comparison between the source and target
+        :param 'SchemaComparisonValidationResultTypeResponse' schema_differences: List of schema differences between the source and target databases
+        :param Mapping[str, builtins.float] source_database_object_count: Count of source database objects
+        :param Mapping[str, builtins.float] target_database_object_count: Count of target database objects
+        :param 'ValidationErrorResponse' validation_errors: List of errors that happened while performing schema compare validation
         """
-        return pulumi.get(self, "last_modified")
+        if schema_differences is not None:
+            pulumi.set(__self__, "schema_differences", schema_differences)
+        if source_database_object_count is not None:
+            pulumi.set(__self__, "source_database_object_count", source_database_object_count)
+        if target_database_object_count is not None:
+            pulumi.set(__self__, "target_database_object_count", target_database_object_count)
+        if validation_errors is not None:
+            pulumi.set(__self__, "validation_errors", validation_errors)
 
     @property
-    @pulumi.getter
-    def size(self) -> builtins.float:
+    @pulumi.getter(name="schemaDifferences")
+    def schema_differences(self) -> Optional['outputs.SchemaComparisonValidationResultTypeResponse']:
         """
-        File size.
+        List of schema differences between the source and target databases
         """
-        return pulumi.get(self, "size")
+        return pulumi.get(self, "schema_differences")
 
     @property
-    @pulumi.getter
-    def extension(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="sourceDatabaseObjectCount")
+    def source_database_object_count(self) -> Optional[Mapping[str, builtins.float]]:
         """
-        Optional File extension. If submitted it should not have a leading period and must match the extension from filePath.
+        Count of source database objects
         """
-        return pulumi.get(self, "extension")
+        return pulumi.get(self, "source_database_object_count")
 
     @property
-    @pulumi.getter(name="filePath")
-    def file_path(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="targetDatabaseObjectCount")
+    def target_database_object_count(self) -> Optional[Mapping[str, builtins.float]]:
         """
-        Relative path of this file resource. This property can be set when creating or updating the file resource.
+        Count of target database objects
         """
-        return pulumi.get(self, "file_path")
+        return pulumi.get(self, "target_database_object_count")
 
     @property
-    @pulumi.getter(name="mediaType")
-    def media_type(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="validationErrors")
+    def validation_errors(self) -> Optional['outputs.ValidationErrorResponse']:
         """
-        File content type. This property can be modified to reflect the file content type.
+        List of errors that happened while performing schema compare validation
         """
-        return pulumi.get(self, "media_type")
+        return pulumi.get(self, "validation_errors")
 
 
 @pulumi.output_type
-class QueryAnalysisValidationResultResponse(dict):
+class SchemaComparisonValidationResultTypeResponse(dict):
     """
-    Results for query analysis comparison between the source and target
+    Description about the errors happen while performing migration validation
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "queryResults":
-            suggest = "query_results"
-        elif key == "validationErrors":
-            suggest = "validation_errors"
+        if key == "objectName":
+            suggest = "object_name"
+        elif key == "objectType":
+            suggest = "object_type"
+        elif key == "updateAction":
+            suggest = "update_action"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in QueryAnalysisValidationResultResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in SchemaComparisonValidationResultTypeResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        QueryAnalysisValidationResultResponse.__key_warning(key)
+        SchemaComparisonValidationResultTypeResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        QueryAnalysisValidationResultResponse.__key_warning(key)
+        SchemaComparisonValidationResultTypeResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 query_results: Optional['outputs.QueryExecutionResultResponse'] = None,
-                 validation_errors: Optional['outputs.ValidationErrorResponse'] = None):
+                 object_name: Optional[builtins.str] = None,
+                 object_type: Optional[builtins.str] = None,
+                 update_action: Optional[builtins.str] = None):
         """
-        Results for query analysis comparison between the source and target
-        :param 'QueryExecutionResultResponse' query_results: List of queries executed and it's execution results in source and target
-        :param 'ValidationErrorResponse' validation_errors: Errors that are part of the execution
+        Description about the errors happen while performing migration validation
+        :param builtins.str object_name: Name of the object that has the difference
+        :param builtins.str object_type: Type of the object that has the difference. e.g (Table/View/StoredProcedure)
+        :param builtins.str update_action: Update action type with respect to target
         """
-        if query_results is not None:
-            pulumi.set(__self__, "query_results", query_results)
-        if validation_errors is not None:
-            pulumi.set(__self__, "validation_errors", validation_errors)
+        if object_name is not None:
+            pulumi.set(__self__, "object_name", object_name)
+        if object_type is not None:
+            pulumi.set(__self__, "object_type", object_type)
+        if update_action is not None:
+            pulumi.set(__self__, "update_action", update_action)
 
     @property
-    @pulumi.getter(name="queryResults")
-    def query_results(self) -> Optional['outputs.QueryExecutionResultResponse']:
+    @pulumi.getter(name="objectName")
+    def object_name(self) -> Optional[builtins.str]:
         """
-        List of queries executed and it's execution results in source and target
+        Name of the object that has the difference
         """
-        return pulumi.get(self, "query_results")
+        return pulumi.get(self, "object_name")
 
     @property
-    @pulumi.getter(name="validationErrors")
-    def validation_errors(self) -> Optional['outputs.ValidationErrorResponse']:
+    @pulumi.getter(name="objectType")
+    def object_type(self) -> Optional[builtins.str]:
         """
-        Errors that are part of the execution
+        Type of the object that has the difference. e.g (Table/View/StoredProcedure)
         """
-        return pulumi.get(self, "validation_errors")
+        return pulumi.get(self, "object_type")
+
+    @property
+    @pulumi.getter(name="updateAction")
+    def update_action(self) -> Optional[builtins.str]:
+        """
+        Update action type with respect to target
+        """
+        return pulumi.get(self, "update_action")
 
 
 @pulumi.output_type
-class QueryExecutionResultResponse(dict):
+class SelectedCertificateInputResponse(dict):
     """
-    Describes query analysis results for execution in source and target
+    Info for certificate to be exported for TDE enabled databases.
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "queryText":
-            suggest = "query_text"
-        elif key == "sourceResult":
-            suggest = "source_result"
-        elif key == "statementsInBatch":
-            suggest = "statements_in_batch"
-        elif key == "targetResult":
-            suggest = "target_result"
+        if key == "certificateName":
+            suggest = "certificate_name"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in QueryExecutionResultResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in SelectedCertificateInputResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        QueryExecutionResultResponse.__key_warning(key)
+        SelectedCertificateInputResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        QueryExecutionResultResponse.__key_warning(key)
+        SelectedCertificateInputResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 query_text: Optional[builtins.str] = None,
-                 source_result: Optional['outputs.ExecutionStatisticsResponse'] = None,
-                 statements_in_batch: Optional[builtins.float] = None,
-                 target_result: Optional['outputs.ExecutionStatisticsResponse'] = None):
-        """
-        Describes query analysis results for execution in source and target
-        :param builtins.str query_text: Query text retrieved from the source server
-        :param 'ExecutionStatisticsResponse' source_result: Query analysis result from the source
-        :param builtins.float statements_in_batch: Total no. of statements in the batch
-        :param 'ExecutionStatisticsResponse' target_result: Query analysis result from the target
-        """
-        if query_text is not None:
-            pulumi.set(__self__, "query_text", query_text)
-        if source_result is not None:
-            pulumi.set(__self__, "source_result", source_result)
-        if statements_in_batch is not None:
-            pulumi.set(__self__, "statements_in_batch", statements_in_batch)
-        if target_result is not None:
-            pulumi.set(__self__, "target_result", target_result)
-
-    @property
-    @pulumi.getter(name="queryText")
-    def query_text(self) -> Optional[builtins.str]:
-        """
-        Query text retrieved from the source server
-        """
-        return pulumi.get(self, "query_text")
-
-    @property
-    @pulumi.getter(name="sourceResult")
-    def source_result(self) -> Optional['outputs.ExecutionStatisticsResponse']:
+                 certificate_name: builtins.str,
+                 password: builtins.str):
         """
-        Query analysis result from the source
+        Info for certificate to be exported for TDE enabled databases.
+        :param builtins.str certificate_name: Name of certificate to be exported.
+        :param builtins.str password: Password to use for encrypting the exported certificate.
         """
-        return pulumi.get(self, "source_result")
+        pulumi.set(__self__, "certificate_name", certificate_name)
+        pulumi.set(__self__, "password", password)
 
     @property
-    @pulumi.getter(name="statementsInBatch")
-    def statements_in_batch(self) -> Optional[builtins.float]:
+    @pulumi.getter(name="certificateName")
+    def certificate_name(self) -> builtins.str:
         """
-        Total no. of statements in the batch
+        Name of certificate to be exported.
         """
-        return pulumi.get(self, "statements_in_batch")
+        return pulumi.get(self, "certificate_name")
 
     @property
-    @pulumi.getter(name="targetResult")
-    def target_result(self) -> Optional['outputs.ExecutionStatisticsResponse']:
+    @pulumi.getter
+    def password(self) -> builtins.str:
         """
-        Query analysis result from the target
+        Password to use for encrypting the exported certificate.
         """
-        return pulumi.get(self, "target_result")
+        return pulumi.get(self, "password")
 
 
 @pulumi.output_type
-class ReportableExceptionResponse(dict):
+class ServerPropertiesResponse(dict):
     """
-    Exception object for all custom exceptions
+    Server properties for MySQL type source
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "actionableMessage":
-            suggest = "actionable_message"
-        elif key == "filePath":
-            suggest = "file_path"
-        elif key == "hResult":
-            suggest = "h_result"
-        elif key == "lineNumber":
-            suggest = "line_number"
-        elif key == "stackTrace":
-            suggest = "stack_trace"
+        if key == "serverDatabaseCount":
+            suggest = "server_database_count"
+        elif key == "serverEdition":
+            suggest = "server_edition"
+        elif key == "serverName":
+            suggest = "server_name"
+        elif key == "serverOperatingSystemVersion":
+            suggest = "server_operating_system_version"
+        elif key == "serverPlatform":
+            suggest = "server_platform"
+        elif key == "serverVersion":
+            suggest = "server_version"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ReportableExceptionResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in ServerPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        ReportableExceptionResponse.__key_warning(key)
+        ServerPropertiesResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        ReportableExceptionResponse.__key_warning(key)
+        ServerPropertiesResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 actionable_message: Optional[builtins.str] = None,
-                 file_path: Optional[builtins.str] = None,
-                 h_result: Optional[builtins.int] = None,
-                 line_number: Optional[builtins.str] = None,
-                 message: Optional[builtins.str] = None,
-                 stack_trace: Optional[builtins.str] = None):
+                 server_database_count: builtins.int,
+                 server_edition: builtins.str,
+                 server_name: builtins.str,
+                 server_operating_system_version: builtins.str,
+                 server_platform: builtins.str,
+                 server_version: builtins.str):
         """
-        Exception object for all custom exceptions
-        :param builtins.str actionable_message: Actionable steps for this exception
-        :param builtins.str file_path: The path to the file where exception occurred
-        :param builtins.int h_result: Coded numerical value that is assigned to a specific exception
-        :param builtins.str line_number: The line number where exception occurred
-        :param builtins.str message: Error message
-        :param builtins.str stack_trace: Stack trace
+        Server properties for MySQL type source
+        :param builtins.int server_database_count: Number of databases in the server
+        :param builtins.str server_edition: Edition of the database server
+        :param builtins.str server_name: Name of the server
+        :param builtins.str server_operating_system_version: Version of the operating system
+        :param builtins.str server_platform: Name of the server platform
+        :param builtins.str server_version: Version of the database server
         """
-        if actionable_message is not None:
-            pulumi.set(__self__, "actionable_message", actionable_message)
-        if file_path is not None:
-            pulumi.set(__self__, "file_path", file_path)
-        if h_result is not None:
-            pulumi.set(__self__, "h_result", h_result)
-        if line_number is not None:
-            pulumi.set(__self__, "line_number", line_number)
-        if message is not None:
-            pulumi.set(__self__, "message", message)
-        if stack_trace is not None:
-            pulumi.set(__self__, "stack_trace", stack_trace)
+        pulumi.set(__self__, "server_database_count", server_database_count)
+        pulumi.set(__self__, "server_edition", server_edition)
+        pulumi.set(__self__, "server_name", server_name)
+        pulumi.set(__self__, "server_operating_system_version", server_operating_system_version)
+        pulumi.set(__self__, "server_platform", server_platform)
+        pulumi.set(__self__, "server_version", server_version)
 
     @property
-    @pulumi.getter(name="actionableMessage")
-    def actionable_message(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="serverDatabaseCount")
+    def server_database_count(self) -> builtins.int:
         """
-        Actionable steps for this exception
+        Number of databases in the server
         """
-        return pulumi.get(self, "actionable_message")
+        return pulumi.get(self, "server_database_count")
 
     @property
-    @pulumi.getter(name="filePath")
-    def file_path(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="serverEdition")
+    def server_edition(self) -> builtins.str:
         """
-        The path to the file where exception occurred
+        Edition of the database server
         """
-        return pulumi.get(self, "file_path")
+        return pulumi.get(self, "server_edition")
 
     @property
-    @pulumi.getter(name="hResult")
-    def h_result(self) -> Optional[builtins.int]:
+    @pulumi.getter(name="serverName")
+    def server_name(self) -> builtins.str:
         """
-        Coded numerical value that is assigned to a specific exception
+        Name of the server
         """
-        return pulumi.get(self, "h_result")
+        return pulumi.get(self, "server_name")
 
     @property
-    @pulumi.getter(name="lineNumber")
-    def line_number(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="serverOperatingSystemVersion")
+    def server_operating_system_version(self) -> builtins.str:
         """
-        The line number where exception occurred
+        Version of the operating system
         """
-        return pulumi.get(self, "line_number")
+        return pulumi.get(self, "server_operating_system_version")
 
     @property
-    @pulumi.getter
-    def message(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="serverPlatform")
+    def server_platform(self) -> builtins.str:
         """
-        Error message
+        Name of the server platform
         """
-        return pulumi.get(self, "message")
+        return pulumi.get(self, "server_platform")
 
     @property
-    @pulumi.getter(name="stackTrace")
-    def stack_trace(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="serverVersion")
+    def server_version(self) -> builtins.str:
         """
-        Stack trace
+        Version of the database server
         """
-        return pulumi.get(self, "stack_trace")
+        return pulumi.get(self, "server_version")
 
 
 @pulumi.output_type
-class SchemaComparisonValidationResultResponse(dict):
+class ServiceSkuResponse(dict):
     """
-    Results for schema comparison between the source and target
+    An Azure SKU instance
     """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "schemaDifferences":
-            suggest = "schema_differences"
-        elif key == "sourceDatabaseObjectCount":
-            suggest = "source_database_object_count"
-        elif key == "targetDatabaseObjectCount":
-            suggest = "target_database_object_count"
-        elif key == "validationErrors":
-            suggest = "validation_errors"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in SchemaComparisonValidationResultResponse. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        SchemaComparisonValidationResultResponse.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        SchemaComparisonValidationResultResponse.__key_warning(key)
-        return super().get(key, default)
-
     def __init__(__self__, *,
-                 schema_differences: Optional['outputs.SchemaComparisonValidationResultTypeResponse'] = None,
-                 source_database_object_count: Optional[Mapping[str, builtins.float]] = None,
-                 target_database_object_count: Optional[Mapping[str, builtins.float]] = None,
-                 validation_errors: Optional['outputs.ValidationErrorResponse'] = None):
+                 capacity: Optional[builtins.int] = None,
+                 family: Optional[builtins.str] = None,
+                 name: Optional[builtins.str] = None,
+                 size: Optional[builtins.str] = None,
+                 tier: Optional[builtins.str] = None):
         """
-        Results for schema comparison between the source and target
-        :param 'SchemaComparisonValidationResultTypeResponse' schema_differences: List of schema differences between the source and target databases
-        :param Mapping[str, builtins.float] source_database_object_count: Count of source database objects
-        :param Mapping[str, builtins.float] target_database_object_count: Count of target database objects
-        :param 'ValidationErrorResponse' validation_errors: List of errors that happened while performing schema compare validation
+        An Azure SKU instance
+        :param builtins.int capacity: The capacity of the SKU, if it supports scaling
+        :param builtins.str family: The SKU family, used when the service has multiple performance classes within a tier, such as 'A', 'D', etc. for virtual machines
+        :param builtins.str name: The unique name of the SKU, such as 'P3'
+        :param builtins.str size: The size of the SKU, used when the name alone does not denote a service size or when a SKU has multiple performance classes within a family, e.g. 'A1' for virtual machines
+        :param builtins.str tier: The tier of the SKU, such as 'Basic', 'General Purpose', or 'Business Critical'
         """
-        if schema_differences is not None:
-            pulumi.set(__self__, "schema_differences", schema_differences)
-        if source_database_object_count is not None:
-            pulumi.set(__self__, "source_database_object_count", source_database_object_count)
-        if target_database_object_count is not None:
-            pulumi.set(__self__, "target_database_object_count", target_database_object_count)
-        if validation_errors is not None:
-            pulumi.set(__self__, "validation_errors", validation_errors)
+        if capacity is not None:
+            pulumi.set(__self__, "capacity", capacity)
+        if family is not None:
+            pulumi.set(__self__, "family", family)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if size is not None:
+            pulumi.set(__self__, "size", size)
+        if tier is not None:
+            pulumi.set(__self__, "tier", tier)
 
     @property
-    @pulumi.getter(name="schemaDifferences")
-    def schema_differences(self) -> Optional['outputs.SchemaComparisonValidationResultTypeResponse']:
+    @pulumi.getter
+    def capacity(self) -> Optional[builtins.int]:
         """
-        List of schema differences between the source and target databases
+        The capacity of the SKU, if it supports scaling
         """
-        return pulumi.get(self, "schema_differences")
+        return pulumi.get(self, "capacity")
 
     @property
-    @pulumi.getter(name="sourceDatabaseObjectCount")
-    def source_database_object_count(self) -> Optional[Mapping[str, builtins.float]]:
+    @pulumi.getter
+    def family(self) -> Optional[builtins.str]:
         """
-        Count of source database objects
+        The SKU family, used when the service has multiple performance classes within a tier, such as 'A', 'D', etc. for virtual machines
         """
-        return pulumi.get(self, "source_database_object_count")
+        return pulumi.get(self, "family")
 
     @property
-    @pulumi.getter(name="targetDatabaseObjectCount")
-    def target_database_object_count(self) -> Optional[Mapping[str, builtins.float]]:
+    @pulumi.getter
+    def name(self) -> Optional[builtins.str]:
         """
-        Count of target database objects
+        The unique name of the SKU, such as 'P3'
         """
-        return pulumi.get(self, "target_database_object_count")
+        return pulumi.get(self, "name")
 
     @property
-    @pulumi.getter(name="validationErrors")
-    def validation_errors(self) -> Optional['outputs.ValidationErrorResponse']:
+    @pulumi.getter
+    def size(self) -> Optional[builtins.str]:
         """
-        List of errors that happened while performing schema compare validation
+        The size of the SKU, used when the name alone does not denote a service size or when a SKU has multiple performance classes within a family, e.g. 'A1' for virtual machines
         """
-        return pulumi.get(self, "validation_errors")
+        return pulumi.get(self, "size")
+
+    @property
+    @pulumi.getter
+    def tier(self) -> Optional[builtins.str]:
+        """
+        The tier of the SKU, such as 'Basic', 'General Purpose', or 'Business Critical'
+        """
+        return pulumi.get(self, "tier")
 
 
 @pulumi.output_type
-class SchemaComparisonValidationResultTypeResponse(dict):
+class SourceLocationResponse(dict):
     """
-    Description about the errors happen while performing migration validation
+    Source Location details of backups.
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "objectName":
-            suggest = "object_name"
-        elif key == "objectType":
-            suggest = "object_type"
-        elif key == "updateAction":
-            suggest = "update_action"
+        if key == "fileStorageType":
+            suggest = "file_storage_type"
+        elif key == "azureBlob":
+            suggest = "azure_blob"
+        elif key == "fileShare":
+            suggest = "file_share"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in SchemaComparisonValidationResultTypeResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in SourceLocationResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        SchemaComparisonValidationResultTypeResponse.__key_warning(key)
+        SourceLocationResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        SchemaComparisonValidationResultTypeResponse.__key_warning(key)
+        SourceLocationResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 object_name: Optional[builtins.str] = None,
-                 object_type: Optional[builtins.str] = None,
-                 update_action: Optional[builtins.str] = None):
+                 file_storage_type: builtins.str,
+                 azure_blob: Optional['outputs.AzureBlobResponse'] = None,
+                 file_share: Optional['outputs.SqlFileShareResponse'] = None):
         """
-        Description about the errors happen while performing migration validation
-        :param builtins.str object_name: Name of the object that has the difference
-        :param builtins.str object_type: Type of the object that has the difference. e.g (Table/View/StoredProcedure)
-        :param builtins.str update_action: Update action type with respect to target
+        Source Location details of backups.
+        :param builtins.str file_storage_type: Backup storage Type.
+        :param 'AzureBlobResponse' azure_blob: Source Azure Blob.
+        :param 'SqlFileShareResponse' file_share: Source File share.
         """
-        if object_name is not None:
-            pulumi.set(__self__, "object_name", object_name)
-        if object_type is not None:
-            pulumi.set(__self__, "object_type", object_type)
-        if update_action is not None:
-            pulumi.set(__self__, "update_action", update_action)
+        pulumi.set(__self__, "file_storage_type", file_storage_type)
+        if azure_blob is not None:
+            pulumi.set(__self__, "azure_blob", azure_blob)
+        if file_share is not None:
+            pulumi.set(__self__, "file_share", file_share)
 
     @property
-    @pulumi.getter(name="objectName")
-    def object_name(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="fileStorageType")
+    def file_storage_type(self) -> builtins.str:
         """
-        Name of the object that has the difference
+        Backup storage Type.
         """
-        return pulumi.get(self, "object_name")
+        return pulumi.get(self, "file_storage_type")
 
     @property
-    @pulumi.getter(name="objectType")
-    def object_type(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="azureBlob")
+    def azure_blob(self) -> Optional['outputs.AzureBlobResponse']:
         """
-        Type of the object that has the difference. e.g (Table/View/StoredProcedure)
+        Source Azure Blob.
         """
-        return pulumi.get(self, "object_type")
+        return pulumi.get(self, "azure_blob")
 
     @property
-    @pulumi.getter(name="updateAction")
-    def update_action(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="fileShare")
+    def file_share(self) -> Optional['outputs.SqlFileShareResponse']:
         """
-        Update action type with respect to target
+        Source File share.
         """
-        return pulumi.get(self, "update_action")
+        return pulumi.get(self, "file_share")
 
 
 @pulumi.output_type
-class SelectedCertificateInputResponse(dict):
+class SqlBackupFileInfoResponse(dict):
     """
-    Info for certificate to be exported for TDE enabled databases.
+    Information of backup file
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "certificateName":
-            suggest = "certificate_name"
+        if key == "copyDuration":
+            suggest = "copy_duration"
+        elif key == "copyThroughput":
+            suggest = "copy_throughput"
+        elif key == "dataRead":
+            suggest = "data_read"
+        elif key == "dataWritten":
+            suggest = "data_written"
+        elif key == "familySequenceNumber":
+            suggest = "family_sequence_number"
+        elif key == "fileName":
+            suggest = "file_name"
+        elif key == "totalSize":
+            suggest = "total_size"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in SelectedCertificateInputResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in SqlBackupFileInfoResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        SelectedCertificateInputResponse.__key_warning(key)
+        SqlBackupFileInfoResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        SelectedCertificateInputResponse.__key_warning(key)
+        SqlBackupFileInfoResponse.__key_warning(key)
         return super().get(key, default)
 
-    def __init__(__self__, *,
-                 certificate_name: builtins.str,
-                 password: builtins.str):
+    def __init__(__self__, *,
+                 copy_duration: builtins.int,
+                 copy_throughput: builtins.float,
+                 data_read: builtins.float,
+                 data_written: builtins.float,
+                 family_sequence_number: builtins.int,
+                 file_name: builtins.str,
+                 status: builtins.str,
+                 total_size: builtins.float):
+        """
+        Information of backup file
+        :param builtins.int copy_duration: Copy Duration in seconds
+        :param builtins.float copy_throughput: Copy throughput in KBps
+        :param builtins.float data_read: Bytes read
+        :param builtins.float data_written: Bytes written
+        :param builtins.int family_sequence_number: Media family sequence number
+        :param builtins.str file_name: File name.
+        :param builtins.str status: Status of the file. (Initial, Uploading, Uploaded, Restoring, Restored or Skipped)
+        :param builtins.float total_size: File size in bytes
+        """
+        pulumi.set(__self__, "copy_duration", copy_duration)
+        pulumi.set(__self__, "copy_throughput", copy_throughput)
+        pulumi.set(__self__, "data_read", data_read)
+        pulumi.set(__self__, "data_written", data_written)
+        pulumi.set(__self__, "family_sequence_number", family_sequence_number)
+        pulumi.set(__self__, "file_name", file_name)
+        pulumi.set(__self__, "status", status)
+        pulumi.set(__self__, "total_size", total_size)
+
+    @property
+    @pulumi.getter(name="copyDuration")
+    def copy_duration(self) -> builtins.int:
+        """
+        Copy Duration in seconds
+        """
+        return pulumi.get(self, "copy_duration")
+
+    @property
+    @pulumi.getter(name="copyThroughput")
+    def copy_throughput(self) -> builtins.float:
+        """
+        Copy throughput in KBps
+        """
+        return pulumi.get(self, "copy_throughput")
+
+    @property
+    @pulumi.getter(name="dataRead")
+    def data_read(self) -> builtins.float:
+        """
+        Bytes read
+        """
+        return pulumi.get(self, "data_read")
+
+    @property
+    @pulumi.getter(name="dataWritten")
+    def data_written(self) -> builtins.float:
+        """
+        Bytes written
+        """
+        return pulumi.get(self, "data_written")
+
+    @property
+    @pulumi.getter(name="familySequenceNumber")
+    def family_sequence_number(self) -> builtins.int:
         """
-        Info for certificate to be exported for TDE enabled databases.
-        :param builtins.str certificate_name: Name of certificate to be exported.
-        :param builtins.str password: Password to use for encrypting the exported certificate.
+        Media family sequence number
         """
-        pulumi.set(__self__, "certificate_name", certificate_name)
-        pulumi.set(__self__, "password", password)
+        return pulumi.get(self, "family_sequence_number")
 
     @property
-    @pulumi.getter(name="certificateName")
-    def certificate_name(self) -> builtins.str:
+    @pulumi.getter(name="fileName")
+    def file_name(self) -> builtins.str:
         """
-        Name of certificate to be exported.
+        File name.
         """
-        return pulumi.get(self, "certificate_name")
+        return pulumi.get(self, "file_name")
 
     @property
     @pulumi.getter
-    def password(self) -> builtins.str:
+    def status(self) -> builtins.str:
         """
-        Password to use for encrypting the exported certificate.
+        Status of the file. (Initial, Uploading, Uploaded, Restoring, Restored or Skipped)
         """
-        return pulumi.get(self, "password")
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="totalSize")
+    def total_size(self) -> builtins.float:
+        """
+        File size in bytes
+        """
+        return pulumi.get(self, "total_size")
 
 
 @pulumi.output_type
-class ServerPropertiesResponse(dict):
+class SqlBackupSetInfoResponse(dict):
     """
-    Server properties for MySQL type source
+    Information of backup set
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "serverDatabaseCount":
-            suggest = "server_database_count"
-        elif key == "serverEdition":
-            suggest = "server_edition"
-        elif key == "serverName":
-            suggest = "server_name"
-        elif key == "serverOperatingSystemVersion":
-            suggest = "server_operating_system_version"
-        elif key == "serverPlatform":
-            suggest = "server_platform"
-        elif key == "serverVersion":
-            suggest = "server_version"
+        if key == "backupFinishDate":
+            suggest = "backup_finish_date"
+        elif key == "backupSetId":
+            suggest = "backup_set_id"
+        elif key == "backupStartDate":
+            suggest = "backup_start_date"
+        elif key == "backupType":
+            suggest = "backup_type"
+        elif key == "familyCount":
+            suggest = "family_count"
+        elif key == "firstLSN":
+            suggest = "first_lsn"
+        elif key == "hasBackupChecksums":
+            suggest = "has_backup_checksums"
+        elif key == "ignoreReasons":
+            suggest = "ignore_reasons"
+        elif key == "isBackupRestored":
+            suggest = "is_backup_restored"
+        elif key == "lastLSN":
+            suggest = "last_lsn"
+        elif key == "listOfBackupFiles":
+            suggest = "list_of_backup_files"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ServerPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in SqlBackupSetInfoResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        ServerPropertiesResponse.__key_warning(key)
+        SqlBackupSetInfoResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        ServerPropertiesResponse.__key_warning(key)
+        SqlBackupSetInfoResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 server_database_count: builtins.int,
-                 server_edition: builtins.str,
-                 server_name: builtins.str,
-                 server_operating_system_version: builtins.str,
-                 server_platform: builtins.str,
-                 server_version: builtins.str):
+                 backup_finish_date: builtins.str,
+                 backup_set_id: builtins.str,
+                 backup_start_date: builtins.str,
+                 backup_type: builtins.str,
+                 family_count: builtins.int,
+                 first_lsn: builtins.str,
+                 has_backup_checksums: builtins.bool,
+                 ignore_reasons: Sequence[builtins.str],
+                 is_backup_restored: builtins.bool,
+                 last_lsn: builtins.str,
+                 list_of_backup_files: Sequence['outputs.SqlBackupFileInfoResponse']):
         """
-        Server properties for MySQL type source
-        :param builtins.int server_database_count: Number of databases in the server
-        :param builtins.str server_edition: Edition of the database server
-        :param builtins.str server_name: Name of the server
-        :param builtins.str server_operating_system_version: Version of the operating system
-        :param builtins.str server_platform: Name of the server platform
-        :param builtins.str server_version: Version of the database server
+        Information of backup set
+        :param builtins.str backup_finish_date: Backup end time.
+        :param builtins.str backup_set_id: Backup set id.
+        :param builtins.str backup_start_date: Backup start date.
+        :param builtins.str backup_type: Backup type.
+        :param builtins.int family_count: Media family count
+        :param builtins.str first_lsn: First LSN of the backup set.
+        :param builtins.bool has_backup_checksums: Has Backup Checksums
+        :param Sequence[builtins.str] ignore_reasons: The reasons why the backup set is ignored
+        :param builtins.bool is_backup_restored: Whether this backup set has been restored or not.
+        :param builtins.str last_lsn: Last LSN of the backup set.
+        :param Sequence['SqlBackupFileInfoResponse'] list_of_backup_files: List of files in the backup set.
         """
-        pulumi.set(__self__, "server_database_count", server_database_count)
-        pulumi.set(__self__, "server_edition", server_edition)
-        pulumi.set(__self__, "server_name", server_name)
-        pulumi.set(__self__, "server_operating_system_version", server_operating_system_version)
-        pulumi.set(__self__, "server_platform", server_platform)
-        pulumi.set(__self__, "server_version", server_version)
+        pulumi.set(__self__, "backup_finish_date", backup_finish_date)
+        pulumi.set(__self__, "backup_set_id", backup_set_id)
+        pulumi.set(__self__, "backup_start_date", backup_start_date)
+        pulumi.set(__self__, "backup_type", backup_type)
+        pulumi.set(__self__, "family_count", family_count)
+        pulumi.set(__self__, "first_lsn", first_lsn)
+        pulumi.set(__self__, "has_backup_checksums", has_backup_checksums)
+        pulumi.set(__self__, "ignore_reasons", ignore_reasons)
+        pulumi.set(__self__, "is_backup_restored", is_backup_restored)
+        pulumi.set(__self__, "last_lsn", last_lsn)
+        pulumi.set(__self__, "list_of_backup_files", list_of_backup_files)
 
     @property
-    @pulumi.getter(name="serverDatabaseCount")
-    def server_database_count(self) -> builtins.int:
+    @pulumi.getter(name="backupFinishDate")
+    def backup_finish_date(self) -> builtins.str:
         """
-        Number of databases in the server
+        Backup end time.
         """
-        return pulumi.get(self, "server_database_count")
+        return pulumi.get(self, "backup_finish_date")
 
     @property
-    @pulumi.getter(name="serverEdition")
-    def server_edition(self) -> builtins.str:
+    @pulumi.getter(name="backupSetId")
+    def backup_set_id(self) -> builtins.str:
         """
-        Edition of the database server
+        Backup set id.
         """
-        return pulumi.get(self, "server_edition")
+        return pulumi.get(self, "backup_set_id")
 
     @property
-    @pulumi.getter(name="serverName")
-    def server_name(self) -> builtins.str:
+    @pulumi.getter(name="backupStartDate")
+    def backup_start_date(self) -> builtins.str:
         """
-        Name of the server
+        Backup start date.
         """
-        return pulumi.get(self, "server_name")
+        return pulumi.get(self, "backup_start_date")
 
     @property
-    @pulumi.getter(name="serverOperatingSystemVersion")
-    def server_operating_system_version(self) -> builtins.str:
+    @pulumi.getter(name="backupType")
+    def backup_type(self) -> builtins.str:
         """
-        Version of the operating system
+        Backup type.
         """
-        return pulumi.get(self, "server_operating_system_version")
+        return pulumi.get(self, "backup_type")
 
     @property
-    @pulumi.getter(name="serverPlatform")
-    def server_platform(self) -> builtins.str:
+    @pulumi.getter(name="familyCount")
+    def family_count(self) -> builtins.int:
         """
-        Name of the server platform
+        Media family count
         """
-        return pulumi.get(self, "server_platform")
+        return pulumi.get(self, "family_count")
 
     @property
-    @pulumi.getter(name="serverVersion")
-    def server_version(self) -> builtins.str:
-        """
-        Version of the database server
-        """
-        return pulumi.get(self, "server_version")
-
-
-@pulumi.output_type
-class ServiceSkuResponse(dict):
-    """
-    An Azure SKU instance
-    """
-    def __init__(__self__, *,
-                 capacity: Optional[builtins.int] = None,
-                 family: Optional[builtins.str] = None,
-                 name: Optional[builtins.str] = None,
-                 size: Optional[builtins.str] = None,
-                 tier: Optional[builtins.str] = None):
+    @pulumi.getter(name="firstLSN")
+    def first_lsn(self) -> builtins.str:
         """
-        An Azure SKU instance
-        :param builtins.int capacity: The capacity of the SKU, if it supports scaling
-        :param builtins.str family: The SKU family, used when the service has multiple performance classes within a tier, such as 'A', 'D', etc. for virtual machines
-        :param builtins.str name: The unique name of the SKU, such as 'P3'
-        :param builtins.str size: The size of the SKU, used when the name alone does not denote a service size or when a SKU has multiple performance classes within a family, e.g. 'A1' for virtual machines
-        :param builtins.str tier: The tier of the SKU, such as 'Basic', 'General Purpose', or 'Business Critical'
+        First LSN of the backup set.
         """
-        if capacity is not None:
-            pulumi.set(__self__, "capacity", capacity)
-        if family is not None:
-            pulumi.set(__self__, "family", family)
-        if name is not None:
-            pulumi.set(__self__, "name", name)
-        if size is not None:
-            pulumi.set(__self__, "size", size)
-        if tier is not None:
-            pulumi.set(__self__, "tier", tier)
+        return pulumi.get(self, "first_lsn")
 
     @property
-    @pulumi.getter
-    def capacity(self) -> Optional[builtins.int]:
+    @pulumi.getter(name="hasBackupChecksums")
+    def has_backup_checksums(self) -> builtins.bool:
         """
-        The capacity of the SKU, if it supports scaling
+        Has Backup Checksums
         """
-        return pulumi.get(self, "capacity")
+        return pulumi.get(self, "has_backup_checksums")
 
     @property
-    @pulumi.getter
-    def family(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="ignoreReasons")
+    def ignore_reasons(self) -> Sequence[builtins.str]:
         """
-        The SKU family, used when the service has multiple performance classes within a tier, such as 'A', 'D', etc. for virtual machines
+        The reasons why the backup set is ignored
         """
-        return pulumi.get(self, "family")
+        return pulumi.get(self, "ignore_reasons")
 
     @property
-    @pulumi.getter
-    def name(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="isBackupRestored")
+    def is_backup_restored(self) -> builtins.bool:
         """
-        The unique name of the SKU, such as 'P3'
+        Whether this backup set has been restored or not.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "is_backup_restored")
 
     @property
-    @pulumi.getter
-    def size(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="lastLSN")
+    def last_lsn(self) -> builtins.str:
         """
-        The size of the SKU, used when the name alone does not denote a service size or when a SKU has multiple performance classes within a family, e.g. 'A1' for virtual machines
+        Last LSN of the backup set.
         """
-        return pulumi.get(self, "size")
+        return pulumi.get(self, "last_lsn")
 
     @property
-    @pulumi.getter
-    def tier(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="listOfBackupFiles")
+    def list_of_backup_files(self) -> Sequence['outputs.SqlBackupFileInfoResponse']:
         """
-        The tier of the SKU, such as 'Basic', 'General Purpose', or 'Business Critical'
+        List of files in the backup set.
         """
-        return pulumi.get(self, "tier")
+        return pulumi.get(self, "list_of_backup_files")
 
 
 @pulumi.output_type
@@ -20290,6 +21647,41 @@ class SqlDbOfflineConfigurationResponse(dict):
         return pulumi.get(self, "offline")
 
 
+@pulumi.output_type
+class SqlFileShareResponse(dict):
+    """
+    File share
+    """
+    def __init__(__self__, *,
+                 path: Optional[builtins.str] = None,
+                 username: Optional[builtins.str] = None):
+        """
+        File share
+        :param builtins.str path: Location as SMB share or local drive where backups are placed.
+        :param builtins.str username: Username to access the file share location for backups.
+        """
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if username is not None:
+            pulumi.set(__self__, "username", username)
+
+    @property
+    @pulumi.getter
+    def path(self) -> Optional[builtins.str]:
+        """
+        Location as SMB share or local drive where backups are placed.
+        """
+        return pulumi.get(self, "path")
+
+    @property
+    @pulumi.getter
+    def username(self) -> Optional[builtins.str]:
+        """
+        Username to access the file share location for backups.
+        """
+        return pulumi.get(self, "username")
+
+
 @pulumi.output_type
 class SsisMigrationInfoResponse(dict):
     """
@@ -20564,6 +21956,112 @@ class SystemDataResponse(dict):
         return pulumi.get(self, "last_modified_by_type")
 
 
+@pulumi.output_type
+class TargetLocationResponse(dict):
+    """
+    Target Location details for optional copy of backups
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "accountKey":
+            suggest = "account_key"
+        elif key == "storageAccountResourceId":
+            suggest = "storage_account_resource_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TargetLocationResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TargetLocationResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TargetLocationResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 account_key: Optional[builtins.str] = None,
+                 storage_account_resource_id: Optional[builtins.str] = None):
+        """
+        Target Location details for optional copy of backups
+        :param builtins.str account_key: Storage Account Key.
+        :param builtins.str storage_account_resource_id: Resource Id of the storage account copying backups.
+        """
+        if account_key is not None:
+            pulumi.set(__self__, "account_key", account_key)
+        if storage_account_resource_id is not None:
+            pulumi.set(__self__, "storage_account_resource_id", storage_account_resource_id)
+
+    @property
+    @pulumi.getter(name="accountKey")
+    def account_key(self) -> Optional[builtins.str]:
+        """
+        Storage Account Key.
+        """
+        return pulumi.get(self, "account_key")
+
+    @property
+    @pulumi.getter(name="storageAccountResourceId")
+    def storage_account_resource_id(self) -> Optional[builtins.str]:
+        """
+        Resource Id of the storage account copying backups.
+        """
+        return pulumi.get(self, "storage_account_resource_id")
+
+
+@pulumi.output_type
+class UserAssignedIdentityResponse(dict):
+    """
+    User assigned identity properties
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "clientId":
+            suggest = "client_id"
+        elif key == "principalId":
+            suggest = "principal_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in UserAssignedIdentityResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        UserAssignedIdentityResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        UserAssignedIdentityResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 client_id: builtins.str,
+                 principal_id: builtins.str):
+        """
+        User assigned identity properties
+        :param builtins.str client_id: The client ID of the assigned identity.
+        :param builtins.str principal_id: The principal ID of the assigned identity.
+        """
+        pulumi.set(__self__, "client_id", client_id)
+        pulumi.set(__self__, "principal_id", principal_id)
+
+    @property
+    @pulumi.getter(name="clientId")
+    def client_id(self) -> builtins.str:
+        """
+        The client ID of the assigned identity.
+        """
+        return pulumi.get(self, "client_id")
+
+    @property
+    @pulumi.getter(name="principalId")
+    def principal_id(self) -> builtins.str:
+        """
+        The principal ID of the assigned identity.
+        """
+        return pulumi.get(self, "principal_id")
+
+
 @pulumi.output_type
 class ValidateMigrationInputSqlServerSqlDbSyncTaskPropertiesResponse(dict):
     """