Module types

Module types 

Source
Expand description

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.