Module types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that AWS Well-Architected Tool can respond with.

Structs

• AccountJiraConfigurationInput

  Account-level: Input for the Jira configuration.

• AccountJiraConfigurationOutput

  Account-level: Output configuration of the Jira integration.

• AdditionalResources

  The choice level additional resources for a custom lens.

  This field does not apply to Amazon Web Services official lenses.

• Answer

  An answer of the question.

• AnswerSummary

  An answer summary of a lens review in a workload.

• BestPractice

  A best practice, or question choice, that has been identified as a risk in this question.

• CheckDetail

  Account details for a Well-Architected best practice in relation to Trusted Advisor checks.

• CheckSummary

  Trusted Advisor check summary.

• Choice

  A choice available to answer question.

• ChoiceAnswer

  A choice that has been answered on a question in your workload.

• ChoiceAnswerSummary

  A choice summary that has been answered on a question in your workload.

• ChoiceContent

  The choice content.

• ChoiceImprovementPlan

  The choice level improvement plan.

• ChoiceUpdate

  A list of choices to be updated.

• ConsolidatedReportMetric

  A metric that contributes to the consolidated report.

• ImprovementSummary

  An improvement summary of a lens review in a workload.

• JiraConfiguration

  Configuration of the Jira integration.

• JiraSelectedQuestionConfiguration

  Selected questions in the workload.

• Lens

  A lens return object.

• LensMetric

  A metric for a particular lens in a workload.

• LensReview

  A lens review of a question.

• LensReviewReport

  A report of a lens review.

• LensReviewSummary

  A lens review summary of a workload.

• LensShareSummary

  A lens share summary return object.

• LensSummary

  A lens summary of a lens.

• LensUpgradeSummary

  Lens upgrade summary return object.

• Milestone

  A milestone return object.

• MilestoneSummary

  A milestone summary return object.

• NotificationSummary

  A notification summary return object.

• PillarDifference

  A pillar difference return object.

• PillarMetric

  A metric for a particular pillar in a lens.

• PillarReviewSummary

  A pillar review summary of a lens review.

• Profile

  A profile.

• ProfileChoice

  The profile choice.

• ProfileNotificationSummary

  The profile notification summary.

• ProfileQuestion

  A profile question.

• ProfileQuestionUpdate

  An update to a profile question.

• ProfileShareSummary

  Summary of a profile share.

• ProfileSummary

  Summary of a profile.

• ProfileTemplate

  The profile template.

• ProfileTemplateChoice

  A profile template choice.

• ProfileTemplateQuestion

  A profile template question.

• QuestionDifference

  A question difference return object.

• QuestionMetric

  A metric for a particular question in the pillar.

• ReviewTemplate

  A review template.

• ReviewTemplateAnswer

  An answer of the question.

• ReviewTemplateAnswerSummary

  The summary of review template answers.

• ReviewTemplateLensReview

  The lens review of a review template.

• ReviewTemplatePillarReviewSummary

  Summary of a review template.

• ReviewTemplateSummary

  Summary of a review template.

• SelectedPillar

  The selected pillar.

• ShareInvitation

  The share invitation.

• ShareInvitationSummary

  A share invitation summary return object.

• TemplateShareSummary

  Summary of a review template share.

• ValidationExceptionField

  Stores information about a field passed inside a request that resulted in an exception.

• VersionDifferences

  The differences between the base and latest versions of the lens.

• Workload

  A workload return object.

• WorkloadDiscoveryConfig

  Discovery configuration associated to the workload.

• WorkloadJiraConfigurationInput

  Workload-level: Input for the Jira configuration.

• WorkloadJiraConfigurationOutput

  Workload-level: Output configuration of the Jira integration.

• WorkloadProfile

  The profile associated with a workload.

• WorkloadShare

  A workload share return object.

• WorkloadShareSummary

  A workload share summary return object.

• WorkloadSummary

  A workload summary return object.

Enums

• AccountJiraIssueManagementStatus
  When writing a match expression against AccountJiraIssueManagementStatus, 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.
• AdditionalResourceType
  When writing a match expression against AdditionalResourceType, 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.
• AnswerReason
  When writing a match expression against AnswerReason, 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.
• CheckFailureReason
  When writing a match expression against CheckFailureReason, 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.
• CheckProvider
  When writing a match expression against CheckProvider, 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.
• CheckStatus
  When writing a match expression against CheckStatus, 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.
• ChoiceReason
  When writing a match expression against ChoiceReason, 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.
• ChoiceStatus
  When writing a match expression against ChoiceStatus, 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.
• DefinitionType
  When writing a match expression against DefinitionType, 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.
• DifferenceStatus
  When writing a match expression against DifferenceStatus, 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.
• DiscoveryIntegrationStatus
  When writing a match expression against DiscoveryIntegrationStatus, 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.
• ImportLensStatus
  When writing a match expression against ImportLensStatus, 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.
• IntegratingService
  When writing a match expression against IntegratingService, 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.
• IntegrationStatus
  When writing a match expression against IntegrationStatus, 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.
• IntegrationStatusInput
  When writing a match expression against IntegrationStatusInput, 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.
• IssueManagementType
  When writing a match expression against IssueManagementType, 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.
• LensStatus
  When writing a match expression against LensStatus, 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.
• LensStatusType
  When writing a match expression against LensStatusType, 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.
• LensType
  When writing a match expression against LensType, 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.
• MetricType
  When writing a match expression against MetricType, 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.
• NotificationType
  When writing a match expression against NotificationType, 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.
• OrganizationSharingStatus
  When writing a match expression against OrganizationSharingStatus, 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.
• PermissionType
  When writing a match expression against PermissionType, 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.
• ProfileNotificationType
  When writing a match expression against ProfileNotificationType, 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.
• ProfileOwnerType
  When writing a match expression against ProfileOwnerType, 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.
• Question
  When writing a match expression against Question, 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.
• QuestionPriority
  When writing a match expression against QuestionPriority, 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.
• QuestionType
  When writing a match expression against QuestionType, 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.
• ReportFormat
  When writing a match expression against ReportFormat, 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.
• ReviewTemplateAnswerStatus
  When writing a match expression against ReviewTemplateAnswerStatus, 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.
• ReviewTemplateUpdateStatus
  When writing a match expression against ReviewTemplateUpdateStatus, 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.
• Risk
  When writing a match expression against Risk, 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.
• ShareInvitationAction
  When writing a match expression against ShareInvitationAction, 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.
• ShareResourceType
  When writing a match expression against ShareResourceType, 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.
• ShareStatus
  When writing a match expression against ShareStatus, 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.
• TrustedAdvisorIntegrationStatus
  When writing a match expression against TrustedAdvisorIntegrationStatus, 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.
• ValidationExceptionReason
  When writing a match expression against ValidationExceptionReason, 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.
• WorkloadEnvironment
  When writing a match expression against WorkloadEnvironment, 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.
• WorkloadImprovementStatus
  When writing a match expression against WorkloadImprovementStatus, 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.
• WorkloadIssueManagementStatus
  When writing a match expression against WorkloadIssueManagementStatus, 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.