Module aws_sdk_workspaces::types

Data structures used by operation inputs/outputs.

Modules

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

Structs

• AccountLink

  Information about about the account link.

• AccountModification

  Describes a modification to the configuration of Bring Your Own License (BYOL) for the specified account.

• ApplicationResourceAssociation

  Describes the association between an application and an application resource.

• AssociationStateReason

  Indicates the reason that the association deployment failed, including the error code and error message.

• BundleResourceAssociation

  Describes the association between an application and a bundle resource.

• CertificateBasedAuthProperties

  Describes the properties of the certificate-based authentication you want to use with your WorkSpaces.

• ClientProperties

  Describes an Amazon WorkSpaces client.

• ClientPropertiesResult

  Information about the Amazon WorkSpaces client.

• ComputeType

  Describes the compute type of the bundle.

• ConnectClientAddIn

  Describes an Amazon Connect client add-in.

• ConnectionAlias

  Describes a connection alias. Connection aliases are used for cross-Region redirection. For more information, see Cross-Region Redirection for Amazon WorkSpaces.

• ConnectionAliasAssociation

  Describes a connection alias association that is used for cross-Region redirection. For more information, see Cross-Region Redirection for Amazon WorkSpaces.

• ConnectionAliasPermission

  Describes the permissions for a connection alias. Connection aliases are used for cross-Region redirection. For more information, see Cross-Region Redirection for Amazon WorkSpaces.

• DataReplicationSettings

  Describes the data replication settings.

• DefaultClientBrandingAttributes

  Returns default client branding attributes that were imported. These attributes display on the client login screen.

• DefaultImportClientBrandingAttributes

  The default client branding attributes to be imported. These attributes display on the client login screen.

• DefaultWorkspaceCreationProperties

  Describes the default values that are used to create WorkSpaces. For more information, see Update Directory Details for Your WorkSpaces.

• ErrorDetails

  Describes in-depth details about the error. These details include the possible causes of the error and troubleshooting information.

• FailedCreateStandbyWorkspacesRequest

  Describes the standby WorkSpace that could not be created.

• FailedCreateWorkspaceRequest

  Describes a WorkSpace that cannot be created.

• FailedWorkspaceChangeRequest

  Describes a WorkSpace that could not be rebooted. (RebootWorkspaces), rebuilt (RebuildWorkspaces), restored (RestoreWorkspace), terminated (TerminateWorkspaces), started (StartWorkspaces), or stopped (StopWorkspaces).

• ImagePermission

  Describes the Amazon Web Services accounts that have been granted permission to use a shared image. For more information about sharing images, see Share or Unshare a Custom WorkSpaces Image.

• ImageResourceAssociation

  Describes the association between an application and an image resource.

• IosClientBrandingAttributes

  The client branding attributes for iOS device types. These attributes are displayed on the iOS client login screen only.

• IosImportClientBrandingAttributes

  The client branding attributes to import for iOS device types. These attributes are displayed on the iOS client login screen.

• IpRuleItem

  Describes a rule for an IP access control group.

• ModificationState

  Describes a WorkSpace modification.

• OperatingSystem

  The operating system that the image is running.

• PendingCreateStandbyWorkspacesRequest

  Information about the standby WorkSpace.

• RebootRequest

  Describes the information used to reboot a WorkSpace.

• RebuildRequest

  Describes the information used to rebuild a WorkSpace.

• RelatedWorkspaceProperties

  Describes the related WorkSpace. The related WorkSpace could be a standby WorkSpace or primary WorkSpace related to the specified WorkSpace.

• RootStorage

  Describes the root volume for a WorkSpace bundle.

• SamlProperties

  Describes the enablement status, user access URL, and relay state parameter name that are used for configuring federation with an SAML 2.0 identity provider.

• SelfservicePermissions

  Describes the self-service permissions for a directory. For more information, see Enable Self-Service WorkSpace Management Capabilities for Your Users.

• Snapshot

  Describes a snapshot.

• StandbyWorkspace

  Describes a standby WorkSpace.

• StandbyWorkspacesProperties

  Describes the properties of the related standby WorkSpaces.

• StartRequest

  Information used to start a WorkSpace.

• StopRequest

  Describes the information used to stop a WorkSpace.

• Tag

  Describes a tag.

• TerminateRequest

  Describes the information used to terminate a WorkSpace.

• UpdateResult

  Describes whether a WorkSpace image needs to be updated with the latest drivers and other components required by Amazon WorkSpaces.

• UserStorage

  Describes the user volume for a WorkSpace bundle.

• WorkSpaceApplication

  Describes the WorkSpace application.

• WorkSpaceApplicationDeployment

  Describes the WorkSpace application deployment.

• Workspace

  Describes a WorkSpace.

• WorkspaceAccessProperties

  The device types and operating systems that can be used to access a WorkSpace. For more information, see Amazon WorkSpaces Client Network Requirements.

• WorkspaceBundle

  Describes a WorkSpace bundle.

• WorkspaceConnectionStatus

  Describes the connection status of a WorkSpace.

• WorkspaceCreationProperties

  Describes the default properties that are used for creating WorkSpaces. For more information, see Update Directory Details for Your WorkSpaces.

• WorkspaceDirectory

  Describes a directory that is used with Amazon WorkSpaces.

• WorkspaceImage

  Describes a WorkSpace image.

• WorkspaceProperties

  Describes a WorkSpace.

• WorkspaceRequest

  Describes the information used to create a WorkSpace.

• WorkspaceResourceAssociation

  Describes the association between an application and a WorkSpace resource.

• WorkspacesIpGroup

  Describes an IP access control group.

Enums

• AccessPropertyValue
  When writing a match expression against AccessPropertyValue, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AccountLinkStatusEnum
  When writing a match expression against AccountLinkStatusEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Application
  When writing a match expression against Application, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ApplicationAssociatedResourceType
  When writing a match expression against ApplicationAssociatedResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AssociationErrorCode
  When writing a match expression against AssociationErrorCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AssociationState
  When writing a match expression against AssociationState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AssociationStatus
  When writing a match expression against AssociationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• BundleAssociatedResourceType
  When writing a match expression against BundleAssociatedResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• BundleType
  When writing a match expression against BundleType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• CertificateBasedAuthStatusEnum
  When writing a match expression against CertificateBasedAuthStatusEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ClientDeviceType
  When writing a match expression against ClientDeviceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Compute
  When writing a match expression against Compute, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ConnectionAliasState
  When writing a match expression against ConnectionAliasState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ConnectionState
  When writing a match expression against ConnectionState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DataReplication
  When writing a match expression against DataReplication, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DedicatedTenancyAccountType
  When writing a match expression against DedicatedTenancyAccountType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DedicatedTenancyModificationStateEnum
  When writing a match expression against DedicatedTenancyModificationStateEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DedicatedTenancySupportEnum
  When writing a match expression against DedicatedTenancySupportEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DedicatedTenancySupportResultEnum
  When writing a match expression against DedicatedTenancySupportResultEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DeletableCertificateBasedAuthProperty
  When writing a match expression against DeletableCertificateBasedAuthProperty, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DeletableSamlProperty
  When writing a match expression against DeletableSamlProperty, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ImageAssociatedResourceType
  When writing a match expression against ImageAssociatedResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ImageType
  When writing a match expression against ImageType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• LogUploadEnum
  When writing a match expression against LogUploadEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ModificationResourceEnum
  When writing a match expression against ModificationResourceEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ModificationStateEnum
  When writing a match expression against ModificationStateEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• OperatingSystemName
  When writing a match expression against OperatingSystemName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• OperatingSystemType
  When writing a match expression against OperatingSystemType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Protocol
  When writing a match expression against Protocol, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ReconnectEnum
  When writing a match expression against ReconnectEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RunningMode
  When writing a match expression against RunningMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SamlStatusEnum
  When writing a match expression against SamlStatusEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• StandbyWorkspaceRelationshipType
  When writing a match expression against StandbyWorkspaceRelationshipType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• TargetWorkspaceState
  When writing a match expression against TargetWorkspaceState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• Tenancy
  When writing a match expression against Tenancy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• WorkSpaceApplicationLicenseType
  When writing a match expression against WorkSpaceApplicationLicenseType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• WorkSpaceApplicationState
  When writing a match expression against WorkSpaceApplicationState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• WorkSpaceAssociatedResourceType
  When writing a match expression against WorkSpaceAssociatedResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• WorkspaceBundleState
  When writing a match expression against WorkspaceBundleState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• WorkspaceDirectoryState
  When writing a match expression against WorkspaceDirectoryState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• WorkspaceDirectoryType
  When writing a match expression against WorkspaceDirectoryType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• WorkspaceImageErrorDetailCode
  When writing a match expression against WorkspaceImageErrorDetailCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• WorkspaceImageIngestionProcess
  When writing a match expression against WorkspaceImageIngestionProcess, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• WorkspaceImageRequiredTenancy
  When writing a match expression against WorkspaceImageRequiredTenancy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• WorkspaceImageState
  When writing a match expression against WorkspaceImageState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• WorkspaceState
  When writing a match expression against WorkspaceState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.