Module aws_sdk_appstream::types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that Amazon AppStream can respond with.

Structs

• AccessEndpoint

  Describes an interface VPC endpoint (interface endpoint) that lets you create a private connection between the virtual private cloud (VPC) that you specify and AppStream 2.0. When you specify an interface endpoint for a stack, users of the stack can connect to AppStream 2.0 only through that endpoint. When you specify an interface endpoint for an image builder, administrators can connect to the image builder only through that endpoint.

• AppBlock

  Describes an app block.

• AppBlockBuilder

  Describes an app block builder.

• AppBlockBuilderAppBlockAssociation

  Describes an association between an app block builder and app block.

• AppBlockBuilderStateChangeReason

  Describes the reason why the last app block builder state change occurred.

• Application

  Describes an application in the application catalog.

• ApplicationFleetAssociation

  Describes the application fleet association.

• ApplicationSettings

  The persistent application settings for users of a stack.

• ApplicationSettingsResponse

  Describes the persistent application settings for users of a stack.

• CertificateBasedAuthProperties

  The certificate-based authentication properties used to authenticate SAML 2.0 Identity Provider (IdP) user identities to Active Directory domain-joined streaming instances. Fallback is turned on by default when certificate-based authentication is Enabled . Fallback allows users to log in using their AD domain password if certificate-based authentication is unsuccessful, or to unlock a desktop lock screen. Enabled_no_directory_login_fallback enables certificate-based authentication, but does not allow users to log in using their AD domain password. Users will be disconnected to re-authenticate using certificates.

• ComputeCapacity

  Describes the capacity for a fleet.

• ComputeCapacityStatus

  Describes the capacity status for a fleet.

• DirectoryConfig

  Describes the configuration information required to join fleets and image builders to Microsoft Active Directory domains.

• DomainJoinInfo

  Describes the configuration information required to join fleets and image builders to Microsoft Active Directory domains.

• EntitledApplication

  The application associated to an entitlement. Access is controlled based on user attributes.

• Entitlement

  Specifies an entitlement. Entitlements control access to specific applications within a stack, based on user attributes. Entitlements apply to SAML 2.0 federated user identities. Amazon AppStream 2.0 user pool and streaming URL users are entitled to all applications in a stack. Entitlements don't apply to the desktop stream view application, or to applications managed by a dynamic app provider using the Dynamic Application Framework.

• EntitlementAttribute

  An attribute associated with an entitlement. Application entitlements work by matching a supported SAML 2.0 attribute name to a value when a user identity federates to an Amazon AppStream 2.0 SAML application.

• ErrorDetails

  The error details.

• Fleet

  Describes a fleet.

• FleetError

  Describes a fleet error.

• Image

  Describes an image.

• ImageBuilder

  Describes a virtual machine that is used to create an image.

• ImageBuilderStateChangeReason

  Describes the reason why the last image builder state change occurred.

• ImagePermissions

  Describes the permissions for an image.

• ImageStateChangeReason

  Describes the reason why the last image state change occurred.

• LastReportGenerationExecutionError

  Describes the error that is returned when a usage report can't be generated.

• NetworkAccessConfiguration

  Describes the network details of the fleet or image builder instance.

• ResourceError

  Describes a resource error.

• S3Location

  Describes the S3 location.

• ScriptDetails

  Describes the details of the script.

• ServiceAccountCredentials

  Describes the credentials for the service account used by the fleet or image builder to connect to the directory.

• Session

  Describes a streaming session.

• SharedImagePermissions

  Describes the permissions that are available to the specified AWS account for a shared image.

• Stack

  Describes a stack.

• StackError

  Describes a stack error.

• StorageConnector

  Describes a connector that enables persistent storage for users.

• StreamingExperienceSettings

  The streaming protocol you want your stack to prefer. This can be UDP or TCP. Currently, UDP is only supported in the Windows native client.

• UsageReportSubscription

  Describes information about the usage report subscription.

• User

  Describes a user in the user pool.

• UserSetting

  Describes an action and whether the action is enabled or disabled for users during their streaming sessions.

• UserStackAssociation

  Describes a user in the user pool and the associated stack.

• UserStackAssociationError

  Describes the error that is returned when a user can’t be associated with or disassociated from a stack.

• VpcConfig

  Describes VPC configuration information for fleets and image builders.

Enums

• AccessEndpointType
  When writing a match expression against AccessEndpointType, 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.
• Action
  When writing a match expression against Action, 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.
• AppBlockBuilderAttribute
  When writing a match expression against AppBlockBuilderAttribute, 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.
• AppBlockBuilderPlatformType
  When writing a match expression against AppBlockBuilderPlatformType, 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.
• AppBlockBuilderState
  When writing a match expression against AppBlockBuilderState, 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.
• AppBlockBuilderStateChangeReasonCode
  When writing a match expression against AppBlockBuilderStateChangeReasonCode, 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.
• AppBlockState
  When writing a match expression against AppBlockState, 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.
• AppVisibility
  When writing a match expression against AppVisibility, 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.
• ApplicationAttribute
  When writing a match expression against ApplicationAttribute, 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.
• AuthenticationType
  When writing a match expression against AuthenticationType, 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.
• CertificateBasedAuthStatus
  When writing a match expression against CertificateBasedAuthStatus, 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.
• FleetAttribute
  When writing a match expression against FleetAttribute, 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.
• FleetErrorCode
  When writing a match expression against FleetErrorCode, 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.
• FleetState
  When writing a match expression against FleetState, 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.
• FleetType
  When writing a match expression against FleetType, 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.
• ImageBuilderState
  When writing a match expression against ImageBuilderState, 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.
• ImageBuilderStateChangeReasonCode
  When writing a match expression against ImageBuilderStateChangeReasonCode, 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.
• ImageState
  When writing a match expression against ImageState, 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.
• ImageStateChangeReasonCode
  When writing a match expression against ImageStateChangeReasonCode, 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.
• MessageAction
  When writing a match expression against MessageAction, 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.
• PackagingType
  When writing a match expression against PackagingType, 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.
• Permission
  When writing a match expression against Permission, 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.
• PlatformType
  When writing a match expression against PlatformType, 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.
• PreferredProtocol
  When writing a match expression against PreferredProtocol, 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.
• SessionConnectionState
  When writing a match expression against SessionConnectionState, 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.
• SessionState
  When writing a match expression against SessionState, 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.
• StackAttribute
  When writing a match expression against StackAttribute, 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.
• StackErrorCode
  When writing a match expression against StackErrorCode, 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.
• StorageConnectorType
  When writing a match expression against StorageConnectorType, 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.
• StreamView
  When writing a match expression against StreamView, 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.
• UsageReportExecutionErrorCode
  When writing a match expression against UsageReportExecutionErrorCode, 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.
• UsageReportSchedule
  When writing a match expression against UsageReportSchedule, 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.
• UserStackAssociationErrorCode
  When writing a match expression against UserStackAssociationErrorCode, 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.
• VisibilityType
  When writing a match expression against VisibilityType, 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.