Module aws_sdk_migrationhubstrategy::types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that Migration Hub Strategy Recommendations can respond with.

Structs

• AnalyzableServerSummary
  Summary information about an analyzable server.
• AntipatternReportResult

  The anti-pattern report result.

• AntipatternSeveritySummary

  Contains the summary of anti-patterns and their severity.

• AppUnitError

  Error in the analysis of the application unit.

• ApplicationComponentDetail

  Contains detailed information about an application component.

• ApplicationComponentStatusSummary

  Summary of the analysis status of the application component.

• ApplicationComponentStrategy

  Contains information about a strategy recommendation for an application component.

• ApplicationComponentSummary

  Contains the summary of application components.

• ApplicationPreferences

  Application preferences that you specify.

• AssessmentSummary

  Contains the summary of the assessment results.

• AssessmentTarget

  Defines the criteria of assessment.

• AssociatedApplication

  Object containing details about applications as defined in Application Discovery Service.

• AwsManagedResources

  Object containing the choice of application destination that you specify.

• BusinessGoals

  Business goals that you specify.

• Collector

  Process data collector that runs in the environment that you specify.

• ConfigurationSummary

  Summary of the collector configuration.

• DataCollectionDetails

  Detailed information about an assessment.

• DatabaseConfigDetail

  Configuration information used for assessing databases.

• DatabasePreferences

  Preferences on managing your databases on AWS.

• Group

  The object containing information about distinct imports or groups for Strategy Recommendations.

• Heterogeneous

  The object containing details about heterogeneous database preferences.

• Homogeneous

  The object containing details about homogeneous database preferences.

• ImportFileTaskInformation

  Information about the import file tasks you request.

• IpAddressBasedRemoteInfo

  IP address based configurations.

• NetworkInfo

  Information about the server's network for which the assessment was run.

• NoDatabaseMigrationPreference

  The object containing details about database migration preferences, when you have no particular preference.

• NoManagementPreference

  Object containing the choice of application destination that you specify.

• OsInfo

  Information about the operating system.

• PipelineInfo

  Detailed information of the pipeline.

• PrioritizeBusinessGoals

  Rank of business goals based on priority.

• RecommendationReportDetails

  Contains detailed information about a recommendation report.

• RecommendationSet

  Contains a recommendation set.

• RemoteSourceCodeAnalysisServerInfo

  Information about the server configured for source code analysis.

• Result

  The error in server analysis.

• S3Object

  Contains the S3 bucket name and the Amazon S3 key name.

• SelfManageResources

  Self-managed resources.

• ServerDetail

  Detailed information about a server.

• ServerError

  The error in server analysis.

• ServerStatusSummary

  The status summary of the server analysis.

• ServerStrategy

  Contains information about a strategy recommendation for a server.

• ServerSummary

  Object containing details about the servers imported by Application Discovery Service

• SourceCode

  Object containing source code information that is linked to an application component.

• SourceCodeRepository

  Object containing source code information that is linked to an application component.

• StrategyOption

  Information about all the available strategy options for migrating and modernizing an application component.

• StrategySummary

  Object containing the summary of the strategy recommendations.

• SystemInfo

  Information about the server that hosts application components.

• TransformationTool

  Information of the transformation tool that can be used to migrate and modernize the application.

• VcenterBasedRemoteInfo

  Details about the server in vCenter.

• VersionControlInfo

  Details about the version control configuration.

Enums

• AnalysisStatusUnion

  A combination of existing analysis statuses.

• AnalysisType
  When writing a match expression against AnalysisType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AnalyzerNameUnion

  The combination of the existing analyzers.

• AntipatternReportStatus
  When writing a match expression against AntipatternReportStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AppType
  When writing a match expression against AppType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AppUnitErrorCategory
  When writing a match expression against AppUnitErrorCategory, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ApplicationComponentCriteria
  When writing a match expression against ApplicationComponentCriteria, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ApplicationMode
  When writing a match expression against ApplicationMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AssessmentDataSourceType
  When writing a match expression against AssessmentDataSourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AssessmentStatus
  When writing a match expression against AssessmentStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AuthType
  When writing a match expression against AuthType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AwsManagedTargetDestination
  When writing a match expression against AwsManagedTargetDestination, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• BinaryAnalyzerName
  When writing a match expression against BinaryAnalyzerName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• CollectorHealth
  When writing a match expression against CollectorHealth, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Condition
  When writing a match expression against Condition, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DataSourceType
  When writing a match expression against DataSourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DatabaseManagementPreference
  When writing a match expression against DatabaseManagementPreference, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DatabaseMigrationPreference

  Preferences for migrating a database to AWS.

• GroupName
  When writing a match expression against GroupName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• HeterogeneousTargetDatabaseEngine
  When writing a match expression against HeterogeneousTargetDatabaseEngine, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• HomogeneousTargetDatabaseEngine
  When writing a match expression against HomogeneousTargetDatabaseEngine, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ImportFileTaskStatus
  When writing a match expression against ImportFileTaskStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• InclusionStatus
  When writing a match expression against InclusionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ManagementPreference

  Preferences for migrating an application to AWS.

• NoPreferenceTargetDestination
  When writing a match expression against NoPreferenceTargetDestination, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• OsType
  When writing a match expression against OsType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• OutputFormat
  When writing a match expression against OutputFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• PipelineType
  When writing a match expression against PipelineType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RecommendationReportStatus
  When writing a match expression against RecommendationReportStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ResourceSubType
  When writing a match expression against ResourceSubType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RunTimeAnalyzerName
  When writing a match expression against RunTimeAnalyzerName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RunTimeAssessmentStatus
  When writing a match expression against RunTimeAssessmentStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RuntimeAnalysisStatus
  When writing a match expression against RuntimeAnalysisStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SelfManageTargetDestination
  When writing a match expression against SelfManageTargetDestination, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ServerCriteria
  When writing a match expression against ServerCriteria, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ServerErrorCategory
  When writing a match expression against ServerErrorCategory, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ServerOsType
  When writing a match expression against ServerOsType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Severity
  When writing a match expression against Severity, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SortOrder
  When writing a match expression against SortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SourceCodeAnalyzerName
  When writing a match expression against SourceCodeAnalyzerName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SrcCodeOrDbAnalysisStatus
  When writing a match expression against SrcCodeOrDbAnalysisStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Strategy
  When writing a match expression against Strategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• StrategyRecommendation
  When writing a match expression against StrategyRecommendation, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• TargetDatabaseEngine
  When writing a match expression against TargetDatabaseEngine, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• TargetDestination
  When writing a match expression against TargetDestination, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• TransformationToolName
  When writing a match expression against TransformationToolName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• VersionControl
  When writing a match expression against VersionControl, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• VersionControlType
  When writing a match expression against VersionControlType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.