Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessEndpoint

type AccessEndpoint struct {

	// The type of interface endpoint.
	//
	// This member is required.
	EndpointType AccessEndpointType

	// The identifier (ID) of the VPC in which the interface endpoint is used.
	VpceId *string
}

    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.

    type AccessEndpointType

    type AccessEndpointType string
    const (
    	AccessEndpointTypeStreaming AccessEndpointType = "STREAMING"
    )

      Enum values for AccessEndpointType

      func (AccessEndpointType) Values

        Values returns all known values for AccessEndpointType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

        type Action

        type Action string
        const (
        	ActionClipboardCopyFromLocalDevice Action = "CLIPBOARD_COPY_FROM_LOCAL_DEVICE"
        	ActionClipboardCopyToLocalDevice   Action = "CLIPBOARD_COPY_TO_LOCAL_DEVICE"
        	ActionFileUpload                   Action = "FILE_UPLOAD"
        	ActionFileDownload                 Action = "FILE_DOWNLOAD"
        	ActionPrintingToLocalDevice        Action = "PRINTING_TO_LOCAL_DEVICE"
        )

          Enum values for Action

          func (Action) Values

          func (Action) Values() []Action

            Values returns all known values for Action. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

            type Application

            type Application struct {
            
            	// The application name to display.
            	DisplayName *string
            
            	// If there is a problem, the application can be disabled after image creation.
            	Enabled bool
            
            	// The URL for the application icon. This URL might be time-limited.
            	IconURL *string
            
            	// The arguments that are passed to the application at launch.
            	LaunchParameters *string
            
            	// The path to the application executable in the instance.
            	LaunchPath *string
            
            	// Additional attributes that describe the application.
            	Metadata map[string]string
            
            	// The name of the application.
            	Name *string
            }

              Describes an application in the application catalog.

              type ApplicationSettings

              type ApplicationSettings struct {
              
              	// Enables or disables persistent application settings for users during their
              	// streaming sessions.
              	//
              	// This member is required.
              	Enabled bool
              
              	// The path prefix for the S3 bucket where users’ persistent application settings
              	// are stored. You can allow the same persistent application settings to be used
              	// across multiple stacks by specifying the same settings group for each stack.
              	SettingsGroup *string
              }

                The persistent application settings for users of a stack.

                type ApplicationSettingsResponse

                type ApplicationSettingsResponse struct {
                
                	// Specifies whether persistent application settings are enabled for users during
                	// their streaming sessions.
                	Enabled bool
                
                	// The S3 bucket where users’ persistent application settings are stored. When
                	// persistent application settings are enabled for the first time for an account in
                	// an AWS Region, an S3 bucket is created. The bucket is unique to the AWS account
                	// and the Region.
                	S3BucketName *string
                
                	// The path prefix for the S3 bucket where users’ persistent application settings
                	// are stored.
                	SettingsGroup *string
                }

                  Describes the persistent application settings for users of a stack.

                  type AuthenticationType

                  type AuthenticationType string
                  const (
                  	AuthenticationTypeApi      AuthenticationType = "API"
                  	AuthenticationTypeSaml     AuthenticationType = "SAML"
                  	AuthenticationTypeUserpool AuthenticationType = "USERPOOL"
                  )

                    Enum values for AuthenticationType

                    func (AuthenticationType) Values

                      Values returns all known values for AuthenticationType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                      type ComputeCapacity

                      type ComputeCapacity struct {
                      
                      	// The desired number of streaming instances.
                      	//
                      	// This member is required.
                      	DesiredInstances *int32
                      }

                        Describes the capacity for a fleet.

                        type ComputeCapacityStatus

                        type ComputeCapacityStatus struct {
                        
                        	// The desired number of streaming instances.
                        	//
                        	// This member is required.
                        	Desired *int32
                        
                        	// The number of currently available instances that can be used to stream sessions.
                        	Available *int32
                        
                        	// The number of instances in use for streaming.
                        	InUse *int32
                        
                        	// The total number of simultaneous streaming instances that are running.
                        	Running *int32
                        }

                          Describes the capacity status for a fleet.

                          type ConcurrentModificationException

                          type ConcurrentModificationException struct {
                          	Message *string
                          }

                            An API error occurred. Wait a few minutes and try again.

                            func (*ConcurrentModificationException) Error

                            func (*ConcurrentModificationException) ErrorCode

                            func (e *ConcurrentModificationException) ErrorCode() string

                            func (*ConcurrentModificationException) ErrorFault

                            func (*ConcurrentModificationException) ErrorMessage

                            func (e *ConcurrentModificationException) ErrorMessage() string

                            type DirectoryConfig

                            type DirectoryConfig struct {
                            
                            	// The fully qualified name of the directory (for example, corp.example.com).
                            	//
                            	// This member is required.
                            	DirectoryName *string
                            
                            	// The time the directory configuration was created.
                            	CreatedTime *time.Time
                            
                            	// The distinguished names of the organizational units for computer accounts.
                            	OrganizationalUnitDistinguishedNames []string
                            
                            	// The credentials for the service account used by the fleet or image builder to
                            	// connect to the directory.
                            	ServiceAccountCredentials *ServiceAccountCredentials
                            }

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

                              type DomainJoinInfo

                              type DomainJoinInfo struct {
                              
                              	// The fully qualified name of the directory (for example, corp.example.com).
                              	DirectoryName *string
                              
                              	// The distinguished name of the organizational unit for computer accounts.
                              	OrganizationalUnitDistinguishedName *string
                              }

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

                                type Fleet

                                type Fleet struct {
                                
                                	// The Amazon Resource Name (ARN) for the fleet.
                                	//
                                	// This member is required.
                                	Arn *string
                                
                                	// The capacity status for the fleet.
                                	//
                                	// This member is required.
                                	ComputeCapacityStatus *ComputeCapacityStatus
                                
                                	// The instance type to use when launching fleet instances. The following instance
                                	// types are available:
                                	//
                                	// * stream.standard.medium
                                	//
                                	// * stream.standard.large
                                	//
                                	// *
                                	// stream.compute.large
                                	//
                                	// * stream.compute.xlarge
                                	//
                                	// * stream.compute.2xlarge
                                	//
                                	// *
                                	// stream.compute.4xlarge
                                	//
                                	// * stream.compute.8xlarge
                                	//
                                	// * stream.memory.large
                                	//
                                	// *
                                	// stream.memory.xlarge
                                	//
                                	// * stream.memory.2xlarge
                                	//
                                	// * stream.memory.4xlarge
                                	//
                                	// *
                                	// stream.memory.8xlarge
                                	//
                                	// * stream.memory.z1d.large
                                	//
                                	// * stream.memory.z1d.xlarge
                                	//
                                	// *
                                	// stream.memory.z1d.2xlarge
                                	//
                                	// * stream.memory.z1d.3xlarge
                                	//
                                	// *
                                	// stream.memory.z1d.6xlarge
                                	//
                                	// * stream.memory.z1d.12xlarge
                                	//
                                	// *
                                	// stream.graphics-design.large
                                	//
                                	// * stream.graphics-design.xlarge
                                	//
                                	// *
                                	// stream.graphics-design.2xlarge
                                	//
                                	// * stream.graphics-design.4xlarge
                                	//
                                	// *
                                	// stream.graphics-desktop.2xlarge
                                	//
                                	// * stream.graphics.g4dn.xlarge
                                	//
                                	// *
                                	// stream.graphics.g4dn.2xlarge
                                	//
                                	// * stream.graphics.g4dn.4xlarge
                                	//
                                	// *
                                	// stream.graphics.g4dn.8xlarge
                                	//
                                	// * stream.graphics.g4dn.12xlarge
                                	//
                                	// *
                                	// stream.graphics.g4dn.16xlarge
                                	//
                                	// * stream.graphics-pro.4xlarge
                                	//
                                	// *
                                	// stream.graphics-pro.8xlarge
                                	//
                                	// * stream.graphics-pro.16xlarge
                                	//
                                	// This member is required.
                                	InstanceType *string
                                
                                	// The name of the fleet.
                                	//
                                	// This member is required.
                                	Name *string
                                
                                	// The current state for the fleet.
                                	//
                                	// This member is required.
                                	State FleetState
                                
                                	// The time the fleet was created.
                                	CreatedTime *time.Time
                                
                                	// The description to display.
                                	Description *string
                                
                                	// The amount of time that a streaming session remains active after users
                                	// disconnect. If they try to reconnect to the streaming session after a
                                	// disconnection or network interruption within this time interval, they are
                                	// connected to their previous session. Otherwise, they are connected to a new
                                	// session with a new streaming instance. Specify a value between 60 and 360000.
                                	DisconnectTimeoutInSeconds *int32
                                
                                	// The fleet name to display.
                                	DisplayName *string
                                
                                	// The name of the directory and organizational unit (OU) to use to join the fleet
                                	// to a Microsoft Active Directory domain.
                                	DomainJoinInfo *DomainJoinInfo
                                
                                	// Indicates whether default internet access is enabled for the fleet.
                                	EnableDefaultInternetAccess *bool
                                
                                	// The fleet errors.
                                	FleetErrors []FleetError
                                
                                	// The fleet type. ALWAYS_ON Provides users with instant-on access to their apps.
                                	// You are charged for all running instances in your fleet, even if no users are
                                	// streaming apps. ON_DEMAND Provide users with access to applications after they
                                	// connect, which takes one to two minutes. You are charged for instance streaming
                                	// when users are connected and a small hourly fee for instances that are not
                                	// streaming apps.
                                	FleetType FleetType
                                
                                	// The ARN of the IAM role that is applied to the fleet. To assume a role, the
                                	// fleet instance calls the AWS Security Token Service (STS) AssumeRole API
                                	// operation and passes the ARN of the role to use. The operation creates a new
                                	// session with temporary credentials. AppStream 2.0 retrieves the temporary
                                	// credentials and creates the appstream_machine_role credential profile on the
                                	// instance. For more information, see Using an IAM Role to Grant Permissions to
                                	// Applications and Scripts Running on AppStream 2.0 Streaming Instances
                                	// (https://docs.aws.amazon.com/appstream2/latest/developerguide/using-iam-roles-to-grant-permissions-to-applications-scripts-streaming-instances.html)
                                	// in the Amazon AppStream 2.0 Administration Guide.
                                	IamRoleArn *string
                                
                                	// The amount of time that users can be idle (inactive) before they are
                                	// disconnected from their streaming session and the DisconnectTimeoutInSeconds
                                	// time interval begins. Users are notified before they are disconnected due to
                                	// inactivity. If users try to reconnect to the streaming session before the time
                                	// interval specified in DisconnectTimeoutInSeconds elapses, they are connected to
                                	// their previous session. Users are considered idle when they stop providing
                                	// keyboard or mouse input during their streaming session. File uploads and
                                	// downloads, audio in, audio out, and pixels changing do not qualify as user
                                	// activity. If users continue to be idle after the time interval in
                                	// IdleDisconnectTimeoutInSeconds elapses, they are disconnected. To prevent users
                                	// from being disconnected due to inactivity, specify a value of 0. Otherwise,
                                	// specify a value between 60 and 3600. The default value is 0. If you enable this
                                	// feature, we recommend that you specify a value that corresponds exactly to a
                                	// whole number of minutes (for example, 60, 120, and 180). If you don't do this,
                                	// the value is rounded to the nearest minute. For example, if you specify a value
                                	// of 70, users are disconnected after 1 minute of inactivity. If you specify a
                                	// value that is at the midpoint between two different minutes, the value is
                                	// rounded up. For example, if you specify a value of 90, users are disconnected
                                	// after 2 minutes of inactivity.
                                	IdleDisconnectTimeoutInSeconds *int32
                                
                                	// The ARN for the public, private, or shared image.
                                	ImageArn *string
                                
                                	// The name of the image used to create the fleet.
                                	ImageName *string
                                
                                	// The maximum amount of time that a streaming session can remain active, in
                                	// seconds. If users are still connected to a streaming instance five minutes
                                	// before this limit is reached, they are prompted to save any open documents
                                	// before being disconnected. After this time elapses, the instance is terminated
                                	// and replaced by a new instance. Specify a value between 600 and 360000.
                                	MaxUserDurationInSeconds *int32
                                
                                	// The AppStream 2.0 view that is displayed to your users when they stream from the
                                	// fleet. When APP is specified, only the windows of applications opened by users
                                	// display. When DESKTOP is specified, the standard desktop that is provided by the
                                	// operating system displays. The default value is APP.
                                	StreamView StreamView
                                
                                	// The VPC configuration for the fleet.
                                	VpcConfig *VpcConfig
                                }

                                  Describes a fleet.

                                  type FleetAttribute

                                  type FleetAttribute string
                                  const (
                                  	FleetAttributeVpcConfiguration                 FleetAttribute = "VPC_CONFIGURATION"
                                  	FleetAttributeVpcConfigurationSecurityGroupIds FleetAttribute = "VPC_CONFIGURATION_SECURITY_GROUP_IDS"
                                  	FleetAttributeDomainJoinInfo                   FleetAttribute = "DOMAIN_JOIN_INFO"
                                  	FleetAttributeIamRoleArn                       FleetAttribute = "IAM_ROLE_ARN"
                                  )

                                    Enum values for FleetAttribute

                                    func (FleetAttribute) Values

                                    func (FleetAttribute) Values() []FleetAttribute

                                      Values returns all known values for FleetAttribute. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                      type FleetError

                                      type FleetError struct {
                                      
                                      	// The error code.
                                      	ErrorCode FleetErrorCode
                                      
                                      	// The error message.
                                      	ErrorMessage *string
                                      }

                                        Describes a fleet error.

                                        type FleetErrorCode

                                        type FleetErrorCode string
                                        const (
                                        	FleetErrorCodeIamServiceRoleMissingEniDescribeAction            FleetErrorCode = "IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION"
                                        	FleetErrorCodeIamServiceRoleMissingEniCreateAction              FleetErrorCode = "IAM_SERVICE_ROLE_MISSING_ENI_CREATE_ACTION"
                                        	FleetErrorCodeIamServiceRoleMissingEniDeleteAction              FleetErrorCode = "IAM_SERVICE_ROLE_MISSING_ENI_DELETE_ACTION"
                                        	FleetErrorCodeNetworkInterfaceLimitExceeded                     FleetErrorCode = "NETWORK_INTERFACE_LIMIT_EXCEEDED"
                                        	FleetErrorCodeInternalServiceError                              FleetErrorCode = "INTERNAL_SERVICE_ERROR"
                                        	FleetErrorCodeIamServiceRoleIsMissing                           FleetErrorCode = "IAM_SERVICE_ROLE_IS_MISSING"
                                        	FleetErrorCodeMachineRoleIsMissing                              FleetErrorCode = "MACHINE_ROLE_IS_MISSING"
                                        	FleetErrorCodeStsDisabledInRegion                               FleetErrorCode = "STS_DISABLED_IN_REGION"
                                        	FleetErrorCodeSubnetHasInsufficientIpAddresses                  FleetErrorCode = "SUBNET_HAS_INSUFFICIENT_IP_ADDRESSES"
                                        	FleetErrorCodeIamServiceRoleMissingDescribeSubnetAction         FleetErrorCode = "IAM_SERVICE_ROLE_MISSING_DESCRIBE_SUBNET_ACTION"
                                        	FleetErrorCodeSubnetNotFound                                    FleetErrorCode = "SUBNET_NOT_FOUND"
                                        	FleetErrorCodeImageNotFound                                     FleetErrorCode = "IMAGE_NOT_FOUND"
                                        	FleetErrorCodeInvalidSubnetConfiguration                        FleetErrorCode = "INVALID_SUBNET_CONFIGURATION"
                                        	FleetErrorCodeSecurityGroupsNotFound                            FleetErrorCode = "SECURITY_GROUPS_NOT_FOUND"
                                        	FleetErrorCodeIgwNotAttached                                    FleetErrorCode = "IGW_NOT_ATTACHED"
                                        	FleetErrorCodeIamServiceRoleMissingDescribeSecurityGroupsAction FleetErrorCode = "IAM_SERVICE_ROLE_MISSING_DESCRIBE_SECURITY_GROUPS_ACTION"
                                        	FleetErrorCodeDomainJoinErrorFileNotFound                       FleetErrorCode = "DOMAIN_JOIN_ERROR_FILE_NOT_FOUND"
                                        	FleetErrorCodeDomainJoinErrorAccessDenied                       FleetErrorCode = "DOMAIN_JOIN_ERROR_ACCESS_DENIED"
                                        	FleetErrorCodeDomainJoinErrorLogonFailure                       FleetErrorCode = "DOMAIN_JOIN_ERROR_LOGON_FAILURE"
                                        	FleetErrorCodeDomainJoinErrorInvalidParameter                   FleetErrorCode = "DOMAIN_JOIN_ERROR_INVALID_PARAMETER"
                                        	FleetErrorCodeDomainJoinErrorMoreData                           FleetErrorCode = "DOMAIN_JOIN_ERROR_MORE_DATA"
                                        	FleetErrorCodeDomainJoinErrorNoSuchDomain                       FleetErrorCode = "DOMAIN_JOIN_ERROR_NO_SUCH_DOMAIN"
                                        	FleetErrorCodeDomainJoinErrorNotSupported                       FleetErrorCode = "DOMAIN_JOIN_ERROR_NOT_SUPPORTED"
                                        	FleetErrorCodeDomainJoinNerrInvalidWorkgroupName                FleetErrorCode = "DOMAIN_JOIN_NERR_INVALID_WORKGROUP_NAME"
                                        	FleetErrorCodeDomainJoinNerrWorkstationNotStarted               FleetErrorCode = "DOMAIN_JOIN_NERR_WORKSTATION_NOT_STARTED"
                                        	FleetErrorCodeDomainJoinErrorDsMachineAccountQuotaExceeded      FleetErrorCode = "DOMAIN_JOIN_ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED"
                                        	FleetErrorCodeDomainJoinNerrPasswordExpired                     FleetErrorCode = "DOMAIN_JOIN_NERR_PASSWORD_EXPIRED"
                                        	FleetErrorCodeDomainJoinInternalServiceError                    FleetErrorCode = "DOMAIN_JOIN_INTERNAL_SERVICE_ERROR"
                                        )

                                          Enum values for FleetErrorCode

                                          func (FleetErrorCode) Values

                                          func (FleetErrorCode) Values() []FleetErrorCode

                                            Values returns all known values for FleetErrorCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                            type FleetState

                                            type FleetState string
                                            const (
                                            	FleetStateStarting FleetState = "STARTING"
                                            	FleetStateRunning  FleetState = "RUNNING"
                                            	FleetStateStopping FleetState = "STOPPING"
                                            	FleetStateStopped  FleetState = "STOPPED"
                                            )

                                              Enum values for FleetState

                                              func (FleetState) Values

                                              func (FleetState) Values() []FleetState

                                                Values returns all known values for FleetState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                type FleetType

                                                type FleetType string
                                                const (
                                                	FleetTypeAlwaysOn FleetType = "ALWAYS_ON"
                                                	FleetTypeOnDemand FleetType = "ON_DEMAND"
                                                )

                                                  Enum values for FleetType

                                                  func (FleetType) Values

                                                  func (FleetType) Values() []FleetType

                                                    Values returns all known values for FleetType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                    type Image

                                                    type Image struct {
                                                    
                                                    	// The name of the image.
                                                    	//
                                                    	// This member is required.
                                                    	Name *string
                                                    
                                                    	// The applications associated with the image.
                                                    	Applications []Application
                                                    
                                                    	// The version of the AppStream 2.0 agent to use for instances that are launched
                                                    	// from this image.
                                                    	AppstreamAgentVersion *string
                                                    
                                                    	// The ARN of the image.
                                                    	Arn *string
                                                    
                                                    	// The ARN of the image from which this image was created.
                                                    	BaseImageArn *string
                                                    
                                                    	// The time the image was created.
                                                    	CreatedTime *time.Time
                                                    
                                                    	// The description to display.
                                                    	Description *string
                                                    
                                                    	// The image name to display.
                                                    	DisplayName *string
                                                    
                                                    	// The name of the image builder that was used to create the private image. If the
                                                    	// image is shared, this value is null.
                                                    	ImageBuilderName *string
                                                    
                                                    	// Indicates whether an image builder can be launched from this image.
                                                    	ImageBuilderSupported bool
                                                    
                                                    	// The permissions to provide to the destination AWS account for the specified
                                                    	// image.
                                                    	ImagePermissions *ImagePermissions
                                                    
                                                    	// The operating system platform of the image.
                                                    	Platform PlatformType
                                                    
                                                    	// The release date of the public base image. For private images, this date is the
                                                    	// release date of the base image from which the image was created.
                                                    	PublicBaseImageReleasedDate *time.Time
                                                    
                                                    	// The image starts in the PENDING state. If image creation succeeds, the state is
                                                    	// AVAILABLE. If image creation fails, the state is FAILED.
                                                    	State ImageState
                                                    
                                                    	// The reason why the last state change occurred.
                                                    	StateChangeReason *ImageStateChangeReason
                                                    
                                                    	// Indicates whether the image is public or private.
                                                    	Visibility VisibilityType
                                                    }

                                                      Describes an image.

                                                      type ImageBuilder

                                                      type ImageBuilder struct {
                                                      
                                                      	// The name of the image builder.
                                                      	//
                                                      	// This member is required.
                                                      	Name *string
                                                      
                                                      	// The list of virtual private cloud (VPC) interface endpoint objects.
                                                      	// Administrators can connect to the image builder only through the specified
                                                      	// endpoints.
                                                      	AccessEndpoints []AccessEndpoint
                                                      
                                                      	// The version of the AppStream 2.0 agent that is currently being used by the image
                                                      	// builder.
                                                      	AppstreamAgentVersion *string
                                                      
                                                      	// The ARN for the image builder.
                                                      	Arn *string
                                                      
                                                      	// The time stamp when the image builder was created.
                                                      	CreatedTime *time.Time
                                                      
                                                      	// The description to display.
                                                      	Description *string
                                                      
                                                      	// The image builder name to display.
                                                      	DisplayName *string
                                                      
                                                      	// The name of the directory and organizational unit (OU) to use to join the image
                                                      	// builder to a Microsoft Active Directory domain.
                                                      	DomainJoinInfo *DomainJoinInfo
                                                      
                                                      	// Enables or disables default internet access for the image builder.
                                                      	EnableDefaultInternetAccess *bool
                                                      
                                                      	// The ARN of the IAM role that is applied to the image builder. To assume a role,
                                                      	// the image builder calls the AWS Security Token Service (STS) AssumeRole API
                                                      	// operation and passes the ARN of the role to use. The operation creates a new
                                                      	// session with temporary credentials. AppStream 2.0 retrieves the temporary
                                                      	// credentials and creates the appstream_machine_role credential profile on the
                                                      	// instance. For more information, see Using an IAM Role to Grant Permissions to
                                                      	// Applications and Scripts Running on AppStream 2.0 Streaming Instances
                                                      	// (https://docs.aws.amazon.com/appstream2/latest/developerguide/using-iam-roles-to-grant-permissions-to-applications-scripts-streaming-instances.html)
                                                      	// in the Amazon AppStream 2.0 Administration Guide.
                                                      	IamRoleArn *string
                                                      
                                                      	// The ARN of the image from which this builder was created.
                                                      	ImageArn *string
                                                      
                                                      	// The image builder errors.
                                                      	ImageBuilderErrors []ResourceError
                                                      
                                                      	// The instance type for the image builder. The following instance types are
                                                      	// available:
                                                      	//
                                                      	// * stream.standard.medium
                                                      	//
                                                      	// * stream.standard.large
                                                      	//
                                                      	// *
                                                      	// stream.compute.large
                                                      	//
                                                      	// * stream.compute.xlarge
                                                      	//
                                                      	// * stream.compute.2xlarge
                                                      	//
                                                      	// *
                                                      	// stream.compute.4xlarge
                                                      	//
                                                      	// * stream.compute.8xlarge
                                                      	//
                                                      	// * stream.memory.large
                                                      	//
                                                      	// *
                                                      	// stream.memory.xlarge
                                                      	//
                                                      	// * stream.memory.2xlarge
                                                      	//
                                                      	// * stream.memory.4xlarge
                                                      	//
                                                      	// *
                                                      	// stream.memory.8xlarge
                                                      	//
                                                      	// * stream.memory.z1d.large
                                                      	//
                                                      	// * stream.memory.z1d.xlarge
                                                      	//
                                                      	// *
                                                      	// stream.memory.z1d.2xlarge
                                                      	//
                                                      	// * stream.memory.z1d.3xlarge
                                                      	//
                                                      	// *
                                                      	// stream.memory.z1d.6xlarge
                                                      	//
                                                      	// * stream.memory.z1d.12xlarge
                                                      	//
                                                      	// *
                                                      	// stream.graphics-design.large
                                                      	//
                                                      	// * stream.graphics-design.xlarge
                                                      	//
                                                      	// *
                                                      	// stream.graphics-design.2xlarge
                                                      	//
                                                      	// * stream.graphics-design.4xlarge
                                                      	//
                                                      	// *
                                                      	// stream.graphics-desktop.2xlarge
                                                      	//
                                                      	// * stream.graphics.g4dn.xlarge
                                                      	//
                                                      	// *
                                                      	// stream.graphics.g4dn.2xlarge
                                                      	//
                                                      	// * stream.graphics.g4dn.4xlarge
                                                      	//
                                                      	// *
                                                      	// stream.graphics.g4dn.8xlarge
                                                      	//
                                                      	// * stream.graphics.g4dn.12xlarge
                                                      	//
                                                      	// *
                                                      	// stream.graphics.g4dn.16xlarge
                                                      	//
                                                      	// * stream.graphics-pro.4xlarge
                                                      	//
                                                      	// *
                                                      	// stream.graphics-pro.8xlarge
                                                      	//
                                                      	// * stream.graphics-pro.16xlarge
                                                      	InstanceType *string
                                                      
                                                      	// Describes the network details of the fleet or image builder instance.
                                                      	NetworkAccessConfiguration *NetworkAccessConfiguration
                                                      
                                                      	// The operating system platform of the image builder.
                                                      	Platform PlatformType
                                                      
                                                      	// The state of the image builder.
                                                      	State ImageBuilderState
                                                      
                                                      	// The reason why the last state change occurred.
                                                      	StateChangeReason *ImageBuilderStateChangeReason
                                                      
                                                      	// The VPC configuration of the image builder.
                                                      	VpcConfig *VpcConfig
                                                      }

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

                                                        type ImageBuilderState

                                                        type ImageBuilderState string
                                                        const (
                                                        	ImageBuilderStatePending       ImageBuilderState = "PENDING"
                                                        	ImageBuilderStateUpdatingAgent ImageBuilderState = "UPDATING_AGENT"
                                                        	ImageBuilderStateRunning       ImageBuilderState = "RUNNING"
                                                        	ImageBuilderStateStopping      ImageBuilderState = "STOPPING"
                                                        	ImageBuilderStateStopped       ImageBuilderState = "STOPPED"
                                                        	ImageBuilderStateRebooting     ImageBuilderState = "REBOOTING"
                                                        	ImageBuilderStateSnapshotting  ImageBuilderState = "SNAPSHOTTING"
                                                        	ImageBuilderStateDeleting      ImageBuilderState = "DELETING"
                                                        	ImageBuilderStateFailed        ImageBuilderState = "FAILED"
                                                        )

                                                          Enum values for ImageBuilderState

                                                          func (ImageBuilderState) Values

                                                            Values returns all known values for ImageBuilderState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                            type ImageBuilderStateChangeReason

                                                            type ImageBuilderStateChangeReason struct {
                                                            
                                                            	// The state change reason code.
                                                            	Code ImageBuilderStateChangeReasonCode
                                                            
                                                            	// The state change reason message.
                                                            	Message *string
                                                            }

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

                                                              type ImageBuilderStateChangeReasonCode

                                                              type ImageBuilderStateChangeReasonCode string
                                                              const (
                                                              	ImageBuilderStateChangeReasonCodeInternalError    ImageBuilderStateChangeReasonCode = "INTERNAL_ERROR"
                                                              	ImageBuilderStateChangeReasonCodeImageUnavailable ImageBuilderStateChangeReasonCode = "IMAGE_UNAVAILABLE"
                                                              )

                                                                Enum values for ImageBuilderStateChangeReasonCode

                                                                func (ImageBuilderStateChangeReasonCode) Values

                                                                  Values returns all known values for ImageBuilderStateChangeReasonCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                  type ImagePermissions

                                                                  type ImagePermissions struct {
                                                                  
                                                                  	// Indicates whether the image can be used for a fleet.
                                                                  	AllowFleet *bool
                                                                  
                                                                  	// Indicates whether the image can be used for an image builder.
                                                                  	AllowImageBuilder *bool
                                                                  }

                                                                    Describes the permissions for an image.

                                                                    type ImageState

                                                                    type ImageState string
                                                                    const (
                                                                    	ImageStatePending   ImageState = "PENDING"
                                                                    	ImageStateAvailable ImageState = "AVAILABLE"
                                                                    	ImageStateFailed    ImageState = "FAILED"
                                                                    	ImageStateCopying   ImageState = "COPYING"
                                                                    	ImageStateDeleting  ImageState = "DELETING"
                                                                    )

                                                                      Enum values for ImageState

                                                                      func (ImageState) Values

                                                                      func (ImageState) Values() []ImageState

                                                                        Values returns all known values for ImageState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                        type ImageStateChangeReason

                                                                        type ImageStateChangeReason struct {
                                                                        
                                                                        	// The state change reason code.
                                                                        	Code ImageStateChangeReasonCode
                                                                        
                                                                        	// The state change reason message.
                                                                        	Message *string
                                                                        }

                                                                          Describes the reason why the last image state change occurred.

                                                                          type ImageStateChangeReasonCode

                                                                          type ImageStateChangeReasonCode string
                                                                          const (
                                                                          	ImageStateChangeReasonCodeInternalError            ImageStateChangeReasonCode = "INTERNAL_ERROR"
                                                                          	ImageStateChangeReasonCodeImageBuilderNotAvailable ImageStateChangeReasonCode = "IMAGE_BUILDER_NOT_AVAILABLE"
                                                                          	ImageStateChangeReasonCodeImageCopyFailure         ImageStateChangeReasonCode = "IMAGE_COPY_FAILURE"
                                                                          )

                                                                            Enum values for ImageStateChangeReasonCode

                                                                            func (ImageStateChangeReasonCode) Values

                                                                              Values returns all known values for ImageStateChangeReasonCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                              type IncompatibleImageException

                                                                              type IncompatibleImageException struct {
                                                                              	Message *string
                                                                              }

                                                                                The image does not support storage connectors.

                                                                                func (*IncompatibleImageException) Error

                                                                                func (*IncompatibleImageException) ErrorCode

                                                                                func (e *IncompatibleImageException) ErrorCode() string

                                                                                func (*IncompatibleImageException) ErrorFault

                                                                                func (*IncompatibleImageException) ErrorMessage

                                                                                func (e *IncompatibleImageException) ErrorMessage() string

                                                                                type InvalidAccountStatusException

                                                                                type InvalidAccountStatusException struct {
                                                                                	Message *string
                                                                                }

                                                                                  The resource cannot be created because your AWS account is suspended. For assistance, contact AWS Support.

                                                                                  func (*InvalidAccountStatusException) Error

                                                                                  func (*InvalidAccountStatusException) ErrorCode

                                                                                  func (e *InvalidAccountStatusException) ErrorCode() string

                                                                                  func (*InvalidAccountStatusException) ErrorFault

                                                                                  func (*InvalidAccountStatusException) ErrorMessage

                                                                                  func (e *InvalidAccountStatusException) ErrorMessage() string

                                                                                  type InvalidParameterCombinationException

                                                                                  type InvalidParameterCombinationException struct {
                                                                                  	Message *string
                                                                                  }

                                                                                    Indicates an incorrect combination of parameters, or a missing parameter.

                                                                                    func (*InvalidParameterCombinationException) Error

                                                                                    func (*InvalidParameterCombinationException) ErrorCode

                                                                                    func (*InvalidParameterCombinationException) ErrorFault

                                                                                    func (*InvalidParameterCombinationException) ErrorMessage

                                                                                    func (e *InvalidParameterCombinationException) ErrorMessage() string

                                                                                    type InvalidRoleException

                                                                                    type InvalidRoleException struct {
                                                                                    	Message *string
                                                                                    }

                                                                                      The specified role is invalid.

                                                                                      func (*InvalidRoleException) Error

                                                                                      func (e *InvalidRoleException) Error() string

                                                                                      func (*InvalidRoleException) ErrorCode

                                                                                      func (e *InvalidRoleException) ErrorCode() string

                                                                                      func (*InvalidRoleException) ErrorFault

                                                                                      func (e *InvalidRoleException) ErrorFault() smithy.ErrorFault

                                                                                      func (*InvalidRoleException) ErrorMessage

                                                                                      func (e *InvalidRoleException) ErrorMessage() string

                                                                                      type LastReportGenerationExecutionError

                                                                                      type LastReportGenerationExecutionError struct {
                                                                                      
                                                                                      	// The error code for the error that is returned when a usage report can't be
                                                                                      	// generated.
                                                                                      	ErrorCode UsageReportExecutionErrorCode
                                                                                      
                                                                                      	// The error message for the error that is returned when a usage report can't be
                                                                                      	// generated.
                                                                                      	ErrorMessage *string
                                                                                      }

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

                                                                                        type LimitExceededException

                                                                                        type LimitExceededException struct {
                                                                                        	Message *string
                                                                                        }

                                                                                          The requested limit exceeds the permitted limit for an account.

                                                                                          func (*LimitExceededException) Error

                                                                                          func (e *LimitExceededException) Error() string

                                                                                          func (*LimitExceededException) ErrorCode

                                                                                          func (e *LimitExceededException) ErrorCode() string

                                                                                          func (*LimitExceededException) ErrorFault

                                                                                          func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                                                                          func (*LimitExceededException) ErrorMessage

                                                                                          func (e *LimitExceededException) ErrorMessage() string

                                                                                          type MessageAction

                                                                                          type MessageAction string
                                                                                          const (
                                                                                          	MessageActionSuppress MessageAction = "SUPPRESS"
                                                                                          	MessageActionResend   MessageAction = "RESEND"
                                                                                          )

                                                                                            Enum values for MessageAction

                                                                                            func (MessageAction) Values

                                                                                            func (MessageAction) Values() []MessageAction

                                                                                              Values returns all known values for MessageAction. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                              type NetworkAccessConfiguration

                                                                                              type NetworkAccessConfiguration struct {
                                                                                              
                                                                                              	// The resource identifier of the elastic network interface that is attached to
                                                                                              	// instances in your VPC. All network interfaces have the eni-xxxxxxxx resource
                                                                                              	// identifier.
                                                                                              	EniId *string
                                                                                              
                                                                                              	// The private IP address of the elastic network interface that is attached to
                                                                                              	// instances in your VPC.
                                                                                              	EniPrivateIpAddress *string
                                                                                              }

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

                                                                                                type OperationNotPermittedException

                                                                                                type OperationNotPermittedException struct {
                                                                                                	Message *string
                                                                                                }

                                                                                                  The attempted operation is not permitted.

                                                                                                  func (*OperationNotPermittedException) Error

                                                                                                  func (*OperationNotPermittedException) ErrorCode

                                                                                                  func (e *OperationNotPermittedException) ErrorCode() string

                                                                                                  func (*OperationNotPermittedException) ErrorFault

                                                                                                  func (*OperationNotPermittedException) ErrorMessage

                                                                                                  func (e *OperationNotPermittedException) ErrorMessage() string

                                                                                                  type Permission

                                                                                                  type Permission string
                                                                                                  const (
                                                                                                  	PermissionEnabled  Permission = "ENABLED"
                                                                                                  	PermissionDisabled Permission = "DISABLED"
                                                                                                  )

                                                                                                    Enum values for Permission

                                                                                                    func (Permission) Values

                                                                                                    func (Permission) Values() []Permission

                                                                                                      Values returns all known values for Permission. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                      type PlatformType

                                                                                                      type PlatformType string
                                                                                                      const (
                                                                                                      	PlatformTypeWindows           PlatformType = "WINDOWS"
                                                                                                      	PlatformTypeWindowsServer2016 PlatformType = "WINDOWS_SERVER_2016"
                                                                                                      	PlatformTypeWindowsServer2019 PlatformType = "WINDOWS_SERVER_2019"
                                                                                                      )

                                                                                                        Enum values for PlatformType

                                                                                                        func (PlatformType) Values

                                                                                                        func (PlatformType) Values() []PlatformType

                                                                                                          Values returns all known values for PlatformType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                          type RequestLimitExceededException

                                                                                                          type RequestLimitExceededException struct {
                                                                                                          	Message *string
                                                                                                          }

                                                                                                            AppStream 2.0 can’t process the request right now because the Describe calls from your AWS account are being throttled by Amazon EC2. Try again later.

                                                                                                            func (*RequestLimitExceededException) Error

                                                                                                            func (*RequestLimitExceededException) ErrorCode

                                                                                                            func (e *RequestLimitExceededException) ErrorCode() string

                                                                                                            func (*RequestLimitExceededException) ErrorFault

                                                                                                            func (*RequestLimitExceededException) ErrorMessage

                                                                                                            func (e *RequestLimitExceededException) ErrorMessage() string

                                                                                                            type ResourceAlreadyExistsException

                                                                                                            type ResourceAlreadyExistsException struct {
                                                                                                            	Message *string
                                                                                                            }

                                                                                                              The specified resource already exists.

                                                                                                              func (*ResourceAlreadyExistsException) Error

                                                                                                              func (*ResourceAlreadyExistsException) ErrorCode

                                                                                                              func (e *ResourceAlreadyExistsException) ErrorCode() string

                                                                                                              func (*ResourceAlreadyExistsException) ErrorFault

                                                                                                              func (*ResourceAlreadyExistsException) ErrorMessage

                                                                                                              func (e *ResourceAlreadyExistsException) ErrorMessage() string

                                                                                                              type ResourceError

                                                                                                              type ResourceError struct {
                                                                                                              
                                                                                                              	// The error code.
                                                                                                              	ErrorCode FleetErrorCode
                                                                                                              
                                                                                                              	// The error message.
                                                                                                              	ErrorMessage *string
                                                                                                              
                                                                                                              	// The time the error occurred.
                                                                                                              	ErrorTimestamp *time.Time
                                                                                                              }

                                                                                                                Describes a resource error.

                                                                                                                type ResourceInUseException

                                                                                                                type ResourceInUseException struct {
                                                                                                                	Message *string
                                                                                                                }

                                                                                                                  The specified resource is in use.

                                                                                                                  func (*ResourceInUseException) Error

                                                                                                                  func (e *ResourceInUseException) Error() string

                                                                                                                  func (*ResourceInUseException) ErrorCode

                                                                                                                  func (e *ResourceInUseException) ErrorCode() string

                                                                                                                  func (*ResourceInUseException) ErrorFault

                                                                                                                  func (e *ResourceInUseException) ErrorFault() smithy.ErrorFault

                                                                                                                  func (*ResourceInUseException) ErrorMessage

                                                                                                                  func (e *ResourceInUseException) ErrorMessage() string

                                                                                                                  type ResourceNotAvailableException

                                                                                                                  type ResourceNotAvailableException struct {
                                                                                                                  	Message *string
                                                                                                                  }

                                                                                                                    The specified resource exists and is not in use, but isn't available.

                                                                                                                    func (*ResourceNotAvailableException) Error

                                                                                                                    func (*ResourceNotAvailableException) ErrorCode

                                                                                                                    func (e *ResourceNotAvailableException) ErrorCode() string

                                                                                                                    func (*ResourceNotAvailableException) ErrorFault

                                                                                                                    func (*ResourceNotAvailableException) ErrorMessage

                                                                                                                    func (e *ResourceNotAvailableException) ErrorMessage() string

                                                                                                                    type ResourceNotFoundException

                                                                                                                    type ResourceNotFoundException struct {
                                                                                                                    	Message *string
                                                                                                                    }

                                                                                                                      The specified resource was not found.

                                                                                                                      func (*ResourceNotFoundException) Error

                                                                                                                      func (e *ResourceNotFoundException) Error() string

                                                                                                                      func (*ResourceNotFoundException) ErrorCode

                                                                                                                      func (e *ResourceNotFoundException) ErrorCode() string

                                                                                                                      func (*ResourceNotFoundException) ErrorFault

                                                                                                                      func (*ResourceNotFoundException) ErrorMessage

                                                                                                                      func (e *ResourceNotFoundException) ErrorMessage() string

                                                                                                                      type ServiceAccountCredentials

                                                                                                                      type ServiceAccountCredentials struct {
                                                                                                                      
                                                                                                                      	// The user name of the account. This account must have the following privileges:
                                                                                                                      	// create computer objects, join computers to the domain, and change/reset the
                                                                                                                      	// password on descendant computer objects for the organizational units specified.
                                                                                                                      	//
                                                                                                                      	// This member is required.
                                                                                                                      	AccountName *string
                                                                                                                      
                                                                                                                      	// The password for the account.
                                                                                                                      	//
                                                                                                                      	// This member is required.
                                                                                                                      	AccountPassword *string
                                                                                                                      }

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

                                                                                                                        type Session

                                                                                                                        type Session struct {
                                                                                                                        
                                                                                                                        	// The name of the fleet for the streaming session.
                                                                                                                        	//
                                                                                                                        	// This member is required.
                                                                                                                        	FleetName *string
                                                                                                                        
                                                                                                                        	// The identifier of the streaming session.
                                                                                                                        	//
                                                                                                                        	// This member is required.
                                                                                                                        	Id *string
                                                                                                                        
                                                                                                                        	// The name of the stack for the streaming session.
                                                                                                                        	//
                                                                                                                        	// This member is required.
                                                                                                                        	StackName *string
                                                                                                                        
                                                                                                                        	// The current state of the streaming session.
                                                                                                                        	//
                                                                                                                        	// This member is required.
                                                                                                                        	State SessionState
                                                                                                                        
                                                                                                                        	// The identifier of the user for whom the session was created.
                                                                                                                        	//
                                                                                                                        	// This member is required.
                                                                                                                        	UserId *string
                                                                                                                        
                                                                                                                        	// The authentication method. The user is authenticated using a streaming URL (API)
                                                                                                                        	// or SAML 2.0 federation (SAML).
                                                                                                                        	AuthenticationType AuthenticationType
                                                                                                                        
                                                                                                                        	// Specifies whether a user is connected to the streaming session.
                                                                                                                        	ConnectionState SessionConnectionState
                                                                                                                        
                                                                                                                        	// The time when the streaming session is set to expire. This time is based on the
                                                                                                                        	// MaxUserDurationinSeconds value, which determines the maximum length of time that
                                                                                                                        	// a streaming session can run. A streaming session might end earlier than the time
                                                                                                                        	// specified in SessionMaxExpirationTime, when the DisconnectTimeOutInSeconds
                                                                                                                        	// elapses or the user chooses to end his or her session. If the
                                                                                                                        	// DisconnectTimeOutInSeconds elapses, or the user chooses to end his or her
                                                                                                                        	// session, the streaming instance is terminated and the streaming session ends.
                                                                                                                        	MaxExpirationTime *time.Time
                                                                                                                        
                                                                                                                        	// The network details for the streaming session.
                                                                                                                        	NetworkAccessConfiguration *NetworkAccessConfiguration
                                                                                                                        
                                                                                                                        	// The time when a streaming instance is dedicated for the user.
                                                                                                                        	StartTime *time.Time
                                                                                                                        }

                                                                                                                          Describes a streaming session.

                                                                                                                          type SessionConnectionState

                                                                                                                          type SessionConnectionState string
                                                                                                                          const (
                                                                                                                          	SessionConnectionStateConnected    SessionConnectionState = "CONNECTED"
                                                                                                                          	SessionConnectionStateNotConnected SessionConnectionState = "NOT_CONNECTED"
                                                                                                                          )

                                                                                                                            Enum values for SessionConnectionState

                                                                                                                            func (SessionConnectionState) Values

                                                                                                                              Values returns all known values for SessionConnectionState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                              type SessionState

                                                                                                                              type SessionState string
                                                                                                                              const (
                                                                                                                              	SessionStateActive  SessionState = "ACTIVE"
                                                                                                                              	SessionStatePending SessionState = "PENDING"
                                                                                                                              	SessionStateExpired SessionState = "EXPIRED"
                                                                                                                              )

                                                                                                                                Enum values for SessionState

                                                                                                                                func (SessionState) Values

                                                                                                                                func (SessionState) Values() []SessionState

                                                                                                                                  Values returns all known values for SessionState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                  type SharedImagePermissions

                                                                                                                                  type SharedImagePermissions struct {
                                                                                                                                  
                                                                                                                                  	// Describes the permissions for a shared image.
                                                                                                                                  	//
                                                                                                                                  	// This member is required.
                                                                                                                                  	ImagePermissions *ImagePermissions
                                                                                                                                  
                                                                                                                                  	// The 12-digit identifier of the AWS account with which the image is shared.
                                                                                                                                  	//
                                                                                                                                  	// This member is required.
                                                                                                                                  	SharedAccountId *string
                                                                                                                                  }

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

                                                                                                                                    type Stack

                                                                                                                                    type Stack struct {
                                                                                                                                    
                                                                                                                                    	// The name of the stack.
                                                                                                                                    	//
                                                                                                                                    	// This member is required.
                                                                                                                                    	Name *string
                                                                                                                                    
                                                                                                                                    	// The list of virtual private cloud (VPC) interface endpoint objects. Users of the
                                                                                                                                    	// stack can connect to AppStream 2.0 only through the specified endpoints.
                                                                                                                                    	AccessEndpoints []AccessEndpoint
                                                                                                                                    
                                                                                                                                    	// The persistent application settings for users of the stack.
                                                                                                                                    	ApplicationSettings *ApplicationSettingsResponse
                                                                                                                                    
                                                                                                                                    	// The ARN of the stack.
                                                                                                                                    	Arn *string
                                                                                                                                    
                                                                                                                                    	// The time the stack was created.
                                                                                                                                    	CreatedTime *time.Time
                                                                                                                                    
                                                                                                                                    	// The description to display.
                                                                                                                                    	Description *string
                                                                                                                                    
                                                                                                                                    	// The stack name to display.
                                                                                                                                    	DisplayName *string
                                                                                                                                    
                                                                                                                                    	// The domains where AppStream 2.0 streaming sessions can be embedded in an iframe.
                                                                                                                                    	// You must approve the domains that you want to host embedded AppStream 2.0
                                                                                                                                    	// streaming sessions.
                                                                                                                                    	EmbedHostDomains []string
                                                                                                                                    
                                                                                                                                    	// The URL that users are redirected to after they click the Send Feedback link. If
                                                                                                                                    	// no URL is specified, no Send Feedback link is displayed.
                                                                                                                                    	FeedbackURL *string
                                                                                                                                    
                                                                                                                                    	// The URL that users are redirected to after their streaming session ends.
                                                                                                                                    	RedirectURL *string
                                                                                                                                    
                                                                                                                                    	// The errors for the stack.
                                                                                                                                    	StackErrors []StackError
                                                                                                                                    
                                                                                                                                    	// The storage connectors to enable.
                                                                                                                                    	StorageConnectors []StorageConnector
                                                                                                                                    
                                                                                                                                    	// The actions that are enabled or disabled for users during their streaming
                                                                                                                                    	// sessions. By default these actions are enabled.
                                                                                                                                    	UserSettings []UserSetting
                                                                                                                                    }

                                                                                                                                      Describes a stack.

                                                                                                                                      type StackAttribute

                                                                                                                                      type StackAttribute string
                                                                                                                                      const (
                                                                                                                                      	StackAttributeStorageConnectors           StackAttribute = "STORAGE_CONNECTORS"
                                                                                                                                      	StackAttributeStorageConnectorHomefolders StackAttribute = "STORAGE_CONNECTOR_HOMEFOLDERS"
                                                                                                                                      	StackAttributeStorageConnectorGoogleDrive StackAttribute = "STORAGE_CONNECTOR_GOOGLE_DRIVE"
                                                                                                                                      	StackAttributeStorageConnectorOneDrive    StackAttribute = "STORAGE_CONNECTOR_ONE_DRIVE"
                                                                                                                                      	StackAttributeRedirectUrl                 StackAttribute = "REDIRECT_URL"
                                                                                                                                      	StackAttributeFeedbackUrl                 StackAttribute = "FEEDBACK_URL"
                                                                                                                                      	StackAttributeThemeName                   StackAttribute = "THEME_NAME"
                                                                                                                                      	StackAttributeUserSettings                StackAttribute = "USER_SETTINGS"
                                                                                                                                      	StackAttributeEmbedHostDomains            StackAttribute = "EMBED_HOST_DOMAINS"
                                                                                                                                      	StackAttributeIamRoleArn                  StackAttribute = "IAM_ROLE_ARN"
                                                                                                                                      	StackAttributeAccessEndpoints             StackAttribute = "ACCESS_ENDPOINTS"
                                                                                                                                      )

                                                                                                                                        Enum values for StackAttribute

                                                                                                                                        func (StackAttribute) Values

                                                                                                                                        func (StackAttribute) Values() []StackAttribute

                                                                                                                                          Values returns all known values for StackAttribute. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                          type StackError

                                                                                                                                          type StackError struct {
                                                                                                                                          
                                                                                                                                          	// The error code.
                                                                                                                                          	ErrorCode StackErrorCode
                                                                                                                                          
                                                                                                                                          	// The error message.
                                                                                                                                          	ErrorMessage *string
                                                                                                                                          }

                                                                                                                                            Describes a stack error.

                                                                                                                                            type StackErrorCode

                                                                                                                                            type StackErrorCode string
                                                                                                                                            const (
                                                                                                                                            	StackErrorCodeStorageConnectorError StackErrorCode = "STORAGE_CONNECTOR_ERROR"
                                                                                                                                            	StackErrorCodeInternalServiceError  StackErrorCode = "INTERNAL_SERVICE_ERROR"
                                                                                                                                            )

                                                                                                                                              Enum values for StackErrorCode

                                                                                                                                              func (StackErrorCode) Values

                                                                                                                                              func (StackErrorCode) Values() []StackErrorCode

                                                                                                                                                Values returns all known values for StackErrorCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                type StorageConnector

                                                                                                                                                type StorageConnector struct {
                                                                                                                                                
                                                                                                                                                	// The type of storage connector.
                                                                                                                                                	//
                                                                                                                                                	// This member is required.
                                                                                                                                                	ConnectorType StorageConnectorType
                                                                                                                                                
                                                                                                                                                	// The names of the domains for the account.
                                                                                                                                                	Domains []string
                                                                                                                                                
                                                                                                                                                	// The ARN of the storage connector.
                                                                                                                                                	ResourceIdentifier *string
                                                                                                                                                }

                                                                                                                                                  Describes a connector that enables persistent storage for users.

                                                                                                                                                  type StorageConnectorType

                                                                                                                                                  type StorageConnectorType string
                                                                                                                                                  const (
                                                                                                                                                  	StorageConnectorTypeHomefolders StorageConnectorType = "HOMEFOLDERS"
                                                                                                                                                  	StorageConnectorTypeGoogleDrive StorageConnectorType = "GOOGLE_DRIVE"
                                                                                                                                                  	StorageConnectorTypeOneDrive    StorageConnectorType = "ONE_DRIVE"
                                                                                                                                                  )

                                                                                                                                                    Enum values for StorageConnectorType

                                                                                                                                                    func (StorageConnectorType) Values

                                                                                                                                                      Values returns all known values for StorageConnectorType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                      type StreamView

                                                                                                                                                      type StreamView string
                                                                                                                                                      const (
                                                                                                                                                      	StreamViewApp     StreamView = "APP"
                                                                                                                                                      	StreamViewDesktop StreamView = "DESKTOP"
                                                                                                                                                      )

                                                                                                                                                        Enum values for StreamView

                                                                                                                                                        func (StreamView) Values

                                                                                                                                                        func (StreamView) Values() []StreamView

                                                                                                                                                          Values returns all known values for StreamView. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                          type UsageReportExecutionErrorCode

                                                                                                                                                          type UsageReportExecutionErrorCode string
                                                                                                                                                          const (
                                                                                                                                                          	UsageReportExecutionErrorCodeResourceNotFound     UsageReportExecutionErrorCode = "RESOURCE_NOT_FOUND"
                                                                                                                                                          	UsageReportExecutionErrorCodeAccessDenied         UsageReportExecutionErrorCode = "ACCESS_DENIED"
                                                                                                                                                          	UsageReportExecutionErrorCodeInternalServiceError UsageReportExecutionErrorCode = "INTERNAL_SERVICE_ERROR"
                                                                                                                                                          )

                                                                                                                                                            Enum values for UsageReportExecutionErrorCode

                                                                                                                                                            func (UsageReportExecutionErrorCode) Values

                                                                                                                                                              Values returns all known values for UsageReportExecutionErrorCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                              type UsageReportSchedule

                                                                                                                                                              type UsageReportSchedule string
                                                                                                                                                              const (
                                                                                                                                                              	UsageReportScheduleDaily UsageReportSchedule = "DAILY"
                                                                                                                                                              )

                                                                                                                                                                Enum values for UsageReportSchedule

                                                                                                                                                                func (UsageReportSchedule) Values

                                                                                                                                                                  Values returns all known values for UsageReportSchedule. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                  type UsageReportSubscription

                                                                                                                                                                  type UsageReportSubscription struct {
                                                                                                                                                                  
                                                                                                                                                                  	// The time when the last usage report was generated.
                                                                                                                                                                  	LastGeneratedReportDate *time.Time
                                                                                                                                                                  
                                                                                                                                                                  	// The Amazon S3 bucket where generated reports are stored. If you enabled
                                                                                                                                                                  	// on-instance session scripts and Amazon S3 logging for your session script
                                                                                                                                                                  	// configuration, AppStream 2.0 created an S3 bucket to store the script output.
                                                                                                                                                                  	// The bucket is unique to your account and Region. When you enable usage reporting
                                                                                                                                                                  	// in this case, AppStream 2.0 uses the same bucket to store your usage reports. If
                                                                                                                                                                  	// you haven't already enabled on-instance session scripts, when you enable usage
                                                                                                                                                                  	// reports, AppStream 2.0 creates a new S3 bucket.
                                                                                                                                                                  	S3BucketName *string
                                                                                                                                                                  
                                                                                                                                                                  	// The schedule for generating usage reports.
                                                                                                                                                                  	Schedule UsageReportSchedule
                                                                                                                                                                  
                                                                                                                                                                  	// The errors that were returned if usage reports couldn't be generated.
                                                                                                                                                                  	SubscriptionErrors []LastReportGenerationExecutionError
                                                                                                                                                                  }

                                                                                                                                                                    Describes information about the usage report subscription.

                                                                                                                                                                    type User

                                                                                                                                                                    type User struct {
                                                                                                                                                                    
                                                                                                                                                                    	// The authentication type for the user.
                                                                                                                                                                    	//
                                                                                                                                                                    	// This member is required.
                                                                                                                                                                    	AuthenticationType AuthenticationType
                                                                                                                                                                    
                                                                                                                                                                    	// The ARN of the user.
                                                                                                                                                                    	Arn *string
                                                                                                                                                                    
                                                                                                                                                                    	// The date and time the user was created in the user pool.
                                                                                                                                                                    	CreatedTime *time.Time
                                                                                                                                                                    
                                                                                                                                                                    	// Specifies whether the user in the user pool is enabled.
                                                                                                                                                                    	Enabled bool
                                                                                                                                                                    
                                                                                                                                                                    	// The first name, or given name, of the user.
                                                                                                                                                                    	FirstName *string
                                                                                                                                                                    
                                                                                                                                                                    	// The last name, or surname, of the user.
                                                                                                                                                                    	LastName *string
                                                                                                                                                                    
                                                                                                                                                                    	// The status of the user in the user pool. The status can be one of the
                                                                                                                                                                    	// following:
                                                                                                                                                                    	//
                                                                                                                                                                    	// * UNCONFIRMED – The user is created but not confirmed.
                                                                                                                                                                    	//
                                                                                                                                                                    	// * CONFIRMED
                                                                                                                                                                    	// – The user is confirmed.
                                                                                                                                                                    	//
                                                                                                                                                                    	// * ARCHIVED – The user is no longer active.
                                                                                                                                                                    	//
                                                                                                                                                                    	// *
                                                                                                                                                                    	// COMPROMISED – The user is disabled because of a potential security threat.
                                                                                                                                                                    	//
                                                                                                                                                                    	// *
                                                                                                                                                                    	// UNKNOWN – The user status is not known.
                                                                                                                                                                    	Status *string
                                                                                                                                                                    
                                                                                                                                                                    	// The email address of the user. Users' email addresses are case-sensitive.
                                                                                                                                                                    	UserName *string
                                                                                                                                                                    }

                                                                                                                                                                      Describes a user in the user pool.

                                                                                                                                                                      type UserSetting

                                                                                                                                                                      type UserSetting struct {
                                                                                                                                                                      
                                                                                                                                                                      	// The action that is enabled or disabled.
                                                                                                                                                                      	//
                                                                                                                                                                      	// This member is required.
                                                                                                                                                                      	Action Action
                                                                                                                                                                      
                                                                                                                                                                      	// Indicates whether the action is enabled or disabled.
                                                                                                                                                                      	//
                                                                                                                                                                      	// This member is required.
                                                                                                                                                                      	Permission Permission
                                                                                                                                                                      }

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

                                                                                                                                                                        type UserStackAssociation

                                                                                                                                                                        type UserStackAssociation struct {
                                                                                                                                                                        
                                                                                                                                                                        	// The authentication type for the user.
                                                                                                                                                                        	//
                                                                                                                                                                        	// This member is required.
                                                                                                                                                                        	AuthenticationType AuthenticationType
                                                                                                                                                                        
                                                                                                                                                                        	// The name of the stack that is associated with the user.
                                                                                                                                                                        	//
                                                                                                                                                                        	// This member is required.
                                                                                                                                                                        	StackName *string
                                                                                                                                                                        
                                                                                                                                                                        	// The email address of the user who is associated with the stack. Users' email
                                                                                                                                                                        	// addresses are case-sensitive.
                                                                                                                                                                        	//
                                                                                                                                                                        	// This member is required.
                                                                                                                                                                        	UserName *string
                                                                                                                                                                        
                                                                                                                                                                        	// Specifies whether a welcome email is sent to a user after the user is created in
                                                                                                                                                                        	// the user pool.
                                                                                                                                                                        	SendEmailNotification bool
                                                                                                                                                                        }

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

                                                                                                                                                                          type UserStackAssociationError

                                                                                                                                                                          type UserStackAssociationError struct {
                                                                                                                                                                          
                                                                                                                                                                          	// The error code for the error that is returned when a user can’t be associated
                                                                                                                                                                          	// with or disassociated from a stack.
                                                                                                                                                                          	ErrorCode UserStackAssociationErrorCode
                                                                                                                                                                          
                                                                                                                                                                          	// The error message for the error that is returned when a user can’t be associated
                                                                                                                                                                          	// with or disassociated from a stack.
                                                                                                                                                                          	ErrorMessage *string
                                                                                                                                                                          
                                                                                                                                                                          	// Information about the user and associated stack.
                                                                                                                                                                          	UserStackAssociation *UserStackAssociation
                                                                                                                                                                          }

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

                                                                                                                                                                            type UserStackAssociationErrorCode

                                                                                                                                                                            type UserStackAssociationErrorCode string
                                                                                                                                                                            const (
                                                                                                                                                                            	UserStackAssociationErrorCodeStackNotFound     UserStackAssociationErrorCode = "STACK_NOT_FOUND"
                                                                                                                                                                            	UserStackAssociationErrorCodeUserNameNotFound  UserStackAssociationErrorCode = "USER_NAME_NOT_FOUND"
                                                                                                                                                                            	UserStackAssociationErrorCodeDirectoryNotFound UserStackAssociationErrorCode = "DIRECTORY_NOT_FOUND"
                                                                                                                                                                            	UserStackAssociationErrorCodeInternalError     UserStackAssociationErrorCode = "INTERNAL_ERROR"
                                                                                                                                                                            )

                                                                                                                                                                              Enum values for UserStackAssociationErrorCode

                                                                                                                                                                              func (UserStackAssociationErrorCode) Values

                                                                                                                                                                                Values returns all known values for UserStackAssociationErrorCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                type VisibilityType

                                                                                                                                                                                type VisibilityType string
                                                                                                                                                                                const (
                                                                                                                                                                                	VisibilityTypePublic  VisibilityType = "PUBLIC"
                                                                                                                                                                                	VisibilityTypePrivate VisibilityType = "PRIVATE"
                                                                                                                                                                                	VisibilityTypeShared  VisibilityType = "SHARED"
                                                                                                                                                                                )

                                                                                                                                                                                  Enum values for VisibilityType

                                                                                                                                                                                  func (VisibilityType) Values

                                                                                                                                                                                  func (VisibilityType) Values() []VisibilityType

                                                                                                                                                                                    Values returns all known values for VisibilityType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                    type VpcConfig

                                                                                                                                                                                    type VpcConfig struct {
                                                                                                                                                                                    
                                                                                                                                                                                    	// The identifiers of the security groups for the fleet or image builder.
                                                                                                                                                                                    	SecurityGroupIds []string
                                                                                                                                                                                    
                                                                                                                                                                                    	// The identifiers of the subnets to which a network interface is attached from the
                                                                                                                                                                                    	// fleet instance or image builder instance. Fleet instances use one or more
                                                                                                                                                                                    	// subnets. Image builder instances use one subnet.
                                                                                                                                                                                    	SubnetIds []string
                                                                                                                                                                                    }

                                                                                                                                                                                      Describes VPC configuration information for fleets and image builders.