Expand description
Data structures used by operation inputs/outputs.
Modules§
Structs§
- Analyzable
Server Summary - Summary information about an analyzable server.
- Antipattern
Report Result The anti-pattern report result.
- Antipattern
Severity Summary Contains the summary of anti-patterns and their severity.
- AppUnit
Error Error in the analysis of the application unit.
- Application
Component Detail Contains detailed information about an application component.
- Application
Component Status Summary Summary of the analysis status of the application component.
- Application
Component Strategy Contains information about a strategy recommendation for an application component.
- Application
Component Summary Contains the summary of application components.
- Application
Preferences Application preferences that you specify.
- Assessment
Summary Contains the summary of the assessment results.
- Assessment
Target Defines the criteria of assessment.
- Associated
Application Object containing details about applications as defined in Application Discovery Service.
- AwsManaged
Resources Object containing the choice of application destination that you specify.
- Business
Goals Business goals that you specify.
- Collector
Process data collector that runs in the environment that you specify.
- Configuration
Summary Summary of the collector configuration.
- Data
Collection Details Detailed information about an assessment.
- Database
Config Detail Configuration information used for assessing databases.
- Database
Preferences 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.
- Import
File Task Information Information about the import file tasks you request.
- IpAddress
Based Remote Info IP address based configurations.
- Network
Info Information about the server's network for which the assessment was run.
- NoDatabase
Migration Preference The object containing details about database migration preferences, when you have no particular preference.
- NoManagement
Preference Object containing the choice of application destination that you specify.
- OsInfo
Information about the operating system.
- Pipeline
Info Detailed information of the pipeline.
- Prioritize
Business Goals Rank of business goals based on priority.
- Recommendation
Report Details Contains detailed information about a recommendation report.
- Recommendation
Set Contains a recommendation set.
- Remote
Source Code Analysis Server Info 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.
- Self
Manage Resources Self-managed resources.
- Server
Detail Detailed information about a server.
- Server
Error The error in server analysis.
- Server
Status Summary The status summary of the server analysis.
- Server
Strategy Contains information about a strategy recommendation for a server.
- Server
Summary Object containing details about the servers imported by Application Discovery Service
- Source
Code Object containing source code information that is linked to an application component.
- Source
Code Repository Object containing source code information that is linked to an application component.
- Strategy
Option Information about all the available strategy options for migrating and modernizing an application component.
- Strategy
Summary Object containing the summary of the strategy recommendations.
- System
Info Information about the server that hosts application components.
- Transformation
Tool Information of the transformation tool that can be used to migrate and modernize the application.
- Vcenter
Based Remote Info Details about the server in vCenter.
- Version
Control Info Details about the version control configuration.
Enums§
- Analysis
Status Union A combination of existing analysis statuses.
- Analysis
Type - 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. - Analyzer
Name Union The combination of the existing analyzers.
- Antipattern
Report Status - 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. - AppUnit
Error Category - 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. - Application
Component Criteria - 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. - Application
Mode - 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. - Assessment
Data Source Type - 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. - Assessment
Status - 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. - Auth
Type - 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. - AwsManaged
Target Destination - 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. - Binary
Analyzer Name - 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. - Collector
Health - 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. - Data
Source Type - 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. - Database
Management Preference - 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. - Database
Migration Preference Preferences for migrating a database to AWS.
- Group
Name - 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. - Heterogeneous
Target Database Engine - 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. - Homogeneous
Target Database Engine - 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. - Import
File Task Status - 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. - Inclusion
Status - 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. - Management
Preference Preferences for migrating an application to AWS.
- NoPreference
Target Destination - 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. - Output
Format - 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. - Pipeline
Type - 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. - Recommendation
Report Status - 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. - Resource
SubType - 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. - RunTime
Analyzer Name - 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. - RunTime
Assessment Status - 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. - Runtime
Analysis Status - 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. - Self
Manage Target Destination - 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. - Server
Criteria - 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. - Server
Error Category - 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. - Server
OsType - 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. - Sort
Order - 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. - Source
Code Analyzer Name - 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. - SrcCode
OrDb Analysis Status - 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. - Strategy
Recommendation - 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. - Target
Database Engine - 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. - Target
Destination - 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. - Transformation
Tool Name - 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. - Version
Control - 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. - Version
Control Type - 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.