workspaces

package
v7.0.0-alpha.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jun 20, 2025 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ConnectionAlias

type ConnectionAlias struct {
	pulumi.CustomResourceState

	// The connection string specified for the connection alias. The connection string must be in the form of a fully qualified domain name (FQDN), such as www.example.com.
	ConnectionString pulumi.StringOutput `pulumi:"connectionString"`
	// The identifier of the Amazon Web Services account that owns the connection alias.
	OwnerAccountId pulumi.StringOutput `pulumi:"ownerAccountId"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
	// The current state of the connection alias.
	State pulumi.StringOutput `pulumi:"state"`
	// A map of tags assigned to the WorkSpaces Connection Alias. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll  pulumi.StringMapOutput           `pulumi:"tagsAll"`
	Timeouts ConnectionAliasTimeoutsPtrOutput `pulumi:"timeouts"`
}

Resource for managing an AWS WorkSpaces Connection Alias.

## Example Usage

### Basic Usage

```go package main

import (

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/workspaces"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := workspaces.NewConnectionAlias(ctx, "example", &workspaces.ConnectionAliasArgs{
			ConnectionString: pulumi.String("testdomain.test"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Using `pulumi import`, import WorkSpaces Connection Alias using the connection alias ID. For example:

```sh $ pulumi import aws:workspaces/connectionAlias:ConnectionAlias example rft-8012925589 ```

func GetConnectionAlias

func GetConnectionAlias(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ConnectionAliasState, opts ...pulumi.ResourceOption) (*ConnectionAlias, error)

GetConnectionAlias gets an existing ConnectionAlias resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewConnectionAlias

func NewConnectionAlias(ctx *pulumi.Context,
	name string, args *ConnectionAliasArgs, opts ...pulumi.ResourceOption) (*ConnectionAlias, error)

NewConnectionAlias registers a new resource with the given unique name, arguments, and options.

func (*ConnectionAlias) ElementType

func (*ConnectionAlias) ElementType() reflect.Type

func (*ConnectionAlias) ToConnectionAliasOutput

func (i *ConnectionAlias) ToConnectionAliasOutput() ConnectionAliasOutput

func (*ConnectionAlias) ToConnectionAliasOutputWithContext

func (i *ConnectionAlias) ToConnectionAliasOutputWithContext(ctx context.Context) ConnectionAliasOutput

type ConnectionAliasArgs

type ConnectionAliasArgs struct {
	// The connection string specified for the connection alias. The connection string must be in the form of a fully qualified domain name (FQDN), such as www.example.com.
	ConnectionString pulumi.StringInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// A map of tags assigned to the WorkSpaces Connection Alias. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags     pulumi.StringMapInput
	Timeouts ConnectionAliasTimeoutsPtrInput
}

The set of arguments for constructing a ConnectionAlias resource.

func (ConnectionAliasArgs) ElementType

func (ConnectionAliasArgs) ElementType() reflect.Type

type ConnectionAliasArray

type ConnectionAliasArray []ConnectionAliasInput

func (ConnectionAliasArray) ElementType

func (ConnectionAliasArray) ElementType() reflect.Type

func (ConnectionAliasArray) ToConnectionAliasArrayOutput

func (i ConnectionAliasArray) ToConnectionAliasArrayOutput() ConnectionAliasArrayOutput

func (ConnectionAliasArray) ToConnectionAliasArrayOutputWithContext

func (i ConnectionAliasArray) ToConnectionAliasArrayOutputWithContext(ctx context.Context) ConnectionAliasArrayOutput

type ConnectionAliasArrayInput

type ConnectionAliasArrayInput interface {
	pulumi.Input

	ToConnectionAliasArrayOutput() ConnectionAliasArrayOutput
	ToConnectionAliasArrayOutputWithContext(context.Context) ConnectionAliasArrayOutput
}

ConnectionAliasArrayInput is an input type that accepts ConnectionAliasArray and ConnectionAliasArrayOutput values. You can construct a concrete instance of `ConnectionAliasArrayInput` via:

ConnectionAliasArray{ ConnectionAliasArgs{...} }

type ConnectionAliasArrayOutput

type ConnectionAliasArrayOutput struct{ *pulumi.OutputState }

func (ConnectionAliasArrayOutput) ElementType

func (ConnectionAliasArrayOutput) ElementType() reflect.Type

func (ConnectionAliasArrayOutput) Index

func (ConnectionAliasArrayOutput) ToConnectionAliasArrayOutput

func (o ConnectionAliasArrayOutput) ToConnectionAliasArrayOutput() ConnectionAliasArrayOutput

func (ConnectionAliasArrayOutput) ToConnectionAliasArrayOutputWithContext

func (o ConnectionAliasArrayOutput) ToConnectionAliasArrayOutputWithContext(ctx context.Context) ConnectionAliasArrayOutput

type ConnectionAliasInput

type ConnectionAliasInput interface {
	pulumi.Input

	ToConnectionAliasOutput() ConnectionAliasOutput
	ToConnectionAliasOutputWithContext(ctx context.Context) ConnectionAliasOutput
}

type ConnectionAliasMap

type ConnectionAliasMap map[string]ConnectionAliasInput

func (ConnectionAliasMap) ElementType

func (ConnectionAliasMap) ElementType() reflect.Type

func (ConnectionAliasMap) ToConnectionAliasMapOutput

func (i ConnectionAliasMap) ToConnectionAliasMapOutput() ConnectionAliasMapOutput

func (ConnectionAliasMap) ToConnectionAliasMapOutputWithContext

func (i ConnectionAliasMap) ToConnectionAliasMapOutputWithContext(ctx context.Context) ConnectionAliasMapOutput

type ConnectionAliasMapInput

type ConnectionAliasMapInput interface {
	pulumi.Input

	ToConnectionAliasMapOutput() ConnectionAliasMapOutput
	ToConnectionAliasMapOutputWithContext(context.Context) ConnectionAliasMapOutput
}

ConnectionAliasMapInput is an input type that accepts ConnectionAliasMap and ConnectionAliasMapOutput values. You can construct a concrete instance of `ConnectionAliasMapInput` via:

ConnectionAliasMap{ "key": ConnectionAliasArgs{...} }

type ConnectionAliasMapOutput

type ConnectionAliasMapOutput struct{ *pulumi.OutputState }

func (ConnectionAliasMapOutput) ElementType

func (ConnectionAliasMapOutput) ElementType() reflect.Type

func (ConnectionAliasMapOutput) MapIndex

func (ConnectionAliasMapOutput) ToConnectionAliasMapOutput

func (o ConnectionAliasMapOutput) ToConnectionAliasMapOutput() ConnectionAliasMapOutput

func (ConnectionAliasMapOutput) ToConnectionAliasMapOutputWithContext

func (o ConnectionAliasMapOutput) ToConnectionAliasMapOutputWithContext(ctx context.Context) ConnectionAliasMapOutput

type ConnectionAliasOutput

type ConnectionAliasOutput struct{ *pulumi.OutputState }

func (ConnectionAliasOutput) ConnectionString

func (o ConnectionAliasOutput) ConnectionString() pulumi.StringOutput

The connection string specified for the connection alias. The connection string must be in the form of a fully qualified domain name (FQDN), such as www.example.com.

func (ConnectionAliasOutput) ElementType

func (ConnectionAliasOutput) ElementType() reflect.Type

func (ConnectionAliasOutput) OwnerAccountId

func (o ConnectionAliasOutput) OwnerAccountId() pulumi.StringOutput

The identifier of the Amazon Web Services account that owns the connection alias.

func (ConnectionAliasOutput) Region

Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.

func (ConnectionAliasOutput) State

The current state of the connection alias.

func (ConnectionAliasOutput) Tags

A map of tags assigned to the WorkSpaces Connection Alias. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.

func (ConnectionAliasOutput) TagsAll

A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

func (ConnectionAliasOutput) Timeouts

func (ConnectionAliasOutput) ToConnectionAliasOutput

func (o ConnectionAliasOutput) ToConnectionAliasOutput() ConnectionAliasOutput

func (ConnectionAliasOutput) ToConnectionAliasOutputWithContext

func (o ConnectionAliasOutput) ToConnectionAliasOutputWithContext(ctx context.Context) ConnectionAliasOutput

type ConnectionAliasState

type ConnectionAliasState struct {
	// The connection string specified for the connection alias. The connection string must be in the form of a fully qualified domain name (FQDN), such as www.example.com.
	ConnectionString pulumi.StringPtrInput
	// The identifier of the Amazon Web Services account that owns the connection alias.
	OwnerAccountId pulumi.StringPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// The current state of the connection alias.
	State pulumi.StringPtrInput
	// A map of tags assigned to the WorkSpaces Connection Alias. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll  pulumi.StringMapInput
	Timeouts ConnectionAliasTimeoutsPtrInput
}

func (ConnectionAliasState) ElementType

func (ConnectionAliasState) ElementType() reflect.Type

type ConnectionAliasTimeouts

type ConnectionAliasTimeouts struct {
	// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
	Create *string `pulumi:"create"`
	// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
	Delete *string `pulumi:"delete"`
}

type ConnectionAliasTimeoutsArgs

type ConnectionAliasTimeoutsArgs struct {
	// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
	Create pulumi.StringPtrInput `pulumi:"create"`
	// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
	Delete pulumi.StringPtrInput `pulumi:"delete"`
}

func (ConnectionAliasTimeoutsArgs) ElementType

func (ConnectionAliasTimeoutsArgs) ToConnectionAliasTimeoutsOutput

func (i ConnectionAliasTimeoutsArgs) ToConnectionAliasTimeoutsOutput() ConnectionAliasTimeoutsOutput

func (ConnectionAliasTimeoutsArgs) ToConnectionAliasTimeoutsOutputWithContext

func (i ConnectionAliasTimeoutsArgs) ToConnectionAliasTimeoutsOutputWithContext(ctx context.Context) ConnectionAliasTimeoutsOutput

func (ConnectionAliasTimeoutsArgs) ToConnectionAliasTimeoutsPtrOutput

func (i ConnectionAliasTimeoutsArgs) ToConnectionAliasTimeoutsPtrOutput() ConnectionAliasTimeoutsPtrOutput

func (ConnectionAliasTimeoutsArgs) ToConnectionAliasTimeoutsPtrOutputWithContext

func (i ConnectionAliasTimeoutsArgs) ToConnectionAliasTimeoutsPtrOutputWithContext(ctx context.Context) ConnectionAliasTimeoutsPtrOutput

type ConnectionAliasTimeoutsInput

type ConnectionAliasTimeoutsInput interface {
	pulumi.Input

	ToConnectionAliasTimeoutsOutput() ConnectionAliasTimeoutsOutput
	ToConnectionAliasTimeoutsOutputWithContext(context.Context) ConnectionAliasTimeoutsOutput
}

ConnectionAliasTimeoutsInput is an input type that accepts ConnectionAliasTimeoutsArgs and ConnectionAliasTimeoutsOutput values. You can construct a concrete instance of `ConnectionAliasTimeoutsInput` via:

ConnectionAliasTimeoutsArgs{...}

type ConnectionAliasTimeoutsOutput

type ConnectionAliasTimeoutsOutput struct{ *pulumi.OutputState }

func (ConnectionAliasTimeoutsOutput) Create

A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).

func (ConnectionAliasTimeoutsOutput) Delete

A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.

func (ConnectionAliasTimeoutsOutput) ElementType

func (ConnectionAliasTimeoutsOutput) ToConnectionAliasTimeoutsOutput

func (o ConnectionAliasTimeoutsOutput) ToConnectionAliasTimeoutsOutput() ConnectionAliasTimeoutsOutput

func (ConnectionAliasTimeoutsOutput) ToConnectionAliasTimeoutsOutputWithContext

func (o ConnectionAliasTimeoutsOutput) ToConnectionAliasTimeoutsOutputWithContext(ctx context.Context) ConnectionAliasTimeoutsOutput

func (ConnectionAliasTimeoutsOutput) ToConnectionAliasTimeoutsPtrOutput

func (o ConnectionAliasTimeoutsOutput) ToConnectionAliasTimeoutsPtrOutput() ConnectionAliasTimeoutsPtrOutput

func (ConnectionAliasTimeoutsOutput) ToConnectionAliasTimeoutsPtrOutputWithContext

func (o ConnectionAliasTimeoutsOutput) ToConnectionAliasTimeoutsPtrOutputWithContext(ctx context.Context) ConnectionAliasTimeoutsPtrOutput

type ConnectionAliasTimeoutsPtrInput

type ConnectionAliasTimeoutsPtrInput interface {
	pulumi.Input

	ToConnectionAliasTimeoutsPtrOutput() ConnectionAliasTimeoutsPtrOutput
	ToConnectionAliasTimeoutsPtrOutputWithContext(context.Context) ConnectionAliasTimeoutsPtrOutput
}

ConnectionAliasTimeoutsPtrInput is an input type that accepts ConnectionAliasTimeoutsArgs, ConnectionAliasTimeoutsPtr and ConnectionAliasTimeoutsPtrOutput values. You can construct a concrete instance of `ConnectionAliasTimeoutsPtrInput` via:

        ConnectionAliasTimeoutsArgs{...}

or:

        nil

type ConnectionAliasTimeoutsPtrOutput

type ConnectionAliasTimeoutsPtrOutput struct{ *pulumi.OutputState }

func (ConnectionAliasTimeoutsPtrOutput) Create

A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).

func (ConnectionAliasTimeoutsPtrOutput) Delete

A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.

func (ConnectionAliasTimeoutsPtrOutput) Elem

func (ConnectionAliasTimeoutsPtrOutput) ElementType

func (ConnectionAliasTimeoutsPtrOutput) ToConnectionAliasTimeoutsPtrOutput

func (o ConnectionAliasTimeoutsPtrOutput) ToConnectionAliasTimeoutsPtrOutput() ConnectionAliasTimeoutsPtrOutput

func (ConnectionAliasTimeoutsPtrOutput) ToConnectionAliasTimeoutsPtrOutputWithContext

func (o ConnectionAliasTimeoutsPtrOutput) ToConnectionAliasTimeoutsPtrOutputWithContext(ctx context.Context) ConnectionAliasTimeoutsPtrOutput

type Directory

type Directory struct {
	pulumi.CustomResourceState

	// Configuration for Active Directory integration when `workspaceType` is set to `POOLS`. Defined below.
	ActiveDirectoryConfig DirectoryActiveDirectoryConfigPtrOutput `pulumi:"activeDirectoryConfig"`
	// The directory alias.
	Alias pulumi.StringOutput `pulumi:"alias"`
	// Configuration of certificate-based authentication (CBA) integration. Requires SAML authentication to be enabled. Defined below.
	CertificateBasedAuthProperties DirectoryCertificateBasedAuthPropertiesOutput `pulumi:"certificateBasedAuthProperties"`
	// The user name for the service account.
	CustomerUserName pulumi.StringOutput `pulumi:"customerUserName"`
	// The directory identifier for registration in WorkSpaces service.
	DirectoryId pulumi.StringOutput `pulumi:"directoryId"`
	// The name of the directory.
	DirectoryName pulumi.StringOutput `pulumi:"directoryName"`
	// The directory type.
	DirectoryType pulumi.StringOutput `pulumi:"directoryType"`
	// The IP addresses of the DNS servers for the directory.
	DnsIpAddresses pulumi.StringArrayOutput `pulumi:"dnsIpAddresses"`
	// The identifier of the IAM role. This is the role that allows Amazon WorkSpaces to make calls to other services, such as Amazon EC2, on your behalf.
	IamRoleId pulumi.StringOutput `pulumi:"iamRoleId"`
	// The identifiers of the IP access control groups associated with the directory.
	IpGroupIds pulumi.StringArrayOutput `pulumi:"ipGroupIds"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
	// The registration code for the directory. This is the code that users enter in their Amazon WorkSpaces client application to connect to the directory.
	RegistrationCode pulumi.StringOutput `pulumi:"registrationCode"`
	// Configuration of SAML authentication integration. Defined below.
	SamlProperties DirectorySamlPropertiesOutput `pulumi:"samlProperties"`
	// Permissions to enable or disable self-service capabilities when `workspaceType` is set to `PERSONAL`.. Defined below.
	SelfServicePermissions DirectorySelfServicePermissionsOutput `pulumi:"selfServicePermissions"`
	// The identifiers of the subnets where the directory resides.
	SubnetIds pulumi.StringArrayOutput `pulumi:"subnetIds"`
	// A map of tags assigned to the WorkSpaces directory. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// Specifies the user identity type for the WorkSpaces directory. Valid values are `CUSTOMER_MANAGED`, `AWS_DIRECTORY_SERVICE`, `AWS_IAM_IDENTITY_CENTER`.
	//
	// > **Note:** When `workspaceType` is set to `POOLS`, the `directoryId` is automatically generated and cannot be manually set.
	UserIdentityType pulumi.StringOutput `pulumi:"userIdentityType"`
	// Specifies which devices and operating systems users can use to access their WorkSpaces. Defined below.
	WorkspaceAccessProperties DirectoryWorkspaceAccessPropertiesOutput `pulumi:"workspaceAccessProperties"`
	// Default properties that are used for creating WorkSpaces. Defined below.
	WorkspaceCreationProperties DirectoryWorkspaceCreationPropertiesOutput `pulumi:"workspaceCreationProperties"`
	// The description of the WorkSpaces directory when `workspaceType` is set to `POOLS`.
	WorkspaceDirectoryDescription pulumi.StringPtrOutput `pulumi:"workspaceDirectoryDescription"`
	// The name of the WorkSpaces directory when `workspaceType` is set to `POOLS`.
	WorkspaceDirectoryName pulumi.StringPtrOutput `pulumi:"workspaceDirectoryName"`
	// The identifier of the security group that is assigned to new WorkSpaces.
	WorkspaceSecurityGroupId pulumi.StringOutput `pulumi:"workspaceSecurityGroupId"`
	// Specifies the type of WorkSpaces directory. Valid values are `PERSONAL` and `POOLS`. Default is `PERSONAL`.
	WorkspaceType pulumi.StringPtrOutput `pulumi:"workspaceType"`
}

Provides a WorkSpaces directory in AWS WorkSpaces Service.

> **NOTE:** AWS WorkSpaces service requires [`workspaces_DefaultRole`](https://docs.aws.amazon.com/workspaces/latest/adminguide/workspaces-access-control.html#create-default-role) IAM role to operate normally.

## Example Usage

```go package main

import (

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/directoryservice"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/workspaces"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleVpc, err := ec2.NewVpc(ctx, "example", &ec2.VpcArgs{
			CidrBlock: pulumi.String("10.0.0.0/16"),
		})
		if err != nil {
			return err
		}
		exampleA, err := ec2.NewSubnet(ctx, "example_a", &ec2.SubnetArgs{
			VpcId:            exampleVpc.ID(),
			AvailabilityZone: pulumi.String("us-east-1a"),
			CidrBlock:        pulumi.String("10.0.0.0/24"),
		})
		if err != nil {
			return err
		}
		exampleB, err := ec2.NewSubnet(ctx, "example_b", &ec2.SubnetArgs{
			VpcId:            exampleVpc.ID(),
			AvailabilityZone: pulumi.String("us-east-1b"),
			CidrBlock:        pulumi.String("10.0.1.0/24"),
		})
		if err != nil {
			return err
		}
		exampleDirectory, err := directoryservice.NewDirectory(ctx, "example", &directoryservice.DirectoryArgs{
			Name:     pulumi.String("corp.example.com"),
			Password: pulumi.String("#S1ncerely"),
			Size:     pulumi.String("Small"),
			VpcSettings: &directoryservice.DirectoryVpcSettingsArgs{
				VpcId: exampleVpc.ID(),
				SubnetIds: pulumi.StringArray{
					exampleA.ID(),
					exampleB.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		workspaces, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
			Statements: []iam.GetPolicyDocumentStatement{
				{
					Actions: []string{
						"sts:AssumeRole",
					},
					Principals: []iam.GetPolicyDocumentStatementPrincipal{
						{
							Type: "Service",
							Identifiers: []string{
								"workspaces.amazonaws.com",
							},
						},
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		workspacesDefault, err := iam.NewRole(ctx, "workspaces_default", &iam.RoleArgs{
			Name:             pulumi.String("workspaces_DefaultRole"),
			AssumeRolePolicy: pulumi.String(workspaces.Json),
		})
		if err != nil {
			return err
		}
		workspacesDefaultServiceAccess, err := iam.NewRolePolicyAttachment(ctx, "workspaces_default_service_access", &iam.RolePolicyAttachmentArgs{
			Role:      workspacesDefault.Name,
			PolicyArn: pulumi.String("arn:aws:iam::aws:policy/AmazonWorkSpacesServiceAccess"),
		})
		if err != nil {
			return err
		}
		workspacesDefaultSelfServiceAccess, err := iam.NewRolePolicyAttachment(ctx, "workspaces_default_self_service_access", &iam.RolePolicyAttachmentArgs{
			Role:      workspacesDefault.Name,
			PolicyArn: pulumi.String("arn:aws:iam::aws:policy/AmazonWorkSpacesSelfServiceAccess"),
		})
		if err != nil {
			return err
		}
		exampleC, err := ec2.NewSubnet(ctx, "example_c", &ec2.SubnetArgs{
			VpcId:            exampleVpc.ID(),
			AvailabilityZone: pulumi.String("us-east-1c"),
			CidrBlock:        pulumi.String("10.0.2.0/24"),
		})
		if err != nil {
			return err
		}
		exampleD, err := ec2.NewSubnet(ctx, "example_d", &ec2.SubnetArgs{
			VpcId:            exampleVpc.ID(),
			AvailabilityZone: pulumi.String("us-east-1d"),
			CidrBlock:        pulumi.String("10.0.3.0/24"),
		})
		if err != nil {
			return err
		}
		_, err = workspaces.NewDirectory(ctx, "example", &workspaces.DirectoryArgs{
			DirectoryId: exampleDirectory.ID(),
			SubnetIds: pulumi.StringArray{
				exampleC.ID(),
				exampleD.ID(),
			},
			Tags: pulumi.StringMap{
				"Example": pulumi.String("true"),
			},
			CertificateBasedAuthProperties: &workspaces.DirectoryCertificateBasedAuthPropertiesArgs{
				CertificateAuthorityArn: pulumi.String("arn:aws:acm-pca:us-east-1:123456789012:certificate-authority/12345678-1234-1234-1234-123456789012"),
				Status:                  pulumi.String("ENABLED"),
			},
			SamlProperties: &workspaces.DirectorySamlPropertiesArgs{
				UserAccessUrl: pulumi.String("https://sso.example.com/"),
				Status:        pulumi.String("ENABLED"),
			},
			SelfServicePermissions: &workspaces.DirectorySelfServicePermissionsArgs{
				ChangeComputeType:  pulumi.Bool(true),
				IncreaseVolumeSize: pulumi.Bool(true),
				RebuildWorkspace:   pulumi.Bool(true),
				RestartWorkspace:   pulumi.Bool(true),
				SwitchRunningMode:  pulumi.Bool(true),
			},
			WorkspaceAccessProperties: &workspaces.DirectoryWorkspaceAccessPropertiesArgs{
				DeviceTypeAndroid:    pulumi.String("ALLOW"),
				DeviceTypeChromeos:   pulumi.String("ALLOW"),
				DeviceTypeIos:        pulumi.String("ALLOW"),
				DeviceTypeLinux:      pulumi.String("DENY"),
				DeviceTypeOsx:        pulumi.String("ALLOW"),
				DeviceTypeWeb:        pulumi.String("DENY"),
				DeviceTypeWindows:    pulumi.String("DENY"),
				DeviceTypeZeroclient: pulumi.String("DENY"),
			},
			WorkspaceCreationProperties: &workspaces.DirectoryWorkspaceCreationPropertiesArgs{
				CustomSecurityGroupId:           pulumi.Any(exampleAwsSecurityGroup.Id),
				DefaultOu:                       pulumi.String("OU=AWS,DC=Workgroup,DC=Example,DC=com"),
				EnableInternetAccess:            pulumi.Bool(true),
				EnableMaintenanceMode:           pulumi.Bool(true),
				UserEnabledAsLocalAdministrator: pulumi.Bool(true),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			workspacesDefaultServiceAccess,
			workspacesDefaultSelfServiceAccess,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

```

### WorkSpaces Pools

```go package main

import (

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/workspaces"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := workspaces.NewDirectory(ctx, "example", &workspaces.DirectoryArgs{
			SubnetIds: pulumi.StringArray{
				exampleC.Id,
				exampleD.Id,
			},
			WorkspaceType:                 pulumi.String("POOLS"),
			WorkspaceDirectoryName:        pulumi.String("Pool directory"),
			WorkspaceDirectoryDescription: pulumi.String("WorkSpaces Pools directory"),
			UserIdentityType:              pulumi.String("CUSTOMER_MANAGED"),
			ActiveDirectoryConfig: &workspaces.DirectoryActiveDirectoryConfigArgs{
				DomainName:              pulumi.String("example.internal"),
				ServiceAccountSecretArn: pulumi.Any(exampleAwsSecretsmanagerSecret.Arn),
			},
			WorkspaceAccessProperties: &workspaces.DirectoryWorkspaceAccessPropertiesArgs{
				DeviceTypeAndroid:    pulumi.String("ALLOW"),
				DeviceTypeChromeos:   pulumi.String("ALLOW"),
				DeviceTypeIos:        pulumi.String("ALLOW"),
				DeviceTypeLinux:      pulumi.String("DENY"),
				DeviceTypeOsx:        pulumi.String("ALLOW"),
				DeviceTypeWeb:        pulumi.String("DENY"),
				DeviceTypeWindows:    pulumi.String("DENY"),
				DeviceTypeZeroclient: pulumi.String("DENY"),
			},
			WorkspaceCreationProperties: &workspaces.DirectoryWorkspaceCreationPropertiesArgs{
				CustomSecurityGroupId: pulumi.Any(exampleAwsSecurityGroup.Id),
				DefaultOu:             pulumi.String("OU=AWS,DC=Workgroup,DC=Example,DC=com"),
				EnableInternetAccess:  pulumi.Bool(true),
			},
			SamlProperties: &workspaces.DirectorySamlPropertiesArgs{
				RelayStateParameterName: pulumi.String("RelayState"),
				UserAccessUrl:           pulumi.String("https://sso.example.com/"),
				Status:                  pulumi.String("ENABLED"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

### IP Groups

```go package main

import (

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/workspaces"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleIpGroup, err := workspaces.NewIpGroup(ctx, "example", &workspaces.IpGroupArgs{
			Name: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		_, err = workspaces.NewDirectory(ctx, "example", &workspaces.DirectoryArgs{
			DirectoryId: pulumi.Any(exampleAwsDirectoryServiceDirectory.Id),
			IpGroupIds: pulumi.StringArray{
				exampleIpGroup.ID(),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Using `pulumi import`, import Workspaces directory using the directory ID. For example:

```sh $ pulumi import aws:workspaces/directory:Directory main d-4444444444 ```

func GetDirectory

func GetDirectory(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DirectoryState, opts ...pulumi.ResourceOption) (*Directory, error)

GetDirectory gets an existing Directory resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewDirectory

func NewDirectory(ctx *pulumi.Context,
	name string, args *DirectoryArgs, opts ...pulumi.ResourceOption) (*Directory, error)

NewDirectory registers a new resource with the given unique name, arguments, and options.

func (*Directory) ElementType

func (*Directory) ElementType() reflect.Type

func (*Directory) ToDirectoryOutput

func (i *Directory) ToDirectoryOutput() DirectoryOutput

func (*Directory) ToDirectoryOutputWithContext

func (i *Directory) ToDirectoryOutputWithContext(ctx context.Context) DirectoryOutput

type DirectoryActiveDirectoryConfig

type DirectoryActiveDirectoryConfig struct {
	// Fully qualified domain name of the AWS Directory Service directory.
	DomainName string `pulumi:"domainName"`
	// ARN of the Secrets Manager secret that contains the credentials for the service account. For more information, see [Service Account Details](https://docs.aws.amazon.com/workspaces/latest/adminguide/pools-service-account-details.html).
	ServiceAccountSecretArn string `pulumi:"serviceAccountSecretArn"`
}

type DirectoryActiveDirectoryConfigArgs

type DirectoryActiveDirectoryConfigArgs struct {
	// Fully qualified domain name of the AWS Directory Service directory.
	DomainName pulumi.StringInput `pulumi:"domainName"`
	// ARN of the Secrets Manager secret that contains the credentials for the service account. For more information, see [Service Account Details](https://docs.aws.amazon.com/workspaces/latest/adminguide/pools-service-account-details.html).
	ServiceAccountSecretArn pulumi.StringInput `pulumi:"serviceAccountSecretArn"`
}

func (DirectoryActiveDirectoryConfigArgs) ElementType

func (DirectoryActiveDirectoryConfigArgs) ToDirectoryActiveDirectoryConfigOutput

func (i DirectoryActiveDirectoryConfigArgs) ToDirectoryActiveDirectoryConfigOutput() DirectoryActiveDirectoryConfigOutput

func (DirectoryActiveDirectoryConfigArgs) ToDirectoryActiveDirectoryConfigOutputWithContext

func (i DirectoryActiveDirectoryConfigArgs) ToDirectoryActiveDirectoryConfigOutputWithContext(ctx context.Context) DirectoryActiveDirectoryConfigOutput

func (DirectoryActiveDirectoryConfigArgs) ToDirectoryActiveDirectoryConfigPtrOutput

func (i DirectoryActiveDirectoryConfigArgs) ToDirectoryActiveDirectoryConfigPtrOutput() DirectoryActiveDirectoryConfigPtrOutput

func (DirectoryActiveDirectoryConfigArgs) ToDirectoryActiveDirectoryConfigPtrOutputWithContext

func (i DirectoryActiveDirectoryConfigArgs) ToDirectoryActiveDirectoryConfigPtrOutputWithContext(ctx context.Context) DirectoryActiveDirectoryConfigPtrOutput

type DirectoryActiveDirectoryConfigInput

type DirectoryActiveDirectoryConfigInput interface {
	pulumi.Input

	ToDirectoryActiveDirectoryConfigOutput() DirectoryActiveDirectoryConfigOutput
	ToDirectoryActiveDirectoryConfigOutputWithContext(context.Context) DirectoryActiveDirectoryConfigOutput
}

DirectoryActiveDirectoryConfigInput is an input type that accepts DirectoryActiveDirectoryConfigArgs and DirectoryActiveDirectoryConfigOutput values. You can construct a concrete instance of `DirectoryActiveDirectoryConfigInput` via:

DirectoryActiveDirectoryConfigArgs{...}

type DirectoryActiveDirectoryConfigOutput

type DirectoryActiveDirectoryConfigOutput struct{ *pulumi.OutputState }

func (DirectoryActiveDirectoryConfigOutput) DomainName

Fully qualified domain name of the AWS Directory Service directory.

func (DirectoryActiveDirectoryConfigOutput) ElementType

func (DirectoryActiveDirectoryConfigOutput) ServiceAccountSecretArn

func (o DirectoryActiveDirectoryConfigOutput) ServiceAccountSecretArn() pulumi.StringOutput

ARN of the Secrets Manager secret that contains the credentials for the service account. For more information, see [Service Account Details](https://docs.aws.amazon.com/workspaces/latest/adminguide/pools-service-account-details.html).

func (DirectoryActiveDirectoryConfigOutput) ToDirectoryActiveDirectoryConfigOutput

func (o DirectoryActiveDirectoryConfigOutput) ToDirectoryActiveDirectoryConfigOutput() DirectoryActiveDirectoryConfigOutput

func (DirectoryActiveDirectoryConfigOutput) ToDirectoryActiveDirectoryConfigOutputWithContext

func (o DirectoryActiveDirectoryConfigOutput) ToDirectoryActiveDirectoryConfigOutputWithContext(ctx context.Context) DirectoryActiveDirectoryConfigOutput

func (DirectoryActiveDirectoryConfigOutput) ToDirectoryActiveDirectoryConfigPtrOutput

func (o DirectoryActiveDirectoryConfigOutput) ToDirectoryActiveDirectoryConfigPtrOutput() DirectoryActiveDirectoryConfigPtrOutput

func (DirectoryActiveDirectoryConfigOutput) ToDirectoryActiveDirectoryConfigPtrOutputWithContext

func (o DirectoryActiveDirectoryConfigOutput) ToDirectoryActiveDirectoryConfigPtrOutputWithContext(ctx context.Context) DirectoryActiveDirectoryConfigPtrOutput

type DirectoryActiveDirectoryConfigPtrInput

type DirectoryActiveDirectoryConfigPtrInput interface {
	pulumi.Input

	ToDirectoryActiveDirectoryConfigPtrOutput() DirectoryActiveDirectoryConfigPtrOutput
	ToDirectoryActiveDirectoryConfigPtrOutputWithContext(context.Context) DirectoryActiveDirectoryConfigPtrOutput
}

DirectoryActiveDirectoryConfigPtrInput is an input type that accepts DirectoryActiveDirectoryConfigArgs, DirectoryActiveDirectoryConfigPtr and DirectoryActiveDirectoryConfigPtrOutput values. You can construct a concrete instance of `DirectoryActiveDirectoryConfigPtrInput` via:

        DirectoryActiveDirectoryConfigArgs{...}

or:

        nil

type DirectoryActiveDirectoryConfigPtrOutput

type DirectoryActiveDirectoryConfigPtrOutput struct{ *pulumi.OutputState }

func (DirectoryActiveDirectoryConfigPtrOutput) DomainName

Fully qualified domain name of the AWS Directory Service directory.

func (DirectoryActiveDirectoryConfigPtrOutput) Elem

func (DirectoryActiveDirectoryConfigPtrOutput) ElementType

func (DirectoryActiveDirectoryConfigPtrOutput) ServiceAccountSecretArn

ARN of the Secrets Manager secret that contains the credentials for the service account. For more information, see [Service Account Details](https://docs.aws.amazon.com/workspaces/latest/adminguide/pools-service-account-details.html).

func (DirectoryActiveDirectoryConfigPtrOutput) ToDirectoryActiveDirectoryConfigPtrOutput

func (o DirectoryActiveDirectoryConfigPtrOutput) ToDirectoryActiveDirectoryConfigPtrOutput() DirectoryActiveDirectoryConfigPtrOutput

func (DirectoryActiveDirectoryConfigPtrOutput) ToDirectoryActiveDirectoryConfigPtrOutputWithContext

func (o DirectoryActiveDirectoryConfigPtrOutput) ToDirectoryActiveDirectoryConfigPtrOutputWithContext(ctx context.Context) DirectoryActiveDirectoryConfigPtrOutput

type DirectoryArgs

type DirectoryArgs struct {
	// Configuration for Active Directory integration when `workspaceType` is set to `POOLS`. Defined below.
	ActiveDirectoryConfig DirectoryActiveDirectoryConfigPtrInput
	// Configuration of certificate-based authentication (CBA) integration. Requires SAML authentication to be enabled. Defined below.
	CertificateBasedAuthProperties DirectoryCertificateBasedAuthPropertiesPtrInput
	// The directory identifier for registration in WorkSpaces service.
	DirectoryId pulumi.StringPtrInput
	// The identifiers of the IP access control groups associated with the directory.
	IpGroupIds pulumi.StringArrayInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// Configuration of SAML authentication integration. Defined below.
	SamlProperties DirectorySamlPropertiesPtrInput
	// Permissions to enable or disable self-service capabilities when `workspaceType` is set to `PERSONAL`.. Defined below.
	SelfServicePermissions DirectorySelfServicePermissionsPtrInput
	// The identifiers of the subnets where the directory resides.
	SubnetIds pulumi.StringArrayInput
	// A map of tags assigned to the WorkSpaces directory. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// Specifies the user identity type for the WorkSpaces directory. Valid values are `CUSTOMER_MANAGED`, `AWS_DIRECTORY_SERVICE`, `AWS_IAM_IDENTITY_CENTER`.
	//
	// > **Note:** When `workspaceType` is set to `POOLS`, the `directoryId` is automatically generated and cannot be manually set.
	UserIdentityType pulumi.StringPtrInput
	// Specifies which devices and operating systems users can use to access their WorkSpaces. Defined below.
	WorkspaceAccessProperties DirectoryWorkspaceAccessPropertiesPtrInput
	// Default properties that are used for creating WorkSpaces. Defined below.
	WorkspaceCreationProperties DirectoryWorkspaceCreationPropertiesPtrInput
	// The description of the WorkSpaces directory when `workspaceType` is set to `POOLS`.
	WorkspaceDirectoryDescription pulumi.StringPtrInput
	// The name of the WorkSpaces directory when `workspaceType` is set to `POOLS`.
	WorkspaceDirectoryName pulumi.StringPtrInput
	// Specifies the type of WorkSpaces directory. Valid values are `PERSONAL` and `POOLS`. Default is `PERSONAL`.
	WorkspaceType pulumi.StringPtrInput
}

The set of arguments for constructing a Directory resource.

func (DirectoryArgs) ElementType

func (DirectoryArgs) ElementType() reflect.Type

type DirectoryArray

type DirectoryArray []DirectoryInput

func (DirectoryArray) ElementType

func (DirectoryArray) ElementType() reflect.Type

func (DirectoryArray) ToDirectoryArrayOutput

func (i DirectoryArray) ToDirectoryArrayOutput() DirectoryArrayOutput

func (DirectoryArray) ToDirectoryArrayOutputWithContext

func (i DirectoryArray) ToDirectoryArrayOutputWithContext(ctx context.Context) DirectoryArrayOutput

type DirectoryArrayInput

type DirectoryArrayInput interface {
	pulumi.Input

	ToDirectoryArrayOutput() DirectoryArrayOutput
	ToDirectoryArrayOutputWithContext(context.Context) DirectoryArrayOutput
}

DirectoryArrayInput is an input type that accepts DirectoryArray and DirectoryArrayOutput values. You can construct a concrete instance of `DirectoryArrayInput` via:

DirectoryArray{ DirectoryArgs{...} }

type DirectoryArrayOutput

type DirectoryArrayOutput struct{ *pulumi.OutputState }

func (DirectoryArrayOutput) ElementType

func (DirectoryArrayOutput) ElementType() reflect.Type

func (DirectoryArrayOutput) Index

func (DirectoryArrayOutput) ToDirectoryArrayOutput

func (o DirectoryArrayOutput) ToDirectoryArrayOutput() DirectoryArrayOutput

func (DirectoryArrayOutput) ToDirectoryArrayOutputWithContext

func (o DirectoryArrayOutput) ToDirectoryArrayOutputWithContext(ctx context.Context) DirectoryArrayOutput

type DirectoryCertificateBasedAuthProperties

type DirectoryCertificateBasedAuthProperties struct {
	// The Amazon Resource Name (ARN) of the certificate manager private certificate authority (ACM-PCA) that is used for certificate-based authentication.
	CertificateAuthorityArn *string `pulumi:"certificateAuthorityArn"`
	// Status of certificate-based authentication. Default `DISABLED`.
	Status *string `pulumi:"status"`
}

type DirectoryCertificateBasedAuthPropertiesArgs

type DirectoryCertificateBasedAuthPropertiesArgs struct {
	// The Amazon Resource Name (ARN) of the certificate manager private certificate authority (ACM-PCA) that is used for certificate-based authentication.
	CertificateAuthorityArn pulumi.StringPtrInput `pulumi:"certificateAuthorityArn"`
	// Status of certificate-based authentication. Default `DISABLED`.
	Status pulumi.StringPtrInput `pulumi:"status"`
}

func (DirectoryCertificateBasedAuthPropertiesArgs) ElementType

func (DirectoryCertificateBasedAuthPropertiesArgs) ToDirectoryCertificateBasedAuthPropertiesOutput

func (i DirectoryCertificateBasedAuthPropertiesArgs) ToDirectoryCertificateBasedAuthPropertiesOutput() DirectoryCertificateBasedAuthPropertiesOutput

func (DirectoryCertificateBasedAuthPropertiesArgs) ToDirectoryCertificateBasedAuthPropertiesOutputWithContext

func (i DirectoryCertificateBasedAuthPropertiesArgs) ToDirectoryCertificateBasedAuthPropertiesOutputWithContext(ctx context.Context) DirectoryCertificateBasedAuthPropertiesOutput

func (DirectoryCertificateBasedAuthPropertiesArgs) ToDirectoryCertificateBasedAuthPropertiesPtrOutput

func (i DirectoryCertificateBasedAuthPropertiesArgs) ToDirectoryCertificateBasedAuthPropertiesPtrOutput() DirectoryCertificateBasedAuthPropertiesPtrOutput

func (DirectoryCertificateBasedAuthPropertiesArgs) ToDirectoryCertificateBasedAuthPropertiesPtrOutputWithContext

func (i DirectoryCertificateBasedAuthPropertiesArgs) ToDirectoryCertificateBasedAuthPropertiesPtrOutputWithContext(ctx context.Context) DirectoryCertificateBasedAuthPropertiesPtrOutput

type DirectoryCertificateBasedAuthPropertiesInput

type DirectoryCertificateBasedAuthPropertiesInput interface {
	pulumi.Input

	ToDirectoryCertificateBasedAuthPropertiesOutput() DirectoryCertificateBasedAuthPropertiesOutput
	ToDirectoryCertificateBasedAuthPropertiesOutputWithContext(context.Context) DirectoryCertificateBasedAuthPropertiesOutput
}

DirectoryCertificateBasedAuthPropertiesInput is an input type that accepts DirectoryCertificateBasedAuthPropertiesArgs and DirectoryCertificateBasedAuthPropertiesOutput values. You can construct a concrete instance of `DirectoryCertificateBasedAuthPropertiesInput` via:

DirectoryCertificateBasedAuthPropertiesArgs{...}

type DirectoryCertificateBasedAuthPropertiesOutput

type DirectoryCertificateBasedAuthPropertiesOutput struct{ *pulumi.OutputState }

func (DirectoryCertificateBasedAuthPropertiesOutput) CertificateAuthorityArn

The Amazon Resource Name (ARN) of the certificate manager private certificate authority (ACM-PCA) that is used for certificate-based authentication.

func (DirectoryCertificateBasedAuthPropertiesOutput) ElementType

func (DirectoryCertificateBasedAuthPropertiesOutput) Status

Status of certificate-based authentication. Default `DISABLED`.

func (DirectoryCertificateBasedAuthPropertiesOutput) ToDirectoryCertificateBasedAuthPropertiesOutput

func (o DirectoryCertificateBasedAuthPropertiesOutput) ToDirectoryCertificateBasedAuthPropertiesOutput() DirectoryCertificateBasedAuthPropertiesOutput

func (DirectoryCertificateBasedAuthPropertiesOutput) ToDirectoryCertificateBasedAuthPropertiesOutputWithContext

func (o DirectoryCertificateBasedAuthPropertiesOutput) ToDirectoryCertificateBasedAuthPropertiesOutputWithContext(ctx context.Context) DirectoryCertificateBasedAuthPropertiesOutput

func (DirectoryCertificateBasedAuthPropertiesOutput) ToDirectoryCertificateBasedAuthPropertiesPtrOutput

func (o DirectoryCertificateBasedAuthPropertiesOutput) ToDirectoryCertificateBasedAuthPropertiesPtrOutput() DirectoryCertificateBasedAuthPropertiesPtrOutput

func (DirectoryCertificateBasedAuthPropertiesOutput) ToDirectoryCertificateBasedAuthPropertiesPtrOutputWithContext

func (o DirectoryCertificateBasedAuthPropertiesOutput) ToDirectoryCertificateBasedAuthPropertiesPtrOutputWithContext(ctx context.Context) DirectoryCertificateBasedAuthPropertiesPtrOutput

type DirectoryCertificateBasedAuthPropertiesPtrInput

type DirectoryCertificateBasedAuthPropertiesPtrInput interface {
	pulumi.Input

	ToDirectoryCertificateBasedAuthPropertiesPtrOutput() DirectoryCertificateBasedAuthPropertiesPtrOutput
	ToDirectoryCertificateBasedAuthPropertiesPtrOutputWithContext(context.Context) DirectoryCertificateBasedAuthPropertiesPtrOutput
}

DirectoryCertificateBasedAuthPropertiesPtrInput is an input type that accepts DirectoryCertificateBasedAuthPropertiesArgs, DirectoryCertificateBasedAuthPropertiesPtr and DirectoryCertificateBasedAuthPropertiesPtrOutput values. You can construct a concrete instance of `DirectoryCertificateBasedAuthPropertiesPtrInput` via:

        DirectoryCertificateBasedAuthPropertiesArgs{...}

or:

        nil

type DirectoryCertificateBasedAuthPropertiesPtrOutput

type DirectoryCertificateBasedAuthPropertiesPtrOutput struct{ *pulumi.OutputState }

func (DirectoryCertificateBasedAuthPropertiesPtrOutput) CertificateAuthorityArn

The Amazon Resource Name (ARN) of the certificate manager private certificate authority (ACM-PCA) that is used for certificate-based authentication.

func (DirectoryCertificateBasedAuthPropertiesPtrOutput) Elem

func (DirectoryCertificateBasedAuthPropertiesPtrOutput) ElementType

func (DirectoryCertificateBasedAuthPropertiesPtrOutput) Status

Status of certificate-based authentication. Default `DISABLED`.

func (DirectoryCertificateBasedAuthPropertiesPtrOutput) ToDirectoryCertificateBasedAuthPropertiesPtrOutput

func (o DirectoryCertificateBasedAuthPropertiesPtrOutput) ToDirectoryCertificateBasedAuthPropertiesPtrOutput() DirectoryCertificateBasedAuthPropertiesPtrOutput

func (DirectoryCertificateBasedAuthPropertiesPtrOutput) ToDirectoryCertificateBasedAuthPropertiesPtrOutputWithContext

func (o DirectoryCertificateBasedAuthPropertiesPtrOutput) ToDirectoryCertificateBasedAuthPropertiesPtrOutputWithContext(ctx context.Context) DirectoryCertificateBasedAuthPropertiesPtrOutput

type DirectoryInput

type DirectoryInput interface {
	pulumi.Input

	ToDirectoryOutput() DirectoryOutput
	ToDirectoryOutputWithContext(ctx context.Context) DirectoryOutput
}

type DirectoryMap

type DirectoryMap map[string]DirectoryInput

func (DirectoryMap) ElementType

func (DirectoryMap) ElementType() reflect.Type

func (DirectoryMap) ToDirectoryMapOutput

func (i DirectoryMap) ToDirectoryMapOutput() DirectoryMapOutput

func (DirectoryMap) ToDirectoryMapOutputWithContext

func (i DirectoryMap) ToDirectoryMapOutputWithContext(ctx context.Context) DirectoryMapOutput

type DirectoryMapInput

type DirectoryMapInput interface {
	pulumi.Input

	ToDirectoryMapOutput() DirectoryMapOutput
	ToDirectoryMapOutputWithContext(context.Context) DirectoryMapOutput
}

DirectoryMapInput is an input type that accepts DirectoryMap and DirectoryMapOutput values. You can construct a concrete instance of `DirectoryMapInput` via:

DirectoryMap{ "key": DirectoryArgs{...} }

type DirectoryMapOutput

type DirectoryMapOutput struct{ *pulumi.OutputState }

func (DirectoryMapOutput) ElementType

func (DirectoryMapOutput) ElementType() reflect.Type

func (DirectoryMapOutput) MapIndex

func (DirectoryMapOutput) ToDirectoryMapOutput

func (o DirectoryMapOutput) ToDirectoryMapOutput() DirectoryMapOutput

func (DirectoryMapOutput) ToDirectoryMapOutputWithContext

func (o DirectoryMapOutput) ToDirectoryMapOutputWithContext(ctx context.Context) DirectoryMapOutput

type DirectoryOutput

type DirectoryOutput struct{ *pulumi.OutputState }

func (DirectoryOutput) ActiveDirectoryConfig

func (o DirectoryOutput) ActiveDirectoryConfig() DirectoryActiveDirectoryConfigPtrOutput

Configuration for Active Directory integration when `workspaceType` is set to `POOLS`. Defined below.

func (DirectoryOutput) Alias

The directory alias.

func (DirectoryOutput) CertificateBasedAuthProperties

func (o DirectoryOutput) CertificateBasedAuthProperties() DirectoryCertificateBasedAuthPropertiesOutput

Configuration of certificate-based authentication (CBA) integration. Requires SAML authentication to be enabled. Defined below.

func (DirectoryOutput) CustomerUserName

func (o DirectoryOutput) CustomerUserName() pulumi.StringOutput

The user name for the service account.

func (DirectoryOutput) DirectoryId

func (o DirectoryOutput) DirectoryId() pulumi.StringOutput

The directory identifier for registration in WorkSpaces service.

func (DirectoryOutput) DirectoryName

func (o DirectoryOutput) DirectoryName() pulumi.StringOutput

The name of the directory.

func (DirectoryOutput) DirectoryType

func (o DirectoryOutput) DirectoryType() pulumi.StringOutput

The directory type.

func (DirectoryOutput) DnsIpAddresses

func (o DirectoryOutput) DnsIpAddresses() pulumi.StringArrayOutput

The IP addresses of the DNS servers for the directory.

func (DirectoryOutput) ElementType

func (DirectoryOutput) ElementType() reflect.Type

func (DirectoryOutput) IamRoleId

func (o DirectoryOutput) IamRoleId() pulumi.StringOutput

The identifier of the IAM role. This is the role that allows Amazon WorkSpaces to make calls to other services, such as Amazon EC2, on your behalf.

func (DirectoryOutput) IpGroupIds

func (o DirectoryOutput) IpGroupIds() pulumi.StringArrayOutput

The identifiers of the IP access control groups associated with the directory.

func (DirectoryOutput) Region

func (o DirectoryOutput) Region() pulumi.StringOutput

Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.

func (DirectoryOutput) RegistrationCode

func (o DirectoryOutput) RegistrationCode() pulumi.StringOutput

The registration code for the directory. This is the code that users enter in their Amazon WorkSpaces client application to connect to the directory.

func (DirectoryOutput) SamlProperties

Configuration of SAML authentication integration. Defined below.

func (DirectoryOutput) SelfServicePermissions

func (o DirectoryOutput) SelfServicePermissions() DirectorySelfServicePermissionsOutput

Permissions to enable or disable self-service capabilities when `workspaceType` is set to `PERSONAL`.. Defined below.

func (DirectoryOutput) SubnetIds

The identifiers of the subnets where the directory resides.

func (DirectoryOutput) Tags

A map of tags assigned to the WorkSpaces directory. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.

func (DirectoryOutput) TagsAll

A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

func (DirectoryOutput) ToDirectoryOutput

func (o DirectoryOutput) ToDirectoryOutput() DirectoryOutput

func (DirectoryOutput) ToDirectoryOutputWithContext

func (o DirectoryOutput) ToDirectoryOutputWithContext(ctx context.Context) DirectoryOutput

func (DirectoryOutput) UserIdentityType

func (o DirectoryOutput) UserIdentityType() pulumi.StringOutput

Specifies the user identity type for the WorkSpaces directory. Valid values are `CUSTOMER_MANAGED`, `AWS_DIRECTORY_SERVICE`, `AWS_IAM_IDENTITY_CENTER`.

> **Note:** When `workspaceType` is set to `POOLS`, the `directoryId` is automatically generated and cannot be manually set.

func (DirectoryOutput) WorkspaceAccessProperties

func (o DirectoryOutput) WorkspaceAccessProperties() DirectoryWorkspaceAccessPropertiesOutput

Specifies which devices and operating systems users can use to access their WorkSpaces. Defined below.

func (DirectoryOutput) WorkspaceCreationProperties

func (o DirectoryOutput) WorkspaceCreationProperties() DirectoryWorkspaceCreationPropertiesOutput

Default properties that are used for creating WorkSpaces. Defined below.

func (DirectoryOutput) WorkspaceDirectoryDescription

func (o DirectoryOutput) WorkspaceDirectoryDescription() pulumi.StringPtrOutput

The description of the WorkSpaces directory when `workspaceType` is set to `POOLS`.

func (DirectoryOutput) WorkspaceDirectoryName

func (o DirectoryOutput) WorkspaceDirectoryName() pulumi.StringPtrOutput

The name of the WorkSpaces directory when `workspaceType` is set to `POOLS`.

func (DirectoryOutput) WorkspaceSecurityGroupId

func (o DirectoryOutput) WorkspaceSecurityGroupId() pulumi.StringOutput

The identifier of the security group that is assigned to new WorkSpaces.

func (DirectoryOutput) WorkspaceType

func (o DirectoryOutput) WorkspaceType() pulumi.StringPtrOutput

Specifies the type of WorkSpaces directory. Valid values are `PERSONAL` and `POOLS`. Default is `PERSONAL`.

type DirectorySamlProperties

type DirectorySamlProperties struct {
	// The relay state parameter name supported by the SAML 2.0 identity provider (IdP). Default `RelayState`.
	RelayStateParameterName *string `pulumi:"relayStateParameterName"`
	// Status of SAML 2.0 authentication. Default `DISABLED`.
	Status *string `pulumi:"status"`
	// The SAML 2.0 identity provider (IdP) user access URL.
	UserAccessUrl *string `pulumi:"userAccessUrl"`
}

type DirectorySamlPropertiesArgs

type DirectorySamlPropertiesArgs struct {
	// The relay state parameter name supported by the SAML 2.0 identity provider (IdP). Default `RelayState`.
	RelayStateParameterName pulumi.StringPtrInput `pulumi:"relayStateParameterName"`
	// Status of SAML 2.0 authentication. Default `DISABLED`.
	Status pulumi.StringPtrInput `pulumi:"status"`
	// The SAML 2.0 identity provider (IdP) user access URL.
	UserAccessUrl pulumi.StringPtrInput `pulumi:"userAccessUrl"`
}

func (DirectorySamlPropertiesArgs) ElementType

func (DirectorySamlPropertiesArgs) ToDirectorySamlPropertiesOutput

func (i DirectorySamlPropertiesArgs) ToDirectorySamlPropertiesOutput() DirectorySamlPropertiesOutput

func (DirectorySamlPropertiesArgs) ToDirectorySamlPropertiesOutputWithContext

func (i DirectorySamlPropertiesArgs) ToDirectorySamlPropertiesOutputWithContext(ctx context.Context) DirectorySamlPropertiesOutput

func (DirectorySamlPropertiesArgs) ToDirectorySamlPropertiesPtrOutput

func (i DirectorySamlPropertiesArgs) ToDirectorySamlPropertiesPtrOutput() DirectorySamlPropertiesPtrOutput

func (DirectorySamlPropertiesArgs) ToDirectorySamlPropertiesPtrOutputWithContext

func (i DirectorySamlPropertiesArgs) ToDirectorySamlPropertiesPtrOutputWithContext(ctx context.Context) DirectorySamlPropertiesPtrOutput

type DirectorySamlPropertiesInput

type DirectorySamlPropertiesInput interface {
	pulumi.Input

	ToDirectorySamlPropertiesOutput() DirectorySamlPropertiesOutput
	ToDirectorySamlPropertiesOutputWithContext(context.Context) DirectorySamlPropertiesOutput
}

DirectorySamlPropertiesInput is an input type that accepts DirectorySamlPropertiesArgs and DirectorySamlPropertiesOutput values. You can construct a concrete instance of `DirectorySamlPropertiesInput` via:

DirectorySamlPropertiesArgs{...}

type DirectorySamlPropertiesOutput

type DirectorySamlPropertiesOutput struct{ *pulumi.OutputState }

func (DirectorySamlPropertiesOutput) ElementType

func (DirectorySamlPropertiesOutput) RelayStateParameterName

func (o DirectorySamlPropertiesOutput) RelayStateParameterName() pulumi.StringPtrOutput

The relay state parameter name supported by the SAML 2.0 identity provider (IdP). Default `RelayState`.

func (DirectorySamlPropertiesOutput) Status

Status of SAML 2.0 authentication. Default `DISABLED`.

func (DirectorySamlPropertiesOutput) ToDirectorySamlPropertiesOutput

func (o DirectorySamlPropertiesOutput) ToDirectorySamlPropertiesOutput() DirectorySamlPropertiesOutput

func (DirectorySamlPropertiesOutput) ToDirectorySamlPropertiesOutputWithContext

func (o DirectorySamlPropertiesOutput) ToDirectorySamlPropertiesOutputWithContext(ctx context.Context) DirectorySamlPropertiesOutput

func (DirectorySamlPropertiesOutput) ToDirectorySamlPropertiesPtrOutput

func (o DirectorySamlPropertiesOutput) ToDirectorySamlPropertiesPtrOutput() DirectorySamlPropertiesPtrOutput

func (DirectorySamlPropertiesOutput) ToDirectorySamlPropertiesPtrOutputWithContext

func (o DirectorySamlPropertiesOutput) ToDirectorySamlPropertiesPtrOutputWithContext(ctx context.Context) DirectorySamlPropertiesPtrOutput

func (DirectorySamlPropertiesOutput) UserAccessUrl

The SAML 2.0 identity provider (IdP) user access URL.

type DirectorySamlPropertiesPtrInput

type DirectorySamlPropertiesPtrInput interface {
	pulumi.Input

	ToDirectorySamlPropertiesPtrOutput() DirectorySamlPropertiesPtrOutput
	ToDirectorySamlPropertiesPtrOutputWithContext(context.Context) DirectorySamlPropertiesPtrOutput
}

DirectorySamlPropertiesPtrInput is an input type that accepts DirectorySamlPropertiesArgs, DirectorySamlPropertiesPtr and DirectorySamlPropertiesPtrOutput values. You can construct a concrete instance of `DirectorySamlPropertiesPtrInput` via:

        DirectorySamlPropertiesArgs{...}

or:

        nil

type DirectorySamlPropertiesPtrOutput

type DirectorySamlPropertiesPtrOutput struct{ *pulumi.OutputState }

func (DirectorySamlPropertiesPtrOutput) Elem

func (DirectorySamlPropertiesPtrOutput) ElementType

func (DirectorySamlPropertiesPtrOutput) RelayStateParameterName

func (o DirectorySamlPropertiesPtrOutput) RelayStateParameterName() pulumi.StringPtrOutput

The relay state parameter name supported by the SAML 2.0 identity provider (IdP). Default `RelayState`.

func (DirectorySamlPropertiesPtrOutput) Status

Status of SAML 2.0 authentication. Default `DISABLED`.

func (DirectorySamlPropertiesPtrOutput) ToDirectorySamlPropertiesPtrOutput

func (o DirectorySamlPropertiesPtrOutput) ToDirectorySamlPropertiesPtrOutput() DirectorySamlPropertiesPtrOutput

func (DirectorySamlPropertiesPtrOutput) ToDirectorySamlPropertiesPtrOutputWithContext

func (o DirectorySamlPropertiesPtrOutput) ToDirectorySamlPropertiesPtrOutputWithContext(ctx context.Context) DirectorySamlPropertiesPtrOutput

func (DirectorySamlPropertiesPtrOutput) UserAccessUrl

The SAML 2.0 identity provider (IdP) user access URL.

type DirectorySelfServicePermissions

type DirectorySelfServicePermissions struct {
	// Whether WorkSpaces directory users can change the compute type (bundle) for their workspace. Default `false`.
	ChangeComputeType *bool `pulumi:"changeComputeType"`
	// Whether WorkSpaces directory users can increase the volume size of the drives on their workspace. Default `false`.
	IncreaseVolumeSize *bool `pulumi:"increaseVolumeSize"`
	// Whether WorkSpaces directory users can rebuild the operating system of a workspace to its original state. Default `false`.
	RebuildWorkspace *bool `pulumi:"rebuildWorkspace"`
	// Whether WorkSpaces directory users can restart their workspace. Default `true`.
	RestartWorkspace *bool `pulumi:"restartWorkspace"`
	// Whether WorkSpaces directory users can switch the running mode of their workspace. Default `false`.
	SwitchRunningMode *bool `pulumi:"switchRunningMode"`
}

type DirectorySelfServicePermissionsArgs

type DirectorySelfServicePermissionsArgs struct {
	// Whether WorkSpaces directory users can change the compute type (bundle) for their workspace. Default `false`.
	ChangeComputeType pulumi.BoolPtrInput `pulumi:"changeComputeType"`
	// Whether WorkSpaces directory users can increase the volume size of the drives on their workspace. Default `false`.
	IncreaseVolumeSize pulumi.BoolPtrInput `pulumi:"increaseVolumeSize"`
	// Whether WorkSpaces directory users can rebuild the operating system of a workspace to its original state. Default `false`.
	RebuildWorkspace pulumi.BoolPtrInput `pulumi:"rebuildWorkspace"`
	// Whether WorkSpaces directory users can restart their workspace. Default `true`.
	RestartWorkspace pulumi.BoolPtrInput `pulumi:"restartWorkspace"`
	// Whether WorkSpaces directory users can switch the running mode of their workspace. Default `false`.
	SwitchRunningMode pulumi.BoolPtrInput `pulumi:"switchRunningMode"`
}

func (DirectorySelfServicePermissionsArgs) ElementType

func (DirectorySelfServicePermissionsArgs) ToDirectorySelfServicePermissionsOutput

func (i DirectorySelfServicePermissionsArgs) ToDirectorySelfServicePermissionsOutput() DirectorySelfServicePermissionsOutput

func (DirectorySelfServicePermissionsArgs) ToDirectorySelfServicePermissionsOutputWithContext

func (i DirectorySelfServicePermissionsArgs) ToDirectorySelfServicePermissionsOutputWithContext(ctx context.Context) DirectorySelfServicePermissionsOutput

func (DirectorySelfServicePermissionsArgs) ToDirectorySelfServicePermissionsPtrOutput

func (i DirectorySelfServicePermissionsArgs) ToDirectorySelfServicePermissionsPtrOutput() DirectorySelfServicePermissionsPtrOutput

func (DirectorySelfServicePermissionsArgs) ToDirectorySelfServicePermissionsPtrOutputWithContext

func (i DirectorySelfServicePermissionsArgs) ToDirectorySelfServicePermissionsPtrOutputWithContext(ctx context.Context) DirectorySelfServicePermissionsPtrOutput

type DirectorySelfServicePermissionsInput

type DirectorySelfServicePermissionsInput interface {
	pulumi.Input

	ToDirectorySelfServicePermissionsOutput() DirectorySelfServicePermissionsOutput
	ToDirectorySelfServicePermissionsOutputWithContext(context.Context) DirectorySelfServicePermissionsOutput
}

DirectorySelfServicePermissionsInput is an input type that accepts DirectorySelfServicePermissionsArgs and DirectorySelfServicePermissionsOutput values. You can construct a concrete instance of `DirectorySelfServicePermissionsInput` via:

DirectorySelfServicePermissionsArgs{...}

type DirectorySelfServicePermissionsOutput

type DirectorySelfServicePermissionsOutput struct{ *pulumi.OutputState }

func (DirectorySelfServicePermissionsOutput) ChangeComputeType

Whether WorkSpaces directory users can change the compute type (bundle) for their workspace. Default `false`.

func (DirectorySelfServicePermissionsOutput) ElementType

func (DirectorySelfServicePermissionsOutput) IncreaseVolumeSize

Whether WorkSpaces directory users can increase the volume size of the drives on their workspace. Default `false`.

func (DirectorySelfServicePermissionsOutput) RebuildWorkspace

Whether WorkSpaces directory users can rebuild the operating system of a workspace to its original state. Default `false`.

func (DirectorySelfServicePermissionsOutput) RestartWorkspace

Whether WorkSpaces directory users can restart their workspace. Default `true`.

func (DirectorySelfServicePermissionsOutput) SwitchRunningMode

Whether WorkSpaces directory users can switch the running mode of their workspace. Default `false`.

func (DirectorySelfServicePermissionsOutput) ToDirectorySelfServicePermissionsOutput

func (o DirectorySelfServicePermissionsOutput) ToDirectorySelfServicePermissionsOutput() DirectorySelfServicePermissionsOutput

func (DirectorySelfServicePermissionsOutput) ToDirectorySelfServicePermissionsOutputWithContext

func (o DirectorySelfServicePermissionsOutput) ToDirectorySelfServicePermissionsOutputWithContext(ctx context.Context) DirectorySelfServicePermissionsOutput

func (DirectorySelfServicePermissionsOutput) ToDirectorySelfServicePermissionsPtrOutput

func (o DirectorySelfServicePermissionsOutput) ToDirectorySelfServicePermissionsPtrOutput() DirectorySelfServicePermissionsPtrOutput

func (DirectorySelfServicePermissionsOutput) ToDirectorySelfServicePermissionsPtrOutputWithContext

func (o DirectorySelfServicePermissionsOutput) ToDirectorySelfServicePermissionsPtrOutputWithContext(ctx context.Context) DirectorySelfServicePermissionsPtrOutput

type DirectorySelfServicePermissionsPtrInput

type DirectorySelfServicePermissionsPtrInput interface {
	pulumi.Input

	ToDirectorySelfServicePermissionsPtrOutput() DirectorySelfServicePermissionsPtrOutput
	ToDirectorySelfServicePermissionsPtrOutputWithContext(context.Context) DirectorySelfServicePermissionsPtrOutput
}

DirectorySelfServicePermissionsPtrInput is an input type that accepts DirectorySelfServicePermissionsArgs, DirectorySelfServicePermissionsPtr and DirectorySelfServicePermissionsPtrOutput values. You can construct a concrete instance of `DirectorySelfServicePermissionsPtrInput` via:

        DirectorySelfServicePermissionsArgs{...}

or:

        nil

type DirectorySelfServicePermissionsPtrOutput

type DirectorySelfServicePermissionsPtrOutput struct{ *pulumi.OutputState }

func (DirectorySelfServicePermissionsPtrOutput) ChangeComputeType

Whether WorkSpaces directory users can change the compute type (bundle) for their workspace. Default `false`.

func (DirectorySelfServicePermissionsPtrOutput) Elem

func (DirectorySelfServicePermissionsPtrOutput) ElementType

func (DirectorySelfServicePermissionsPtrOutput) IncreaseVolumeSize

Whether WorkSpaces directory users can increase the volume size of the drives on their workspace. Default `false`.

func (DirectorySelfServicePermissionsPtrOutput) RebuildWorkspace

Whether WorkSpaces directory users can rebuild the operating system of a workspace to its original state. Default `false`.

func (DirectorySelfServicePermissionsPtrOutput) RestartWorkspace

Whether WorkSpaces directory users can restart their workspace. Default `true`.

func (DirectorySelfServicePermissionsPtrOutput) SwitchRunningMode

Whether WorkSpaces directory users can switch the running mode of their workspace. Default `false`.

func (DirectorySelfServicePermissionsPtrOutput) ToDirectorySelfServicePermissionsPtrOutput

func (o DirectorySelfServicePermissionsPtrOutput) ToDirectorySelfServicePermissionsPtrOutput() DirectorySelfServicePermissionsPtrOutput

func (DirectorySelfServicePermissionsPtrOutput) ToDirectorySelfServicePermissionsPtrOutputWithContext

func (o DirectorySelfServicePermissionsPtrOutput) ToDirectorySelfServicePermissionsPtrOutputWithContext(ctx context.Context) DirectorySelfServicePermissionsPtrOutput

type DirectoryState

type DirectoryState struct {
	// Configuration for Active Directory integration when `workspaceType` is set to `POOLS`. Defined below.
	ActiveDirectoryConfig DirectoryActiveDirectoryConfigPtrInput
	// The directory alias.
	Alias pulumi.StringPtrInput
	// Configuration of certificate-based authentication (CBA) integration. Requires SAML authentication to be enabled. Defined below.
	CertificateBasedAuthProperties DirectoryCertificateBasedAuthPropertiesPtrInput
	// The user name for the service account.
	CustomerUserName pulumi.StringPtrInput
	// The directory identifier for registration in WorkSpaces service.
	DirectoryId pulumi.StringPtrInput
	// The name of the directory.
	DirectoryName pulumi.StringPtrInput
	// The directory type.
	DirectoryType pulumi.StringPtrInput
	// The IP addresses of the DNS servers for the directory.
	DnsIpAddresses pulumi.StringArrayInput
	// The identifier of the IAM role. This is the role that allows Amazon WorkSpaces to make calls to other services, such as Amazon EC2, on your behalf.
	IamRoleId pulumi.StringPtrInput
	// The identifiers of the IP access control groups associated with the directory.
	IpGroupIds pulumi.StringArrayInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// The registration code for the directory. This is the code that users enter in their Amazon WorkSpaces client application to connect to the directory.
	RegistrationCode pulumi.StringPtrInput
	// Configuration of SAML authentication integration. Defined below.
	SamlProperties DirectorySamlPropertiesPtrInput
	// Permissions to enable or disable self-service capabilities when `workspaceType` is set to `PERSONAL`.. Defined below.
	SelfServicePermissions DirectorySelfServicePermissionsPtrInput
	// The identifiers of the subnets where the directory resides.
	SubnetIds pulumi.StringArrayInput
	// A map of tags assigned to the WorkSpaces directory. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapInput
	// Specifies the user identity type for the WorkSpaces directory. Valid values are `CUSTOMER_MANAGED`, `AWS_DIRECTORY_SERVICE`, `AWS_IAM_IDENTITY_CENTER`.
	//
	// > **Note:** When `workspaceType` is set to `POOLS`, the `directoryId` is automatically generated and cannot be manually set.
	UserIdentityType pulumi.StringPtrInput
	// Specifies which devices and operating systems users can use to access their WorkSpaces. Defined below.
	WorkspaceAccessProperties DirectoryWorkspaceAccessPropertiesPtrInput
	// Default properties that are used for creating WorkSpaces. Defined below.
	WorkspaceCreationProperties DirectoryWorkspaceCreationPropertiesPtrInput
	// The description of the WorkSpaces directory when `workspaceType` is set to `POOLS`.
	WorkspaceDirectoryDescription pulumi.StringPtrInput
	// The name of the WorkSpaces directory when `workspaceType` is set to `POOLS`.
	WorkspaceDirectoryName pulumi.StringPtrInput
	// The identifier of the security group that is assigned to new WorkSpaces.
	WorkspaceSecurityGroupId pulumi.StringPtrInput
	// Specifies the type of WorkSpaces directory. Valid values are `PERSONAL` and `POOLS`. Default is `PERSONAL`.
	WorkspaceType pulumi.StringPtrInput
}

func (DirectoryState) ElementType

func (DirectoryState) ElementType() reflect.Type

type DirectoryWorkspaceAccessProperties

type DirectoryWorkspaceAccessProperties struct {
	// Indicates whether users can use Android devices to access their WorkSpaces.
	DeviceTypeAndroid *string `pulumi:"deviceTypeAndroid"`
	// Indicates whether users can use Chromebooks to access their WorkSpaces.
	DeviceTypeChromeos *string `pulumi:"deviceTypeChromeos"`
	// Indicates whether users can use iOS devices to access their WorkSpaces.
	DeviceTypeIos *string `pulumi:"deviceTypeIos"`
	// Indicates whether users can use Linux clients to access their WorkSpaces.
	DeviceTypeLinux *string `pulumi:"deviceTypeLinux"`
	// Indicates whether users can use macOS clients to access their WorkSpaces.
	DeviceTypeOsx *string `pulumi:"deviceTypeOsx"`
	// Indicates whether users can access their WorkSpaces through a web browser.
	DeviceTypeWeb *string `pulumi:"deviceTypeWeb"`
	// Indicates whether users can use Windows clients to access their WorkSpaces.
	DeviceTypeWindows *string `pulumi:"deviceTypeWindows"`
	// Indicates whether users can use zero client devices to access their WorkSpaces.
	DeviceTypeZeroclient *string `pulumi:"deviceTypeZeroclient"`
}

type DirectoryWorkspaceAccessPropertiesArgs

type DirectoryWorkspaceAccessPropertiesArgs struct {
	// Indicates whether users can use Android devices to access their WorkSpaces.
	DeviceTypeAndroid pulumi.StringPtrInput `pulumi:"deviceTypeAndroid"`
	// Indicates whether users can use Chromebooks to access their WorkSpaces.
	DeviceTypeChromeos pulumi.StringPtrInput `pulumi:"deviceTypeChromeos"`
	// Indicates whether users can use iOS devices to access their WorkSpaces.
	DeviceTypeIos pulumi.StringPtrInput `pulumi:"deviceTypeIos"`
	// Indicates whether users can use Linux clients to access their WorkSpaces.
	DeviceTypeLinux pulumi.StringPtrInput `pulumi:"deviceTypeLinux"`
	// Indicates whether users can use macOS clients to access their WorkSpaces.
	DeviceTypeOsx pulumi.StringPtrInput `pulumi:"deviceTypeOsx"`
	// Indicates whether users can access their WorkSpaces through a web browser.
	DeviceTypeWeb pulumi.StringPtrInput `pulumi:"deviceTypeWeb"`
	// Indicates whether users can use Windows clients to access their WorkSpaces.
	DeviceTypeWindows pulumi.StringPtrInput `pulumi:"deviceTypeWindows"`
	// Indicates whether users can use zero client devices to access their WorkSpaces.
	DeviceTypeZeroclient pulumi.StringPtrInput `pulumi:"deviceTypeZeroclient"`
}

func (DirectoryWorkspaceAccessPropertiesArgs) ElementType

func (DirectoryWorkspaceAccessPropertiesArgs) ToDirectoryWorkspaceAccessPropertiesOutput

func (i DirectoryWorkspaceAccessPropertiesArgs) ToDirectoryWorkspaceAccessPropertiesOutput() DirectoryWorkspaceAccessPropertiesOutput

func (DirectoryWorkspaceAccessPropertiesArgs) ToDirectoryWorkspaceAccessPropertiesOutputWithContext

func (i DirectoryWorkspaceAccessPropertiesArgs) ToDirectoryWorkspaceAccessPropertiesOutputWithContext(ctx context.Context) DirectoryWorkspaceAccessPropertiesOutput

func (DirectoryWorkspaceAccessPropertiesArgs) ToDirectoryWorkspaceAccessPropertiesPtrOutput

func (i DirectoryWorkspaceAccessPropertiesArgs) ToDirectoryWorkspaceAccessPropertiesPtrOutput() DirectoryWorkspaceAccessPropertiesPtrOutput

func (DirectoryWorkspaceAccessPropertiesArgs) ToDirectoryWorkspaceAccessPropertiesPtrOutputWithContext

func (i DirectoryWorkspaceAccessPropertiesArgs) ToDirectoryWorkspaceAccessPropertiesPtrOutputWithContext(ctx context.Context) DirectoryWorkspaceAccessPropertiesPtrOutput

type DirectoryWorkspaceAccessPropertiesInput

type DirectoryWorkspaceAccessPropertiesInput interface {
	pulumi.Input

	ToDirectoryWorkspaceAccessPropertiesOutput() DirectoryWorkspaceAccessPropertiesOutput
	ToDirectoryWorkspaceAccessPropertiesOutputWithContext(context.Context) DirectoryWorkspaceAccessPropertiesOutput
}

DirectoryWorkspaceAccessPropertiesInput is an input type that accepts DirectoryWorkspaceAccessPropertiesArgs and DirectoryWorkspaceAccessPropertiesOutput values. You can construct a concrete instance of `DirectoryWorkspaceAccessPropertiesInput` via:

DirectoryWorkspaceAccessPropertiesArgs{...}

type DirectoryWorkspaceAccessPropertiesOutput

type DirectoryWorkspaceAccessPropertiesOutput struct{ *pulumi.OutputState }

func (DirectoryWorkspaceAccessPropertiesOutput) DeviceTypeAndroid

Indicates whether users can use Android devices to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesOutput) DeviceTypeChromeos

Indicates whether users can use Chromebooks to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesOutput) DeviceTypeIos

Indicates whether users can use iOS devices to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesOutput) DeviceTypeLinux

Indicates whether users can use Linux clients to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesOutput) DeviceTypeOsx

Indicates whether users can use macOS clients to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesOutput) DeviceTypeWeb

Indicates whether users can access their WorkSpaces through a web browser.

func (DirectoryWorkspaceAccessPropertiesOutput) DeviceTypeWindows

Indicates whether users can use Windows clients to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesOutput) DeviceTypeZeroclient

Indicates whether users can use zero client devices to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesOutput) ElementType

func (DirectoryWorkspaceAccessPropertiesOutput) ToDirectoryWorkspaceAccessPropertiesOutput

func (o DirectoryWorkspaceAccessPropertiesOutput) ToDirectoryWorkspaceAccessPropertiesOutput() DirectoryWorkspaceAccessPropertiesOutput

func (DirectoryWorkspaceAccessPropertiesOutput) ToDirectoryWorkspaceAccessPropertiesOutputWithContext

func (o DirectoryWorkspaceAccessPropertiesOutput) ToDirectoryWorkspaceAccessPropertiesOutputWithContext(ctx context.Context) DirectoryWorkspaceAccessPropertiesOutput

func (DirectoryWorkspaceAccessPropertiesOutput) ToDirectoryWorkspaceAccessPropertiesPtrOutput

func (o DirectoryWorkspaceAccessPropertiesOutput) ToDirectoryWorkspaceAccessPropertiesPtrOutput() DirectoryWorkspaceAccessPropertiesPtrOutput

func (DirectoryWorkspaceAccessPropertiesOutput) ToDirectoryWorkspaceAccessPropertiesPtrOutputWithContext

func (o DirectoryWorkspaceAccessPropertiesOutput) ToDirectoryWorkspaceAccessPropertiesPtrOutputWithContext(ctx context.Context) DirectoryWorkspaceAccessPropertiesPtrOutput

type DirectoryWorkspaceAccessPropertiesPtrInput

type DirectoryWorkspaceAccessPropertiesPtrInput interface {
	pulumi.Input

	ToDirectoryWorkspaceAccessPropertiesPtrOutput() DirectoryWorkspaceAccessPropertiesPtrOutput
	ToDirectoryWorkspaceAccessPropertiesPtrOutputWithContext(context.Context) DirectoryWorkspaceAccessPropertiesPtrOutput
}

DirectoryWorkspaceAccessPropertiesPtrInput is an input type that accepts DirectoryWorkspaceAccessPropertiesArgs, DirectoryWorkspaceAccessPropertiesPtr and DirectoryWorkspaceAccessPropertiesPtrOutput values. You can construct a concrete instance of `DirectoryWorkspaceAccessPropertiesPtrInput` via:

        DirectoryWorkspaceAccessPropertiesArgs{...}

or:

        nil

type DirectoryWorkspaceAccessPropertiesPtrOutput

type DirectoryWorkspaceAccessPropertiesPtrOutput struct{ *pulumi.OutputState }

func (DirectoryWorkspaceAccessPropertiesPtrOutput) DeviceTypeAndroid

Indicates whether users can use Android devices to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesPtrOutput) DeviceTypeChromeos

Indicates whether users can use Chromebooks to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesPtrOutput) DeviceTypeIos

Indicates whether users can use iOS devices to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesPtrOutput) DeviceTypeLinux

Indicates whether users can use Linux clients to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesPtrOutput) DeviceTypeOsx

Indicates whether users can use macOS clients to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesPtrOutput) DeviceTypeWeb

Indicates whether users can access their WorkSpaces through a web browser.

func (DirectoryWorkspaceAccessPropertiesPtrOutput) DeviceTypeWindows

Indicates whether users can use Windows clients to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesPtrOutput) DeviceTypeZeroclient

Indicates whether users can use zero client devices to access their WorkSpaces.

func (DirectoryWorkspaceAccessPropertiesPtrOutput) Elem

func (DirectoryWorkspaceAccessPropertiesPtrOutput) ElementType

func (DirectoryWorkspaceAccessPropertiesPtrOutput) ToDirectoryWorkspaceAccessPropertiesPtrOutput

func (o DirectoryWorkspaceAccessPropertiesPtrOutput) ToDirectoryWorkspaceAccessPropertiesPtrOutput() DirectoryWorkspaceAccessPropertiesPtrOutput

func (DirectoryWorkspaceAccessPropertiesPtrOutput) ToDirectoryWorkspaceAccessPropertiesPtrOutputWithContext

func (o DirectoryWorkspaceAccessPropertiesPtrOutput) ToDirectoryWorkspaceAccessPropertiesPtrOutputWithContext(ctx context.Context) DirectoryWorkspaceAccessPropertiesPtrOutput

type DirectoryWorkspaceCreationProperties

type DirectoryWorkspaceCreationProperties struct {
	// The identifier of your custom security group. Should relate to the same VPC, where workspaces reside in.
	CustomSecurityGroupId *string `pulumi:"customSecurityGroupId"`
	// The default organizational unit (OU) for your WorkSpace directories. Should conform `"OU=<value>,DC=<value>,...,DC=<value>"` pattern.
	DefaultOu *string `pulumi:"defaultOu"`
	// Indicates whether internet access is enabled for your WorkSpaces.
	EnableInternetAccess *bool `pulumi:"enableInternetAccess"`
	// Indicates whether maintenance mode is enabled for your WorkSpaces. Valid only if `workspaceType` is set to `PERSONAL`.
	EnableMaintenanceMode *bool `pulumi:"enableMaintenanceMode"`
	// Indicates whether users are local administrators of their WorkSpaces. Valid only if `workspaceType` is set to `PERSONAL`.
	UserEnabledAsLocalAdministrator *bool `pulumi:"userEnabledAsLocalAdministrator"`
}

type DirectoryWorkspaceCreationPropertiesArgs

type DirectoryWorkspaceCreationPropertiesArgs struct {
	// The identifier of your custom security group. Should relate to the same VPC, where workspaces reside in.
	CustomSecurityGroupId pulumi.StringPtrInput `pulumi:"customSecurityGroupId"`
	// The default organizational unit (OU) for your WorkSpace directories. Should conform `"OU=<value>,DC=<value>,...,DC=<value>"` pattern.
	DefaultOu pulumi.StringPtrInput `pulumi:"defaultOu"`
	// Indicates whether internet access is enabled for your WorkSpaces.
	EnableInternetAccess pulumi.BoolPtrInput `pulumi:"enableInternetAccess"`
	// Indicates whether maintenance mode is enabled for your WorkSpaces. Valid only if `workspaceType` is set to `PERSONAL`.
	EnableMaintenanceMode pulumi.BoolPtrInput `pulumi:"enableMaintenanceMode"`
	// Indicates whether users are local administrators of their WorkSpaces. Valid only if `workspaceType` is set to `PERSONAL`.
	UserEnabledAsLocalAdministrator pulumi.BoolPtrInput `pulumi:"userEnabledAsLocalAdministrator"`
}

func (DirectoryWorkspaceCreationPropertiesArgs) ElementType

func (DirectoryWorkspaceCreationPropertiesArgs) ToDirectoryWorkspaceCreationPropertiesOutput

func (i DirectoryWorkspaceCreationPropertiesArgs) ToDirectoryWorkspaceCreationPropertiesOutput() DirectoryWorkspaceCreationPropertiesOutput

func (DirectoryWorkspaceCreationPropertiesArgs) ToDirectoryWorkspaceCreationPropertiesOutputWithContext

func (i DirectoryWorkspaceCreationPropertiesArgs) ToDirectoryWorkspaceCreationPropertiesOutputWithContext(ctx context.Context) DirectoryWorkspaceCreationPropertiesOutput

func (DirectoryWorkspaceCreationPropertiesArgs) ToDirectoryWorkspaceCreationPropertiesPtrOutput

func (i DirectoryWorkspaceCreationPropertiesArgs) ToDirectoryWorkspaceCreationPropertiesPtrOutput() DirectoryWorkspaceCreationPropertiesPtrOutput

func (DirectoryWorkspaceCreationPropertiesArgs) ToDirectoryWorkspaceCreationPropertiesPtrOutputWithContext

func (i DirectoryWorkspaceCreationPropertiesArgs) ToDirectoryWorkspaceCreationPropertiesPtrOutputWithContext(ctx context.Context) DirectoryWorkspaceCreationPropertiesPtrOutput

type DirectoryWorkspaceCreationPropertiesInput

type DirectoryWorkspaceCreationPropertiesInput interface {
	pulumi.Input

	ToDirectoryWorkspaceCreationPropertiesOutput() DirectoryWorkspaceCreationPropertiesOutput
	ToDirectoryWorkspaceCreationPropertiesOutputWithContext(context.Context) DirectoryWorkspaceCreationPropertiesOutput
}

DirectoryWorkspaceCreationPropertiesInput is an input type that accepts DirectoryWorkspaceCreationPropertiesArgs and DirectoryWorkspaceCreationPropertiesOutput values. You can construct a concrete instance of `DirectoryWorkspaceCreationPropertiesInput` via:

DirectoryWorkspaceCreationPropertiesArgs{...}

type DirectoryWorkspaceCreationPropertiesOutput

type DirectoryWorkspaceCreationPropertiesOutput struct{ *pulumi.OutputState }

func (DirectoryWorkspaceCreationPropertiesOutput) CustomSecurityGroupId

The identifier of your custom security group. Should relate to the same VPC, where workspaces reside in.

func (DirectoryWorkspaceCreationPropertiesOutput) DefaultOu

The default organizational unit (OU) for your WorkSpace directories. Should conform `"OU=<value>,DC=<value>,...,DC=<value>"` pattern.

func (DirectoryWorkspaceCreationPropertiesOutput) ElementType

func (DirectoryWorkspaceCreationPropertiesOutput) EnableInternetAccess

Indicates whether internet access is enabled for your WorkSpaces.

func (DirectoryWorkspaceCreationPropertiesOutput) EnableMaintenanceMode

Indicates whether maintenance mode is enabled for your WorkSpaces. Valid only if `workspaceType` is set to `PERSONAL`.

func (DirectoryWorkspaceCreationPropertiesOutput) ToDirectoryWorkspaceCreationPropertiesOutput

func (o DirectoryWorkspaceCreationPropertiesOutput) ToDirectoryWorkspaceCreationPropertiesOutput() DirectoryWorkspaceCreationPropertiesOutput

func (DirectoryWorkspaceCreationPropertiesOutput) ToDirectoryWorkspaceCreationPropertiesOutputWithContext

func (o DirectoryWorkspaceCreationPropertiesOutput) ToDirectoryWorkspaceCreationPropertiesOutputWithContext(ctx context.Context) DirectoryWorkspaceCreationPropertiesOutput

func (DirectoryWorkspaceCreationPropertiesOutput) ToDirectoryWorkspaceCreationPropertiesPtrOutput

func (o DirectoryWorkspaceCreationPropertiesOutput) ToDirectoryWorkspaceCreationPropertiesPtrOutput() DirectoryWorkspaceCreationPropertiesPtrOutput

func (DirectoryWorkspaceCreationPropertiesOutput) ToDirectoryWorkspaceCreationPropertiesPtrOutputWithContext

func (o DirectoryWorkspaceCreationPropertiesOutput) ToDirectoryWorkspaceCreationPropertiesPtrOutputWithContext(ctx context.Context) DirectoryWorkspaceCreationPropertiesPtrOutput

func (DirectoryWorkspaceCreationPropertiesOutput) UserEnabledAsLocalAdministrator

func (o DirectoryWorkspaceCreationPropertiesOutput) UserEnabledAsLocalAdministrator() pulumi.BoolPtrOutput

Indicates whether users are local administrators of their WorkSpaces. Valid only if `workspaceType` is set to `PERSONAL`.

type DirectoryWorkspaceCreationPropertiesPtrInput

type DirectoryWorkspaceCreationPropertiesPtrInput interface {
	pulumi.Input

	ToDirectoryWorkspaceCreationPropertiesPtrOutput() DirectoryWorkspaceCreationPropertiesPtrOutput
	ToDirectoryWorkspaceCreationPropertiesPtrOutputWithContext(context.Context) DirectoryWorkspaceCreationPropertiesPtrOutput
}

DirectoryWorkspaceCreationPropertiesPtrInput is an input type that accepts DirectoryWorkspaceCreationPropertiesArgs, DirectoryWorkspaceCreationPropertiesPtr and DirectoryWorkspaceCreationPropertiesPtrOutput values. You can construct a concrete instance of `DirectoryWorkspaceCreationPropertiesPtrInput` via:

        DirectoryWorkspaceCreationPropertiesArgs{...}

or:

        nil

type DirectoryWorkspaceCreationPropertiesPtrOutput

type DirectoryWorkspaceCreationPropertiesPtrOutput struct{ *pulumi.OutputState }

func (DirectoryWorkspaceCreationPropertiesPtrOutput) CustomSecurityGroupId

The identifier of your custom security group. Should relate to the same VPC, where workspaces reside in.

func (DirectoryWorkspaceCreationPropertiesPtrOutput) DefaultOu

The default organizational unit (OU) for your WorkSpace directories. Should conform `"OU=<value>,DC=<value>,...,DC=<value>"` pattern.

func (DirectoryWorkspaceCreationPropertiesPtrOutput) Elem

func (DirectoryWorkspaceCreationPropertiesPtrOutput) ElementType

func (DirectoryWorkspaceCreationPropertiesPtrOutput) EnableInternetAccess

Indicates whether internet access is enabled for your WorkSpaces.

func (DirectoryWorkspaceCreationPropertiesPtrOutput) EnableMaintenanceMode

Indicates whether maintenance mode is enabled for your WorkSpaces. Valid only if `workspaceType` is set to `PERSONAL`.

func (DirectoryWorkspaceCreationPropertiesPtrOutput) ToDirectoryWorkspaceCreationPropertiesPtrOutput

func (o DirectoryWorkspaceCreationPropertiesPtrOutput) ToDirectoryWorkspaceCreationPropertiesPtrOutput() DirectoryWorkspaceCreationPropertiesPtrOutput

func (DirectoryWorkspaceCreationPropertiesPtrOutput) ToDirectoryWorkspaceCreationPropertiesPtrOutputWithContext

func (o DirectoryWorkspaceCreationPropertiesPtrOutput) ToDirectoryWorkspaceCreationPropertiesPtrOutputWithContext(ctx context.Context) DirectoryWorkspaceCreationPropertiesPtrOutput

func (DirectoryWorkspaceCreationPropertiesPtrOutput) UserEnabledAsLocalAdministrator

func (o DirectoryWorkspaceCreationPropertiesPtrOutput) UserEnabledAsLocalAdministrator() pulumi.BoolPtrOutput

Indicates whether users are local administrators of their WorkSpaces. Valid only if `workspaceType` is set to `PERSONAL`.

type GetBundleArgs

type GetBundleArgs struct {
	// ID of the bundle.
	BundleId *string `pulumi:"bundleId"`
	// Name of the bundle. You cannot combine this parameter with `bundleId`.
	Name *string `pulumi:"name"`
	// Owner of the bundles. You have to leave it blank for own bundles. You cannot combine this parameter with `bundleId`.
	Owner *string `pulumi:"owner"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region *string `pulumi:"region"`
}

A collection of arguments for invoking getBundle.

type GetBundleComputeType

type GetBundleComputeType struct {
	// Name of the bundle. You cannot combine this parameter with `bundleId`.
	Name string `pulumi:"name"`
}

type GetBundleComputeTypeArgs

type GetBundleComputeTypeArgs struct {
	// Name of the bundle. You cannot combine this parameter with `bundleId`.
	Name pulumi.StringInput `pulumi:"name"`
}

func (GetBundleComputeTypeArgs) ElementType

func (GetBundleComputeTypeArgs) ElementType() reflect.Type

func (GetBundleComputeTypeArgs) ToGetBundleComputeTypeOutput

func (i GetBundleComputeTypeArgs) ToGetBundleComputeTypeOutput() GetBundleComputeTypeOutput

func (GetBundleComputeTypeArgs) ToGetBundleComputeTypeOutputWithContext

func (i GetBundleComputeTypeArgs) ToGetBundleComputeTypeOutputWithContext(ctx context.Context) GetBundleComputeTypeOutput

type GetBundleComputeTypeArray

type GetBundleComputeTypeArray []GetBundleComputeTypeInput

func (GetBundleComputeTypeArray) ElementType

func (GetBundleComputeTypeArray) ElementType() reflect.Type

func (GetBundleComputeTypeArray) ToGetBundleComputeTypeArrayOutput

func (i GetBundleComputeTypeArray) ToGetBundleComputeTypeArrayOutput() GetBundleComputeTypeArrayOutput

func (GetBundleComputeTypeArray) ToGetBundleComputeTypeArrayOutputWithContext

func (i GetBundleComputeTypeArray) ToGetBundleComputeTypeArrayOutputWithContext(ctx context.Context) GetBundleComputeTypeArrayOutput

type GetBundleComputeTypeArrayInput

type GetBundleComputeTypeArrayInput interface {
	pulumi.Input

	ToGetBundleComputeTypeArrayOutput() GetBundleComputeTypeArrayOutput
	ToGetBundleComputeTypeArrayOutputWithContext(context.Context) GetBundleComputeTypeArrayOutput
}

GetBundleComputeTypeArrayInput is an input type that accepts GetBundleComputeTypeArray and GetBundleComputeTypeArrayOutput values. You can construct a concrete instance of `GetBundleComputeTypeArrayInput` via:

GetBundleComputeTypeArray{ GetBundleComputeTypeArgs{...} }

type GetBundleComputeTypeArrayOutput

type GetBundleComputeTypeArrayOutput struct{ *pulumi.OutputState }

func (GetBundleComputeTypeArrayOutput) ElementType

func (GetBundleComputeTypeArrayOutput) Index

func (GetBundleComputeTypeArrayOutput) ToGetBundleComputeTypeArrayOutput

func (o GetBundleComputeTypeArrayOutput) ToGetBundleComputeTypeArrayOutput() GetBundleComputeTypeArrayOutput

func (GetBundleComputeTypeArrayOutput) ToGetBundleComputeTypeArrayOutputWithContext

func (o GetBundleComputeTypeArrayOutput) ToGetBundleComputeTypeArrayOutputWithContext(ctx context.Context) GetBundleComputeTypeArrayOutput

type GetBundleComputeTypeInput

type GetBundleComputeTypeInput interface {
	pulumi.Input

	ToGetBundleComputeTypeOutput() GetBundleComputeTypeOutput
	ToGetBundleComputeTypeOutputWithContext(context.Context) GetBundleComputeTypeOutput
}

GetBundleComputeTypeInput is an input type that accepts GetBundleComputeTypeArgs and GetBundleComputeTypeOutput values. You can construct a concrete instance of `GetBundleComputeTypeInput` via:

GetBundleComputeTypeArgs{...}

type GetBundleComputeTypeOutput

type GetBundleComputeTypeOutput struct{ *pulumi.OutputState }

func (GetBundleComputeTypeOutput) ElementType

func (GetBundleComputeTypeOutput) ElementType() reflect.Type

func (GetBundleComputeTypeOutput) Name

Name of the bundle. You cannot combine this parameter with `bundleId`.

func (GetBundleComputeTypeOutput) ToGetBundleComputeTypeOutput

func (o GetBundleComputeTypeOutput) ToGetBundleComputeTypeOutput() GetBundleComputeTypeOutput

func (GetBundleComputeTypeOutput) ToGetBundleComputeTypeOutputWithContext

func (o GetBundleComputeTypeOutput) ToGetBundleComputeTypeOutputWithContext(ctx context.Context) GetBundleComputeTypeOutput

type GetBundleOutputArgs

type GetBundleOutputArgs struct {
	// ID of the bundle.
	BundleId pulumi.StringPtrInput `pulumi:"bundleId"`
	// Name of the bundle. You cannot combine this parameter with `bundleId`.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// Owner of the bundles. You have to leave it blank for own bundles. You cannot combine this parameter with `bundleId`.
	Owner pulumi.StringPtrInput `pulumi:"owner"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput `pulumi:"region"`
}

A collection of arguments for invoking getBundle.

func (GetBundleOutputArgs) ElementType

func (GetBundleOutputArgs) ElementType() reflect.Type

type GetBundleResult

type GetBundleResult struct {
	// The ID of the bundle.
	BundleId *string `pulumi:"bundleId"`
	// The compute type. See supported fields below.
	ComputeTypes []GetBundleComputeType `pulumi:"computeTypes"`
	// The description of the bundle.
	Description string `pulumi:"description"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Name of the compute type.
	Name *string `pulumi:"name"`
	// The owner of the bundle.
	Owner  *string `pulumi:"owner"`
	Region string  `pulumi:"region"`
	// The root volume. See supported fields below.
	RootStorages []GetBundleRootStorage `pulumi:"rootStorages"`
	// The user storage. See supported fields below.
	UserStorages []GetBundleUserStorage `pulumi:"userStorages"`
}

A collection of values returned by getBundle.

func GetBundle

func GetBundle(ctx *pulumi.Context, args *GetBundleArgs, opts ...pulumi.InvokeOption) (*GetBundleResult, error)

Retrieve information about an AWS WorkSpaces bundle.

## Example Usage

### By ID

```go package main

import (

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/workspaces"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := workspaces.GetBundle(ctx, &workspaces.GetBundleArgs{
			BundleId: pulumi.StringRef("wsb-b0s22j3d7"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

### By Owner & Name

```go package main

import (

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/workspaces"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := workspaces.GetBundle(ctx, &workspaces.GetBundleArgs{
			Owner: pulumi.StringRef("AMAZON"),
			Name:  pulumi.StringRef("Value with Windows 10 and Office 2016"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetBundleResultOutput

type GetBundleResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getBundle.

func (GetBundleResultOutput) BundleId

The ID of the bundle.

func (GetBundleResultOutput) ComputeTypes

The compute type. See supported fields below.

func (GetBundleResultOutput) Description

func (o GetBundleResultOutput) Description() pulumi.StringOutput

The description of the bundle.

func (GetBundleResultOutput) ElementType

func (GetBundleResultOutput) ElementType() reflect.Type

func (GetBundleResultOutput) Id

The provider-assigned unique ID for this managed resource.

func (GetBundleResultOutput) Name

Name of the compute type.

func (GetBundleResultOutput) Owner

The owner of the bundle.

func (GetBundleResultOutput) Region

func (GetBundleResultOutput) RootStorages

The root volume. See supported fields below.

func (GetBundleResultOutput) ToGetBundleResultOutput

func (o GetBundleResultOutput) ToGetBundleResultOutput() GetBundleResultOutput

func (GetBundleResultOutput) ToGetBundleResultOutputWithContext

func (o GetBundleResultOutput) ToGetBundleResultOutputWithContext(ctx context.Context) GetBundleResultOutput

func (GetBundleResultOutput) UserStorages

The user storage. See supported fields below.

type GetBundleRootStorage

type GetBundleRootStorage struct {
	// Size of the user storage.
	Capacity string `pulumi:"capacity"`
}

type GetBundleRootStorageArgs

type GetBundleRootStorageArgs struct {
	// Size of the user storage.
	Capacity pulumi.StringInput `pulumi:"capacity"`
}

func (GetBundleRootStorageArgs) ElementType

func (GetBundleRootStorageArgs) ElementType() reflect.Type

func (GetBundleRootStorageArgs) ToGetBundleRootStorageOutput

func (i GetBundleRootStorageArgs) ToGetBundleRootStorageOutput() GetBundleRootStorageOutput

func (GetBundleRootStorageArgs) ToGetBundleRootStorageOutputWithContext

func (i GetBundleRootStorageArgs) ToGetBundleRootStorageOutputWithContext(ctx context.Context) GetBundleRootStorageOutput

type GetBundleRootStorageArray

type GetBundleRootStorageArray []GetBundleRootStorageInput

func (GetBundleRootStorageArray) ElementType

func (GetBundleRootStorageArray) ElementType() reflect.Type

func (GetBundleRootStorageArray) ToGetBundleRootStorageArrayOutput

func (i GetBundleRootStorageArray) ToGetBundleRootStorageArrayOutput() GetBundleRootStorageArrayOutput

func (GetBundleRootStorageArray) ToGetBundleRootStorageArrayOutputWithContext

func (i GetBundleRootStorageArray) ToGetBundleRootStorageArrayOutputWithContext(ctx context.Context) GetBundleRootStorageArrayOutput

type GetBundleRootStorageArrayInput

type GetBundleRootStorageArrayInput interface {
	pulumi.Input

	ToGetBundleRootStorageArrayOutput() GetBundleRootStorageArrayOutput
	ToGetBundleRootStorageArrayOutputWithContext(context.Context) GetBundleRootStorageArrayOutput
}

GetBundleRootStorageArrayInput is an input type that accepts GetBundleRootStorageArray and GetBundleRootStorageArrayOutput values. You can construct a concrete instance of `GetBundleRootStorageArrayInput` via:

GetBundleRootStorageArray{ GetBundleRootStorageArgs{...} }

type GetBundleRootStorageArrayOutput

type GetBundleRootStorageArrayOutput struct{ *pulumi.OutputState }

func (GetBundleRootStorageArrayOutput) ElementType

func (GetBundleRootStorageArrayOutput) Index

func (GetBundleRootStorageArrayOutput) ToGetBundleRootStorageArrayOutput

func (o GetBundleRootStorageArrayOutput) ToGetBundleRootStorageArrayOutput() GetBundleRootStorageArrayOutput

func (GetBundleRootStorageArrayOutput) ToGetBundleRootStorageArrayOutputWithContext

func (o GetBundleRootStorageArrayOutput) ToGetBundleRootStorageArrayOutputWithContext(ctx context.Context) GetBundleRootStorageArrayOutput

type GetBundleRootStorageInput

type GetBundleRootStorageInput interface {
	pulumi.Input

	ToGetBundleRootStorageOutput() GetBundleRootStorageOutput
	ToGetBundleRootStorageOutputWithContext(context.Context) GetBundleRootStorageOutput
}

GetBundleRootStorageInput is an input type that accepts GetBundleRootStorageArgs and GetBundleRootStorageOutput values. You can construct a concrete instance of `GetBundleRootStorageInput` via:

GetBundleRootStorageArgs{...}

type GetBundleRootStorageOutput

type GetBundleRootStorageOutput struct{ *pulumi.OutputState }

func (GetBundleRootStorageOutput) Capacity

Size of the user storage.

func (GetBundleRootStorageOutput) ElementType

func (GetBundleRootStorageOutput) ElementType() reflect.Type

func (GetBundleRootStorageOutput) ToGetBundleRootStorageOutput

func (o GetBundleRootStorageOutput) ToGetBundleRootStorageOutput() GetBundleRootStorageOutput

func (GetBundleRootStorageOutput) ToGetBundleRootStorageOutputWithContext

func (o GetBundleRootStorageOutput) ToGetBundleRootStorageOutputWithContext(ctx context.Context) GetBundleRootStorageOutput

type GetBundleUserStorage

type GetBundleUserStorage struct {
	// Size of the user storage.
	Capacity string `pulumi:"capacity"`
}

type GetBundleUserStorageArgs

type GetBundleUserStorageArgs struct {
	// Size of the user storage.
	Capacity pulumi.StringInput `pulumi:"capacity"`
}

func (GetBundleUserStorageArgs) ElementType

func (GetBundleUserStorageArgs) ElementType() reflect.Type

func (GetBundleUserStorageArgs) ToGetBundleUserStorageOutput

func (i GetBundleUserStorageArgs) ToGetBundleUserStorageOutput() GetBundleUserStorageOutput

func (GetBundleUserStorageArgs) ToGetBundleUserStorageOutputWithContext

func (i GetBundleUserStorageArgs) ToGetBundleUserStorageOutputWithContext(ctx context.Context) GetBundleUserStorageOutput

type GetBundleUserStorageArray

type GetBundleUserStorageArray []GetBundleUserStorageInput

func (GetBundleUserStorageArray) ElementType

func (GetBundleUserStorageArray) ElementType() reflect.Type

func (GetBundleUserStorageArray) ToGetBundleUserStorageArrayOutput

func (i GetBundleUserStorageArray) ToGetBundleUserStorageArrayOutput() GetBundleUserStorageArrayOutput

func (GetBundleUserStorageArray) ToGetBundleUserStorageArrayOutputWithContext

func (i GetBundleUserStorageArray) ToGetBundleUserStorageArrayOutputWithContext(ctx context.Context) GetBundleUserStorageArrayOutput

type GetBundleUserStorageArrayInput

type GetBundleUserStorageArrayInput interface {
	pulumi.Input

	ToGetBundleUserStorageArrayOutput() GetBundleUserStorageArrayOutput
	ToGetBundleUserStorageArrayOutputWithContext(context.Context) GetBundleUserStorageArrayOutput
}

GetBundleUserStorageArrayInput is an input type that accepts GetBundleUserStorageArray and GetBundleUserStorageArrayOutput values. You can construct a concrete instance of `GetBundleUserStorageArrayInput` via:

GetBundleUserStorageArray{ GetBundleUserStorageArgs{...} }

type GetBundleUserStorageArrayOutput

type GetBundleUserStorageArrayOutput struct{ *pulumi.OutputState }

func (GetBundleUserStorageArrayOutput) ElementType

func (GetBundleUserStorageArrayOutput) Index

func (GetBundleUserStorageArrayOutput) ToGetBundleUserStorageArrayOutput

func (o GetBundleUserStorageArrayOutput) ToGetBundleUserStorageArrayOutput() GetBundleUserStorageArrayOutput

func (GetBundleUserStorageArrayOutput) ToGetBundleUserStorageArrayOutputWithContext

func (o GetBundleUserStorageArrayOutput) ToGetBundleUserStorageArrayOutputWithContext(ctx context.Context) GetBundleUserStorageArrayOutput

type GetBundleUserStorageInput

type GetBundleUserStorageInput interface {
	pulumi.Input

	ToGetBundleUserStorageOutput() GetBundleUserStorageOutput
	ToGetBundleUserStorageOutputWithContext(context.Context) GetBundleUserStorageOutput
}

GetBundleUserStorageInput is an input type that accepts GetBundleUserStorageArgs and GetBundleUserStorageOutput values. You can construct a concrete instance of `GetBundleUserStorageInput` via:

GetBundleUserStorageArgs{...}

type GetBundleUserStorageOutput

type GetBundleUserStorageOutput struct{ *pulumi.OutputState }

func (GetBundleUserStorageOutput) Capacity

Size of the user storage.

func (GetBundleUserStorageOutput) ElementType

func (GetBundleUserStorageOutput) ElementType() reflect.Type

func (GetBundleUserStorageOutput) ToGetBundleUserStorageOutput

func (o GetBundleUserStorageOutput) ToGetBundleUserStorageOutput() GetBundleUserStorageOutput

func (GetBundleUserStorageOutput) ToGetBundleUserStorageOutputWithContext

func (o GetBundleUserStorageOutput) ToGetBundleUserStorageOutputWithContext(ctx context.Context) GetBundleUserStorageOutput

type GetDirectoryActiveDirectoryConfig

type GetDirectoryActiveDirectoryConfig struct {
	// Fully qualified domain name of the AWS Directory Service directory.
	DomainName string `pulumi:"domainName"`
	// ARN of the Secrets Manager secret that contains the credentials for the service account.
	ServiceAccountSecretArn string `pulumi:"serviceAccountSecretArn"`
}

type GetDirectoryActiveDirectoryConfigArgs

type GetDirectoryActiveDirectoryConfigArgs struct {
	// Fully qualified domain name of the AWS Directory Service directory.
	DomainName pulumi.StringInput `pulumi:"domainName"`
	// ARN of the Secrets Manager secret that contains the credentials for the service account.
	ServiceAccountSecretArn pulumi.StringInput `pulumi:"serviceAccountSecretArn"`
}

func (GetDirectoryActiveDirectoryConfigArgs) ElementType

func (GetDirectoryActiveDirectoryConfigArgs) ToGetDirectoryActiveDirectoryConfigOutput

func (i GetDirectoryActiveDirectoryConfigArgs) ToGetDirectoryActiveDirectoryConfigOutput() GetDirectoryActiveDirectoryConfigOutput

func (GetDirectoryActiveDirectoryConfigArgs) ToGetDirectoryActiveDirectoryConfigOutputWithContext

func (i GetDirectoryActiveDirectoryConfigArgs) ToGetDirectoryActiveDirectoryConfigOutputWithContext(ctx context.Context) GetDirectoryActiveDirectoryConfigOutput

type GetDirectoryActiveDirectoryConfigArray

type GetDirectoryActiveDirectoryConfigArray []GetDirectoryActiveDirectoryConfigInput

func (GetDirectoryActiveDirectoryConfigArray) ElementType

func (GetDirectoryActiveDirectoryConfigArray) ToGetDirectoryActiveDirectoryConfigArrayOutput

func (i GetDirectoryActiveDirectoryConfigArray) ToGetDirectoryActiveDirectoryConfigArrayOutput() GetDirectoryActiveDirectoryConfigArrayOutput

func (GetDirectoryActiveDirectoryConfigArray) ToGetDirectoryActiveDirectoryConfigArrayOutputWithContext

func (i GetDirectoryActiveDirectoryConfigArray) ToGetDirectoryActiveDirectoryConfigArrayOutputWithContext(ctx context.Context) GetDirectoryActiveDirectoryConfigArrayOutput

type GetDirectoryActiveDirectoryConfigArrayInput

type GetDirectoryActiveDirectoryConfigArrayInput interface {
	pulumi.Input

	ToGetDirectoryActiveDirectoryConfigArrayOutput() GetDirectoryActiveDirectoryConfigArrayOutput
	ToGetDirectoryActiveDirectoryConfigArrayOutputWithContext(context.Context) GetDirectoryActiveDirectoryConfigArrayOutput
}

GetDirectoryActiveDirectoryConfigArrayInput is an input type that accepts GetDirectoryActiveDirectoryConfigArray and GetDirectoryActiveDirectoryConfigArrayOutput values. You can construct a concrete instance of `GetDirectoryActiveDirectoryConfigArrayInput` via:

GetDirectoryActiveDirectoryConfigArray{ GetDirectoryActiveDirectoryConfigArgs{...} }

type GetDirectoryActiveDirectoryConfigArrayOutput

type GetDirectoryActiveDirectoryConfigArrayOutput struct{ *pulumi.OutputState }

func (GetDirectoryActiveDirectoryConfigArrayOutput) ElementType

func (GetDirectoryActiveDirectoryConfigArrayOutput) Index

func (GetDirectoryActiveDirectoryConfigArrayOutput) ToGetDirectoryActiveDirectoryConfigArrayOutput

func (o GetDirectoryActiveDirectoryConfigArrayOutput) ToGetDirectoryActiveDirectoryConfigArrayOutput() GetDirectoryActiveDirectoryConfigArrayOutput

func (GetDirectoryActiveDirectoryConfigArrayOutput) ToGetDirectoryActiveDirectoryConfigArrayOutputWithContext

func (o GetDirectoryActiveDirectoryConfigArrayOutput) ToGetDirectoryActiveDirectoryConfigArrayOutputWithContext(ctx context.Context) GetDirectoryActiveDirectoryConfigArrayOutput

type GetDirectoryActiveDirectoryConfigInput

type GetDirectoryActiveDirectoryConfigInput interface {
	pulumi.Input

	ToGetDirectoryActiveDirectoryConfigOutput() GetDirectoryActiveDirectoryConfigOutput
	ToGetDirectoryActiveDirectoryConfigOutputWithContext(context.Context) GetDirectoryActiveDirectoryConfigOutput
}

GetDirectoryActiveDirectoryConfigInput is an input type that accepts GetDirectoryActiveDirectoryConfigArgs and GetDirectoryActiveDirectoryConfigOutput values. You can construct a concrete instance of `GetDirectoryActiveDirectoryConfigInput` via:

GetDirectoryActiveDirectoryConfigArgs{...}

type GetDirectoryActiveDirectoryConfigOutput

type GetDirectoryActiveDirectoryConfigOutput struct{ *pulumi.OutputState }

func (GetDirectoryActiveDirectoryConfigOutput) DomainName

Fully qualified domain name of the AWS Directory Service directory.

func (GetDirectoryActiveDirectoryConfigOutput) ElementType

func (GetDirectoryActiveDirectoryConfigOutput) ServiceAccountSecretArn

func (o GetDirectoryActiveDirectoryConfigOutput) ServiceAccountSecretArn() pulumi.StringOutput

ARN of the Secrets Manager secret that contains the credentials for the service account.

func (GetDirectoryActiveDirectoryConfigOutput) ToGetDirectoryActiveDirectoryConfigOutput

func (o GetDirectoryActiveDirectoryConfigOutput) ToGetDirectoryActiveDirectoryConfigOutput() GetDirectoryActiveDirectoryConfigOutput

func (GetDirectoryActiveDirectoryConfigOutput) ToGetDirectoryActiveDirectoryConfigOutputWithContext

func (o GetDirectoryActiveDirectoryConfigOutput) ToGetDirectoryActiveDirectoryConfigOutputWithContext(ctx context.Context) GetDirectoryActiveDirectoryConfigOutput

type GetDirectoryCertificateBasedAuthProperty

type GetDirectoryCertificateBasedAuthProperty struct {
	CertificateAuthorityArn string `pulumi:"certificateAuthorityArn"`
	Status                  string `pulumi:"status"`
}

type GetDirectoryCertificateBasedAuthPropertyArgs

type GetDirectoryCertificateBasedAuthPropertyArgs struct {
	CertificateAuthorityArn pulumi.StringInput `pulumi:"certificateAuthorityArn"`
	Status                  pulumi.StringInput `pulumi:"status"`
}

func (GetDirectoryCertificateBasedAuthPropertyArgs) ElementType

func (GetDirectoryCertificateBasedAuthPropertyArgs) ToGetDirectoryCertificateBasedAuthPropertyOutput

func (i GetDirectoryCertificateBasedAuthPropertyArgs) ToGetDirectoryCertificateBasedAuthPropertyOutput() GetDirectoryCertificateBasedAuthPropertyOutput

func (GetDirectoryCertificateBasedAuthPropertyArgs) ToGetDirectoryCertificateBasedAuthPropertyOutputWithContext

func (i GetDirectoryCertificateBasedAuthPropertyArgs) ToGetDirectoryCertificateBasedAuthPropertyOutputWithContext(ctx context.Context) GetDirectoryCertificateBasedAuthPropertyOutput

type GetDirectoryCertificateBasedAuthPropertyArray

type GetDirectoryCertificateBasedAuthPropertyArray []GetDirectoryCertificateBasedAuthPropertyInput

func (GetDirectoryCertificateBasedAuthPropertyArray) ElementType

func (GetDirectoryCertificateBasedAuthPropertyArray) ToGetDirectoryCertificateBasedAuthPropertyArrayOutput

func (i GetDirectoryCertificateBasedAuthPropertyArray) ToGetDirectoryCertificateBasedAuthPropertyArrayOutput() GetDirectoryCertificateBasedAuthPropertyArrayOutput

func (GetDirectoryCertificateBasedAuthPropertyArray) ToGetDirectoryCertificateBasedAuthPropertyArrayOutputWithContext

func (i GetDirectoryCertificateBasedAuthPropertyArray) ToGetDirectoryCertificateBasedAuthPropertyArrayOutputWithContext(ctx context.Context) GetDirectoryCertificateBasedAuthPropertyArrayOutput

type GetDirectoryCertificateBasedAuthPropertyArrayInput

type GetDirectoryCertificateBasedAuthPropertyArrayInput interface {
	pulumi.Input

	ToGetDirectoryCertificateBasedAuthPropertyArrayOutput() GetDirectoryCertificateBasedAuthPropertyArrayOutput
	ToGetDirectoryCertificateBasedAuthPropertyArrayOutputWithContext(context.Context) GetDirectoryCertificateBasedAuthPropertyArrayOutput
}

GetDirectoryCertificateBasedAuthPropertyArrayInput is an input type that accepts GetDirectoryCertificateBasedAuthPropertyArray and GetDirectoryCertificateBasedAuthPropertyArrayOutput values. You can construct a concrete instance of `GetDirectoryCertificateBasedAuthPropertyArrayInput` via:

GetDirectoryCertificateBasedAuthPropertyArray{ GetDirectoryCertificateBasedAuthPropertyArgs{...} }

type GetDirectoryCertificateBasedAuthPropertyArrayOutput

type GetDirectoryCertificateBasedAuthPropertyArrayOutput struct{ *pulumi.OutputState }

func (GetDirectoryCertificateBasedAuthPropertyArrayOutput) ElementType

func (GetDirectoryCertificateBasedAuthPropertyArrayOutput) Index

func (GetDirectoryCertificateBasedAuthPropertyArrayOutput) ToGetDirectoryCertificateBasedAuthPropertyArrayOutput

func (o GetDirectoryCertificateBasedAuthPropertyArrayOutput) ToGetDirectoryCertificateBasedAuthPropertyArrayOutput() GetDirectoryCertificateBasedAuthPropertyArrayOutput

func (GetDirectoryCertificateBasedAuthPropertyArrayOutput) ToGetDirectoryCertificateBasedAuthPropertyArrayOutputWithContext

func (o GetDirectoryCertificateBasedAuthPropertyArrayOutput) ToGetDirectoryCertificateBasedAuthPropertyArrayOutputWithContext(ctx context.Context) GetDirectoryCertificateBasedAuthPropertyArrayOutput

type GetDirectoryCertificateBasedAuthPropertyInput

type GetDirectoryCertificateBasedAuthPropertyInput interface {
	pulumi.Input

	ToGetDirectoryCertificateBasedAuthPropertyOutput() GetDirectoryCertificateBasedAuthPropertyOutput
	ToGetDirectoryCertificateBasedAuthPropertyOutputWithContext(context.Context) GetDirectoryCertificateBasedAuthPropertyOutput
}

GetDirectoryCertificateBasedAuthPropertyInput is an input type that accepts GetDirectoryCertificateBasedAuthPropertyArgs and GetDirectoryCertificateBasedAuthPropertyOutput values. You can construct a concrete instance of `GetDirectoryCertificateBasedAuthPropertyInput` via:

GetDirectoryCertificateBasedAuthPropertyArgs{...}

type GetDirectoryCertificateBasedAuthPropertyOutput

type GetDirectoryCertificateBasedAuthPropertyOutput struct{ *pulumi.OutputState }

func (GetDirectoryCertificateBasedAuthPropertyOutput) CertificateAuthorityArn

func (GetDirectoryCertificateBasedAuthPropertyOutput) ElementType

func (GetDirectoryCertificateBasedAuthPropertyOutput) Status

func (GetDirectoryCertificateBasedAuthPropertyOutput) ToGetDirectoryCertificateBasedAuthPropertyOutput

func (o GetDirectoryCertificateBasedAuthPropertyOutput) ToGetDirectoryCertificateBasedAuthPropertyOutput() GetDirectoryCertificateBasedAuthPropertyOutput

func (GetDirectoryCertificateBasedAuthPropertyOutput) ToGetDirectoryCertificateBasedAuthPropertyOutputWithContext

func (o GetDirectoryCertificateBasedAuthPropertyOutput) ToGetDirectoryCertificateBasedAuthPropertyOutputWithContext(ctx context.Context) GetDirectoryCertificateBasedAuthPropertyOutput

type GetDirectorySamlProperty

type GetDirectorySamlProperty struct {
	RelayStateParameterName string `pulumi:"relayStateParameterName"`
	Status                  string `pulumi:"status"`
	UserAccessUrl           string `pulumi:"userAccessUrl"`
}

type GetDirectorySamlPropertyArgs

type GetDirectorySamlPropertyArgs struct {
	RelayStateParameterName pulumi.StringInput `pulumi:"relayStateParameterName"`
	Status                  pulumi.StringInput `pulumi:"status"`
	UserAccessUrl           pulumi.StringInput `pulumi:"userAccessUrl"`
}

func (GetDirectorySamlPropertyArgs) ElementType

func (GetDirectorySamlPropertyArgs) ToGetDirectorySamlPropertyOutput

func (i GetDirectorySamlPropertyArgs) ToGetDirectorySamlPropertyOutput() GetDirectorySamlPropertyOutput

func (GetDirectorySamlPropertyArgs) ToGetDirectorySamlPropertyOutputWithContext

func (i GetDirectorySamlPropertyArgs) ToGetDirectorySamlPropertyOutputWithContext(ctx context.Context) GetDirectorySamlPropertyOutput

type GetDirectorySamlPropertyArray

type GetDirectorySamlPropertyArray []GetDirectorySamlPropertyInput

func (GetDirectorySamlPropertyArray) ElementType

func (GetDirectorySamlPropertyArray) ToGetDirectorySamlPropertyArrayOutput

func (i GetDirectorySamlPropertyArray) ToGetDirectorySamlPropertyArrayOutput() GetDirectorySamlPropertyArrayOutput

func (GetDirectorySamlPropertyArray) ToGetDirectorySamlPropertyArrayOutputWithContext

func (i GetDirectorySamlPropertyArray) ToGetDirectorySamlPropertyArrayOutputWithContext(ctx context.Context) GetDirectorySamlPropertyArrayOutput

type GetDirectorySamlPropertyArrayInput

type GetDirectorySamlPropertyArrayInput interface {
	pulumi.Input

	ToGetDirectorySamlPropertyArrayOutput() GetDirectorySamlPropertyArrayOutput
	ToGetDirectorySamlPropertyArrayOutputWithContext(context.Context) GetDirectorySamlPropertyArrayOutput
}

GetDirectorySamlPropertyArrayInput is an input type that accepts GetDirectorySamlPropertyArray and GetDirectorySamlPropertyArrayOutput values. You can construct a concrete instance of `GetDirectorySamlPropertyArrayInput` via:

GetDirectorySamlPropertyArray{ GetDirectorySamlPropertyArgs{...} }

type GetDirectorySamlPropertyArrayOutput

type GetDirectorySamlPropertyArrayOutput struct{ *pulumi.OutputState }

func (GetDirectorySamlPropertyArrayOutput) ElementType

func (GetDirectorySamlPropertyArrayOutput) Index

func (GetDirectorySamlPropertyArrayOutput) ToGetDirectorySamlPropertyArrayOutput

func (o GetDirectorySamlPropertyArrayOutput) ToGetDirectorySamlPropertyArrayOutput() GetDirectorySamlPropertyArrayOutput

func (GetDirectorySamlPropertyArrayOutput) ToGetDirectorySamlPropertyArrayOutputWithContext

func (o GetDirectorySamlPropertyArrayOutput) ToGetDirectorySamlPropertyArrayOutputWithContext(ctx context.Context) GetDirectorySamlPropertyArrayOutput

type GetDirectorySamlPropertyInput

type GetDirectorySamlPropertyInput interface {
	pulumi.Input

	ToGetDirectorySamlPropertyOutput() GetDirectorySamlPropertyOutput
	ToGetDirectorySamlPropertyOutputWithContext(context.Context) GetDirectorySamlPropertyOutput
}

GetDirectorySamlPropertyInput is an input type that accepts GetDirectorySamlPropertyArgs and GetDirectorySamlPropertyOutput values. You can construct a concrete instance of `GetDirectorySamlPropertyInput` via:

GetDirectorySamlPropertyArgs{...}

type GetDirectorySamlPropertyOutput

type GetDirectorySamlPropertyOutput struct{ *pulumi.OutputState }

func (GetDirectorySamlPropertyOutput) ElementType

func (GetDirectorySamlPropertyOutput) RelayStateParameterName

func (o GetDirectorySamlPropertyOutput) RelayStateParameterName() pulumi.StringOutput

func (GetDirectorySamlPropertyOutput) Status

func (GetDirectorySamlPropertyOutput) ToGetDirectorySamlPropertyOutput

func (o GetDirectorySamlPropertyOutput) ToGetDirectorySamlPropertyOutput() GetDirectorySamlPropertyOutput

func (GetDirectorySamlPropertyOutput) ToGetDirectorySamlPropertyOutputWithContext

func (o GetDirectorySamlPropertyOutput) ToGetDirectorySamlPropertyOutputWithContext(ctx context.Context) GetDirectorySamlPropertyOutput

func (GetDirectorySamlPropertyOutput) UserAccessUrl

type GetDirectorySelfServicePermission

type GetDirectorySelfServicePermission struct {
	// Whether WorkSpaces directory users can change the compute type (bundle) for their workspace.
	ChangeComputeType bool `pulumi:"changeComputeType"`
	// Whether WorkSpaces directory users can increase the volume size of the drives on their workspace.
	IncreaseVolumeSize bool `pulumi:"increaseVolumeSize"`
	// Whether WorkSpaces directory users can rebuild the operating system of a workspace to its original state.
	RebuildWorkspace bool `pulumi:"rebuildWorkspace"`
	// Whether WorkSpaces directory users can restart their workspace.
	RestartWorkspace bool `pulumi:"restartWorkspace"`
	// Whether WorkSpaces directory users can switch the running mode of their workspace.
	SwitchRunningMode bool `pulumi:"switchRunningMode"`
}

type GetDirectorySelfServicePermissionArgs

type GetDirectorySelfServicePermissionArgs struct {
	// Whether WorkSpaces directory users can change the compute type (bundle) for their workspace.
	ChangeComputeType pulumi.BoolInput `pulumi:"changeComputeType"`
	// Whether WorkSpaces directory users can increase the volume size of the drives on their workspace.
	IncreaseVolumeSize pulumi.BoolInput `pulumi:"increaseVolumeSize"`
	// Whether WorkSpaces directory users can rebuild the operating system of a workspace to its original state.
	RebuildWorkspace pulumi.BoolInput `pulumi:"rebuildWorkspace"`
	// Whether WorkSpaces directory users can restart their workspace.
	RestartWorkspace pulumi.BoolInput `pulumi:"restartWorkspace"`
	// Whether WorkSpaces directory users can switch the running mode of their workspace.
	SwitchRunningMode pulumi.BoolInput `pulumi:"switchRunningMode"`
}

func (GetDirectorySelfServicePermissionArgs) ElementType

func (GetDirectorySelfServicePermissionArgs) ToGetDirectorySelfServicePermissionOutput

func (i GetDirectorySelfServicePermissionArgs) ToGetDirectorySelfServicePermissionOutput() GetDirectorySelfServicePermissionOutput

func (GetDirectorySelfServicePermissionArgs) ToGetDirectorySelfServicePermissionOutputWithContext

func (i GetDirectorySelfServicePermissionArgs) ToGetDirectorySelfServicePermissionOutputWithContext(ctx context.Context) GetDirectorySelfServicePermissionOutput

type GetDirectorySelfServicePermissionArray

type GetDirectorySelfServicePermissionArray []GetDirectorySelfServicePermissionInput

func (GetDirectorySelfServicePermissionArray) ElementType

func (GetDirectorySelfServicePermissionArray) ToGetDirectorySelfServicePermissionArrayOutput

func (i GetDirectorySelfServicePermissionArray) ToGetDirectorySelfServicePermissionArrayOutput() GetDirectorySelfServicePermissionArrayOutput

func (GetDirectorySelfServicePermissionArray) ToGetDirectorySelfServicePermissionArrayOutputWithContext

func (i GetDirectorySelfServicePermissionArray) ToGetDirectorySelfServicePermissionArrayOutputWithContext(ctx context.Context) GetDirectorySelfServicePermissionArrayOutput

type GetDirectorySelfServicePermissionArrayInput

type GetDirectorySelfServicePermissionArrayInput interface {
	pulumi.Input

	ToGetDirectorySelfServicePermissionArrayOutput() GetDirectorySelfServicePermissionArrayOutput
	ToGetDirectorySelfServicePermissionArrayOutputWithContext(context.Context) GetDirectorySelfServicePermissionArrayOutput
}

GetDirectorySelfServicePermissionArrayInput is an input type that accepts GetDirectorySelfServicePermissionArray and GetDirectorySelfServicePermissionArrayOutput values. You can construct a concrete instance of `GetDirectorySelfServicePermissionArrayInput` via:

GetDirectorySelfServicePermissionArray{ GetDirectorySelfServicePermissionArgs{...} }

type GetDirectorySelfServicePermissionArrayOutput

type GetDirectorySelfServicePermissionArrayOutput struct{ *pulumi.OutputState }

func (GetDirectorySelfServicePermissionArrayOutput) ElementType

func (GetDirectorySelfServicePermissionArrayOutput) Index

func (GetDirectorySelfServicePermissionArrayOutput) ToGetDirectorySelfServicePermissionArrayOutput

func (o GetDirectorySelfServicePermissionArrayOutput) ToGetDirectorySelfServicePermissionArrayOutput() GetDirectorySelfServicePermissionArrayOutput

func (GetDirectorySelfServicePermissionArrayOutput) ToGetDirectorySelfServicePermissionArrayOutputWithContext

func (o GetDirectorySelfServicePermissionArrayOutput) ToGetDirectorySelfServicePermissionArrayOutputWithContext(ctx context.Context) GetDirectorySelfServicePermissionArrayOutput

type GetDirectorySelfServicePermissionInput

type GetDirectorySelfServicePermissionInput interface {
	pulumi.Input

	ToGetDirectorySelfServicePermissionOutput() GetDirectorySelfServicePermissionOutput
	ToGetDirectorySelfServicePermissionOutputWithContext(context.Context) GetDirectorySelfServicePermissionOutput
}

GetDirectorySelfServicePermissionInput is an input type that accepts GetDirectorySelfServicePermissionArgs and GetDirectorySelfServicePermissionOutput values. You can construct a concrete instance of `GetDirectorySelfServicePermissionInput` via:

GetDirectorySelfServicePermissionArgs{...}

type GetDirectorySelfServicePermissionOutput

type GetDirectorySelfServicePermissionOutput struct{ *pulumi.OutputState }

func (GetDirectorySelfServicePermissionOutput) ChangeComputeType

Whether WorkSpaces directory users can change the compute type (bundle) for their workspace.

func (GetDirectorySelfServicePermissionOutput) ElementType

func (GetDirectorySelfServicePermissionOutput) IncreaseVolumeSize

Whether WorkSpaces directory users can increase the volume size of the drives on their workspace.

func (GetDirectorySelfServicePermissionOutput) RebuildWorkspace

Whether WorkSpaces directory users can rebuild the operating system of a workspace to its original state.

func (GetDirectorySelfServicePermissionOutput) RestartWorkspace

Whether WorkSpaces directory users can restart their workspace.

func (GetDirectorySelfServicePermissionOutput) SwitchRunningMode

Whether WorkSpaces directory users can switch the running mode of their workspace.

func (GetDirectorySelfServicePermissionOutput) ToGetDirectorySelfServicePermissionOutput

func (o GetDirectorySelfServicePermissionOutput) ToGetDirectorySelfServicePermissionOutput() GetDirectorySelfServicePermissionOutput

func (GetDirectorySelfServicePermissionOutput) ToGetDirectorySelfServicePermissionOutputWithContext

func (o GetDirectorySelfServicePermissionOutput) ToGetDirectorySelfServicePermissionOutputWithContext(ctx context.Context) GetDirectorySelfServicePermissionOutput

type GetDirectoryWorkspaceAccessProperty

type GetDirectoryWorkspaceAccessProperty struct {
	// (Optional) Indicates whether users can use Android devices to access their WorkSpaces.
	DeviceTypeAndroid string `pulumi:"deviceTypeAndroid"`
	// (Optional) Indicates whether users can use Chromebooks to access their WorkSpaces.
	DeviceTypeChromeos string `pulumi:"deviceTypeChromeos"`
	// (Optional) Indicates whether users can use iOS devices to access their WorkSpaces.
	DeviceTypeIos string `pulumi:"deviceTypeIos"`
	// (Optional) Indicates whether users can use Linux clients to access their WorkSpaces.
	DeviceTypeLinux string `pulumi:"deviceTypeLinux"`
	// (Optional) Indicates whether users can use macOS clients to access their WorkSpaces.
	DeviceTypeOsx string `pulumi:"deviceTypeOsx"`
	// (Optional) Indicates whether users can access their WorkSpaces through a web browser.
	DeviceTypeWeb string `pulumi:"deviceTypeWeb"`
	// (Optional) Indicates whether users can use Windows clients to access their WorkSpaces.
	DeviceTypeWindows string `pulumi:"deviceTypeWindows"`
	// (Optional) Indicates whether users can use zero client devices to access their WorkSpaces.
	DeviceTypeZeroclient string `pulumi:"deviceTypeZeroclient"`
}

type GetDirectoryWorkspaceAccessPropertyArgs

type GetDirectoryWorkspaceAccessPropertyArgs struct {
	// (Optional) Indicates whether users can use Android devices to access their WorkSpaces.
	DeviceTypeAndroid pulumi.StringInput `pulumi:"deviceTypeAndroid"`
	// (Optional) Indicates whether users can use Chromebooks to access their WorkSpaces.
	DeviceTypeChromeos pulumi.StringInput `pulumi:"deviceTypeChromeos"`
	// (Optional) Indicates whether users can use iOS devices to access their WorkSpaces.
	DeviceTypeIos pulumi.StringInput `pulumi:"deviceTypeIos"`
	// (Optional) Indicates whether users can use Linux clients to access their WorkSpaces.
	DeviceTypeLinux pulumi.StringInput `pulumi:"deviceTypeLinux"`
	// (Optional) Indicates whether users can use macOS clients to access their WorkSpaces.
	DeviceTypeOsx pulumi.StringInput `pulumi:"deviceTypeOsx"`
	// (Optional) Indicates whether users can access their WorkSpaces through a web browser.
	DeviceTypeWeb pulumi.StringInput `pulumi:"deviceTypeWeb"`
	// (Optional) Indicates whether users can use Windows clients to access their WorkSpaces.
	DeviceTypeWindows pulumi.StringInput `pulumi:"deviceTypeWindows"`
	// (Optional) Indicates whether users can use zero client devices to access their WorkSpaces.
	DeviceTypeZeroclient pulumi.StringInput `pulumi:"deviceTypeZeroclient"`
}

func (GetDirectoryWorkspaceAccessPropertyArgs) ElementType

func (GetDirectoryWorkspaceAccessPropertyArgs) ToGetDirectoryWorkspaceAccessPropertyOutput

func (i GetDirectoryWorkspaceAccessPropertyArgs) ToGetDirectoryWorkspaceAccessPropertyOutput() GetDirectoryWorkspaceAccessPropertyOutput

func (GetDirectoryWorkspaceAccessPropertyArgs) ToGetDirectoryWorkspaceAccessPropertyOutputWithContext

func (i GetDirectoryWorkspaceAccessPropertyArgs) ToGetDirectoryWorkspaceAccessPropertyOutputWithContext(ctx context.Context) GetDirectoryWorkspaceAccessPropertyOutput

type GetDirectoryWorkspaceAccessPropertyArray

type GetDirectoryWorkspaceAccessPropertyArray []GetDirectoryWorkspaceAccessPropertyInput

func (GetDirectoryWorkspaceAccessPropertyArray) ElementType

func (GetDirectoryWorkspaceAccessPropertyArray) ToGetDirectoryWorkspaceAccessPropertyArrayOutput

func (i GetDirectoryWorkspaceAccessPropertyArray) ToGetDirectoryWorkspaceAccessPropertyArrayOutput() GetDirectoryWorkspaceAccessPropertyArrayOutput

func (GetDirectoryWorkspaceAccessPropertyArray) ToGetDirectoryWorkspaceAccessPropertyArrayOutputWithContext

func (i GetDirectoryWorkspaceAccessPropertyArray) ToGetDirectoryWorkspaceAccessPropertyArrayOutputWithContext(ctx context.Context) GetDirectoryWorkspaceAccessPropertyArrayOutput

type GetDirectoryWorkspaceAccessPropertyArrayInput

type GetDirectoryWorkspaceAccessPropertyArrayInput interface {
	pulumi.Input

	ToGetDirectoryWorkspaceAccessPropertyArrayOutput() GetDirectoryWorkspaceAccessPropertyArrayOutput
	ToGetDirectoryWorkspaceAccessPropertyArrayOutputWithContext(context.Context) GetDirectoryWorkspaceAccessPropertyArrayOutput
}

GetDirectoryWorkspaceAccessPropertyArrayInput is an input type that accepts GetDirectoryWorkspaceAccessPropertyArray and GetDirectoryWorkspaceAccessPropertyArrayOutput values. You can construct a concrete instance of `GetDirectoryWorkspaceAccessPropertyArrayInput` via:

GetDirectoryWorkspaceAccessPropertyArray{ GetDirectoryWorkspaceAccessPropertyArgs{...} }

type GetDirectoryWorkspaceAccessPropertyArrayOutput

type GetDirectoryWorkspaceAccessPropertyArrayOutput struct{ *pulumi.OutputState }

func (GetDirectoryWorkspaceAccessPropertyArrayOutput) ElementType

func (GetDirectoryWorkspaceAccessPropertyArrayOutput) Index

func (GetDirectoryWorkspaceAccessPropertyArrayOutput) ToGetDirectoryWorkspaceAccessPropertyArrayOutput

func (o GetDirectoryWorkspaceAccessPropertyArrayOutput) ToGetDirectoryWorkspaceAccessPropertyArrayOutput() GetDirectoryWorkspaceAccessPropertyArrayOutput

func (GetDirectoryWorkspaceAccessPropertyArrayOutput) ToGetDirectoryWorkspaceAccessPropertyArrayOutputWithContext

func (o GetDirectoryWorkspaceAccessPropertyArrayOutput) ToGetDirectoryWorkspaceAccessPropertyArrayOutputWithContext(ctx context.Context) GetDirectoryWorkspaceAccessPropertyArrayOutput

type GetDirectoryWorkspaceAccessPropertyInput

type GetDirectoryWorkspaceAccessPropertyInput interface {
	pulumi.Input

	ToGetDirectoryWorkspaceAccessPropertyOutput() GetDirectoryWorkspaceAccessPropertyOutput
	ToGetDirectoryWorkspaceAccessPropertyOutputWithContext(context.Context) GetDirectoryWorkspaceAccessPropertyOutput
}

GetDirectoryWorkspaceAccessPropertyInput is an input type that accepts GetDirectoryWorkspaceAccessPropertyArgs and GetDirectoryWorkspaceAccessPropertyOutput values. You can construct a concrete instance of `GetDirectoryWorkspaceAccessPropertyInput` via:

GetDirectoryWorkspaceAccessPropertyArgs{...}

type GetDirectoryWorkspaceAccessPropertyOutput

type GetDirectoryWorkspaceAccessPropertyOutput struct{ *pulumi.OutputState }

func (GetDirectoryWorkspaceAccessPropertyOutput) DeviceTypeAndroid

(Optional) Indicates whether users can use Android devices to access their WorkSpaces.

func (GetDirectoryWorkspaceAccessPropertyOutput) DeviceTypeChromeos

(Optional) Indicates whether users can use Chromebooks to access their WorkSpaces.

func (GetDirectoryWorkspaceAccessPropertyOutput) DeviceTypeIos

(Optional) Indicates whether users can use iOS devices to access their WorkSpaces.

func (GetDirectoryWorkspaceAccessPropertyOutput) DeviceTypeLinux

(Optional) Indicates whether users can use Linux clients to access their WorkSpaces.

func (GetDirectoryWorkspaceAccessPropertyOutput) DeviceTypeOsx

(Optional) Indicates whether users can use macOS clients to access their WorkSpaces.

func (GetDirectoryWorkspaceAccessPropertyOutput) DeviceTypeWeb

(Optional) Indicates whether users can access their WorkSpaces through a web browser.

func (GetDirectoryWorkspaceAccessPropertyOutput) DeviceTypeWindows

(Optional) Indicates whether users can use Windows clients to access their WorkSpaces.

func (GetDirectoryWorkspaceAccessPropertyOutput) DeviceTypeZeroclient

(Optional) Indicates whether users can use zero client devices to access their WorkSpaces.

func (GetDirectoryWorkspaceAccessPropertyOutput) ElementType

func (GetDirectoryWorkspaceAccessPropertyOutput) ToGetDirectoryWorkspaceAccessPropertyOutput

func (o GetDirectoryWorkspaceAccessPropertyOutput) ToGetDirectoryWorkspaceAccessPropertyOutput() GetDirectoryWorkspaceAccessPropertyOutput

func (GetDirectoryWorkspaceAccessPropertyOutput) ToGetDirectoryWorkspaceAccessPropertyOutputWithContext

func (o GetDirectoryWorkspaceAccessPropertyOutput) ToGetDirectoryWorkspaceAccessPropertyOutputWithContext(ctx context.Context) GetDirectoryWorkspaceAccessPropertyOutput

type GetDirectoryWorkspaceCreationProperty

type GetDirectoryWorkspaceCreationProperty struct {
	// The identifier of your custom security group. Should relate to the same VPC, where workspaces reside in.
	CustomSecurityGroupId string `pulumi:"customSecurityGroupId"`
	// The default organizational unit (OU) for your WorkSpace directories.
	DefaultOu string `pulumi:"defaultOu"`
	// Indicates whether internet access is enabled for your WorkSpaces.
	EnableInternetAccess bool `pulumi:"enableInternetAccess"`
	// Indicates whether maintenance mode is enabled for your WorkSpaces. For more information, see [WorkSpace Maintenance](https://docs.aws.amazon.com/workspaces/latest/adminguide/workspace-maintenance.html).
	EnableMaintenanceMode bool `pulumi:"enableMaintenanceMode"`
	// Indicates whether users are local administrators of their WorkSpaces.
	UserEnabledAsLocalAdministrator bool `pulumi:"userEnabledAsLocalAdministrator"`
}

type GetDirectoryWorkspaceCreationPropertyArgs

type GetDirectoryWorkspaceCreationPropertyArgs struct {
	// The identifier of your custom security group. Should relate to the same VPC, where workspaces reside in.
	CustomSecurityGroupId pulumi.StringInput `pulumi:"customSecurityGroupId"`
	// The default organizational unit (OU) for your WorkSpace directories.
	DefaultOu pulumi.StringInput `pulumi:"defaultOu"`
	// Indicates whether internet access is enabled for your WorkSpaces.
	EnableInternetAccess pulumi.BoolInput `pulumi:"enableInternetAccess"`
	// Indicates whether maintenance mode is enabled for your WorkSpaces. For more information, see [WorkSpace Maintenance](https://docs.aws.amazon.com/workspaces/latest/adminguide/workspace-maintenance.html).
	EnableMaintenanceMode pulumi.BoolInput `pulumi:"enableMaintenanceMode"`
	// Indicates whether users are local administrators of their WorkSpaces.
	UserEnabledAsLocalAdministrator pulumi.BoolInput `pulumi:"userEnabledAsLocalAdministrator"`
}

func (GetDirectoryWorkspaceCreationPropertyArgs) ElementType

func (GetDirectoryWorkspaceCreationPropertyArgs) ToGetDirectoryWorkspaceCreationPropertyOutput

func (i GetDirectoryWorkspaceCreationPropertyArgs) ToGetDirectoryWorkspaceCreationPropertyOutput() GetDirectoryWorkspaceCreationPropertyOutput

func (GetDirectoryWorkspaceCreationPropertyArgs) ToGetDirectoryWorkspaceCreationPropertyOutputWithContext

func (i GetDirectoryWorkspaceCreationPropertyArgs) ToGetDirectoryWorkspaceCreationPropertyOutputWithContext(ctx context.Context) GetDirectoryWorkspaceCreationPropertyOutput

type GetDirectoryWorkspaceCreationPropertyArray

type GetDirectoryWorkspaceCreationPropertyArray []GetDirectoryWorkspaceCreationPropertyInput

func (GetDirectoryWorkspaceCreationPropertyArray) ElementType

func (GetDirectoryWorkspaceCreationPropertyArray) ToGetDirectoryWorkspaceCreationPropertyArrayOutput

func (i GetDirectoryWorkspaceCreationPropertyArray) ToGetDirectoryWorkspaceCreationPropertyArrayOutput() GetDirectoryWorkspaceCreationPropertyArrayOutput

func (GetDirectoryWorkspaceCreationPropertyArray) ToGetDirectoryWorkspaceCreationPropertyArrayOutputWithContext

func (i GetDirectoryWorkspaceCreationPropertyArray) ToGetDirectoryWorkspaceCreationPropertyArrayOutputWithContext(ctx context.Context) GetDirectoryWorkspaceCreationPropertyArrayOutput

type GetDirectoryWorkspaceCreationPropertyArrayInput

type GetDirectoryWorkspaceCreationPropertyArrayInput interface {
	pulumi.Input

	ToGetDirectoryWorkspaceCreationPropertyArrayOutput() GetDirectoryWorkspaceCreationPropertyArrayOutput
	ToGetDirectoryWorkspaceCreationPropertyArrayOutputWithContext(context.Context) GetDirectoryWorkspaceCreationPropertyArrayOutput
}

GetDirectoryWorkspaceCreationPropertyArrayInput is an input type that accepts GetDirectoryWorkspaceCreationPropertyArray and GetDirectoryWorkspaceCreationPropertyArrayOutput values. You can construct a concrete instance of `GetDirectoryWorkspaceCreationPropertyArrayInput` via:

GetDirectoryWorkspaceCreationPropertyArray{ GetDirectoryWorkspaceCreationPropertyArgs{...} }

type GetDirectoryWorkspaceCreationPropertyArrayOutput

type GetDirectoryWorkspaceCreationPropertyArrayOutput struct{ *pulumi.OutputState }

func (GetDirectoryWorkspaceCreationPropertyArrayOutput) ElementType

func (GetDirectoryWorkspaceCreationPropertyArrayOutput) Index

func (GetDirectoryWorkspaceCreationPropertyArrayOutput) ToGetDirectoryWorkspaceCreationPropertyArrayOutput

func (o GetDirectoryWorkspaceCreationPropertyArrayOutput) ToGetDirectoryWorkspaceCreationPropertyArrayOutput() GetDirectoryWorkspaceCreationPropertyArrayOutput

func (GetDirectoryWorkspaceCreationPropertyArrayOutput) ToGetDirectoryWorkspaceCreationPropertyArrayOutputWithContext

func (o GetDirectoryWorkspaceCreationPropertyArrayOutput) ToGetDirectoryWorkspaceCreationPropertyArrayOutputWithContext(ctx context.Context) GetDirectoryWorkspaceCreationPropertyArrayOutput

type GetDirectoryWorkspaceCreationPropertyInput

type GetDirectoryWorkspaceCreationPropertyInput interface {
	pulumi.Input

	ToGetDirectoryWorkspaceCreationPropertyOutput() GetDirectoryWorkspaceCreationPropertyOutput
	ToGetDirectoryWorkspaceCreationPropertyOutputWithContext(context.Context) GetDirectoryWorkspaceCreationPropertyOutput
}

GetDirectoryWorkspaceCreationPropertyInput is an input type that accepts GetDirectoryWorkspaceCreationPropertyArgs and GetDirectoryWorkspaceCreationPropertyOutput values. You can construct a concrete instance of `GetDirectoryWorkspaceCreationPropertyInput` via:

GetDirectoryWorkspaceCreationPropertyArgs{...}

type GetDirectoryWorkspaceCreationPropertyOutput

type GetDirectoryWorkspaceCreationPropertyOutput struct{ *pulumi.OutputState }

func (GetDirectoryWorkspaceCreationPropertyOutput) CustomSecurityGroupId

The identifier of your custom security group. Should relate to the same VPC, where workspaces reside in.

func (GetDirectoryWorkspaceCreationPropertyOutput) DefaultOu

The default organizational unit (OU) for your WorkSpace directories.

func (GetDirectoryWorkspaceCreationPropertyOutput) ElementType

func (GetDirectoryWorkspaceCreationPropertyOutput) EnableInternetAccess

Indicates whether internet access is enabled for your WorkSpaces.

func (GetDirectoryWorkspaceCreationPropertyOutput) EnableMaintenanceMode

Indicates whether maintenance mode is enabled for your WorkSpaces. For more information, see [WorkSpace Maintenance](https://docs.aws.amazon.com/workspaces/latest/adminguide/workspace-maintenance.html).

func (GetDirectoryWorkspaceCreationPropertyOutput) ToGetDirectoryWorkspaceCreationPropertyOutput

func (o GetDirectoryWorkspaceCreationPropertyOutput) ToGetDirectoryWorkspaceCreationPropertyOutput() GetDirectoryWorkspaceCreationPropertyOutput

func (GetDirectoryWorkspaceCreationPropertyOutput) ToGetDirectoryWorkspaceCreationPropertyOutputWithContext

func (o GetDirectoryWorkspaceCreationPropertyOutput) ToGetDirectoryWorkspaceCreationPropertyOutputWithContext(ctx context.Context) GetDirectoryWorkspaceCreationPropertyOutput

func (GetDirectoryWorkspaceCreationPropertyOutput) UserEnabledAsLocalAdministrator

func (o GetDirectoryWorkspaceCreationPropertyOutput) UserEnabledAsLocalAdministrator() pulumi.BoolOutput

Indicates whether users are local administrators of their WorkSpaces.

type GetImageArgs

type GetImageArgs struct {
	// ID of the image.
	ImageId string `pulumi:"imageId"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region *string `pulumi:"region"`
}

A collection of arguments for invoking getImage.

type GetImageOutputArgs

type GetImageOutputArgs struct {
	// ID of the image.
	ImageId pulumi.StringInput `pulumi:"imageId"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput `pulumi:"region"`
}

A collection of arguments for invoking getImage.

func (GetImageOutputArgs) ElementType

func (GetImageOutputArgs) ElementType() reflect.Type

type GetImageResult

type GetImageResult struct {
	// The description of the image.
	Description string `pulumi:"description"`
	// The provider-assigned unique ID for this managed resource.
	Id      string `pulumi:"id"`
	ImageId string `pulumi:"imageId"`
	// The name of the image.
	Name                string `pulumi:"name"`
	OperatingSystemType string `pulumi:"operatingSystemType"`
	Region              string `pulumi:"region"`
	// Specifies whether the image is running on dedicated hardware. When Bring Your Own License (BYOL) is enabled, this value is set to DEDICATED. For more information, see [Bring Your Own Windows Desktop Images](https://docs.aws.amazon.com/workspaces/latest/adminguide/byol-windows-images.html).
	RequiredTenancy string `pulumi:"requiredTenancy"`
	// The status of the image.
	State string `pulumi:"state"`
}

A collection of values returned by getImage.

func GetImage

func GetImage(ctx *pulumi.Context, args *GetImageArgs, opts ...pulumi.InvokeOption) (*GetImageResult, error)

Use this data source to get information about a Workspaces image.

## Example Usage

```go package main

import (

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/workspaces"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := workspaces.GetImage(ctx, &workspaces.GetImageArgs{
			ImageId: "wsi-ten5h0y19",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetImageResultOutput

type GetImageResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getImage.

func (GetImageResultOutput) Description

func (o GetImageResultOutput) Description() pulumi.StringOutput

The description of the image.

func (GetImageResultOutput) ElementType

func (GetImageResultOutput) ElementType() reflect.Type

func (GetImageResultOutput) Id

The provider-assigned unique ID for this managed resource.

func (GetImageResultOutput) ImageId

func (GetImageResultOutput) Name

The name of the image.

func (GetImageResultOutput) OperatingSystemType

func (o GetImageResultOutput) OperatingSystemType() pulumi.StringOutput

func (GetImageResultOutput) Region

func (GetImageResultOutput) RequiredTenancy

func (o GetImageResultOutput) RequiredTenancy() pulumi.StringOutput

Specifies whether the image is running on dedicated hardware. When Bring Your Own License (BYOL) is enabled, this value is set to DEDICATED. For more information, see [Bring Your Own Windows Desktop Images](https://docs.aws.amazon.com/workspaces/latest/adminguide/byol-windows-images.html).

func (GetImageResultOutput) State

The status of the image.

func (GetImageResultOutput) ToGetImageResultOutput

func (o GetImageResultOutput) ToGetImageResultOutput() GetImageResultOutput

func (GetImageResultOutput) ToGetImageResultOutputWithContext

func (o GetImageResultOutput) ToGetImageResultOutputWithContext(ctx context.Context) GetImageResultOutput

type GetWorkspaceWorkspaceProperty

type GetWorkspaceWorkspaceProperty struct {
	// Compute type. For more information, see [Amazon WorkSpaces Bundles](http://aws.amazon.com/workspaces/details/#Amazon_WorkSpaces_Bundles). Valid values are `VALUE`, `STANDARD`, `PERFORMANCE`, `POWER`, `GRAPHICS`, `POWERPRO` and `GRAPHICSPRO`.
	ComputeTypeName string `pulumi:"computeTypeName"`
	// Size of the root volume.
	RootVolumeSizeGib int `pulumi:"rootVolumeSizeGib"`
	// Running mode. For more information, see [Manage the WorkSpace Running Mode](https://docs.aws.amazon.com/workspaces/latest/adminguide/running-mode.html). Valid values are `AUTO_STOP` and `ALWAYS_ON`.
	RunningMode string `pulumi:"runningMode"`
	// Time after a user logs off when WorkSpaces are automatically stopped. Configured in 60-minute intervals.
	RunningModeAutoStopTimeoutInMinutes int `pulumi:"runningModeAutoStopTimeoutInMinutes"`
	// Size of the user storage.
	UserVolumeSizeGib int `pulumi:"userVolumeSizeGib"`
}

type GetWorkspaceWorkspacePropertyArgs

type GetWorkspaceWorkspacePropertyArgs struct {
	// Compute type. For more information, see [Amazon WorkSpaces Bundles](http://aws.amazon.com/workspaces/details/#Amazon_WorkSpaces_Bundles). Valid values are `VALUE`, `STANDARD`, `PERFORMANCE`, `POWER`, `GRAPHICS`, `POWERPRO` and `GRAPHICSPRO`.
	ComputeTypeName pulumi.StringInput `pulumi:"computeTypeName"`
	// Size of the root volume.
	RootVolumeSizeGib pulumi.IntInput `pulumi:"rootVolumeSizeGib"`
	// Running mode. For more information, see [Manage the WorkSpace Running Mode](https://docs.aws.amazon.com/workspaces/latest/adminguide/running-mode.html). Valid values are `AUTO_STOP` and `ALWAYS_ON`.
	RunningMode pulumi.StringInput `pulumi:"runningMode"`
	// Time after a user logs off when WorkSpaces are automatically stopped. Configured in 60-minute intervals.
	RunningModeAutoStopTimeoutInMinutes pulumi.IntInput `pulumi:"runningModeAutoStopTimeoutInMinutes"`
	// Size of the user storage.
	UserVolumeSizeGib pulumi.IntInput `pulumi:"userVolumeSizeGib"`
}

func (GetWorkspaceWorkspacePropertyArgs) ElementType

func (GetWorkspaceWorkspacePropertyArgs) ToGetWorkspaceWorkspacePropertyOutput

func (i GetWorkspaceWorkspacePropertyArgs) ToGetWorkspaceWorkspacePropertyOutput() GetWorkspaceWorkspacePropertyOutput

func (GetWorkspaceWorkspacePropertyArgs) ToGetWorkspaceWorkspacePropertyOutputWithContext

func (i GetWorkspaceWorkspacePropertyArgs) ToGetWorkspaceWorkspacePropertyOutputWithContext(ctx context.Context) GetWorkspaceWorkspacePropertyOutput

type GetWorkspaceWorkspacePropertyArray

type GetWorkspaceWorkspacePropertyArray []GetWorkspaceWorkspacePropertyInput

func (GetWorkspaceWorkspacePropertyArray) ElementType

func (GetWorkspaceWorkspacePropertyArray) ToGetWorkspaceWorkspacePropertyArrayOutput

func (i GetWorkspaceWorkspacePropertyArray) ToGetWorkspaceWorkspacePropertyArrayOutput() GetWorkspaceWorkspacePropertyArrayOutput

func (GetWorkspaceWorkspacePropertyArray) ToGetWorkspaceWorkspacePropertyArrayOutputWithContext

func (i GetWorkspaceWorkspacePropertyArray) ToGetWorkspaceWorkspacePropertyArrayOutputWithContext(ctx context.Context) GetWorkspaceWorkspacePropertyArrayOutput

type GetWorkspaceWorkspacePropertyArrayInput

type GetWorkspaceWorkspacePropertyArrayInput interface {
	pulumi.Input

	ToGetWorkspaceWorkspacePropertyArrayOutput() GetWorkspaceWorkspacePropertyArrayOutput
	ToGetWorkspaceWorkspacePropertyArrayOutputWithContext(context.Context) GetWorkspaceWorkspacePropertyArrayOutput
}

GetWorkspaceWorkspacePropertyArrayInput is an input type that accepts GetWorkspaceWorkspacePropertyArray and GetWorkspaceWorkspacePropertyArrayOutput values. You can construct a concrete instance of `GetWorkspaceWorkspacePropertyArrayInput` via:

GetWorkspaceWorkspacePropertyArray{ GetWorkspaceWorkspacePropertyArgs{...} }

type GetWorkspaceWorkspacePropertyArrayOutput

type GetWorkspaceWorkspacePropertyArrayOutput struct{ *pulumi.OutputState }

func (GetWorkspaceWorkspacePropertyArrayOutput) ElementType

func (GetWorkspaceWorkspacePropertyArrayOutput) Index

func (GetWorkspaceWorkspacePropertyArrayOutput) ToGetWorkspaceWorkspacePropertyArrayOutput

func (o GetWorkspaceWorkspacePropertyArrayOutput) ToGetWorkspaceWorkspacePropertyArrayOutput() GetWorkspaceWorkspacePropertyArrayOutput

func (GetWorkspaceWorkspacePropertyArrayOutput) ToGetWorkspaceWorkspacePropertyArrayOutputWithContext

func (o GetWorkspaceWorkspacePropertyArrayOutput) ToGetWorkspaceWorkspacePropertyArrayOutputWithContext(ctx context.Context) GetWorkspaceWorkspacePropertyArrayOutput

type GetWorkspaceWorkspacePropertyInput

type GetWorkspaceWorkspacePropertyInput interface {
	pulumi.Input

	ToGetWorkspaceWorkspacePropertyOutput() GetWorkspaceWorkspacePropertyOutput
	ToGetWorkspaceWorkspacePropertyOutputWithContext(context.Context) GetWorkspaceWorkspacePropertyOutput
}

GetWorkspaceWorkspacePropertyInput is an input type that accepts GetWorkspaceWorkspacePropertyArgs and GetWorkspaceWorkspacePropertyOutput values. You can construct a concrete instance of `GetWorkspaceWorkspacePropertyInput` via:

GetWorkspaceWorkspacePropertyArgs{...}

type GetWorkspaceWorkspacePropertyOutput

type GetWorkspaceWorkspacePropertyOutput struct{ *pulumi.OutputState }

func (GetWorkspaceWorkspacePropertyOutput) ComputeTypeName

Compute type. For more information, see [Amazon WorkSpaces Bundles](http://aws.amazon.com/workspaces/details/#Amazon_WorkSpaces_Bundles). Valid values are `VALUE`, `STANDARD`, `PERFORMANCE`, `POWER`, `GRAPHICS`, `POWERPRO` and `GRAPHICSPRO`.

func (GetWorkspaceWorkspacePropertyOutput) ElementType

func (GetWorkspaceWorkspacePropertyOutput) RootVolumeSizeGib

Size of the root volume.

func (GetWorkspaceWorkspacePropertyOutput) RunningMode

Running mode. For more information, see [Manage the WorkSpace Running Mode](https://docs.aws.amazon.com/workspaces/latest/adminguide/running-mode.html). Valid values are `AUTO_STOP` and `ALWAYS_ON`.

func (GetWorkspaceWorkspacePropertyOutput) RunningModeAutoStopTimeoutInMinutes

func (o GetWorkspaceWorkspacePropertyOutput) RunningModeAutoStopTimeoutInMinutes() pulumi.IntOutput

Time after a user logs off when WorkSpaces are automatically stopped. Configured in 60-minute intervals.

func (GetWorkspaceWorkspacePropertyOutput) ToGetWorkspaceWorkspacePropertyOutput

func (o GetWorkspaceWorkspacePropertyOutput) ToGetWorkspaceWorkspacePropertyOutput() GetWorkspaceWorkspacePropertyOutput

func (GetWorkspaceWorkspacePropertyOutput) ToGetWorkspaceWorkspacePropertyOutputWithContext

func (o GetWorkspaceWorkspacePropertyOutput) ToGetWorkspaceWorkspacePropertyOutputWithContext(ctx context.Context) GetWorkspaceWorkspacePropertyOutput

func (GetWorkspaceWorkspacePropertyOutput) UserVolumeSizeGib

Size of the user storage.

type IpGroup

type IpGroup struct {
	pulumi.CustomResourceState

	// The description of the IP group.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// The name of the IP group.
	Name pulumi.StringOutput `pulumi:"name"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
	// One or more pairs specifying the IP group rule (in CIDR format) from which web requests originate.
	Rules IpGroupRuleArrayOutput `pulumi:"rules"`
	// A map of tags assigned to the WorkSpaces directory. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

Provides an IP access control group in AWS WorkSpaces Service

## Example Usage

```go package main

import (

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/workspaces"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := workspaces.NewIpGroup(ctx, "contractors", &workspaces.IpGroupArgs{
			Name:        pulumi.String("Contractors"),
			Description: pulumi.String("Contractors IP access control group"),
			Rules: workspaces.IpGroupRuleArray{
				&workspaces.IpGroupRuleArgs{
					Source:      pulumi.String("150.24.14.0/24"),
					Description: pulumi.String("NY"),
				},
				&workspaces.IpGroupRuleArgs{
					Source:      pulumi.String("125.191.14.85/32"),
					Description: pulumi.String("LA"),
				},
				&workspaces.IpGroupRuleArgs{
					Source:      pulumi.String("44.98.100.0/24"),
					Description: pulumi.String("STL"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Using `pulumi import`, import WorkSpaces IP groups using their GroupID. For example:

```sh $ pulumi import aws:workspaces/ipGroup:IpGroup example wsipg-488lrtl3k ```

func GetIpGroup

func GetIpGroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IpGroupState, opts ...pulumi.ResourceOption) (*IpGroup, error)

GetIpGroup gets an existing IpGroup resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewIpGroup

func NewIpGroup(ctx *pulumi.Context,
	name string, args *IpGroupArgs, opts ...pulumi.ResourceOption) (*IpGroup, error)

NewIpGroup registers a new resource with the given unique name, arguments, and options.

func (*IpGroup) ElementType

func (*IpGroup) ElementType() reflect.Type

func (*IpGroup) ToIpGroupOutput

func (i *IpGroup) ToIpGroupOutput() IpGroupOutput

func (*IpGroup) ToIpGroupOutputWithContext

func (i *IpGroup) ToIpGroupOutputWithContext(ctx context.Context) IpGroupOutput

type IpGroupArgs

type IpGroupArgs struct {
	// The description of the IP group.
	Description pulumi.StringPtrInput
	// The name of the IP group.
	Name pulumi.StringPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// One or more pairs specifying the IP group rule (in CIDR format) from which web requests originate.
	Rules IpGroupRuleArrayInput
	// A map of tags assigned to the WorkSpaces directory. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a IpGroup resource.

func (IpGroupArgs) ElementType

func (IpGroupArgs) ElementType() reflect.Type

type IpGroupArray

type IpGroupArray []IpGroupInput

func (IpGroupArray) ElementType

func (IpGroupArray) ElementType() reflect.Type

func (IpGroupArray) ToIpGroupArrayOutput

func (i IpGroupArray) ToIpGroupArrayOutput() IpGroupArrayOutput

func (IpGroupArray) ToIpGroupArrayOutputWithContext

func (i IpGroupArray) ToIpGroupArrayOutputWithContext(ctx context.Context) IpGroupArrayOutput

type IpGroupArrayInput

type IpGroupArrayInput interface {
	pulumi.Input

	ToIpGroupArrayOutput() IpGroupArrayOutput
	ToIpGroupArrayOutputWithContext(context.Context) IpGroupArrayOutput
}

IpGroupArrayInput is an input type that accepts IpGroupArray and IpGroupArrayOutput values. You can construct a concrete instance of `IpGroupArrayInput` via:

IpGroupArray{ IpGroupArgs{...} }

type IpGroupArrayOutput

type IpGroupArrayOutput struct{ *pulumi.OutputState }

func (IpGroupArrayOutput) ElementType

func (IpGroupArrayOutput) ElementType() reflect.Type

func (IpGroupArrayOutput) Index

func (IpGroupArrayOutput) ToIpGroupArrayOutput

func (o IpGroupArrayOutput) ToIpGroupArrayOutput() IpGroupArrayOutput

func (IpGroupArrayOutput) ToIpGroupArrayOutputWithContext

func (o IpGroupArrayOutput) ToIpGroupArrayOutputWithContext(ctx context.Context) IpGroupArrayOutput

type IpGroupInput

type IpGroupInput interface {
	pulumi.Input

	ToIpGroupOutput() IpGroupOutput
	ToIpGroupOutputWithContext(ctx context.Context) IpGroupOutput
}

type IpGroupMap

type IpGroupMap map[string]IpGroupInput

func (IpGroupMap) ElementType

func (IpGroupMap) ElementType() reflect.Type

func (IpGroupMap) ToIpGroupMapOutput

func (i IpGroupMap) ToIpGroupMapOutput() IpGroupMapOutput

func (IpGroupMap) ToIpGroupMapOutputWithContext

func (i IpGroupMap) ToIpGroupMapOutputWithContext(ctx context.Context) IpGroupMapOutput

type IpGroupMapInput

type IpGroupMapInput interface {
	pulumi.Input

	ToIpGroupMapOutput() IpGroupMapOutput
	ToIpGroupMapOutputWithContext(context.Context) IpGroupMapOutput
}

IpGroupMapInput is an input type that accepts IpGroupMap and IpGroupMapOutput values. You can construct a concrete instance of `IpGroupMapInput` via:

IpGroupMap{ "key": IpGroupArgs{...} }

type IpGroupMapOutput

type IpGroupMapOutput struct{ *pulumi.OutputState }

func (IpGroupMapOutput) ElementType

func (IpGroupMapOutput) ElementType() reflect.Type

func (IpGroupMapOutput) MapIndex

func (IpGroupMapOutput) ToIpGroupMapOutput

func (o IpGroupMapOutput) ToIpGroupMapOutput() IpGroupMapOutput

func (IpGroupMapOutput) ToIpGroupMapOutputWithContext

func (o IpGroupMapOutput) ToIpGroupMapOutputWithContext(ctx context.Context) IpGroupMapOutput

type IpGroupOutput

type IpGroupOutput struct{ *pulumi.OutputState }

func (IpGroupOutput) Description

func (o IpGroupOutput) Description() pulumi.StringPtrOutput

The description of the IP group.

func (IpGroupOutput) ElementType

func (IpGroupOutput) ElementType() reflect.Type

func (IpGroupOutput) Name

The name of the IP group.

func (IpGroupOutput) Region

func (o IpGroupOutput) Region() pulumi.StringOutput

Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.

func (IpGroupOutput) Rules

One or more pairs specifying the IP group rule (in CIDR format) from which web requests originate.

func (IpGroupOutput) Tags

A map of tags assigned to the WorkSpaces directory. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.

func (IpGroupOutput) TagsAll

func (o IpGroupOutput) TagsAll() pulumi.StringMapOutput

A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

func (IpGroupOutput) ToIpGroupOutput

func (o IpGroupOutput) ToIpGroupOutput() IpGroupOutput

func (IpGroupOutput) ToIpGroupOutputWithContext

func (o IpGroupOutput) ToIpGroupOutputWithContext(ctx context.Context) IpGroupOutput

type IpGroupRule

type IpGroupRule struct {
	// The description of the IP group.
	Description *string `pulumi:"description"`
	// The IP address range, in CIDR notation, e.g., `10.0.0.0/16`
	Source string `pulumi:"source"`
}

type IpGroupRuleArgs

type IpGroupRuleArgs struct {
	// The description of the IP group.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// The IP address range, in CIDR notation, e.g., `10.0.0.0/16`
	Source pulumi.StringInput `pulumi:"source"`
}

func (IpGroupRuleArgs) ElementType

func (IpGroupRuleArgs) ElementType() reflect.Type

func (IpGroupRuleArgs) ToIpGroupRuleOutput

func (i IpGroupRuleArgs) ToIpGroupRuleOutput() IpGroupRuleOutput

func (IpGroupRuleArgs) ToIpGroupRuleOutputWithContext

func (i IpGroupRuleArgs) ToIpGroupRuleOutputWithContext(ctx context.Context) IpGroupRuleOutput

type IpGroupRuleArray

type IpGroupRuleArray []IpGroupRuleInput

func (IpGroupRuleArray) ElementType

func (IpGroupRuleArray) ElementType() reflect.Type

func (IpGroupRuleArray) ToIpGroupRuleArrayOutput

func (i IpGroupRuleArray) ToIpGroupRuleArrayOutput() IpGroupRuleArrayOutput

func (IpGroupRuleArray) ToIpGroupRuleArrayOutputWithContext

func (i IpGroupRuleArray) ToIpGroupRuleArrayOutputWithContext(ctx context.Context) IpGroupRuleArrayOutput

type IpGroupRuleArrayInput

type IpGroupRuleArrayInput interface {
	pulumi.Input

	ToIpGroupRuleArrayOutput() IpGroupRuleArrayOutput
	ToIpGroupRuleArrayOutputWithContext(context.Context) IpGroupRuleArrayOutput
}

IpGroupRuleArrayInput is an input type that accepts IpGroupRuleArray and IpGroupRuleArrayOutput values. You can construct a concrete instance of `IpGroupRuleArrayInput` via:

IpGroupRuleArray{ IpGroupRuleArgs{...} }

type IpGroupRuleArrayOutput

type IpGroupRuleArrayOutput struct{ *pulumi.OutputState }

func (IpGroupRuleArrayOutput) ElementType

func (IpGroupRuleArrayOutput) ElementType() reflect.Type

func (IpGroupRuleArrayOutput) Index

func (IpGroupRuleArrayOutput) ToIpGroupRuleArrayOutput

func (o IpGroupRuleArrayOutput) ToIpGroupRuleArrayOutput() IpGroupRuleArrayOutput

func (IpGroupRuleArrayOutput) ToIpGroupRuleArrayOutputWithContext

func (o IpGroupRuleArrayOutput) ToIpGroupRuleArrayOutputWithContext(ctx context.Context) IpGroupRuleArrayOutput

type IpGroupRuleInput

type IpGroupRuleInput interface {
	pulumi.Input

	ToIpGroupRuleOutput() IpGroupRuleOutput
	ToIpGroupRuleOutputWithContext(context.Context) IpGroupRuleOutput
}

IpGroupRuleInput is an input type that accepts IpGroupRuleArgs and IpGroupRuleOutput values. You can construct a concrete instance of `IpGroupRuleInput` via:

IpGroupRuleArgs{...}

type IpGroupRuleOutput

type IpGroupRuleOutput struct{ *pulumi.OutputState }

func (IpGroupRuleOutput) Description

func (o IpGroupRuleOutput) Description() pulumi.StringPtrOutput

The description of the IP group.

func (IpGroupRuleOutput) ElementType

func (IpGroupRuleOutput) ElementType() reflect.Type

func (IpGroupRuleOutput) Source

The IP address range, in CIDR notation, e.g., `10.0.0.0/16`

func (IpGroupRuleOutput) ToIpGroupRuleOutput

func (o IpGroupRuleOutput) ToIpGroupRuleOutput() IpGroupRuleOutput

func (IpGroupRuleOutput) ToIpGroupRuleOutputWithContext

func (o IpGroupRuleOutput) ToIpGroupRuleOutputWithContext(ctx context.Context) IpGroupRuleOutput

type IpGroupState

type IpGroupState struct {
	// The description of the IP group.
	Description pulumi.StringPtrInput
	// The name of the IP group.
	Name pulumi.StringPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// One or more pairs specifying the IP group rule (in CIDR format) from which web requests originate.
	Rules IpGroupRuleArrayInput
	// A map of tags assigned to the WorkSpaces directory. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapInput
}

func (IpGroupState) ElementType

func (IpGroupState) ElementType() reflect.Type

type LookupDirectoryArgs

type LookupDirectoryArgs struct {
	// Directory identifier for registration in WorkSpaces service.
	DirectoryId string `pulumi:"directoryId"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region *string `pulumi:"region"`
	// A map of tags assigned to the WorkSpaces directory.
	Tags map[string]string `pulumi:"tags"`
}

A collection of arguments for invoking getDirectory.

type LookupDirectoryOutputArgs

type LookupDirectoryOutputArgs struct {
	// Directory identifier for registration in WorkSpaces service.
	DirectoryId pulumi.StringInput `pulumi:"directoryId"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput `pulumi:"region"`
	// A map of tags assigned to the WorkSpaces directory.
	Tags pulumi.StringMapInput `pulumi:"tags"`
}

A collection of arguments for invoking getDirectory.

func (LookupDirectoryOutputArgs) ElementType

func (LookupDirectoryOutputArgs) ElementType() reflect.Type

type LookupDirectoryResult

type LookupDirectoryResult struct {
	// Configuration for Active Directory integration when `workspaceType` is set to `POOLS`.
	ActiveDirectoryConfigs []GetDirectoryActiveDirectoryConfig `pulumi:"activeDirectoryConfigs"`
	// Directory alias.
	Alias                          string                                     `pulumi:"alias"`
	CertificateBasedAuthProperties []GetDirectoryCertificateBasedAuthProperty `pulumi:"certificateBasedAuthProperties"`
	// User name for the service account.
	CustomerUserName string `pulumi:"customerUserName"`
	DirectoryId      string `pulumi:"directoryId"`
	// Name of the directory.
	DirectoryName string `pulumi:"directoryName"`
	// Directory type.
	DirectoryType string `pulumi:"directoryType"`
	// IP addresses of the DNS servers for the directory.
	DnsIpAddresses []string `pulumi:"dnsIpAddresses"`
	// Identifier of the IAM role. This is the role that allows Amazon WorkSpaces to make calls to other services, such as Amazon EC2, on your behalf.
	IamRoleId string `pulumi:"iamRoleId"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// Identifiers of the IP access control groups associated with the directory.
	IpGroupIds []string `pulumi:"ipGroupIds"`
	Region     string   `pulumi:"region"`
	// Registration code for the directory. This is the code that users enter in their Amazon WorkSpaces client application to connect to the directory.
	RegistrationCode string                     `pulumi:"registrationCode"`
	SamlProperties   []GetDirectorySamlProperty `pulumi:"samlProperties"`
	// The permissions to enable or disable self-service capabilities.
	SelfServicePermissions []GetDirectorySelfServicePermission `pulumi:"selfServicePermissions"`
	// Identifiers of the subnets where the directory resides.
	SubnetIds []string `pulumi:"subnetIds"`
	// A map of tags assigned to the WorkSpaces directory.
	Tags map[string]string `pulumi:"tags"`
	// The user identity type for the WorkSpaces directory.
	UserIdentityType string `pulumi:"userIdentityType"`
	// Specifies which devices and operating systems users can use to access their WorkSpaces.
	WorkspaceAccessProperties []GetDirectoryWorkspaceAccessProperty `pulumi:"workspaceAccessProperties"`
	// The default properties that are used for creating WorkSpaces.
	WorkspaceCreationProperties []GetDirectoryWorkspaceCreationProperty `pulumi:"workspaceCreationProperties"`
	// The description of the WorkSpaces directory when `workspaceType` is set to `POOLS`.
	WorkspaceDirectoryDescription string `pulumi:"workspaceDirectoryDescription"`
	// The name of the WorkSpaces directory when `workspaceType` is set to `POOLS`.
	WorkspaceDirectoryName string `pulumi:"workspaceDirectoryName"`
	// The identifier of the security group that is assigned to new WorkSpaces.
	WorkspaceSecurityGroupId string `pulumi:"workspaceSecurityGroupId"`
	// The type of WorkSpaces directory.
	WorkspaceType string `pulumi:"workspaceType"`
}

A collection of values returned by getDirectory.

func LookupDirectory

func LookupDirectory(ctx *pulumi.Context, args *LookupDirectoryArgs, opts ...pulumi.InvokeOption) (*LookupDirectoryResult, error)

Retrieve information about an AWS WorkSpaces directory.

## Example Usage

```go package main

import (

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/workspaces"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := workspaces.LookupDirectory(ctx, &workspaces.LookupDirectoryArgs{
			DirectoryId: "d-9067783251",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupDirectoryResultOutput

type LookupDirectoryResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getDirectory.

func (LookupDirectoryResultOutput) ActiveDirectoryConfigs

Configuration for Active Directory integration when `workspaceType` is set to `POOLS`.

func (LookupDirectoryResultOutput) Alias

Directory alias.

func (LookupDirectoryResultOutput) CertificateBasedAuthProperties

func (LookupDirectoryResultOutput) CustomerUserName

func (o LookupDirectoryResultOutput) CustomerUserName() pulumi.StringOutput

User name for the service account.

func (LookupDirectoryResultOutput) DirectoryId

func (LookupDirectoryResultOutput) DirectoryName

Name of the directory.

func (LookupDirectoryResultOutput) DirectoryType

Directory type.

func (LookupDirectoryResultOutput) DnsIpAddresses

IP addresses of the DNS servers for the directory.

func (LookupDirectoryResultOutput) ElementType

func (LookupDirectoryResultOutput) IamRoleId

Identifier of the IAM role. This is the role that allows Amazon WorkSpaces to make calls to other services, such as Amazon EC2, on your behalf.

func (LookupDirectoryResultOutput) Id

The provider-assigned unique ID for this managed resource.

func (LookupDirectoryResultOutput) IpGroupIds

Identifiers of the IP access control groups associated with the directory.

func (LookupDirectoryResultOutput) Region

func (LookupDirectoryResultOutput) RegistrationCode

func (o LookupDirectoryResultOutput) RegistrationCode() pulumi.StringOutput

Registration code for the directory. This is the code that users enter in their Amazon WorkSpaces client application to connect to the directory.

func (LookupDirectoryResultOutput) SamlProperties

func (LookupDirectoryResultOutput) SelfServicePermissions

The permissions to enable or disable self-service capabilities.

func (LookupDirectoryResultOutput) SubnetIds

Identifiers of the subnets where the directory resides.

func (LookupDirectoryResultOutput) Tags

A map of tags assigned to the WorkSpaces directory.

func (LookupDirectoryResultOutput) ToLookupDirectoryResultOutput

func (o LookupDirectoryResultOutput) ToLookupDirectoryResultOutput() LookupDirectoryResultOutput

func (LookupDirectoryResultOutput) ToLookupDirectoryResultOutputWithContext

func (o LookupDirectoryResultOutput) ToLookupDirectoryResultOutputWithContext(ctx context.Context) LookupDirectoryResultOutput

func (LookupDirectoryResultOutput) UserIdentityType

func (o LookupDirectoryResultOutput) UserIdentityType() pulumi.StringOutput

The user identity type for the WorkSpaces directory.

func (LookupDirectoryResultOutput) WorkspaceAccessProperties

Specifies which devices and operating systems users can use to access their WorkSpaces.

func (LookupDirectoryResultOutput) WorkspaceCreationProperties

The default properties that are used for creating WorkSpaces.

func (LookupDirectoryResultOutput) WorkspaceDirectoryDescription

func (o LookupDirectoryResultOutput) WorkspaceDirectoryDescription() pulumi.StringOutput

The description of the WorkSpaces directory when `workspaceType` is set to `POOLS`.

func (LookupDirectoryResultOutput) WorkspaceDirectoryName

func (o LookupDirectoryResultOutput) WorkspaceDirectoryName() pulumi.StringOutput

The name of the WorkSpaces directory when `workspaceType` is set to `POOLS`.

func (LookupDirectoryResultOutput) WorkspaceSecurityGroupId

func (o LookupDirectoryResultOutput) WorkspaceSecurityGroupId() pulumi.StringOutput

The identifier of the security group that is assigned to new WorkSpaces.

func (LookupDirectoryResultOutput) WorkspaceType

The type of WorkSpaces directory.

type LookupWorkspaceArgs

type LookupWorkspaceArgs struct {
	// ID of the directory for the WorkSpace. You have to specify `userName` along with `directoryId`. You cannot combine this parameter with `workspaceId`.
	DirectoryId *string `pulumi:"directoryId"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region *string `pulumi:"region"`
	// Tags for the WorkSpace.
	Tags map[string]string `pulumi:"tags"`
	// User name of the user for the WorkSpace. This user name must exist in the directory for the WorkSpace. You cannot combine this parameter with `workspaceId`.
	UserName *string `pulumi:"userName"`
	// ID of the WorkSpace. You cannot combine this parameter with `directoryId`.
	WorkspaceId *string `pulumi:"workspaceId"`
}

A collection of arguments for invoking getWorkspace.

type LookupWorkspaceOutputArgs

type LookupWorkspaceOutputArgs struct {
	// ID of the directory for the WorkSpace. You have to specify `userName` along with `directoryId`. You cannot combine this parameter with `workspaceId`.
	DirectoryId pulumi.StringPtrInput `pulumi:"directoryId"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput `pulumi:"region"`
	// Tags for the WorkSpace.
	Tags pulumi.StringMapInput `pulumi:"tags"`
	// User name of the user for the WorkSpace. This user name must exist in the directory for the WorkSpace. You cannot combine this parameter with `workspaceId`.
	UserName pulumi.StringPtrInput `pulumi:"userName"`
	// ID of the WorkSpace. You cannot combine this parameter with `directoryId`.
	WorkspaceId pulumi.StringPtrInput `pulumi:"workspaceId"`
}

A collection of arguments for invoking getWorkspace.

func (LookupWorkspaceOutputArgs) ElementType

func (LookupWorkspaceOutputArgs) ElementType() reflect.Type

type LookupWorkspaceResult

type LookupWorkspaceResult struct {
	BundleId string `pulumi:"bundleId"`
	// Name of the WorkSpace, as seen by the operating system.
	ComputerName string `pulumi:"computerName"`
	DirectoryId  string `pulumi:"directoryId"`
	// The provider-assigned unique ID for this managed resource.
	Id string `pulumi:"id"`
	// IP address of the WorkSpace.
	IpAddress                   string `pulumi:"ipAddress"`
	Region                      string `pulumi:"region"`
	RootVolumeEncryptionEnabled bool   `pulumi:"rootVolumeEncryptionEnabled"`
	// Operational state of the WorkSpace.
	State                       string                          `pulumi:"state"`
	Tags                        map[string]string               `pulumi:"tags"`
	UserName                    string                          `pulumi:"userName"`
	UserVolumeEncryptionEnabled bool                            `pulumi:"userVolumeEncryptionEnabled"`
	VolumeEncryptionKey         string                          `pulumi:"volumeEncryptionKey"`
	WorkspaceId                 string                          `pulumi:"workspaceId"`
	WorkspaceProperties         []GetWorkspaceWorkspaceProperty `pulumi:"workspaceProperties"`
}

A collection of values returned by getWorkspace.

func LookupWorkspace

func LookupWorkspace(ctx *pulumi.Context, args *LookupWorkspaceArgs, opts ...pulumi.InvokeOption) (*LookupWorkspaceResult, error)

Use this data source to get information about a workspace in [AWS Workspaces](https://docs.aws.amazon.com/workspaces/latest/adminguide/amazon-workspaces.html) Service.

## Example Usage

### Filter By Workspace ID

```go package main

import (

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/workspaces"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := workspaces.LookupWorkspace(ctx, &workspaces.LookupWorkspaceArgs{
			WorkspaceId: pulumi.StringRef("ws-cj5xcxsz5"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

### Filter By Directory ID & User Name

```go package main

import (

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/workspaces"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := workspaces.LookupWorkspace(ctx, &workspaces.LookupWorkspaceArgs{
			DirectoryId: pulumi.StringRef("d-9967252f57"),
			UserName:    pulumi.StringRef("Example"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupWorkspaceResultOutput

type LookupWorkspaceResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getWorkspace.

func (LookupWorkspaceResultOutput) BundleId

func (LookupWorkspaceResultOutput) ComputerName

Name of the WorkSpace, as seen by the operating system.

func (LookupWorkspaceResultOutput) DirectoryId

func (LookupWorkspaceResultOutput) ElementType

func (LookupWorkspaceResultOutput) Id

The provider-assigned unique ID for this managed resource.

func (LookupWorkspaceResultOutput) IpAddress

IP address of the WorkSpace.

func (LookupWorkspaceResultOutput) Region

func (LookupWorkspaceResultOutput) RootVolumeEncryptionEnabled

func (o LookupWorkspaceResultOutput) RootVolumeEncryptionEnabled() pulumi.BoolOutput

func (LookupWorkspaceResultOutput) State

Operational state of the WorkSpace.

func (LookupWorkspaceResultOutput) Tags

func (LookupWorkspaceResultOutput) ToLookupWorkspaceResultOutput

func (o LookupWorkspaceResultOutput) ToLookupWorkspaceResultOutput() LookupWorkspaceResultOutput

func (LookupWorkspaceResultOutput) ToLookupWorkspaceResultOutputWithContext

func (o LookupWorkspaceResultOutput) ToLookupWorkspaceResultOutputWithContext(ctx context.Context) LookupWorkspaceResultOutput

func (LookupWorkspaceResultOutput) UserName

func (LookupWorkspaceResultOutput) UserVolumeEncryptionEnabled

func (o LookupWorkspaceResultOutput) UserVolumeEncryptionEnabled() pulumi.BoolOutput

func (LookupWorkspaceResultOutput) VolumeEncryptionKey

func (o LookupWorkspaceResultOutput) VolumeEncryptionKey() pulumi.StringOutput

func (LookupWorkspaceResultOutput) WorkspaceId

func (LookupWorkspaceResultOutput) WorkspaceProperties

type Workspace

type Workspace struct {
	pulumi.CustomResourceState

	// The ID of the bundle for the WorkSpace.
	BundleId pulumi.StringOutput `pulumi:"bundleId"`
	// The name of the WorkSpace, as seen by the operating system.
	ComputerName pulumi.StringOutput `pulumi:"computerName"`
	// The ID of the directory for the WorkSpace.
	DirectoryId pulumi.StringOutput `pulumi:"directoryId"`
	// The IP address of the WorkSpace.
	IpAddress pulumi.StringOutput `pulumi:"ipAddress"`
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringOutput `pulumi:"region"`
	// Indicates whether the data stored on the root volume is encrypted.
	RootVolumeEncryptionEnabled pulumi.BoolPtrOutput `pulumi:"rootVolumeEncryptionEnabled"`
	// The operational state of the WorkSpace.
	State pulumi.StringOutput `pulumi:"state"`
	// The tags for the WorkSpace. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// The user name of the user for the WorkSpace. This user name must exist in the directory for the WorkSpace.
	UserName pulumi.StringOutput `pulumi:"userName"`
	// Indicates whether the data stored on the user volume is encrypted.
	UserVolumeEncryptionEnabled pulumi.BoolPtrOutput `pulumi:"userVolumeEncryptionEnabled"`
	// The ARN of a symmetric AWS KMS customer master key (CMK) used to encrypt data stored on your WorkSpace. Amazon WorkSpaces does not support asymmetric CMKs.
	VolumeEncryptionKey pulumi.StringPtrOutput `pulumi:"volumeEncryptionKey"`
	// The WorkSpace properties.
	WorkspaceProperties WorkspaceWorkspacePropertiesOutput `pulumi:"workspaceProperties"`
}

Provides a workspace in [AWS Workspaces](https://docs.aws.amazon.com/workspaces/latest/adminguide/amazon-workspaces.html) Service

> **NOTE:** AWS WorkSpaces service requires [`workspaces_DefaultRole`](https://docs.aws.amazon.com/workspaces/latest/adminguide/workspaces-access-control.html#create-default-role) IAM role to operate normally.

## Example Usage

```go package main

import (

"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/kms"
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/workspaces"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		valueWindows10, err := workspaces.GetBundle(ctx, &workspaces.GetBundleArgs{
			BundleId: pulumi.StringRef("wsb-bh8rsxt14"),
		}, nil)
		if err != nil {
			return err
		}
		workspaces, err := kms.LookupKey(ctx, &kms.LookupKeyArgs{
			KeyId: "alias/aws/workspaces",
		}, nil)
		if err != nil {
			return err
		}
		_, err = workspaces.NewWorkspace(ctx, "example", &workspaces.WorkspaceArgs{
			DirectoryId:                 pulumi.Any(exampleAwsWorkspacesDirectory.Id),
			BundleId:                    pulumi.String(valueWindows10.Id),
			UserName:                    pulumi.String("john.doe"),
			RootVolumeEncryptionEnabled: pulumi.Bool(true),
			UserVolumeEncryptionEnabled: pulumi.Bool(true),
			VolumeEncryptionKey:         pulumi.String(workspaces.Arn),
			WorkspaceProperties: &workspaces.WorkspaceWorkspacePropertiesArgs{
				ComputeTypeName:                     pulumi.String("VALUE"),
				UserVolumeSizeGib:                   pulumi.Int(10),
				RootVolumeSizeGib:                   pulumi.Int(80),
				RunningMode:                         pulumi.String("AUTO_STOP"),
				RunningModeAutoStopTimeoutInMinutes: pulumi.Int(60),
			},
			Tags: pulumi.StringMap{
				"Department": pulumi.String("IT"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Using `pulumi import`, import Workspaces using their ID. For example:

```sh $ pulumi import aws:workspaces/workspace:Workspace example ws-9z9zmbkhv ```

func GetWorkspace

func GetWorkspace(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *WorkspaceState, opts ...pulumi.ResourceOption) (*Workspace, error)

GetWorkspace gets an existing Workspace resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewWorkspace

func NewWorkspace(ctx *pulumi.Context,
	name string, args *WorkspaceArgs, opts ...pulumi.ResourceOption) (*Workspace, error)

NewWorkspace registers a new resource with the given unique name, arguments, and options.

func (*Workspace) ElementType

func (*Workspace) ElementType() reflect.Type

func (*Workspace) ToWorkspaceOutput

func (i *Workspace) ToWorkspaceOutput() WorkspaceOutput

func (*Workspace) ToWorkspaceOutputWithContext

func (i *Workspace) ToWorkspaceOutputWithContext(ctx context.Context) WorkspaceOutput

type WorkspaceArgs

type WorkspaceArgs struct {
	// The ID of the bundle for the WorkSpace.
	BundleId pulumi.StringInput
	// The ID of the directory for the WorkSpace.
	DirectoryId pulumi.StringInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// Indicates whether the data stored on the root volume is encrypted.
	RootVolumeEncryptionEnabled pulumi.BoolPtrInput
	// The tags for the WorkSpace. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// The user name of the user for the WorkSpace. This user name must exist in the directory for the WorkSpace.
	UserName pulumi.StringInput
	// Indicates whether the data stored on the user volume is encrypted.
	UserVolumeEncryptionEnabled pulumi.BoolPtrInput
	// The ARN of a symmetric AWS KMS customer master key (CMK) used to encrypt data stored on your WorkSpace. Amazon WorkSpaces does not support asymmetric CMKs.
	VolumeEncryptionKey pulumi.StringPtrInput
	// The WorkSpace properties.
	WorkspaceProperties WorkspaceWorkspacePropertiesPtrInput
}

The set of arguments for constructing a Workspace resource.

func (WorkspaceArgs) ElementType

func (WorkspaceArgs) ElementType() reflect.Type

type WorkspaceArray

type WorkspaceArray []WorkspaceInput

func (WorkspaceArray) ElementType

func (WorkspaceArray) ElementType() reflect.Type

func (WorkspaceArray) ToWorkspaceArrayOutput

func (i WorkspaceArray) ToWorkspaceArrayOutput() WorkspaceArrayOutput

func (WorkspaceArray) ToWorkspaceArrayOutputWithContext

func (i WorkspaceArray) ToWorkspaceArrayOutputWithContext(ctx context.Context) WorkspaceArrayOutput

type WorkspaceArrayInput

type WorkspaceArrayInput interface {
	pulumi.Input

	ToWorkspaceArrayOutput() WorkspaceArrayOutput
	ToWorkspaceArrayOutputWithContext(context.Context) WorkspaceArrayOutput
}

WorkspaceArrayInput is an input type that accepts WorkspaceArray and WorkspaceArrayOutput values. You can construct a concrete instance of `WorkspaceArrayInput` via:

WorkspaceArray{ WorkspaceArgs{...} }

type WorkspaceArrayOutput

type WorkspaceArrayOutput struct{ *pulumi.OutputState }

func (WorkspaceArrayOutput) ElementType

func (WorkspaceArrayOutput) ElementType() reflect.Type

func (WorkspaceArrayOutput) Index

func (WorkspaceArrayOutput) ToWorkspaceArrayOutput

func (o WorkspaceArrayOutput) ToWorkspaceArrayOutput() WorkspaceArrayOutput

func (WorkspaceArrayOutput) ToWorkspaceArrayOutputWithContext

func (o WorkspaceArrayOutput) ToWorkspaceArrayOutputWithContext(ctx context.Context) WorkspaceArrayOutput

type WorkspaceInput

type WorkspaceInput interface {
	pulumi.Input

	ToWorkspaceOutput() WorkspaceOutput
	ToWorkspaceOutputWithContext(ctx context.Context) WorkspaceOutput
}

type WorkspaceMap

type WorkspaceMap map[string]WorkspaceInput

func (WorkspaceMap) ElementType

func (WorkspaceMap) ElementType() reflect.Type

func (WorkspaceMap) ToWorkspaceMapOutput

func (i WorkspaceMap) ToWorkspaceMapOutput() WorkspaceMapOutput

func (WorkspaceMap) ToWorkspaceMapOutputWithContext

func (i WorkspaceMap) ToWorkspaceMapOutputWithContext(ctx context.Context) WorkspaceMapOutput

type WorkspaceMapInput

type WorkspaceMapInput interface {
	pulumi.Input

	ToWorkspaceMapOutput() WorkspaceMapOutput
	ToWorkspaceMapOutputWithContext(context.Context) WorkspaceMapOutput
}

WorkspaceMapInput is an input type that accepts WorkspaceMap and WorkspaceMapOutput values. You can construct a concrete instance of `WorkspaceMapInput` via:

WorkspaceMap{ "key": WorkspaceArgs{...} }

type WorkspaceMapOutput

type WorkspaceMapOutput struct{ *pulumi.OutputState }

func (WorkspaceMapOutput) ElementType

func (WorkspaceMapOutput) ElementType() reflect.Type

func (WorkspaceMapOutput) MapIndex

func (WorkspaceMapOutput) ToWorkspaceMapOutput

func (o WorkspaceMapOutput) ToWorkspaceMapOutput() WorkspaceMapOutput

func (WorkspaceMapOutput) ToWorkspaceMapOutputWithContext

func (o WorkspaceMapOutput) ToWorkspaceMapOutputWithContext(ctx context.Context) WorkspaceMapOutput

type WorkspaceOutput

type WorkspaceOutput struct{ *pulumi.OutputState }

func (WorkspaceOutput) BundleId

func (o WorkspaceOutput) BundleId() pulumi.StringOutput

The ID of the bundle for the WorkSpace.

func (WorkspaceOutput) ComputerName

func (o WorkspaceOutput) ComputerName() pulumi.StringOutput

The name of the WorkSpace, as seen by the operating system.

func (WorkspaceOutput) DirectoryId

func (o WorkspaceOutput) DirectoryId() pulumi.StringOutput

The ID of the directory for the WorkSpace.

func (WorkspaceOutput) ElementType

func (WorkspaceOutput) ElementType() reflect.Type

func (WorkspaceOutput) IpAddress

func (o WorkspaceOutput) IpAddress() pulumi.StringOutput

The IP address of the WorkSpace.

func (WorkspaceOutput) Region

func (o WorkspaceOutput) Region() pulumi.StringOutput

Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.

func (WorkspaceOutput) RootVolumeEncryptionEnabled

func (o WorkspaceOutput) RootVolumeEncryptionEnabled() pulumi.BoolPtrOutput

Indicates whether the data stored on the root volume is encrypted.

func (WorkspaceOutput) State

The operational state of the WorkSpace.

func (WorkspaceOutput) Tags

The tags for the WorkSpace. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.

func (WorkspaceOutput) TagsAll

A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

func (WorkspaceOutput) ToWorkspaceOutput

func (o WorkspaceOutput) ToWorkspaceOutput() WorkspaceOutput

func (WorkspaceOutput) ToWorkspaceOutputWithContext

func (o WorkspaceOutput) ToWorkspaceOutputWithContext(ctx context.Context) WorkspaceOutput

func (WorkspaceOutput) UserName

func (o WorkspaceOutput) UserName() pulumi.StringOutput

The user name of the user for the WorkSpace. This user name must exist in the directory for the WorkSpace.

func (WorkspaceOutput) UserVolumeEncryptionEnabled

func (o WorkspaceOutput) UserVolumeEncryptionEnabled() pulumi.BoolPtrOutput

Indicates whether the data stored on the user volume is encrypted.

func (WorkspaceOutput) VolumeEncryptionKey

func (o WorkspaceOutput) VolumeEncryptionKey() pulumi.StringPtrOutput

The ARN of a symmetric AWS KMS customer master key (CMK) used to encrypt data stored on your WorkSpace. Amazon WorkSpaces does not support asymmetric CMKs.

func (WorkspaceOutput) WorkspaceProperties

func (o WorkspaceOutput) WorkspaceProperties() WorkspaceWorkspacePropertiesOutput

The WorkSpace properties.

type WorkspaceState

type WorkspaceState struct {
	// The ID of the bundle for the WorkSpace.
	BundleId pulumi.StringPtrInput
	// The name of the WorkSpace, as seen by the operating system.
	ComputerName pulumi.StringPtrInput
	// The ID of the directory for the WorkSpace.
	DirectoryId pulumi.StringPtrInput
	// The IP address of the WorkSpace.
	IpAddress pulumi.StringPtrInput
	// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
	Region pulumi.StringPtrInput
	// Indicates whether the data stored on the root volume is encrypted.
	RootVolumeEncryptionEnabled pulumi.BoolPtrInput
	// The operational state of the WorkSpace.
	State pulumi.StringPtrInput
	// The tags for the WorkSpace. If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	TagsAll pulumi.StringMapInput
	// The user name of the user for the WorkSpace. This user name must exist in the directory for the WorkSpace.
	UserName pulumi.StringPtrInput
	// Indicates whether the data stored on the user volume is encrypted.
	UserVolumeEncryptionEnabled pulumi.BoolPtrInput
	// The ARN of a symmetric AWS KMS customer master key (CMK) used to encrypt data stored on your WorkSpace. Amazon WorkSpaces does not support asymmetric CMKs.
	VolumeEncryptionKey pulumi.StringPtrInput
	// The WorkSpace properties.
	WorkspaceProperties WorkspaceWorkspacePropertiesPtrInput
}

func (WorkspaceState) ElementType

func (WorkspaceState) ElementType() reflect.Type

type WorkspaceWorkspaceProperties

type WorkspaceWorkspaceProperties struct {
	// The compute type. For more information, see [Amazon WorkSpaces Bundles](http://aws.amazon.com/workspaces/details/#Amazon_WorkSpaces_Bundles). Valid values are `VALUE`, `STANDARD`, `PERFORMANCE`, `POWER`, `GRAPHICS`, `POWERPRO`, `GRAPHICSPRO`, `GRAPHICS_G4DN`, and `GRAPHICSPRO_G4DN`.
	ComputeTypeName *string `pulumi:"computeTypeName"`
	// The size of the root volume.
	RootVolumeSizeGib *int `pulumi:"rootVolumeSizeGib"`
	// The running mode. For more information, see [Manage the WorkSpace Running Mode](https://docs.aws.amazon.com/workspaces/latest/adminguide/running-mode.html). Valid values are `AUTO_STOP` and `ALWAYS_ON`.
	RunningMode *string `pulumi:"runningMode"`
	// The time after a user logs off when WorkSpaces are automatically stopped. Configured in 60-minute intervals.
	RunningModeAutoStopTimeoutInMinutes *int `pulumi:"runningModeAutoStopTimeoutInMinutes"`
	// The size of the user storage.
	UserVolumeSizeGib *int `pulumi:"userVolumeSizeGib"`
}

type WorkspaceWorkspacePropertiesArgs

type WorkspaceWorkspacePropertiesArgs struct {
	// The compute type. For more information, see [Amazon WorkSpaces Bundles](http://aws.amazon.com/workspaces/details/#Amazon_WorkSpaces_Bundles). Valid values are `VALUE`, `STANDARD`, `PERFORMANCE`, `POWER`, `GRAPHICS`, `POWERPRO`, `GRAPHICSPRO`, `GRAPHICS_G4DN`, and `GRAPHICSPRO_G4DN`.
	ComputeTypeName pulumi.StringPtrInput `pulumi:"computeTypeName"`
	// The size of the root volume.
	RootVolumeSizeGib pulumi.IntPtrInput `pulumi:"rootVolumeSizeGib"`
	// The running mode. For more information, see [Manage the WorkSpace Running Mode](https://docs.aws.amazon.com/workspaces/latest/adminguide/running-mode.html). Valid values are `AUTO_STOP` and `ALWAYS_ON`.
	RunningMode pulumi.StringPtrInput `pulumi:"runningMode"`
	// The time after a user logs off when WorkSpaces are automatically stopped. Configured in 60-minute intervals.
	RunningModeAutoStopTimeoutInMinutes pulumi.IntPtrInput `pulumi:"runningModeAutoStopTimeoutInMinutes"`
	// The size of the user storage.
	UserVolumeSizeGib pulumi.IntPtrInput `pulumi:"userVolumeSizeGib"`
}

func (WorkspaceWorkspacePropertiesArgs) ElementType

func (WorkspaceWorkspacePropertiesArgs) ToWorkspaceWorkspacePropertiesOutput

func (i WorkspaceWorkspacePropertiesArgs) ToWorkspaceWorkspacePropertiesOutput() WorkspaceWorkspacePropertiesOutput

func (WorkspaceWorkspacePropertiesArgs) ToWorkspaceWorkspacePropertiesOutputWithContext

func (i WorkspaceWorkspacePropertiesArgs) ToWorkspaceWorkspacePropertiesOutputWithContext(ctx context.Context) WorkspaceWorkspacePropertiesOutput

func (WorkspaceWorkspacePropertiesArgs) ToWorkspaceWorkspacePropertiesPtrOutput

func (i WorkspaceWorkspacePropertiesArgs) ToWorkspaceWorkspacePropertiesPtrOutput() WorkspaceWorkspacePropertiesPtrOutput

func (WorkspaceWorkspacePropertiesArgs) ToWorkspaceWorkspacePropertiesPtrOutputWithContext

func (i WorkspaceWorkspacePropertiesArgs) ToWorkspaceWorkspacePropertiesPtrOutputWithContext(ctx context.Context) WorkspaceWorkspacePropertiesPtrOutput

type WorkspaceWorkspacePropertiesInput

type WorkspaceWorkspacePropertiesInput interface {
	pulumi.Input

	ToWorkspaceWorkspacePropertiesOutput() WorkspaceWorkspacePropertiesOutput
	ToWorkspaceWorkspacePropertiesOutputWithContext(context.Context) WorkspaceWorkspacePropertiesOutput
}

WorkspaceWorkspacePropertiesInput is an input type that accepts WorkspaceWorkspacePropertiesArgs and WorkspaceWorkspacePropertiesOutput values. You can construct a concrete instance of `WorkspaceWorkspacePropertiesInput` via:

WorkspaceWorkspacePropertiesArgs{...}

type WorkspaceWorkspacePropertiesOutput

type WorkspaceWorkspacePropertiesOutput struct{ *pulumi.OutputState }

func (WorkspaceWorkspacePropertiesOutput) ComputeTypeName

The compute type. For more information, see [Amazon WorkSpaces Bundles](http://aws.amazon.com/workspaces/details/#Amazon_WorkSpaces_Bundles). Valid values are `VALUE`, `STANDARD`, `PERFORMANCE`, `POWER`, `GRAPHICS`, `POWERPRO`, `GRAPHICSPRO`, `GRAPHICS_G4DN`, and `GRAPHICSPRO_G4DN`.

func (WorkspaceWorkspacePropertiesOutput) ElementType

func (WorkspaceWorkspacePropertiesOutput) RootVolumeSizeGib

The size of the root volume.

func (WorkspaceWorkspacePropertiesOutput) RunningMode

The running mode. For more information, see [Manage the WorkSpace Running Mode](https://docs.aws.amazon.com/workspaces/latest/adminguide/running-mode.html). Valid values are `AUTO_STOP` and `ALWAYS_ON`.

func (WorkspaceWorkspacePropertiesOutput) RunningModeAutoStopTimeoutInMinutes

func (o WorkspaceWorkspacePropertiesOutput) RunningModeAutoStopTimeoutInMinutes() pulumi.IntPtrOutput

The time after a user logs off when WorkSpaces are automatically stopped. Configured in 60-minute intervals.

func (WorkspaceWorkspacePropertiesOutput) ToWorkspaceWorkspacePropertiesOutput

func (o WorkspaceWorkspacePropertiesOutput) ToWorkspaceWorkspacePropertiesOutput() WorkspaceWorkspacePropertiesOutput

func (WorkspaceWorkspacePropertiesOutput) ToWorkspaceWorkspacePropertiesOutputWithContext

func (o WorkspaceWorkspacePropertiesOutput) ToWorkspaceWorkspacePropertiesOutputWithContext(ctx context.Context) WorkspaceWorkspacePropertiesOutput

func (WorkspaceWorkspacePropertiesOutput) ToWorkspaceWorkspacePropertiesPtrOutput

func (o WorkspaceWorkspacePropertiesOutput) ToWorkspaceWorkspacePropertiesPtrOutput() WorkspaceWorkspacePropertiesPtrOutput

func (WorkspaceWorkspacePropertiesOutput) ToWorkspaceWorkspacePropertiesPtrOutputWithContext

func (o WorkspaceWorkspacePropertiesOutput) ToWorkspaceWorkspacePropertiesPtrOutputWithContext(ctx context.Context) WorkspaceWorkspacePropertiesPtrOutput

func (WorkspaceWorkspacePropertiesOutput) UserVolumeSizeGib

The size of the user storage.

type WorkspaceWorkspacePropertiesPtrInput

type WorkspaceWorkspacePropertiesPtrInput interface {
	pulumi.Input

	ToWorkspaceWorkspacePropertiesPtrOutput() WorkspaceWorkspacePropertiesPtrOutput
	ToWorkspaceWorkspacePropertiesPtrOutputWithContext(context.Context) WorkspaceWorkspacePropertiesPtrOutput
}

WorkspaceWorkspacePropertiesPtrInput is an input type that accepts WorkspaceWorkspacePropertiesArgs, WorkspaceWorkspacePropertiesPtr and WorkspaceWorkspacePropertiesPtrOutput values. You can construct a concrete instance of `WorkspaceWorkspacePropertiesPtrInput` via:

        WorkspaceWorkspacePropertiesArgs{...}

or:

        nil

type WorkspaceWorkspacePropertiesPtrOutput

type WorkspaceWorkspacePropertiesPtrOutput struct{ *pulumi.OutputState }

func (WorkspaceWorkspacePropertiesPtrOutput) ComputeTypeName

The compute type. For more information, see [Amazon WorkSpaces Bundles](http://aws.amazon.com/workspaces/details/#Amazon_WorkSpaces_Bundles). Valid values are `VALUE`, `STANDARD`, `PERFORMANCE`, `POWER`, `GRAPHICS`, `POWERPRO`, `GRAPHICSPRO`, `GRAPHICS_G4DN`, and `GRAPHICSPRO_G4DN`.

func (WorkspaceWorkspacePropertiesPtrOutput) Elem

func (WorkspaceWorkspacePropertiesPtrOutput) ElementType

func (WorkspaceWorkspacePropertiesPtrOutput) RootVolumeSizeGib

The size of the root volume.

func (WorkspaceWorkspacePropertiesPtrOutput) RunningMode

The running mode. For more information, see [Manage the WorkSpace Running Mode](https://docs.aws.amazon.com/workspaces/latest/adminguide/running-mode.html). Valid values are `AUTO_STOP` and `ALWAYS_ON`.

func (WorkspaceWorkspacePropertiesPtrOutput) RunningModeAutoStopTimeoutInMinutes

func (o WorkspaceWorkspacePropertiesPtrOutput) RunningModeAutoStopTimeoutInMinutes() pulumi.IntPtrOutput

The time after a user logs off when WorkSpaces are automatically stopped. Configured in 60-minute intervals.

func (WorkspaceWorkspacePropertiesPtrOutput) ToWorkspaceWorkspacePropertiesPtrOutput

func (o WorkspaceWorkspacePropertiesPtrOutput) ToWorkspaceWorkspacePropertiesPtrOutput() WorkspaceWorkspacePropertiesPtrOutput

func (WorkspaceWorkspacePropertiesPtrOutput) ToWorkspaceWorkspacePropertiesPtrOutputWithContext

func (o WorkspaceWorkspacePropertiesPtrOutput) ToWorkspaceWorkspacePropertiesPtrOutputWithContext(ctx context.Context) WorkspaceWorkspacePropertiesPtrOutput

func (WorkspaceWorkspacePropertiesPtrOutput) UserVolumeSizeGib

The size of the user storage.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL