temporalcloud

package
v0.6.2 Latest Latest
Warning

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

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

Documentation

Overview

A Pulumi package for creating and managing Temporal Cloud resources.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Apikey

type Apikey struct {
	pulumi.CustomResourceState

	// The description for the API key.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Whether the API key is disabled.
	Disabled pulumi.BoolOutput `pulumi:"disabled"`
	// The display name for the API key.
	DisplayName pulumi.StringOutput `pulumi:"displayName"`
	// The expiry time for the API key in ISO 8601 format.
	ExpiryTime pulumi.StringOutput `pulumi:"expiryTime"`
	// The ID of the owner to create the API key for.
	OwnerId pulumi.StringOutput `pulumi:"ownerId"`
	// The type of the owner to create the API key.
	OwnerType pulumi.StringOutput `pulumi:"ownerType"`
	// The current state of the API key.
	State    pulumi.StringOutput     `pulumi:"state"`
	Timeouts ApikeyTimeoutsPtrOutput `pulumi:"timeouts"`
	Token    pulumi.StringOutput     `pulumi:"token"`
}

Provisions a Temporal Cloud API key.

## Example Usage

```go package main

import (

"github.com/Grip-Security/pulumi-temporalcloud/sdk/go/temporalcloud"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		globalServiceAccount, err := temporalcloud.NewServiceAccount(ctx, "global_service_account", &temporalcloud.ServiceAccountArgs{
			Name:          pulumi.String("admin"),
			AccountAccess: pulumi.String("Admin"),
		})
		if err != nil {
			return err
		}
		_, err = temporalcloud.NewApikey(ctx, "global_apikey", &temporalcloud.ApikeyArgs{
			DisplayName: pulumi.String("admin"),
			OwnerType:   pulumi.String("service-account"),
			OwnerId:     globalServiceAccount.ID(),
			ExpiryTime:  pulumi.String("2024-11-01T00:00:00Z"),
			Disabled:    pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetApikey

func GetApikey(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ApikeyState, opts ...pulumi.ResourceOption) (*Apikey, error)

GetApikey gets an existing Apikey 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 NewApikey

func NewApikey(ctx *pulumi.Context,
	name string, args *ApikeyArgs, opts ...pulumi.ResourceOption) (*Apikey, error)

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

func (*Apikey) ElementType

func (*Apikey) ElementType() reflect.Type

func (*Apikey) ToApikeyOutput

func (i *Apikey) ToApikeyOutput() ApikeyOutput

func (*Apikey) ToApikeyOutputWithContext

func (i *Apikey) ToApikeyOutputWithContext(ctx context.Context) ApikeyOutput

type ApikeyArgs

type ApikeyArgs struct {
	// The description for the API key.
	Description pulumi.StringPtrInput
	// Whether the API key is disabled.
	Disabled pulumi.BoolPtrInput
	// The display name for the API key.
	DisplayName pulumi.StringInput
	// The expiry time for the API key in ISO 8601 format.
	ExpiryTime pulumi.StringInput
	// The ID of the owner to create the API key for.
	OwnerId pulumi.StringInput
	// The type of the owner to create the API key.
	OwnerType pulumi.StringInput
	Timeouts  ApikeyTimeoutsPtrInput
}

The set of arguments for constructing a Apikey resource.

func (ApikeyArgs) ElementType

func (ApikeyArgs) ElementType() reflect.Type

type ApikeyArray

type ApikeyArray []ApikeyInput

func (ApikeyArray) ElementType

func (ApikeyArray) ElementType() reflect.Type

func (ApikeyArray) ToApikeyArrayOutput

func (i ApikeyArray) ToApikeyArrayOutput() ApikeyArrayOutput

func (ApikeyArray) ToApikeyArrayOutputWithContext

func (i ApikeyArray) ToApikeyArrayOutputWithContext(ctx context.Context) ApikeyArrayOutput

type ApikeyArrayInput

type ApikeyArrayInput interface {
	pulumi.Input

	ToApikeyArrayOutput() ApikeyArrayOutput
	ToApikeyArrayOutputWithContext(context.Context) ApikeyArrayOutput
}

ApikeyArrayInput is an input type that accepts ApikeyArray and ApikeyArrayOutput values. You can construct a concrete instance of `ApikeyArrayInput` via:

ApikeyArray{ ApikeyArgs{...} }

type ApikeyArrayOutput

type ApikeyArrayOutput struct{ *pulumi.OutputState }

func (ApikeyArrayOutput) ElementType

func (ApikeyArrayOutput) ElementType() reflect.Type

func (ApikeyArrayOutput) Index

func (ApikeyArrayOutput) ToApikeyArrayOutput

func (o ApikeyArrayOutput) ToApikeyArrayOutput() ApikeyArrayOutput

func (ApikeyArrayOutput) ToApikeyArrayOutputWithContext

func (o ApikeyArrayOutput) ToApikeyArrayOutputWithContext(ctx context.Context) ApikeyArrayOutput

type ApikeyInput

type ApikeyInput interface {
	pulumi.Input

	ToApikeyOutput() ApikeyOutput
	ToApikeyOutputWithContext(ctx context.Context) ApikeyOutput
}

type ApikeyMap

type ApikeyMap map[string]ApikeyInput

func (ApikeyMap) ElementType

func (ApikeyMap) ElementType() reflect.Type

func (ApikeyMap) ToApikeyMapOutput

func (i ApikeyMap) ToApikeyMapOutput() ApikeyMapOutput

func (ApikeyMap) ToApikeyMapOutputWithContext

func (i ApikeyMap) ToApikeyMapOutputWithContext(ctx context.Context) ApikeyMapOutput

type ApikeyMapInput

type ApikeyMapInput interface {
	pulumi.Input

	ToApikeyMapOutput() ApikeyMapOutput
	ToApikeyMapOutputWithContext(context.Context) ApikeyMapOutput
}

ApikeyMapInput is an input type that accepts ApikeyMap and ApikeyMapOutput values. You can construct a concrete instance of `ApikeyMapInput` via:

ApikeyMap{ "key": ApikeyArgs{...} }

type ApikeyMapOutput

type ApikeyMapOutput struct{ *pulumi.OutputState }

func (ApikeyMapOutput) ElementType

func (ApikeyMapOutput) ElementType() reflect.Type

func (ApikeyMapOutput) MapIndex

func (ApikeyMapOutput) ToApikeyMapOutput

func (o ApikeyMapOutput) ToApikeyMapOutput() ApikeyMapOutput

func (ApikeyMapOutput) ToApikeyMapOutputWithContext

func (o ApikeyMapOutput) ToApikeyMapOutputWithContext(ctx context.Context) ApikeyMapOutput

type ApikeyOutput

type ApikeyOutput struct{ *pulumi.OutputState }

func (ApikeyOutput) Description

func (o ApikeyOutput) Description() pulumi.StringPtrOutput

The description for the API key.

func (ApikeyOutput) Disabled

func (o ApikeyOutput) Disabled() pulumi.BoolOutput

Whether the API key is disabled.

func (ApikeyOutput) DisplayName

func (o ApikeyOutput) DisplayName() pulumi.StringOutput

The display name for the API key.

func (ApikeyOutput) ElementType

func (ApikeyOutput) ElementType() reflect.Type

func (ApikeyOutput) ExpiryTime

func (o ApikeyOutput) ExpiryTime() pulumi.StringOutput

The expiry time for the API key in ISO 8601 format.

func (ApikeyOutput) OwnerId

func (o ApikeyOutput) OwnerId() pulumi.StringOutput

The ID of the owner to create the API key for.

func (ApikeyOutput) OwnerType

func (o ApikeyOutput) OwnerType() pulumi.StringOutput

The type of the owner to create the API key.

func (ApikeyOutput) State

func (o ApikeyOutput) State() pulumi.StringOutput

The current state of the API key.

func (ApikeyOutput) Timeouts

func (ApikeyOutput) ToApikeyOutput

func (o ApikeyOutput) ToApikeyOutput() ApikeyOutput

func (ApikeyOutput) ToApikeyOutputWithContext

func (o ApikeyOutput) ToApikeyOutputWithContext(ctx context.Context) ApikeyOutput

func (ApikeyOutput) Token

func (o ApikeyOutput) Token() pulumi.StringOutput

type ApikeyState

type ApikeyState struct {
	// The description for the API key.
	Description pulumi.StringPtrInput
	// Whether the API key is disabled.
	Disabled pulumi.BoolPtrInput
	// The display name for the API key.
	DisplayName pulumi.StringPtrInput
	// The expiry time for the API key in ISO 8601 format.
	ExpiryTime pulumi.StringPtrInput
	// The ID of the owner to create the API key for.
	OwnerId pulumi.StringPtrInput
	// The type of the owner to create the API key.
	OwnerType pulumi.StringPtrInput
	// The current state of the API key.
	State    pulumi.StringPtrInput
	Timeouts ApikeyTimeoutsPtrInput
	Token    pulumi.StringPtrInput
}

func (ApikeyState) ElementType

func (ApikeyState) ElementType() reflect.Type

type ApikeyTimeouts

type ApikeyTimeouts 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 ApikeyTimeoutsArgs

type ApikeyTimeoutsArgs 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 (ApikeyTimeoutsArgs) ElementType

func (ApikeyTimeoutsArgs) ElementType() reflect.Type

func (ApikeyTimeoutsArgs) ToApikeyTimeoutsOutput

func (i ApikeyTimeoutsArgs) ToApikeyTimeoutsOutput() ApikeyTimeoutsOutput

func (ApikeyTimeoutsArgs) ToApikeyTimeoutsOutputWithContext

func (i ApikeyTimeoutsArgs) ToApikeyTimeoutsOutputWithContext(ctx context.Context) ApikeyTimeoutsOutput

func (ApikeyTimeoutsArgs) ToApikeyTimeoutsPtrOutput

func (i ApikeyTimeoutsArgs) ToApikeyTimeoutsPtrOutput() ApikeyTimeoutsPtrOutput

func (ApikeyTimeoutsArgs) ToApikeyTimeoutsPtrOutputWithContext

func (i ApikeyTimeoutsArgs) ToApikeyTimeoutsPtrOutputWithContext(ctx context.Context) ApikeyTimeoutsPtrOutput

type ApikeyTimeoutsInput

type ApikeyTimeoutsInput interface {
	pulumi.Input

	ToApikeyTimeoutsOutput() ApikeyTimeoutsOutput
	ToApikeyTimeoutsOutputWithContext(context.Context) ApikeyTimeoutsOutput
}

ApikeyTimeoutsInput is an input type that accepts ApikeyTimeoutsArgs and ApikeyTimeoutsOutput values. You can construct a concrete instance of `ApikeyTimeoutsInput` via:

ApikeyTimeoutsArgs{...}

type ApikeyTimeoutsOutput

type ApikeyTimeoutsOutput struct{ *pulumi.OutputState }

func (ApikeyTimeoutsOutput) 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 (ApikeyTimeoutsOutput) 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 (ApikeyTimeoutsOutput) ElementType

func (ApikeyTimeoutsOutput) ElementType() reflect.Type

func (ApikeyTimeoutsOutput) ToApikeyTimeoutsOutput

func (o ApikeyTimeoutsOutput) ToApikeyTimeoutsOutput() ApikeyTimeoutsOutput

func (ApikeyTimeoutsOutput) ToApikeyTimeoutsOutputWithContext

func (o ApikeyTimeoutsOutput) ToApikeyTimeoutsOutputWithContext(ctx context.Context) ApikeyTimeoutsOutput

func (ApikeyTimeoutsOutput) ToApikeyTimeoutsPtrOutput

func (o ApikeyTimeoutsOutput) ToApikeyTimeoutsPtrOutput() ApikeyTimeoutsPtrOutput

func (ApikeyTimeoutsOutput) ToApikeyTimeoutsPtrOutputWithContext

func (o ApikeyTimeoutsOutput) ToApikeyTimeoutsPtrOutputWithContext(ctx context.Context) ApikeyTimeoutsPtrOutput

type ApikeyTimeoutsPtrInput

type ApikeyTimeoutsPtrInput interface {
	pulumi.Input

	ToApikeyTimeoutsPtrOutput() ApikeyTimeoutsPtrOutput
	ToApikeyTimeoutsPtrOutputWithContext(context.Context) ApikeyTimeoutsPtrOutput
}

ApikeyTimeoutsPtrInput is an input type that accepts ApikeyTimeoutsArgs, ApikeyTimeoutsPtr and ApikeyTimeoutsPtrOutput values. You can construct a concrete instance of `ApikeyTimeoutsPtrInput` via:

        ApikeyTimeoutsArgs{...}

or:

        nil

type ApikeyTimeoutsPtrOutput

type ApikeyTimeoutsPtrOutput struct{ *pulumi.OutputState }

func (ApikeyTimeoutsPtrOutput) 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 (ApikeyTimeoutsPtrOutput) 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 (ApikeyTimeoutsPtrOutput) Elem

func (ApikeyTimeoutsPtrOutput) ElementType

func (ApikeyTimeoutsPtrOutput) ElementType() reflect.Type

func (ApikeyTimeoutsPtrOutput) ToApikeyTimeoutsPtrOutput

func (o ApikeyTimeoutsPtrOutput) ToApikeyTimeoutsPtrOutput() ApikeyTimeoutsPtrOutput

func (ApikeyTimeoutsPtrOutput) ToApikeyTimeoutsPtrOutputWithContext

func (o ApikeyTimeoutsPtrOutput) ToApikeyTimeoutsPtrOutputWithContext(ctx context.Context) ApikeyTimeoutsPtrOutput

type GetNamespacesNamespace

type GetNamespacesNamespace struct {
	// The Base64-encoded CA cert in PEM format that clients use when authenticating with Temporal Cloud.
	AcceptedClientCa string `pulumi:"acceptedClientCa"`
	// The currently active region for the namespace.
	ActiveRegion string `pulumi:"activeRegion"`
	// If true, Temporal Cloud will use API key authentication for this namespace. If false, mutual TLS (mTLS) authentication will be used.
	ApiKeyAuth *bool `pulumi:"apiKeyAuth"`
	// A list of filters to apply to client certificates when initiating a connection Temporal Cloud. If present, connections will only be allowed from client certificates whose distinguished name properties match at least one of the filters.
	CertificateFilters []GetNamespacesNamespaceCertificateFilter `pulumi:"certificateFilters"`
	// A codec server is used by the Temporal Cloud UI to decode payloads for all users interacting with this namespace, even if the workflow history itself is encrypted.
	CodecServer GetNamespacesNamespaceCodecServer `pulumi:"codecServer"`
	// The date and time when the namespace was created.
	CreatedTime string `pulumi:"createdTime"`
	// The custom search attributes to use for the namespace.
	CustomSearchAttributes map[string]string `pulumi:"customSearchAttributes"`
	// The endpoints for the namespace.
	Endpoints GetNamespacesNamespaceEndpoints `pulumi:"endpoints"`
	// The unique identifier of the namespace across all Temporal Cloud tenants.
	Id string `pulumi:"id"`
	// The date and time when the namespace was last modified. Will not be set if the namespace has never been modified.
	LastModifiedTime string `pulumi:"lastModifiedTime"`
	// The limits set on the namespace currently.
	Limits GetNamespacesNamespaceLimits `pulumi:"limits"`
	// The name of the namespace.
	Name string `pulumi:"name"`
	// The private connectivities for the namespace, if any.
	PrivateConnectivities []GetNamespacesNamespacePrivateConnectivity `pulumi:"privateConnectivities"`
	Regions               []string                                    `pulumi:"regions"`
	// The number of days to retain workflow history. Any changes to the retention period will be applied to all new running workflows.
	RetentionDays int `pulumi:"retentionDays"`
	// The current state of the namespace.
	State string `pulumi:"state"`
}

type GetNamespacesNamespaceArgs

type GetNamespacesNamespaceArgs struct {
	// The Base64-encoded CA cert in PEM format that clients use when authenticating with Temporal Cloud.
	AcceptedClientCa pulumi.StringInput `pulumi:"acceptedClientCa"`
	// The currently active region for the namespace.
	ActiveRegion pulumi.StringInput `pulumi:"activeRegion"`
	// If true, Temporal Cloud will use API key authentication for this namespace. If false, mutual TLS (mTLS) authentication will be used.
	ApiKeyAuth pulumi.BoolPtrInput `pulumi:"apiKeyAuth"`
	// A list of filters to apply to client certificates when initiating a connection Temporal Cloud. If present, connections will only be allowed from client certificates whose distinguished name properties match at least one of the filters.
	CertificateFilters GetNamespacesNamespaceCertificateFilterArrayInput `pulumi:"certificateFilters"`
	// A codec server is used by the Temporal Cloud UI to decode payloads for all users interacting with this namespace, even if the workflow history itself is encrypted.
	CodecServer GetNamespacesNamespaceCodecServerInput `pulumi:"codecServer"`
	// The date and time when the namespace was created.
	CreatedTime pulumi.StringInput `pulumi:"createdTime"`
	// The custom search attributes to use for the namespace.
	CustomSearchAttributes pulumi.StringMapInput `pulumi:"customSearchAttributes"`
	// The endpoints for the namespace.
	Endpoints GetNamespacesNamespaceEndpointsInput `pulumi:"endpoints"`
	// The unique identifier of the namespace across all Temporal Cloud tenants.
	Id pulumi.StringInput `pulumi:"id"`
	// The date and time when the namespace was last modified. Will not be set if the namespace has never been modified.
	LastModifiedTime pulumi.StringInput `pulumi:"lastModifiedTime"`
	// The limits set on the namespace currently.
	Limits GetNamespacesNamespaceLimitsInput `pulumi:"limits"`
	// The name of the namespace.
	Name pulumi.StringInput `pulumi:"name"`
	// The private connectivities for the namespace, if any.
	PrivateConnectivities GetNamespacesNamespacePrivateConnectivityArrayInput `pulumi:"privateConnectivities"`
	Regions               pulumi.StringArrayInput                             `pulumi:"regions"`
	// The number of days to retain workflow history. Any changes to the retention period will be applied to all new running workflows.
	RetentionDays pulumi.IntInput `pulumi:"retentionDays"`
	// The current state of the namespace.
	State pulumi.StringInput `pulumi:"state"`
}

func (GetNamespacesNamespaceArgs) ElementType

func (GetNamespacesNamespaceArgs) ElementType() reflect.Type

func (GetNamespacesNamespaceArgs) ToGetNamespacesNamespaceOutput

func (i GetNamespacesNamespaceArgs) ToGetNamespacesNamespaceOutput() GetNamespacesNamespaceOutput

func (GetNamespacesNamespaceArgs) ToGetNamespacesNamespaceOutputWithContext

func (i GetNamespacesNamespaceArgs) ToGetNamespacesNamespaceOutputWithContext(ctx context.Context) GetNamespacesNamespaceOutput

type GetNamespacesNamespaceArray

type GetNamespacesNamespaceArray []GetNamespacesNamespaceInput

func (GetNamespacesNamespaceArray) ElementType

func (GetNamespacesNamespaceArray) ToGetNamespacesNamespaceArrayOutput

func (i GetNamespacesNamespaceArray) ToGetNamespacesNamespaceArrayOutput() GetNamespacesNamespaceArrayOutput

func (GetNamespacesNamespaceArray) ToGetNamespacesNamespaceArrayOutputWithContext

func (i GetNamespacesNamespaceArray) ToGetNamespacesNamespaceArrayOutputWithContext(ctx context.Context) GetNamespacesNamespaceArrayOutput

type GetNamespacesNamespaceArrayInput

type GetNamespacesNamespaceArrayInput interface {
	pulumi.Input

	ToGetNamespacesNamespaceArrayOutput() GetNamespacesNamespaceArrayOutput
	ToGetNamespacesNamespaceArrayOutputWithContext(context.Context) GetNamespacesNamespaceArrayOutput
}

GetNamespacesNamespaceArrayInput is an input type that accepts GetNamespacesNamespaceArray and GetNamespacesNamespaceArrayOutput values. You can construct a concrete instance of `GetNamespacesNamespaceArrayInput` via:

GetNamespacesNamespaceArray{ GetNamespacesNamespaceArgs{...} }

type GetNamespacesNamespaceArrayOutput

type GetNamespacesNamespaceArrayOutput struct{ *pulumi.OutputState }

func (GetNamespacesNamespaceArrayOutput) ElementType

func (GetNamespacesNamespaceArrayOutput) Index

func (GetNamespacesNamespaceArrayOutput) ToGetNamespacesNamespaceArrayOutput

func (o GetNamespacesNamespaceArrayOutput) ToGetNamespacesNamespaceArrayOutput() GetNamespacesNamespaceArrayOutput

func (GetNamespacesNamespaceArrayOutput) ToGetNamespacesNamespaceArrayOutputWithContext

func (o GetNamespacesNamespaceArrayOutput) ToGetNamespacesNamespaceArrayOutputWithContext(ctx context.Context) GetNamespacesNamespaceArrayOutput

type GetNamespacesNamespaceCertificateFilter

type GetNamespacesNamespaceCertificateFilter struct {
	// The certificate's common name.
	CommonName string `pulumi:"commonName"`
	// The certificate's organization.
	Organization string `pulumi:"organization"`
	// The certificate's organizational unit.
	OrganizationalUnit string `pulumi:"organizationalUnit"`
	// The certificate's subject alternative name (or SAN).
	SubjectAlternativeName string `pulumi:"subjectAlternativeName"`
}

type GetNamespacesNamespaceCertificateFilterArgs

type GetNamespacesNamespaceCertificateFilterArgs struct {
	// The certificate's common name.
	CommonName pulumi.StringInput `pulumi:"commonName"`
	// The certificate's organization.
	Organization pulumi.StringInput `pulumi:"organization"`
	// The certificate's organizational unit.
	OrganizationalUnit pulumi.StringInput `pulumi:"organizationalUnit"`
	// The certificate's subject alternative name (or SAN).
	SubjectAlternativeName pulumi.StringInput `pulumi:"subjectAlternativeName"`
}

func (GetNamespacesNamespaceCertificateFilterArgs) ElementType

func (GetNamespacesNamespaceCertificateFilterArgs) ToGetNamespacesNamespaceCertificateFilterOutput

func (i GetNamespacesNamespaceCertificateFilterArgs) ToGetNamespacesNamespaceCertificateFilterOutput() GetNamespacesNamespaceCertificateFilterOutput

func (GetNamespacesNamespaceCertificateFilterArgs) ToGetNamespacesNamespaceCertificateFilterOutputWithContext

func (i GetNamespacesNamespaceCertificateFilterArgs) ToGetNamespacesNamespaceCertificateFilterOutputWithContext(ctx context.Context) GetNamespacesNamespaceCertificateFilterOutput

type GetNamespacesNamespaceCertificateFilterArray

type GetNamespacesNamespaceCertificateFilterArray []GetNamespacesNamespaceCertificateFilterInput

func (GetNamespacesNamespaceCertificateFilterArray) ElementType

func (GetNamespacesNamespaceCertificateFilterArray) ToGetNamespacesNamespaceCertificateFilterArrayOutput

func (i GetNamespacesNamespaceCertificateFilterArray) ToGetNamespacesNamespaceCertificateFilterArrayOutput() GetNamespacesNamespaceCertificateFilterArrayOutput

func (GetNamespacesNamespaceCertificateFilterArray) ToGetNamespacesNamespaceCertificateFilterArrayOutputWithContext

func (i GetNamespacesNamespaceCertificateFilterArray) ToGetNamespacesNamespaceCertificateFilterArrayOutputWithContext(ctx context.Context) GetNamespacesNamespaceCertificateFilterArrayOutput

type GetNamespacesNamespaceCertificateFilterArrayInput

type GetNamespacesNamespaceCertificateFilterArrayInput interface {
	pulumi.Input

	ToGetNamespacesNamespaceCertificateFilterArrayOutput() GetNamespacesNamespaceCertificateFilterArrayOutput
	ToGetNamespacesNamespaceCertificateFilterArrayOutputWithContext(context.Context) GetNamespacesNamespaceCertificateFilterArrayOutput
}

GetNamespacesNamespaceCertificateFilterArrayInput is an input type that accepts GetNamespacesNamespaceCertificateFilterArray and GetNamespacesNamespaceCertificateFilterArrayOutput values. You can construct a concrete instance of `GetNamespacesNamespaceCertificateFilterArrayInput` via:

GetNamespacesNamespaceCertificateFilterArray{ GetNamespacesNamespaceCertificateFilterArgs{...} }

type GetNamespacesNamespaceCertificateFilterArrayOutput

type GetNamespacesNamespaceCertificateFilterArrayOutput struct{ *pulumi.OutputState }

func (GetNamespacesNamespaceCertificateFilterArrayOutput) ElementType

func (GetNamespacesNamespaceCertificateFilterArrayOutput) Index

func (GetNamespacesNamespaceCertificateFilterArrayOutput) ToGetNamespacesNamespaceCertificateFilterArrayOutput

func (o GetNamespacesNamespaceCertificateFilterArrayOutput) ToGetNamespacesNamespaceCertificateFilterArrayOutput() GetNamespacesNamespaceCertificateFilterArrayOutput

func (GetNamespacesNamespaceCertificateFilterArrayOutput) ToGetNamespacesNamespaceCertificateFilterArrayOutputWithContext

func (o GetNamespacesNamespaceCertificateFilterArrayOutput) ToGetNamespacesNamespaceCertificateFilterArrayOutputWithContext(ctx context.Context) GetNamespacesNamespaceCertificateFilterArrayOutput

type GetNamespacesNamespaceCertificateFilterInput

type GetNamespacesNamespaceCertificateFilterInput interface {
	pulumi.Input

	ToGetNamespacesNamespaceCertificateFilterOutput() GetNamespacesNamespaceCertificateFilterOutput
	ToGetNamespacesNamespaceCertificateFilterOutputWithContext(context.Context) GetNamespacesNamespaceCertificateFilterOutput
}

GetNamespacesNamespaceCertificateFilterInput is an input type that accepts GetNamespacesNamespaceCertificateFilterArgs and GetNamespacesNamespaceCertificateFilterOutput values. You can construct a concrete instance of `GetNamespacesNamespaceCertificateFilterInput` via:

GetNamespacesNamespaceCertificateFilterArgs{...}

type GetNamespacesNamespaceCertificateFilterOutput

type GetNamespacesNamespaceCertificateFilterOutput struct{ *pulumi.OutputState }

func (GetNamespacesNamespaceCertificateFilterOutput) CommonName

The certificate's common name.

func (GetNamespacesNamespaceCertificateFilterOutput) ElementType

func (GetNamespacesNamespaceCertificateFilterOutput) Organization

The certificate's organization.

func (GetNamespacesNamespaceCertificateFilterOutput) OrganizationalUnit

The certificate's organizational unit.

func (GetNamespacesNamespaceCertificateFilterOutput) SubjectAlternativeName

The certificate's subject alternative name (or SAN).

func (GetNamespacesNamespaceCertificateFilterOutput) ToGetNamespacesNamespaceCertificateFilterOutput

func (o GetNamespacesNamespaceCertificateFilterOutput) ToGetNamespacesNamespaceCertificateFilterOutput() GetNamespacesNamespaceCertificateFilterOutput

func (GetNamespacesNamespaceCertificateFilterOutput) ToGetNamespacesNamespaceCertificateFilterOutputWithContext

func (o GetNamespacesNamespaceCertificateFilterOutput) ToGetNamespacesNamespaceCertificateFilterOutputWithContext(ctx context.Context) GetNamespacesNamespaceCertificateFilterOutput

type GetNamespacesNamespaceCodecServer

type GetNamespacesNamespaceCodecServer struct {
	// The endpoint of the codec server.
	Endpoint string `pulumi:"endpoint"`
	// If true, Temporal Cloud will include cross-origin credentials in requests to the codec server.
	IncludeCrossOriginCredentials bool `pulumi:"includeCrossOriginCredentials"`
	// If true, Temporal Cloud will pass the access token to the codec server upon each request.
	PassAccessToken bool `pulumi:"passAccessToken"`
}

type GetNamespacesNamespaceCodecServerArgs

type GetNamespacesNamespaceCodecServerArgs struct {
	// The endpoint of the codec server.
	Endpoint pulumi.StringInput `pulumi:"endpoint"`
	// If true, Temporal Cloud will include cross-origin credentials in requests to the codec server.
	IncludeCrossOriginCredentials pulumi.BoolInput `pulumi:"includeCrossOriginCredentials"`
	// If true, Temporal Cloud will pass the access token to the codec server upon each request.
	PassAccessToken pulumi.BoolInput `pulumi:"passAccessToken"`
}

func (GetNamespacesNamespaceCodecServerArgs) ElementType

func (GetNamespacesNamespaceCodecServerArgs) ToGetNamespacesNamespaceCodecServerOutput

func (i GetNamespacesNamespaceCodecServerArgs) ToGetNamespacesNamespaceCodecServerOutput() GetNamespacesNamespaceCodecServerOutput

func (GetNamespacesNamespaceCodecServerArgs) ToGetNamespacesNamespaceCodecServerOutputWithContext

func (i GetNamespacesNamespaceCodecServerArgs) ToGetNamespacesNamespaceCodecServerOutputWithContext(ctx context.Context) GetNamespacesNamespaceCodecServerOutput

type GetNamespacesNamespaceCodecServerInput

type GetNamespacesNamespaceCodecServerInput interface {
	pulumi.Input

	ToGetNamespacesNamespaceCodecServerOutput() GetNamespacesNamespaceCodecServerOutput
	ToGetNamespacesNamespaceCodecServerOutputWithContext(context.Context) GetNamespacesNamespaceCodecServerOutput
}

GetNamespacesNamespaceCodecServerInput is an input type that accepts GetNamespacesNamespaceCodecServerArgs and GetNamespacesNamespaceCodecServerOutput values. You can construct a concrete instance of `GetNamespacesNamespaceCodecServerInput` via:

GetNamespacesNamespaceCodecServerArgs{...}

type GetNamespacesNamespaceCodecServerOutput

type GetNamespacesNamespaceCodecServerOutput struct{ *pulumi.OutputState }

func (GetNamespacesNamespaceCodecServerOutput) ElementType

func (GetNamespacesNamespaceCodecServerOutput) Endpoint

The endpoint of the codec server.

func (GetNamespacesNamespaceCodecServerOutput) IncludeCrossOriginCredentials

func (o GetNamespacesNamespaceCodecServerOutput) IncludeCrossOriginCredentials() pulumi.BoolOutput

If true, Temporal Cloud will include cross-origin credentials in requests to the codec server.

func (GetNamespacesNamespaceCodecServerOutput) PassAccessToken

If true, Temporal Cloud will pass the access token to the codec server upon each request.

func (GetNamespacesNamespaceCodecServerOutput) ToGetNamespacesNamespaceCodecServerOutput

func (o GetNamespacesNamespaceCodecServerOutput) ToGetNamespacesNamespaceCodecServerOutput() GetNamespacesNamespaceCodecServerOutput

func (GetNamespacesNamespaceCodecServerOutput) ToGetNamespacesNamespaceCodecServerOutputWithContext

func (o GetNamespacesNamespaceCodecServerOutput) ToGetNamespacesNamespaceCodecServerOutputWithContext(ctx context.Context) GetNamespacesNamespaceCodecServerOutput

type GetNamespacesNamespaceEndpoints

type GetNamespacesNamespaceEndpoints struct {
	// The gRPC hostport address that the temporal workers, clients and tctl connect to.
	GrpcAddress string `pulumi:"grpcAddress"`
	// The web UI address.
	WebAddress string `pulumi:"webAddress"`
}

type GetNamespacesNamespaceEndpointsArgs

type GetNamespacesNamespaceEndpointsArgs struct {
	// The gRPC hostport address that the temporal workers, clients and tctl connect to.
	GrpcAddress pulumi.StringInput `pulumi:"grpcAddress"`
	// The web UI address.
	WebAddress pulumi.StringInput `pulumi:"webAddress"`
}

func (GetNamespacesNamespaceEndpointsArgs) ElementType

func (GetNamespacesNamespaceEndpointsArgs) ToGetNamespacesNamespaceEndpointsOutput

func (i GetNamespacesNamespaceEndpointsArgs) ToGetNamespacesNamespaceEndpointsOutput() GetNamespacesNamespaceEndpointsOutput

func (GetNamespacesNamespaceEndpointsArgs) ToGetNamespacesNamespaceEndpointsOutputWithContext

func (i GetNamespacesNamespaceEndpointsArgs) ToGetNamespacesNamespaceEndpointsOutputWithContext(ctx context.Context) GetNamespacesNamespaceEndpointsOutput

type GetNamespacesNamespaceEndpointsInput

type GetNamespacesNamespaceEndpointsInput interface {
	pulumi.Input

	ToGetNamespacesNamespaceEndpointsOutput() GetNamespacesNamespaceEndpointsOutput
	ToGetNamespacesNamespaceEndpointsOutputWithContext(context.Context) GetNamespacesNamespaceEndpointsOutput
}

GetNamespacesNamespaceEndpointsInput is an input type that accepts GetNamespacesNamespaceEndpointsArgs and GetNamespacesNamespaceEndpointsOutput values. You can construct a concrete instance of `GetNamespacesNamespaceEndpointsInput` via:

GetNamespacesNamespaceEndpointsArgs{...}

type GetNamespacesNamespaceEndpointsOutput

type GetNamespacesNamespaceEndpointsOutput struct{ *pulumi.OutputState }

func (GetNamespacesNamespaceEndpointsOutput) ElementType

func (GetNamespacesNamespaceEndpointsOutput) GrpcAddress

The gRPC hostport address that the temporal workers, clients and tctl connect to.

func (GetNamespacesNamespaceEndpointsOutput) ToGetNamespacesNamespaceEndpointsOutput

func (o GetNamespacesNamespaceEndpointsOutput) ToGetNamespacesNamespaceEndpointsOutput() GetNamespacesNamespaceEndpointsOutput

func (GetNamespacesNamespaceEndpointsOutput) ToGetNamespacesNamespaceEndpointsOutputWithContext

func (o GetNamespacesNamespaceEndpointsOutput) ToGetNamespacesNamespaceEndpointsOutputWithContext(ctx context.Context) GetNamespacesNamespaceEndpointsOutput

func (GetNamespacesNamespaceEndpointsOutput) WebAddress

The web UI address.

type GetNamespacesNamespaceInput

type GetNamespacesNamespaceInput interface {
	pulumi.Input

	ToGetNamespacesNamespaceOutput() GetNamespacesNamespaceOutput
	ToGetNamespacesNamespaceOutputWithContext(context.Context) GetNamespacesNamespaceOutput
}

GetNamespacesNamespaceInput is an input type that accepts GetNamespacesNamespaceArgs and GetNamespacesNamespaceOutput values. You can construct a concrete instance of `GetNamespacesNamespaceInput` via:

GetNamespacesNamespaceArgs{...}

type GetNamespacesNamespaceLimits

type GetNamespacesNamespaceLimits struct {
	// The number of actions per second (APS) that is currently allowed for the namespace. The namespace may be throttled if its APS exceeds the limit.
	ActionsPerSecondLimit int `pulumi:"actionsPerSecondLimit"`
}

type GetNamespacesNamespaceLimitsArgs

type GetNamespacesNamespaceLimitsArgs struct {
	// The number of actions per second (APS) that is currently allowed for the namespace. The namespace may be throttled if its APS exceeds the limit.
	ActionsPerSecondLimit pulumi.IntInput `pulumi:"actionsPerSecondLimit"`
}

func (GetNamespacesNamespaceLimitsArgs) ElementType

func (GetNamespacesNamespaceLimitsArgs) ToGetNamespacesNamespaceLimitsOutput

func (i GetNamespacesNamespaceLimitsArgs) ToGetNamespacesNamespaceLimitsOutput() GetNamespacesNamespaceLimitsOutput

func (GetNamespacesNamespaceLimitsArgs) ToGetNamespacesNamespaceLimitsOutputWithContext

func (i GetNamespacesNamespaceLimitsArgs) ToGetNamespacesNamespaceLimitsOutputWithContext(ctx context.Context) GetNamespacesNamespaceLimitsOutput

type GetNamespacesNamespaceLimitsInput

type GetNamespacesNamespaceLimitsInput interface {
	pulumi.Input

	ToGetNamespacesNamespaceLimitsOutput() GetNamespacesNamespaceLimitsOutput
	ToGetNamespacesNamespaceLimitsOutputWithContext(context.Context) GetNamespacesNamespaceLimitsOutput
}

GetNamespacesNamespaceLimitsInput is an input type that accepts GetNamespacesNamespaceLimitsArgs and GetNamespacesNamespaceLimitsOutput values. You can construct a concrete instance of `GetNamespacesNamespaceLimitsInput` via:

GetNamespacesNamespaceLimitsArgs{...}

type GetNamespacesNamespaceLimitsOutput

type GetNamespacesNamespaceLimitsOutput struct{ *pulumi.OutputState }

func (GetNamespacesNamespaceLimitsOutput) ActionsPerSecondLimit

func (o GetNamespacesNamespaceLimitsOutput) ActionsPerSecondLimit() pulumi.IntOutput

The number of actions per second (APS) that is currently allowed for the namespace. The namespace may be throttled if its APS exceeds the limit.

func (GetNamespacesNamespaceLimitsOutput) ElementType

func (GetNamespacesNamespaceLimitsOutput) ToGetNamespacesNamespaceLimitsOutput

func (o GetNamespacesNamespaceLimitsOutput) ToGetNamespacesNamespaceLimitsOutput() GetNamespacesNamespaceLimitsOutput

func (GetNamespacesNamespaceLimitsOutput) ToGetNamespacesNamespaceLimitsOutputWithContext

func (o GetNamespacesNamespaceLimitsOutput) ToGetNamespacesNamespaceLimitsOutputWithContext(ctx context.Context) GetNamespacesNamespaceLimitsOutput

type GetNamespacesNamespaceOutput

type GetNamespacesNamespaceOutput struct{ *pulumi.OutputState }

func (GetNamespacesNamespaceOutput) AcceptedClientCa

func (o GetNamespacesNamespaceOutput) AcceptedClientCa() pulumi.StringOutput

The Base64-encoded CA cert in PEM format that clients use when authenticating with Temporal Cloud.

func (GetNamespacesNamespaceOutput) ActiveRegion

The currently active region for the namespace.

func (GetNamespacesNamespaceOutput) ApiKeyAuth

If true, Temporal Cloud will use API key authentication for this namespace. If false, mutual TLS (mTLS) authentication will be used.

func (GetNamespacesNamespaceOutput) CertificateFilters

A list of filters to apply to client certificates when initiating a connection Temporal Cloud. If present, connections will only be allowed from client certificates whose distinguished name properties match at least one of the filters.

func (GetNamespacesNamespaceOutput) CodecServer

A codec server is used by the Temporal Cloud UI to decode payloads for all users interacting with this namespace, even if the workflow history itself is encrypted.

func (GetNamespacesNamespaceOutput) CreatedTime

The date and time when the namespace was created.

func (GetNamespacesNamespaceOutput) CustomSearchAttributes

func (o GetNamespacesNamespaceOutput) CustomSearchAttributes() pulumi.StringMapOutput

The custom search attributes to use for the namespace.

func (GetNamespacesNamespaceOutput) ElementType

func (GetNamespacesNamespaceOutput) Endpoints

The endpoints for the namespace.

func (GetNamespacesNamespaceOutput) Id

The unique identifier of the namespace across all Temporal Cloud tenants.

func (GetNamespacesNamespaceOutput) LastModifiedTime

func (o GetNamespacesNamespaceOutput) LastModifiedTime() pulumi.StringOutput

The date and time when the namespace was last modified. Will not be set if the namespace has never been modified.

func (GetNamespacesNamespaceOutput) Limits

The limits set on the namespace currently.

func (GetNamespacesNamespaceOutput) Name

The name of the namespace.

func (GetNamespacesNamespaceOutput) PrivateConnectivities

The private connectivities for the namespace, if any.

func (GetNamespacesNamespaceOutput) Regions

func (GetNamespacesNamespaceOutput) RetentionDays

func (o GetNamespacesNamespaceOutput) RetentionDays() pulumi.IntOutput

The number of days to retain workflow history. Any changes to the retention period will be applied to all new running workflows.

func (GetNamespacesNamespaceOutput) State

The current state of the namespace.

func (GetNamespacesNamespaceOutput) ToGetNamespacesNamespaceOutput

func (o GetNamespacesNamespaceOutput) ToGetNamespacesNamespaceOutput() GetNamespacesNamespaceOutput

func (GetNamespacesNamespaceOutput) ToGetNamespacesNamespaceOutputWithContext

func (o GetNamespacesNamespaceOutput) ToGetNamespacesNamespaceOutputWithContext(ctx context.Context) GetNamespacesNamespaceOutput

type GetNamespacesNamespacePrivateConnectivity

type GetNamespacesNamespacePrivateConnectivity struct {
	// The AWS PrivateLink info. This will only be set for namespaces whose cloud provider is AWS.
	AwsPrivateLinkInfo GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfo `pulumi:"awsPrivateLinkInfo"`
	// The id of the region where the private connectivity applies.
	Region string `pulumi:"region"`
}

type GetNamespacesNamespacePrivateConnectivityArgs

type GetNamespacesNamespacePrivateConnectivityArgs struct {
	// The AWS PrivateLink info. This will only be set for namespaces whose cloud provider is AWS.
	AwsPrivateLinkInfo GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoInput `pulumi:"awsPrivateLinkInfo"`
	// The id of the region where the private connectivity applies.
	Region pulumi.StringInput `pulumi:"region"`
}

func (GetNamespacesNamespacePrivateConnectivityArgs) ElementType

func (GetNamespacesNamespacePrivateConnectivityArgs) ToGetNamespacesNamespacePrivateConnectivityOutput

func (i GetNamespacesNamespacePrivateConnectivityArgs) ToGetNamespacesNamespacePrivateConnectivityOutput() GetNamespacesNamespacePrivateConnectivityOutput

func (GetNamespacesNamespacePrivateConnectivityArgs) ToGetNamespacesNamespacePrivateConnectivityOutputWithContext

func (i GetNamespacesNamespacePrivateConnectivityArgs) ToGetNamespacesNamespacePrivateConnectivityOutputWithContext(ctx context.Context) GetNamespacesNamespacePrivateConnectivityOutput

type GetNamespacesNamespacePrivateConnectivityArray

type GetNamespacesNamespacePrivateConnectivityArray []GetNamespacesNamespacePrivateConnectivityInput

func (GetNamespacesNamespacePrivateConnectivityArray) ElementType

func (GetNamespacesNamespacePrivateConnectivityArray) ToGetNamespacesNamespacePrivateConnectivityArrayOutput

func (i GetNamespacesNamespacePrivateConnectivityArray) ToGetNamespacesNamespacePrivateConnectivityArrayOutput() GetNamespacesNamespacePrivateConnectivityArrayOutput

func (GetNamespacesNamespacePrivateConnectivityArray) ToGetNamespacesNamespacePrivateConnectivityArrayOutputWithContext

func (i GetNamespacesNamespacePrivateConnectivityArray) ToGetNamespacesNamespacePrivateConnectivityArrayOutputWithContext(ctx context.Context) GetNamespacesNamespacePrivateConnectivityArrayOutput

type GetNamespacesNamespacePrivateConnectivityArrayInput

type GetNamespacesNamespacePrivateConnectivityArrayInput interface {
	pulumi.Input

	ToGetNamespacesNamespacePrivateConnectivityArrayOutput() GetNamespacesNamespacePrivateConnectivityArrayOutput
	ToGetNamespacesNamespacePrivateConnectivityArrayOutputWithContext(context.Context) GetNamespacesNamespacePrivateConnectivityArrayOutput
}

GetNamespacesNamespacePrivateConnectivityArrayInput is an input type that accepts GetNamespacesNamespacePrivateConnectivityArray and GetNamespacesNamespacePrivateConnectivityArrayOutput values. You can construct a concrete instance of `GetNamespacesNamespacePrivateConnectivityArrayInput` via:

GetNamespacesNamespacePrivateConnectivityArray{ GetNamespacesNamespacePrivateConnectivityArgs{...} }

type GetNamespacesNamespacePrivateConnectivityArrayOutput

type GetNamespacesNamespacePrivateConnectivityArrayOutput struct{ *pulumi.OutputState }

func (GetNamespacesNamespacePrivateConnectivityArrayOutput) ElementType

func (GetNamespacesNamespacePrivateConnectivityArrayOutput) Index

func (GetNamespacesNamespacePrivateConnectivityArrayOutput) ToGetNamespacesNamespacePrivateConnectivityArrayOutput

func (GetNamespacesNamespacePrivateConnectivityArrayOutput) ToGetNamespacesNamespacePrivateConnectivityArrayOutputWithContext

func (o GetNamespacesNamespacePrivateConnectivityArrayOutput) ToGetNamespacesNamespacePrivateConnectivityArrayOutputWithContext(ctx context.Context) GetNamespacesNamespacePrivateConnectivityArrayOutput

type GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfo

type GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfo struct {
	// The list of principal arns that are allowed to access the namespace on the private link.
	AllowedPrincipalArns []string `pulumi:"allowedPrincipalArns"`
	// The list of vpc endpoint service names that are associated with the namespace.
	VpcEndpointServiceNames []string `pulumi:"vpcEndpointServiceNames"`
}

type GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoArgs

type GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoArgs struct {
	// The list of principal arns that are allowed to access the namespace on the private link.
	AllowedPrincipalArns pulumi.StringArrayInput `pulumi:"allowedPrincipalArns"`
	// The list of vpc endpoint service names that are associated with the namespace.
	VpcEndpointServiceNames pulumi.StringArrayInput `pulumi:"vpcEndpointServiceNames"`
}

func (GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoArgs) ElementType

func (GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoArgs) ToGetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput

func (GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoArgs) ToGetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutputWithContext

func (i GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoArgs) ToGetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutputWithContext(ctx context.Context) GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput

type GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoInput

type GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoInput interface {
	pulumi.Input

	ToGetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput() GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput
	ToGetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutputWithContext(context.Context) GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput
}

GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoInput is an input type that accepts GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoArgs and GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput values. You can construct a concrete instance of `GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoInput` via:

GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoArgs{...}

type GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput

type GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput struct{ *pulumi.OutputState }

func (GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput) AllowedPrincipalArns

The list of principal arns that are allowed to access the namespace on the private link.

func (GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput) ElementType

func (GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput) ToGetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput

func (GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput) ToGetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutputWithContext

func (o GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput) ToGetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutputWithContext(ctx context.Context) GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput

func (GetNamespacesNamespacePrivateConnectivityAwsPrivateLinkInfoOutput) VpcEndpointServiceNames

The list of vpc endpoint service names that are associated with the namespace.

type GetNamespacesNamespacePrivateConnectivityInput

type GetNamespacesNamespacePrivateConnectivityInput interface {
	pulumi.Input

	ToGetNamespacesNamespacePrivateConnectivityOutput() GetNamespacesNamespacePrivateConnectivityOutput
	ToGetNamespacesNamespacePrivateConnectivityOutputWithContext(context.Context) GetNamespacesNamespacePrivateConnectivityOutput
}

GetNamespacesNamespacePrivateConnectivityInput is an input type that accepts GetNamespacesNamespacePrivateConnectivityArgs and GetNamespacesNamespacePrivateConnectivityOutput values. You can construct a concrete instance of `GetNamespacesNamespacePrivateConnectivityInput` via:

GetNamespacesNamespacePrivateConnectivityArgs{...}

type GetNamespacesNamespacePrivateConnectivityOutput

type GetNamespacesNamespacePrivateConnectivityOutput struct{ *pulumi.OutputState }

func (GetNamespacesNamespacePrivateConnectivityOutput) AwsPrivateLinkInfo

The AWS PrivateLink info. This will only be set for namespaces whose cloud provider is AWS.

func (GetNamespacesNamespacePrivateConnectivityOutput) ElementType

func (GetNamespacesNamespacePrivateConnectivityOutput) Region

The id of the region where the private connectivity applies.

func (GetNamespacesNamespacePrivateConnectivityOutput) ToGetNamespacesNamespacePrivateConnectivityOutput

func (o GetNamespacesNamespacePrivateConnectivityOutput) ToGetNamespacesNamespacePrivateConnectivityOutput() GetNamespacesNamespacePrivateConnectivityOutput

func (GetNamespacesNamespacePrivateConnectivityOutput) ToGetNamespacesNamespacePrivateConnectivityOutputWithContext

func (o GetNamespacesNamespacePrivateConnectivityOutput) ToGetNamespacesNamespacePrivateConnectivityOutputWithContext(ctx context.Context) GetNamespacesNamespacePrivateConnectivityOutput

type GetNamespacesResult

type GetNamespacesResult struct {
	// The ID of this resource.
	Id         string                   `pulumi:"id"`
	Namespaces []GetNamespacesNamespace `pulumi:"namespaces"`
}

A collection of values returned by getNamespaces.

func GetNamespaces

func GetNamespaces(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetNamespacesResult, error)

## Example Usage

```go package main

import (

"github.com/Grip-Security/pulumi-temporalcloud/sdk/go/temporalcloud"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myNamespaces, err := temporalcloud.GetNamespaces(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		ctx.Export("namespaces", myNamespaces.Namespaces)
		return nil
	})
}

```

type GetNamespacesResultOutput

type GetNamespacesResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getNamespaces.

func GetNamespacesOutput

func GetNamespacesOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetNamespacesResultOutput

func (GetNamespacesResultOutput) ElementType

func (GetNamespacesResultOutput) ElementType() reflect.Type

func (GetNamespacesResultOutput) Id

The ID of this resource.

func (GetNamespacesResultOutput) Namespaces

func (GetNamespacesResultOutput) ToGetNamespacesResultOutput

func (o GetNamespacesResultOutput) ToGetNamespacesResultOutput() GetNamespacesResultOutput

func (GetNamespacesResultOutput) ToGetNamespacesResultOutputWithContext

func (o GetNamespacesResultOutput) ToGetNamespacesResultOutputWithContext(ctx context.Context) GetNamespacesResultOutput

type GetRegionsRegion

type GetRegionsRegion struct {
	// The name of the Cloud provider for this region, e.g. `aws`.
	CloudProvider string `pulumi:"cloudProvider"`
	// The name of the region within the Cloud provider, e.g. `us-east-1`.
	CloudProviderRegion string `pulumi:"cloudProviderRegion"`
	// The unique identifier for the region, e.g. `aws-us-east-1`.
	Id string `pulumi:"id"`
	// The physical location of the region, e.g. "US East (N. Virginia)".
	Location string `pulumi:"location"`
}

type GetRegionsRegionArgs

type GetRegionsRegionArgs struct {
	// The name of the Cloud provider for this region, e.g. `aws`.
	CloudProvider pulumi.StringInput `pulumi:"cloudProvider"`
	// The name of the region within the Cloud provider, e.g. `us-east-1`.
	CloudProviderRegion pulumi.StringInput `pulumi:"cloudProviderRegion"`
	// The unique identifier for the region, e.g. `aws-us-east-1`.
	Id pulumi.StringInput `pulumi:"id"`
	// The physical location of the region, e.g. "US East (N. Virginia)".
	Location pulumi.StringInput `pulumi:"location"`
}

func (GetRegionsRegionArgs) ElementType

func (GetRegionsRegionArgs) ElementType() reflect.Type

func (GetRegionsRegionArgs) ToGetRegionsRegionOutput

func (i GetRegionsRegionArgs) ToGetRegionsRegionOutput() GetRegionsRegionOutput

func (GetRegionsRegionArgs) ToGetRegionsRegionOutputWithContext

func (i GetRegionsRegionArgs) ToGetRegionsRegionOutputWithContext(ctx context.Context) GetRegionsRegionOutput

type GetRegionsRegionArray

type GetRegionsRegionArray []GetRegionsRegionInput

func (GetRegionsRegionArray) ElementType

func (GetRegionsRegionArray) ElementType() reflect.Type

func (GetRegionsRegionArray) ToGetRegionsRegionArrayOutput

func (i GetRegionsRegionArray) ToGetRegionsRegionArrayOutput() GetRegionsRegionArrayOutput

func (GetRegionsRegionArray) ToGetRegionsRegionArrayOutputWithContext

func (i GetRegionsRegionArray) ToGetRegionsRegionArrayOutputWithContext(ctx context.Context) GetRegionsRegionArrayOutput

type GetRegionsRegionArrayInput

type GetRegionsRegionArrayInput interface {
	pulumi.Input

	ToGetRegionsRegionArrayOutput() GetRegionsRegionArrayOutput
	ToGetRegionsRegionArrayOutputWithContext(context.Context) GetRegionsRegionArrayOutput
}

GetRegionsRegionArrayInput is an input type that accepts GetRegionsRegionArray and GetRegionsRegionArrayOutput values. You can construct a concrete instance of `GetRegionsRegionArrayInput` via:

GetRegionsRegionArray{ GetRegionsRegionArgs{...} }

type GetRegionsRegionArrayOutput

type GetRegionsRegionArrayOutput struct{ *pulumi.OutputState }

func (GetRegionsRegionArrayOutput) ElementType

func (GetRegionsRegionArrayOutput) Index

func (GetRegionsRegionArrayOutput) ToGetRegionsRegionArrayOutput

func (o GetRegionsRegionArrayOutput) ToGetRegionsRegionArrayOutput() GetRegionsRegionArrayOutput

func (GetRegionsRegionArrayOutput) ToGetRegionsRegionArrayOutputWithContext

func (o GetRegionsRegionArrayOutput) ToGetRegionsRegionArrayOutputWithContext(ctx context.Context) GetRegionsRegionArrayOutput

type GetRegionsRegionInput

type GetRegionsRegionInput interface {
	pulumi.Input

	ToGetRegionsRegionOutput() GetRegionsRegionOutput
	ToGetRegionsRegionOutputWithContext(context.Context) GetRegionsRegionOutput
}

GetRegionsRegionInput is an input type that accepts GetRegionsRegionArgs and GetRegionsRegionOutput values. You can construct a concrete instance of `GetRegionsRegionInput` via:

GetRegionsRegionArgs{...}

type GetRegionsRegionOutput

type GetRegionsRegionOutput struct{ *pulumi.OutputState }

func (GetRegionsRegionOutput) CloudProvider

func (o GetRegionsRegionOutput) CloudProvider() pulumi.StringOutput

The name of the Cloud provider for this region, e.g. `aws`.

func (GetRegionsRegionOutput) CloudProviderRegion

func (o GetRegionsRegionOutput) CloudProviderRegion() pulumi.StringOutput

The name of the region within the Cloud provider, e.g. `us-east-1`.

func (GetRegionsRegionOutput) ElementType

func (GetRegionsRegionOutput) ElementType() reflect.Type

func (GetRegionsRegionOutput) Id

The unique identifier for the region, e.g. `aws-us-east-1`.

func (GetRegionsRegionOutput) Location

The physical location of the region, e.g. "US East (N. Virginia)".

func (GetRegionsRegionOutput) ToGetRegionsRegionOutput

func (o GetRegionsRegionOutput) ToGetRegionsRegionOutput() GetRegionsRegionOutput

func (GetRegionsRegionOutput) ToGetRegionsRegionOutputWithContext

func (o GetRegionsRegionOutput) ToGetRegionsRegionOutputWithContext(ctx context.Context) GetRegionsRegionOutput

type GetRegionsResult

type GetRegionsResult struct {
	// The ID of this resource.
	Id      string             `pulumi:"id"`
	Regions []GetRegionsRegion `pulumi:"regions"`
}

A collection of values returned by getRegions.

func GetRegions

func GetRegions(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetRegionsResult, error)

## Example Usage

```go package main

import (

"github.com/Grip-Security/pulumi-temporalcloud/sdk/go/temporalcloud"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		regions, err := temporalcloud.GetRegions(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		ctx.Export("regions", regions.Regions)
		return nil
	})
}

```

type GetRegionsResultOutput

type GetRegionsResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getRegions.

func GetRegionsOutput

func GetRegionsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetRegionsResultOutput

func (GetRegionsResultOutput) ElementType

func (GetRegionsResultOutput) ElementType() reflect.Type

func (GetRegionsResultOutput) Id

The ID of this resource.

func (GetRegionsResultOutput) Regions

func (GetRegionsResultOutput) ToGetRegionsResultOutput

func (o GetRegionsResultOutput) ToGetRegionsResultOutput() GetRegionsResultOutput

func (GetRegionsResultOutput) ToGetRegionsResultOutputWithContext

func (o GetRegionsResultOutput) ToGetRegionsResultOutputWithContext(ctx context.Context) GetRegionsResultOutput

type GetServiceAccountsResult

type GetServiceAccountsResult struct {
	// The unique identifier of the Service Accounts data source.
	Id string `pulumi:"id"`
	// The list of Service Accounts.
	ServiceAccounts []GetServiceAccountsServiceAccount `pulumi:"serviceAccounts"`
}

A collection of values returned by getServiceAccounts.

func GetServiceAccounts

func GetServiceAccounts(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetServiceAccountsResult, error)

Fetches details about all Service Accounts.

type GetServiceAccountsResultOutput

type GetServiceAccountsResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getServiceAccounts.

func GetServiceAccountsOutput

func GetServiceAccountsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetServiceAccountsResultOutput

func (GetServiceAccountsResultOutput) ElementType

func (GetServiceAccountsResultOutput) Id

The unique identifier of the Service Accounts data source.

func (GetServiceAccountsResultOutput) ServiceAccounts

The list of Service Accounts.

func (GetServiceAccountsResultOutput) ToGetServiceAccountsResultOutput

func (o GetServiceAccountsResultOutput) ToGetServiceAccountsResultOutput() GetServiceAccountsResultOutput

func (GetServiceAccountsResultOutput) ToGetServiceAccountsResultOutputWithContext

func (o GetServiceAccountsResultOutput) ToGetServiceAccountsResultOutputWithContext(ctx context.Context) GetServiceAccountsResultOutput

type GetServiceAccountsServiceAccount

type GetServiceAccountsServiceAccount struct {
	// The role on the account. Must be one of admin, developer, or read (case-insensitive).
	AccountAccess string `pulumi:"accountAccess"`
	// The creation time of the Service Account.
	CreatedAt string `pulumi:"createdAt"`
	// The description of the Service Account.
	Description string `pulumi:"description"`
	// The unique identifier of the Service Account.
	Id string `pulumi:"id"`
	// The name associated with the service account.
	Name string `pulumi:"name"`
	// The set of namespace permissions for this service account, including each namespace and its role.
	NamespaceAccesses []GetServiceAccountsServiceAccountNamespaceAccess `pulumi:"namespaceAccesses"`
	// The current state of the Service Account.
	State string `pulumi:"state"`
	// The last update time of the Service Account.
	UpdatedAt string `pulumi:"updatedAt"`
}

type GetServiceAccountsServiceAccountArgs

type GetServiceAccountsServiceAccountArgs struct {
	// The role on the account. Must be one of admin, developer, or read (case-insensitive).
	AccountAccess pulumi.StringInput `pulumi:"accountAccess"`
	// The creation time of the Service Account.
	CreatedAt pulumi.StringInput `pulumi:"createdAt"`
	// The description of the Service Account.
	Description pulumi.StringInput `pulumi:"description"`
	// The unique identifier of the Service Account.
	Id pulumi.StringInput `pulumi:"id"`
	// The name associated with the service account.
	Name pulumi.StringInput `pulumi:"name"`
	// The set of namespace permissions for this service account, including each namespace and its role.
	NamespaceAccesses GetServiceAccountsServiceAccountNamespaceAccessArrayInput `pulumi:"namespaceAccesses"`
	// The current state of the Service Account.
	State pulumi.StringInput `pulumi:"state"`
	// The last update time of the Service Account.
	UpdatedAt pulumi.StringInput `pulumi:"updatedAt"`
}

func (GetServiceAccountsServiceAccountArgs) ElementType

func (GetServiceAccountsServiceAccountArgs) ToGetServiceAccountsServiceAccountOutput

func (i GetServiceAccountsServiceAccountArgs) ToGetServiceAccountsServiceAccountOutput() GetServiceAccountsServiceAccountOutput

func (GetServiceAccountsServiceAccountArgs) ToGetServiceAccountsServiceAccountOutputWithContext

func (i GetServiceAccountsServiceAccountArgs) ToGetServiceAccountsServiceAccountOutputWithContext(ctx context.Context) GetServiceAccountsServiceAccountOutput

type GetServiceAccountsServiceAccountArray

type GetServiceAccountsServiceAccountArray []GetServiceAccountsServiceAccountInput

func (GetServiceAccountsServiceAccountArray) ElementType

func (GetServiceAccountsServiceAccountArray) ToGetServiceAccountsServiceAccountArrayOutput

func (i GetServiceAccountsServiceAccountArray) ToGetServiceAccountsServiceAccountArrayOutput() GetServiceAccountsServiceAccountArrayOutput

func (GetServiceAccountsServiceAccountArray) ToGetServiceAccountsServiceAccountArrayOutputWithContext

func (i GetServiceAccountsServiceAccountArray) ToGetServiceAccountsServiceAccountArrayOutputWithContext(ctx context.Context) GetServiceAccountsServiceAccountArrayOutput

type GetServiceAccountsServiceAccountArrayInput

type GetServiceAccountsServiceAccountArrayInput interface {
	pulumi.Input

	ToGetServiceAccountsServiceAccountArrayOutput() GetServiceAccountsServiceAccountArrayOutput
	ToGetServiceAccountsServiceAccountArrayOutputWithContext(context.Context) GetServiceAccountsServiceAccountArrayOutput
}

GetServiceAccountsServiceAccountArrayInput is an input type that accepts GetServiceAccountsServiceAccountArray and GetServiceAccountsServiceAccountArrayOutput values. You can construct a concrete instance of `GetServiceAccountsServiceAccountArrayInput` via:

GetServiceAccountsServiceAccountArray{ GetServiceAccountsServiceAccountArgs{...} }

type GetServiceAccountsServiceAccountArrayOutput

type GetServiceAccountsServiceAccountArrayOutput struct{ *pulumi.OutputState }

func (GetServiceAccountsServiceAccountArrayOutput) ElementType

func (GetServiceAccountsServiceAccountArrayOutput) Index

func (GetServiceAccountsServiceAccountArrayOutput) ToGetServiceAccountsServiceAccountArrayOutput

func (o GetServiceAccountsServiceAccountArrayOutput) ToGetServiceAccountsServiceAccountArrayOutput() GetServiceAccountsServiceAccountArrayOutput

func (GetServiceAccountsServiceAccountArrayOutput) ToGetServiceAccountsServiceAccountArrayOutputWithContext

func (o GetServiceAccountsServiceAccountArrayOutput) ToGetServiceAccountsServiceAccountArrayOutputWithContext(ctx context.Context) GetServiceAccountsServiceAccountArrayOutput

type GetServiceAccountsServiceAccountInput

type GetServiceAccountsServiceAccountInput interface {
	pulumi.Input

	ToGetServiceAccountsServiceAccountOutput() GetServiceAccountsServiceAccountOutput
	ToGetServiceAccountsServiceAccountOutputWithContext(context.Context) GetServiceAccountsServiceAccountOutput
}

GetServiceAccountsServiceAccountInput is an input type that accepts GetServiceAccountsServiceAccountArgs and GetServiceAccountsServiceAccountOutput values. You can construct a concrete instance of `GetServiceAccountsServiceAccountInput` via:

GetServiceAccountsServiceAccountArgs{...}

type GetServiceAccountsServiceAccountNamespaceAccess

type GetServiceAccountsServiceAccountNamespaceAccess struct {
	// The namespace to assign permissions to.
	NamespaceId string `pulumi:"namespaceId"`
	// The permission to assign. Must be one of admin, write, or read (case-insensitive)
	Permission string `pulumi:"permission"`
}

type GetServiceAccountsServiceAccountNamespaceAccessArgs

type GetServiceAccountsServiceAccountNamespaceAccessArgs struct {
	// The namespace to assign permissions to.
	NamespaceId pulumi.StringInput `pulumi:"namespaceId"`
	// The permission to assign. Must be one of admin, write, or read (case-insensitive)
	Permission pulumi.StringInput `pulumi:"permission"`
}

func (GetServiceAccountsServiceAccountNamespaceAccessArgs) ElementType

func (GetServiceAccountsServiceAccountNamespaceAccessArgs) ToGetServiceAccountsServiceAccountNamespaceAccessOutput

func (i GetServiceAccountsServiceAccountNamespaceAccessArgs) ToGetServiceAccountsServiceAccountNamespaceAccessOutput() GetServiceAccountsServiceAccountNamespaceAccessOutput

func (GetServiceAccountsServiceAccountNamespaceAccessArgs) ToGetServiceAccountsServiceAccountNamespaceAccessOutputWithContext

func (i GetServiceAccountsServiceAccountNamespaceAccessArgs) ToGetServiceAccountsServiceAccountNamespaceAccessOutputWithContext(ctx context.Context) GetServiceAccountsServiceAccountNamespaceAccessOutput

type GetServiceAccountsServiceAccountNamespaceAccessArray

type GetServiceAccountsServiceAccountNamespaceAccessArray []GetServiceAccountsServiceAccountNamespaceAccessInput

func (GetServiceAccountsServiceAccountNamespaceAccessArray) ElementType

func (GetServiceAccountsServiceAccountNamespaceAccessArray) ToGetServiceAccountsServiceAccountNamespaceAccessArrayOutput

func (i GetServiceAccountsServiceAccountNamespaceAccessArray) ToGetServiceAccountsServiceAccountNamespaceAccessArrayOutput() GetServiceAccountsServiceAccountNamespaceAccessArrayOutput

func (GetServiceAccountsServiceAccountNamespaceAccessArray) ToGetServiceAccountsServiceAccountNamespaceAccessArrayOutputWithContext

func (i GetServiceAccountsServiceAccountNamespaceAccessArray) ToGetServiceAccountsServiceAccountNamespaceAccessArrayOutputWithContext(ctx context.Context) GetServiceAccountsServiceAccountNamespaceAccessArrayOutput

type GetServiceAccountsServiceAccountNamespaceAccessArrayInput

type GetServiceAccountsServiceAccountNamespaceAccessArrayInput interface {
	pulumi.Input

	ToGetServiceAccountsServiceAccountNamespaceAccessArrayOutput() GetServiceAccountsServiceAccountNamespaceAccessArrayOutput
	ToGetServiceAccountsServiceAccountNamespaceAccessArrayOutputWithContext(context.Context) GetServiceAccountsServiceAccountNamespaceAccessArrayOutput
}

GetServiceAccountsServiceAccountNamespaceAccessArrayInput is an input type that accepts GetServiceAccountsServiceAccountNamespaceAccessArray and GetServiceAccountsServiceAccountNamespaceAccessArrayOutput values. You can construct a concrete instance of `GetServiceAccountsServiceAccountNamespaceAccessArrayInput` via:

GetServiceAccountsServiceAccountNamespaceAccessArray{ GetServiceAccountsServiceAccountNamespaceAccessArgs{...} }

type GetServiceAccountsServiceAccountNamespaceAccessArrayOutput

type GetServiceAccountsServiceAccountNamespaceAccessArrayOutput struct{ *pulumi.OutputState }

func (GetServiceAccountsServiceAccountNamespaceAccessArrayOutput) ElementType

func (GetServiceAccountsServiceAccountNamespaceAccessArrayOutput) Index

func (GetServiceAccountsServiceAccountNamespaceAccessArrayOutput) ToGetServiceAccountsServiceAccountNamespaceAccessArrayOutput

func (GetServiceAccountsServiceAccountNamespaceAccessArrayOutput) ToGetServiceAccountsServiceAccountNamespaceAccessArrayOutputWithContext

func (o GetServiceAccountsServiceAccountNamespaceAccessArrayOutput) ToGetServiceAccountsServiceAccountNamespaceAccessArrayOutputWithContext(ctx context.Context) GetServiceAccountsServiceAccountNamespaceAccessArrayOutput

type GetServiceAccountsServiceAccountNamespaceAccessInput

type GetServiceAccountsServiceAccountNamespaceAccessInput interface {
	pulumi.Input

	ToGetServiceAccountsServiceAccountNamespaceAccessOutput() GetServiceAccountsServiceAccountNamespaceAccessOutput
	ToGetServiceAccountsServiceAccountNamespaceAccessOutputWithContext(context.Context) GetServiceAccountsServiceAccountNamespaceAccessOutput
}

GetServiceAccountsServiceAccountNamespaceAccessInput is an input type that accepts GetServiceAccountsServiceAccountNamespaceAccessArgs and GetServiceAccountsServiceAccountNamespaceAccessOutput values. You can construct a concrete instance of `GetServiceAccountsServiceAccountNamespaceAccessInput` via:

GetServiceAccountsServiceAccountNamespaceAccessArgs{...}

type GetServiceAccountsServiceAccountNamespaceAccessOutput

type GetServiceAccountsServiceAccountNamespaceAccessOutput struct{ *pulumi.OutputState }

func (GetServiceAccountsServiceAccountNamespaceAccessOutput) ElementType

func (GetServiceAccountsServiceAccountNamespaceAccessOutput) NamespaceId

The namespace to assign permissions to.

func (GetServiceAccountsServiceAccountNamespaceAccessOutput) Permission

The permission to assign. Must be one of admin, write, or read (case-insensitive)

func (GetServiceAccountsServiceAccountNamespaceAccessOutput) ToGetServiceAccountsServiceAccountNamespaceAccessOutput

func (GetServiceAccountsServiceAccountNamespaceAccessOutput) ToGetServiceAccountsServiceAccountNamespaceAccessOutputWithContext

func (o GetServiceAccountsServiceAccountNamespaceAccessOutput) ToGetServiceAccountsServiceAccountNamespaceAccessOutputWithContext(ctx context.Context) GetServiceAccountsServiceAccountNamespaceAccessOutput

type GetServiceAccountsServiceAccountOutput

type GetServiceAccountsServiceAccountOutput struct{ *pulumi.OutputState }

func (GetServiceAccountsServiceAccountOutput) AccountAccess

The role on the account. Must be one of admin, developer, or read (case-insensitive).

func (GetServiceAccountsServiceAccountOutput) CreatedAt

The creation time of the Service Account.

func (GetServiceAccountsServiceAccountOutput) Description

The description of the Service Account.

func (GetServiceAccountsServiceAccountOutput) ElementType

func (GetServiceAccountsServiceAccountOutput) Id

The unique identifier of the Service Account.

func (GetServiceAccountsServiceAccountOutput) Name

The name associated with the service account.

func (GetServiceAccountsServiceAccountOutput) NamespaceAccesses

The set of namespace permissions for this service account, including each namespace and its role.

func (GetServiceAccountsServiceAccountOutput) State

The current state of the Service Account.

func (GetServiceAccountsServiceAccountOutput) ToGetServiceAccountsServiceAccountOutput

func (o GetServiceAccountsServiceAccountOutput) ToGetServiceAccountsServiceAccountOutput() GetServiceAccountsServiceAccountOutput

func (GetServiceAccountsServiceAccountOutput) ToGetServiceAccountsServiceAccountOutputWithContext

func (o GetServiceAccountsServiceAccountOutput) ToGetServiceAccountsServiceAccountOutputWithContext(ctx context.Context) GetServiceAccountsServiceAccountOutput

func (GetServiceAccountsServiceAccountOutput) UpdatedAt

The last update time of the Service Account.

type MetricsEndpoint

type MetricsEndpoint struct {
	pulumi.CustomResourceState

	// The Base64-encoded CA cert in PEM format used to authenticate clients connecting to the metrics endpoint.
	AcceptedClientCa pulumi.StringOutput              `pulumi:"acceptedClientCa"`
	Timeouts         MetricsEndpointTimeoutsPtrOutput `pulumi:"timeouts"`
	// The Prometheus metrics endpoint URI
	Uri pulumi.StringOutput `pulumi:"uri"`
}

Configures a Temporal Cloud account's metrics

## Import

```sh $ pulumi import temporalcloud:index/metricsEndpoint:MetricsEndpoint terraform terraform.account-11111-metrics ```

func GetMetricsEndpoint

func GetMetricsEndpoint(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *MetricsEndpointState, opts ...pulumi.ResourceOption) (*MetricsEndpoint, error)

GetMetricsEndpoint gets an existing MetricsEndpoint 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 NewMetricsEndpoint

func NewMetricsEndpoint(ctx *pulumi.Context,
	name string, args *MetricsEndpointArgs, opts ...pulumi.ResourceOption) (*MetricsEndpoint, error)

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

func (*MetricsEndpoint) ElementType

func (*MetricsEndpoint) ElementType() reflect.Type

func (*MetricsEndpoint) ToMetricsEndpointOutput

func (i *MetricsEndpoint) ToMetricsEndpointOutput() MetricsEndpointOutput

func (*MetricsEndpoint) ToMetricsEndpointOutputWithContext

func (i *MetricsEndpoint) ToMetricsEndpointOutputWithContext(ctx context.Context) MetricsEndpointOutput

type MetricsEndpointArgs

type MetricsEndpointArgs struct {
	// The Base64-encoded CA cert in PEM format used to authenticate clients connecting to the metrics endpoint.
	AcceptedClientCa pulumi.StringInput
	Timeouts         MetricsEndpointTimeoutsPtrInput
}

The set of arguments for constructing a MetricsEndpoint resource.

func (MetricsEndpointArgs) ElementType

func (MetricsEndpointArgs) ElementType() reflect.Type

type MetricsEndpointArray

type MetricsEndpointArray []MetricsEndpointInput

func (MetricsEndpointArray) ElementType

func (MetricsEndpointArray) ElementType() reflect.Type

func (MetricsEndpointArray) ToMetricsEndpointArrayOutput

func (i MetricsEndpointArray) ToMetricsEndpointArrayOutput() MetricsEndpointArrayOutput

func (MetricsEndpointArray) ToMetricsEndpointArrayOutputWithContext

func (i MetricsEndpointArray) ToMetricsEndpointArrayOutputWithContext(ctx context.Context) MetricsEndpointArrayOutput

type MetricsEndpointArrayInput

type MetricsEndpointArrayInput interface {
	pulumi.Input

	ToMetricsEndpointArrayOutput() MetricsEndpointArrayOutput
	ToMetricsEndpointArrayOutputWithContext(context.Context) MetricsEndpointArrayOutput
}

MetricsEndpointArrayInput is an input type that accepts MetricsEndpointArray and MetricsEndpointArrayOutput values. You can construct a concrete instance of `MetricsEndpointArrayInput` via:

MetricsEndpointArray{ MetricsEndpointArgs{...} }

type MetricsEndpointArrayOutput

type MetricsEndpointArrayOutput struct{ *pulumi.OutputState }

func (MetricsEndpointArrayOutput) ElementType

func (MetricsEndpointArrayOutput) ElementType() reflect.Type

func (MetricsEndpointArrayOutput) Index

func (MetricsEndpointArrayOutput) ToMetricsEndpointArrayOutput

func (o MetricsEndpointArrayOutput) ToMetricsEndpointArrayOutput() MetricsEndpointArrayOutput

func (MetricsEndpointArrayOutput) ToMetricsEndpointArrayOutputWithContext

func (o MetricsEndpointArrayOutput) ToMetricsEndpointArrayOutputWithContext(ctx context.Context) MetricsEndpointArrayOutput

type MetricsEndpointInput

type MetricsEndpointInput interface {
	pulumi.Input

	ToMetricsEndpointOutput() MetricsEndpointOutput
	ToMetricsEndpointOutputWithContext(ctx context.Context) MetricsEndpointOutput
}

type MetricsEndpointMap

type MetricsEndpointMap map[string]MetricsEndpointInput

func (MetricsEndpointMap) ElementType

func (MetricsEndpointMap) ElementType() reflect.Type

func (MetricsEndpointMap) ToMetricsEndpointMapOutput

func (i MetricsEndpointMap) ToMetricsEndpointMapOutput() MetricsEndpointMapOutput

func (MetricsEndpointMap) ToMetricsEndpointMapOutputWithContext

func (i MetricsEndpointMap) ToMetricsEndpointMapOutputWithContext(ctx context.Context) MetricsEndpointMapOutput

type MetricsEndpointMapInput

type MetricsEndpointMapInput interface {
	pulumi.Input

	ToMetricsEndpointMapOutput() MetricsEndpointMapOutput
	ToMetricsEndpointMapOutputWithContext(context.Context) MetricsEndpointMapOutput
}

MetricsEndpointMapInput is an input type that accepts MetricsEndpointMap and MetricsEndpointMapOutput values. You can construct a concrete instance of `MetricsEndpointMapInput` via:

MetricsEndpointMap{ "key": MetricsEndpointArgs{...} }

type MetricsEndpointMapOutput

type MetricsEndpointMapOutput struct{ *pulumi.OutputState }

func (MetricsEndpointMapOutput) ElementType

func (MetricsEndpointMapOutput) ElementType() reflect.Type

func (MetricsEndpointMapOutput) MapIndex

func (MetricsEndpointMapOutput) ToMetricsEndpointMapOutput

func (o MetricsEndpointMapOutput) ToMetricsEndpointMapOutput() MetricsEndpointMapOutput

func (MetricsEndpointMapOutput) ToMetricsEndpointMapOutputWithContext

func (o MetricsEndpointMapOutput) ToMetricsEndpointMapOutputWithContext(ctx context.Context) MetricsEndpointMapOutput

type MetricsEndpointOutput

type MetricsEndpointOutput struct{ *pulumi.OutputState }

func (MetricsEndpointOutput) AcceptedClientCa

func (o MetricsEndpointOutput) AcceptedClientCa() pulumi.StringOutput

The Base64-encoded CA cert in PEM format used to authenticate clients connecting to the metrics endpoint.

func (MetricsEndpointOutput) ElementType

func (MetricsEndpointOutput) ElementType() reflect.Type

func (MetricsEndpointOutput) Timeouts

func (MetricsEndpointOutput) ToMetricsEndpointOutput

func (o MetricsEndpointOutput) ToMetricsEndpointOutput() MetricsEndpointOutput

func (MetricsEndpointOutput) ToMetricsEndpointOutputWithContext

func (o MetricsEndpointOutput) ToMetricsEndpointOutputWithContext(ctx context.Context) MetricsEndpointOutput

func (MetricsEndpointOutput) Uri

The Prometheus metrics endpoint URI

type MetricsEndpointState

type MetricsEndpointState struct {
	// The Base64-encoded CA cert in PEM format used to authenticate clients connecting to the metrics endpoint.
	AcceptedClientCa pulumi.StringPtrInput
	Timeouts         MetricsEndpointTimeoutsPtrInput
	// The Prometheus metrics endpoint URI
	Uri pulumi.StringPtrInput
}

func (MetricsEndpointState) ElementType

func (MetricsEndpointState) ElementType() reflect.Type

type MetricsEndpointTimeouts

type MetricsEndpointTimeouts 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"`
	// 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).
	Update *string `pulumi:"update"`
}

type MetricsEndpointTimeoutsArgs

type MetricsEndpointTimeoutsArgs 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"`
	// 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).
	Update pulumi.StringPtrInput `pulumi:"update"`
}

func (MetricsEndpointTimeoutsArgs) ElementType

func (MetricsEndpointTimeoutsArgs) ToMetricsEndpointTimeoutsOutput

func (i MetricsEndpointTimeoutsArgs) ToMetricsEndpointTimeoutsOutput() MetricsEndpointTimeoutsOutput

func (MetricsEndpointTimeoutsArgs) ToMetricsEndpointTimeoutsOutputWithContext

func (i MetricsEndpointTimeoutsArgs) ToMetricsEndpointTimeoutsOutputWithContext(ctx context.Context) MetricsEndpointTimeoutsOutput

func (MetricsEndpointTimeoutsArgs) ToMetricsEndpointTimeoutsPtrOutput

func (i MetricsEndpointTimeoutsArgs) ToMetricsEndpointTimeoutsPtrOutput() MetricsEndpointTimeoutsPtrOutput

func (MetricsEndpointTimeoutsArgs) ToMetricsEndpointTimeoutsPtrOutputWithContext

func (i MetricsEndpointTimeoutsArgs) ToMetricsEndpointTimeoutsPtrOutputWithContext(ctx context.Context) MetricsEndpointTimeoutsPtrOutput

type MetricsEndpointTimeoutsInput

type MetricsEndpointTimeoutsInput interface {
	pulumi.Input

	ToMetricsEndpointTimeoutsOutput() MetricsEndpointTimeoutsOutput
	ToMetricsEndpointTimeoutsOutputWithContext(context.Context) MetricsEndpointTimeoutsOutput
}

MetricsEndpointTimeoutsInput is an input type that accepts MetricsEndpointTimeoutsArgs and MetricsEndpointTimeoutsOutput values. You can construct a concrete instance of `MetricsEndpointTimeoutsInput` via:

MetricsEndpointTimeoutsArgs{...}

type MetricsEndpointTimeoutsOutput

type MetricsEndpointTimeoutsOutput struct{ *pulumi.OutputState }

func (MetricsEndpointTimeoutsOutput) 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 (MetricsEndpointTimeoutsOutput) 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 (MetricsEndpointTimeoutsOutput) ElementType

func (MetricsEndpointTimeoutsOutput) ToMetricsEndpointTimeoutsOutput

func (o MetricsEndpointTimeoutsOutput) ToMetricsEndpointTimeoutsOutput() MetricsEndpointTimeoutsOutput

func (MetricsEndpointTimeoutsOutput) ToMetricsEndpointTimeoutsOutputWithContext

func (o MetricsEndpointTimeoutsOutput) ToMetricsEndpointTimeoutsOutputWithContext(ctx context.Context) MetricsEndpointTimeoutsOutput

func (MetricsEndpointTimeoutsOutput) ToMetricsEndpointTimeoutsPtrOutput

func (o MetricsEndpointTimeoutsOutput) ToMetricsEndpointTimeoutsPtrOutput() MetricsEndpointTimeoutsPtrOutput

func (MetricsEndpointTimeoutsOutput) ToMetricsEndpointTimeoutsPtrOutputWithContext

func (o MetricsEndpointTimeoutsOutput) ToMetricsEndpointTimeoutsPtrOutputWithContext(ctx context.Context) MetricsEndpointTimeoutsPtrOutput

func (MetricsEndpointTimeoutsOutput) Update

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).

type MetricsEndpointTimeoutsPtrInput

type MetricsEndpointTimeoutsPtrInput interface {
	pulumi.Input

	ToMetricsEndpointTimeoutsPtrOutput() MetricsEndpointTimeoutsPtrOutput
	ToMetricsEndpointTimeoutsPtrOutputWithContext(context.Context) MetricsEndpointTimeoutsPtrOutput
}

MetricsEndpointTimeoutsPtrInput is an input type that accepts MetricsEndpointTimeoutsArgs, MetricsEndpointTimeoutsPtr and MetricsEndpointTimeoutsPtrOutput values. You can construct a concrete instance of `MetricsEndpointTimeoutsPtrInput` via:

        MetricsEndpointTimeoutsArgs{...}

or:

        nil

type MetricsEndpointTimeoutsPtrOutput

type MetricsEndpointTimeoutsPtrOutput struct{ *pulumi.OutputState }

func (MetricsEndpointTimeoutsPtrOutput) 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 (MetricsEndpointTimeoutsPtrOutput) 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 (MetricsEndpointTimeoutsPtrOutput) Elem

func (MetricsEndpointTimeoutsPtrOutput) ElementType

func (MetricsEndpointTimeoutsPtrOutput) ToMetricsEndpointTimeoutsPtrOutput

func (o MetricsEndpointTimeoutsPtrOutput) ToMetricsEndpointTimeoutsPtrOutput() MetricsEndpointTimeoutsPtrOutput

func (MetricsEndpointTimeoutsPtrOutput) ToMetricsEndpointTimeoutsPtrOutputWithContext

func (o MetricsEndpointTimeoutsPtrOutput) ToMetricsEndpointTimeoutsPtrOutputWithContext(ctx context.Context) MetricsEndpointTimeoutsPtrOutput

func (MetricsEndpointTimeoutsPtrOutput) Update

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).

type Namespace

type Namespace struct {
	pulumi.CustomResourceState

	// The Base64-encoded CA cert in PEM format that clients use when authenticating with Temporal Cloud. This is a required field when a Namespace uses mTLS authentication.
	AcceptedClientCa pulumi.StringPtrOutput `pulumi:"acceptedClientCa"`
	// If true, Temporal Cloud will use API key authentication for this namespace. If false, mutual TLS (mTLS) authentication will be used.
	ApiKeyAuth pulumi.BoolOutput `pulumi:"apiKeyAuth"`
	// A list of filters to apply to client certificates when initiating a connection Temporal Cloud. If present, connections will only be allowed from client certificates whose distinguished name properties match at least one of the filters. Empty lists are not allowed, omit the attribute instead.
	CertificateFilters NamespaceCertificateFilterArrayOutput `pulumi:"certificateFilters"`
	// A codec server is used by the Temporal Cloud UI to decode payloads for all users interacting with this namespace, even if the workflow history itself is encrypted.
	CodecServer NamespaceCodecServerPtrOutput `pulumi:"codecServer"`
	// The endpoints for the namespace.
	Endpoints NamespaceEndpointsOutput `pulumi:"endpoints"`
	// The name of the namespace.
	Name    pulumi.StringOutput      `pulumi:"name"`
	Regions pulumi.StringArrayOutput `pulumi:"regions"`
	// The number of days to retain workflow history. Any changes to the retention period will be applied to all new running workflows.
	RetentionDays pulumi.IntOutput           `pulumi:"retentionDays"`
	Timeouts      NamespaceTimeoutsPtrOutput `pulumi:"timeouts"`
}

Provisions a Temporal Cloud namespace.

## Import

Namespace can be imported to incorporate existing Namespaces into your Terraform pipeline.

To import a Namespace, you need

- a resource configuration in your Terraform configuration file/module to accept the imported Namespace. In the example below, the placeholder is "temporalcloud_namespace" "terraform"

- the Namespace ID, which includes the Namespace Name and Account ID available at the top of the Namespace's page in the Temporal Cloud UI. In the example below, this is namespaceid.acctid

```sh $ pulumi import temporalcloud:index/namespace:Namespace terraform namespaceid.acctid ```

func GetNamespace

func GetNamespace(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *NamespaceState, opts ...pulumi.ResourceOption) (*Namespace, error)

GetNamespace gets an existing Namespace 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 NewNamespace

func NewNamespace(ctx *pulumi.Context,
	name string, args *NamespaceArgs, opts ...pulumi.ResourceOption) (*Namespace, error)

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

func (*Namespace) ElementType

func (*Namespace) ElementType() reflect.Type

func (*Namespace) ToNamespaceOutput

func (i *Namespace) ToNamespaceOutput() NamespaceOutput

func (*Namespace) ToNamespaceOutputWithContext

func (i *Namespace) ToNamespaceOutputWithContext(ctx context.Context) NamespaceOutput

type NamespaceArgs

type NamespaceArgs struct {
	// The Base64-encoded CA cert in PEM format that clients use when authenticating with Temporal Cloud. This is a required field when a Namespace uses mTLS authentication.
	AcceptedClientCa pulumi.StringPtrInput
	// If true, Temporal Cloud will use API key authentication for this namespace. If false, mutual TLS (mTLS) authentication will be used.
	ApiKeyAuth pulumi.BoolPtrInput
	// A list of filters to apply to client certificates when initiating a connection Temporal Cloud. If present, connections will only be allowed from client certificates whose distinguished name properties match at least one of the filters. Empty lists are not allowed, omit the attribute instead.
	CertificateFilters NamespaceCertificateFilterArrayInput
	// A codec server is used by the Temporal Cloud UI to decode payloads for all users interacting with this namespace, even if the workflow history itself is encrypted.
	CodecServer NamespaceCodecServerPtrInput
	// The name of the namespace.
	Name    pulumi.StringPtrInput
	Regions pulumi.StringArrayInput
	// The number of days to retain workflow history. Any changes to the retention period will be applied to all new running workflows.
	RetentionDays pulumi.IntInput
	Timeouts      NamespaceTimeoutsPtrInput
}

The set of arguments for constructing a Namespace resource.

func (NamespaceArgs) ElementType

func (NamespaceArgs) ElementType() reflect.Type

type NamespaceArray

type NamespaceArray []NamespaceInput

func (NamespaceArray) ElementType

func (NamespaceArray) ElementType() reflect.Type

func (NamespaceArray) ToNamespaceArrayOutput

func (i NamespaceArray) ToNamespaceArrayOutput() NamespaceArrayOutput

func (NamespaceArray) ToNamespaceArrayOutputWithContext

func (i NamespaceArray) ToNamespaceArrayOutputWithContext(ctx context.Context) NamespaceArrayOutput

type NamespaceArrayInput

type NamespaceArrayInput interface {
	pulumi.Input

	ToNamespaceArrayOutput() NamespaceArrayOutput
	ToNamespaceArrayOutputWithContext(context.Context) NamespaceArrayOutput
}

NamespaceArrayInput is an input type that accepts NamespaceArray and NamespaceArrayOutput values. You can construct a concrete instance of `NamespaceArrayInput` via:

NamespaceArray{ NamespaceArgs{...} }

type NamespaceArrayOutput

type NamespaceArrayOutput struct{ *pulumi.OutputState }

func (NamespaceArrayOutput) ElementType

func (NamespaceArrayOutput) ElementType() reflect.Type

func (NamespaceArrayOutput) Index

func (NamespaceArrayOutput) ToNamespaceArrayOutput

func (o NamespaceArrayOutput) ToNamespaceArrayOutput() NamespaceArrayOutput

func (NamespaceArrayOutput) ToNamespaceArrayOutputWithContext

func (o NamespaceArrayOutput) ToNamespaceArrayOutputWithContext(ctx context.Context) NamespaceArrayOutput

type NamespaceCertificateFilter

type NamespaceCertificateFilter struct {
	// The certificate's common name.
	CommonName *string `pulumi:"commonName"`
	// The certificate's organization.
	Organization *string `pulumi:"organization"`
	// The certificate's organizational unit.
	OrganizationalUnit *string `pulumi:"organizationalUnit"`
	// The certificate's subject alternative name (or SAN).
	SubjectAlternativeName *string `pulumi:"subjectAlternativeName"`
}

type NamespaceCertificateFilterArgs

type NamespaceCertificateFilterArgs struct {
	// The certificate's common name.
	CommonName pulumi.StringPtrInput `pulumi:"commonName"`
	// The certificate's organization.
	Organization pulumi.StringPtrInput `pulumi:"organization"`
	// The certificate's organizational unit.
	OrganizationalUnit pulumi.StringPtrInput `pulumi:"organizationalUnit"`
	// The certificate's subject alternative name (or SAN).
	SubjectAlternativeName pulumi.StringPtrInput `pulumi:"subjectAlternativeName"`
}

func (NamespaceCertificateFilterArgs) ElementType

func (NamespaceCertificateFilterArgs) ToNamespaceCertificateFilterOutput

func (i NamespaceCertificateFilterArgs) ToNamespaceCertificateFilterOutput() NamespaceCertificateFilterOutput

func (NamespaceCertificateFilterArgs) ToNamespaceCertificateFilterOutputWithContext

func (i NamespaceCertificateFilterArgs) ToNamespaceCertificateFilterOutputWithContext(ctx context.Context) NamespaceCertificateFilterOutput

type NamespaceCertificateFilterArray

type NamespaceCertificateFilterArray []NamespaceCertificateFilterInput

func (NamespaceCertificateFilterArray) ElementType

func (NamespaceCertificateFilterArray) ToNamespaceCertificateFilterArrayOutput

func (i NamespaceCertificateFilterArray) ToNamespaceCertificateFilterArrayOutput() NamespaceCertificateFilterArrayOutput

func (NamespaceCertificateFilterArray) ToNamespaceCertificateFilterArrayOutputWithContext

func (i NamespaceCertificateFilterArray) ToNamespaceCertificateFilterArrayOutputWithContext(ctx context.Context) NamespaceCertificateFilterArrayOutput

type NamespaceCertificateFilterArrayInput

type NamespaceCertificateFilterArrayInput interface {
	pulumi.Input

	ToNamespaceCertificateFilterArrayOutput() NamespaceCertificateFilterArrayOutput
	ToNamespaceCertificateFilterArrayOutputWithContext(context.Context) NamespaceCertificateFilterArrayOutput
}

NamespaceCertificateFilterArrayInput is an input type that accepts NamespaceCertificateFilterArray and NamespaceCertificateFilterArrayOutput values. You can construct a concrete instance of `NamespaceCertificateFilterArrayInput` via:

NamespaceCertificateFilterArray{ NamespaceCertificateFilterArgs{...} }

type NamespaceCertificateFilterArrayOutput

type NamespaceCertificateFilterArrayOutput struct{ *pulumi.OutputState }

func (NamespaceCertificateFilterArrayOutput) ElementType

func (NamespaceCertificateFilterArrayOutput) Index

func (NamespaceCertificateFilterArrayOutput) ToNamespaceCertificateFilterArrayOutput

func (o NamespaceCertificateFilterArrayOutput) ToNamespaceCertificateFilterArrayOutput() NamespaceCertificateFilterArrayOutput

func (NamespaceCertificateFilterArrayOutput) ToNamespaceCertificateFilterArrayOutputWithContext

func (o NamespaceCertificateFilterArrayOutput) ToNamespaceCertificateFilterArrayOutputWithContext(ctx context.Context) NamespaceCertificateFilterArrayOutput

type NamespaceCertificateFilterInput

type NamespaceCertificateFilterInput interface {
	pulumi.Input

	ToNamespaceCertificateFilterOutput() NamespaceCertificateFilterOutput
	ToNamespaceCertificateFilterOutputWithContext(context.Context) NamespaceCertificateFilterOutput
}

NamespaceCertificateFilterInput is an input type that accepts NamespaceCertificateFilterArgs and NamespaceCertificateFilterOutput values. You can construct a concrete instance of `NamespaceCertificateFilterInput` via:

NamespaceCertificateFilterArgs{...}

type NamespaceCertificateFilterOutput

type NamespaceCertificateFilterOutput struct{ *pulumi.OutputState }

func (NamespaceCertificateFilterOutput) CommonName

The certificate's common name.

func (NamespaceCertificateFilterOutput) ElementType

func (NamespaceCertificateFilterOutput) Organization

The certificate's organization.

func (NamespaceCertificateFilterOutput) OrganizationalUnit

The certificate's organizational unit.

func (NamespaceCertificateFilterOutput) SubjectAlternativeName

func (o NamespaceCertificateFilterOutput) SubjectAlternativeName() pulumi.StringPtrOutput

The certificate's subject alternative name (or SAN).

func (NamespaceCertificateFilterOutput) ToNamespaceCertificateFilterOutput

func (o NamespaceCertificateFilterOutput) ToNamespaceCertificateFilterOutput() NamespaceCertificateFilterOutput

func (NamespaceCertificateFilterOutput) ToNamespaceCertificateFilterOutputWithContext

func (o NamespaceCertificateFilterOutput) ToNamespaceCertificateFilterOutputWithContext(ctx context.Context) NamespaceCertificateFilterOutput

type NamespaceCodecServer

type NamespaceCodecServer struct {
	// The endpoint of the codec server. Must begin with "https".
	Endpoint string `pulumi:"endpoint"`
	// If true, Temporal Cloud will include cross-origin credentials in requests to the codec server.
	IncludeCrossOriginCredentials *bool `pulumi:"includeCrossOriginCredentials"`
	// If true, Temporal Cloud will pass the access token to the codec server upon each request.
	PassAccessToken *bool `pulumi:"passAccessToken"`
}

type NamespaceCodecServerArgs

type NamespaceCodecServerArgs struct {
	// The endpoint of the codec server. Must begin with "https".
	Endpoint pulumi.StringInput `pulumi:"endpoint"`
	// If true, Temporal Cloud will include cross-origin credentials in requests to the codec server.
	IncludeCrossOriginCredentials pulumi.BoolPtrInput `pulumi:"includeCrossOriginCredentials"`
	// If true, Temporal Cloud will pass the access token to the codec server upon each request.
	PassAccessToken pulumi.BoolPtrInput `pulumi:"passAccessToken"`
}

func (NamespaceCodecServerArgs) ElementType

func (NamespaceCodecServerArgs) ElementType() reflect.Type

func (NamespaceCodecServerArgs) ToNamespaceCodecServerOutput

func (i NamespaceCodecServerArgs) ToNamespaceCodecServerOutput() NamespaceCodecServerOutput

func (NamespaceCodecServerArgs) ToNamespaceCodecServerOutputWithContext

func (i NamespaceCodecServerArgs) ToNamespaceCodecServerOutputWithContext(ctx context.Context) NamespaceCodecServerOutput

func (NamespaceCodecServerArgs) ToNamespaceCodecServerPtrOutput

func (i NamespaceCodecServerArgs) ToNamespaceCodecServerPtrOutput() NamespaceCodecServerPtrOutput

func (NamespaceCodecServerArgs) ToNamespaceCodecServerPtrOutputWithContext

func (i NamespaceCodecServerArgs) ToNamespaceCodecServerPtrOutputWithContext(ctx context.Context) NamespaceCodecServerPtrOutput

type NamespaceCodecServerInput

type NamespaceCodecServerInput interface {
	pulumi.Input

	ToNamespaceCodecServerOutput() NamespaceCodecServerOutput
	ToNamespaceCodecServerOutputWithContext(context.Context) NamespaceCodecServerOutput
}

NamespaceCodecServerInput is an input type that accepts NamespaceCodecServerArgs and NamespaceCodecServerOutput values. You can construct a concrete instance of `NamespaceCodecServerInput` via:

NamespaceCodecServerArgs{...}

type NamespaceCodecServerOutput

type NamespaceCodecServerOutput struct{ *pulumi.OutputState }

func (NamespaceCodecServerOutput) ElementType

func (NamespaceCodecServerOutput) ElementType() reflect.Type

func (NamespaceCodecServerOutput) Endpoint

The endpoint of the codec server. Must begin with "https".

func (NamespaceCodecServerOutput) IncludeCrossOriginCredentials

func (o NamespaceCodecServerOutput) IncludeCrossOriginCredentials() pulumi.BoolPtrOutput

If true, Temporal Cloud will include cross-origin credentials in requests to the codec server.

func (NamespaceCodecServerOutput) PassAccessToken

func (o NamespaceCodecServerOutput) PassAccessToken() pulumi.BoolPtrOutput

If true, Temporal Cloud will pass the access token to the codec server upon each request.

func (NamespaceCodecServerOutput) ToNamespaceCodecServerOutput

func (o NamespaceCodecServerOutput) ToNamespaceCodecServerOutput() NamespaceCodecServerOutput

func (NamespaceCodecServerOutput) ToNamespaceCodecServerOutputWithContext

func (o NamespaceCodecServerOutput) ToNamespaceCodecServerOutputWithContext(ctx context.Context) NamespaceCodecServerOutput

func (NamespaceCodecServerOutput) ToNamespaceCodecServerPtrOutput

func (o NamespaceCodecServerOutput) ToNamespaceCodecServerPtrOutput() NamespaceCodecServerPtrOutput

func (NamespaceCodecServerOutput) ToNamespaceCodecServerPtrOutputWithContext

func (o NamespaceCodecServerOutput) ToNamespaceCodecServerPtrOutputWithContext(ctx context.Context) NamespaceCodecServerPtrOutput

type NamespaceCodecServerPtrInput

type NamespaceCodecServerPtrInput interface {
	pulumi.Input

	ToNamespaceCodecServerPtrOutput() NamespaceCodecServerPtrOutput
	ToNamespaceCodecServerPtrOutputWithContext(context.Context) NamespaceCodecServerPtrOutput
}

NamespaceCodecServerPtrInput is an input type that accepts NamespaceCodecServerArgs, NamespaceCodecServerPtr and NamespaceCodecServerPtrOutput values. You can construct a concrete instance of `NamespaceCodecServerPtrInput` via:

        NamespaceCodecServerArgs{...}

or:

        nil

type NamespaceCodecServerPtrOutput

type NamespaceCodecServerPtrOutput struct{ *pulumi.OutputState }

func (NamespaceCodecServerPtrOutput) Elem

func (NamespaceCodecServerPtrOutput) ElementType

func (NamespaceCodecServerPtrOutput) Endpoint

The endpoint of the codec server. Must begin with "https".

func (NamespaceCodecServerPtrOutput) IncludeCrossOriginCredentials

func (o NamespaceCodecServerPtrOutput) IncludeCrossOriginCredentials() pulumi.BoolPtrOutput

If true, Temporal Cloud will include cross-origin credentials in requests to the codec server.

func (NamespaceCodecServerPtrOutput) PassAccessToken

If true, Temporal Cloud will pass the access token to the codec server upon each request.

func (NamespaceCodecServerPtrOutput) ToNamespaceCodecServerPtrOutput

func (o NamespaceCodecServerPtrOutput) ToNamespaceCodecServerPtrOutput() NamespaceCodecServerPtrOutput

func (NamespaceCodecServerPtrOutput) ToNamespaceCodecServerPtrOutputWithContext

func (o NamespaceCodecServerPtrOutput) ToNamespaceCodecServerPtrOutputWithContext(ctx context.Context) NamespaceCodecServerPtrOutput

type NamespaceEndpoints

type NamespaceEndpoints struct {
	// The gRPC address for API key client connections (may be empty if API keys are disabled).
	GrpcAddress *string `pulumi:"grpcAddress"`
	// The gRPC address for mTLS client connections (may be empty if mTLS is disabled).
	MtlsGrpcAddress *string `pulumi:"mtlsGrpcAddress"`
	// The address in the Temporal Cloud Web UI for the namespace
	WebAddress *string `pulumi:"webAddress"`
}

type NamespaceEndpointsArgs

type NamespaceEndpointsArgs struct {
	// The gRPC address for API key client connections (may be empty if API keys are disabled).
	GrpcAddress pulumi.StringPtrInput `pulumi:"grpcAddress"`
	// The gRPC address for mTLS client connections (may be empty if mTLS is disabled).
	MtlsGrpcAddress pulumi.StringPtrInput `pulumi:"mtlsGrpcAddress"`
	// The address in the Temporal Cloud Web UI for the namespace
	WebAddress pulumi.StringPtrInput `pulumi:"webAddress"`
}

func (NamespaceEndpointsArgs) ElementType

func (NamespaceEndpointsArgs) ElementType() reflect.Type

func (NamespaceEndpointsArgs) ToNamespaceEndpointsOutput

func (i NamespaceEndpointsArgs) ToNamespaceEndpointsOutput() NamespaceEndpointsOutput

func (NamespaceEndpointsArgs) ToNamespaceEndpointsOutputWithContext

func (i NamespaceEndpointsArgs) ToNamespaceEndpointsOutputWithContext(ctx context.Context) NamespaceEndpointsOutput

func (NamespaceEndpointsArgs) ToNamespaceEndpointsPtrOutput

func (i NamespaceEndpointsArgs) ToNamespaceEndpointsPtrOutput() NamespaceEndpointsPtrOutput

func (NamespaceEndpointsArgs) ToNamespaceEndpointsPtrOutputWithContext

func (i NamespaceEndpointsArgs) ToNamespaceEndpointsPtrOutputWithContext(ctx context.Context) NamespaceEndpointsPtrOutput

type NamespaceEndpointsInput

type NamespaceEndpointsInput interface {
	pulumi.Input

	ToNamespaceEndpointsOutput() NamespaceEndpointsOutput
	ToNamespaceEndpointsOutputWithContext(context.Context) NamespaceEndpointsOutput
}

NamespaceEndpointsInput is an input type that accepts NamespaceEndpointsArgs and NamespaceEndpointsOutput values. You can construct a concrete instance of `NamespaceEndpointsInput` via:

NamespaceEndpointsArgs{...}

type NamespaceEndpointsOutput

type NamespaceEndpointsOutput struct{ *pulumi.OutputState }

func (NamespaceEndpointsOutput) ElementType

func (NamespaceEndpointsOutput) ElementType() reflect.Type

func (NamespaceEndpointsOutput) GrpcAddress

The gRPC address for API key client connections (may be empty if API keys are disabled).

func (NamespaceEndpointsOutput) MtlsGrpcAddress

func (o NamespaceEndpointsOutput) MtlsGrpcAddress() pulumi.StringPtrOutput

The gRPC address for mTLS client connections (may be empty if mTLS is disabled).

func (NamespaceEndpointsOutput) ToNamespaceEndpointsOutput

func (o NamespaceEndpointsOutput) ToNamespaceEndpointsOutput() NamespaceEndpointsOutput

func (NamespaceEndpointsOutput) ToNamespaceEndpointsOutputWithContext

func (o NamespaceEndpointsOutput) ToNamespaceEndpointsOutputWithContext(ctx context.Context) NamespaceEndpointsOutput

func (NamespaceEndpointsOutput) ToNamespaceEndpointsPtrOutput

func (o NamespaceEndpointsOutput) ToNamespaceEndpointsPtrOutput() NamespaceEndpointsPtrOutput

func (NamespaceEndpointsOutput) ToNamespaceEndpointsPtrOutputWithContext

func (o NamespaceEndpointsOutput) ToNamespaceEndpointsPtrOutputWithContext(ctx context.Context) NamespaceEndpointsPtrOutput

func (NamespaceEndpointsOutput) WebAddress

The address in the Temporal Cloud Web UI for the namespace

type NamespaceEndpointsPtrInput

type NamespaceEndpointsPtrInput interface {
	pulumi.Input

	ToNamespaceEndpointsPtrOutput() NamespaceEndpointsPtrOutput
	ToNamespaceEndpointsPtrOutputWithContext(context.Context) NamespaceEndpointsPtrOutput
}

NamespaceEndpointsPtrInput is an input type that accepts NamespaceEndpointsArgs, NamespaceEndpointsPtr and NamespaceEndpointsPtrOutput values. You can construct a concrete instance of `NamespaceEndpointsPtrInput` via:

        NamespaceEndpointsArgs{...}

or:

        nil

type NamespaceEndpointsPtrOutput

type NamespaceEndpointsPtrOutput struct{ *pulumi.OutputState }

func (NamespaceEndpointsPtrOutput) Elem

func (NamespaceEndpointsPtrOutput) ElementType

func (NamespaceEndpointsPtrOutput) GrpcAddress

The gRPC address for API key client connections (may be empty if API keys are disabled).

func (NamespaceEndpointsPtrOutput) MtlsGrpcAddress

The gRPC address for mTLS client connections (may be empty if mTLS is disabled).

func (NamespaceEndpointsPtrOutput) ToNamespaceEndpointsPtrOutput

func (o NamespaceEndpointsPtrOutput) ToNamespaceEndpointsPtrOutput() NamespaceEndpointsPtrOutput

func (NamespaceEndpointsPtrOutput) ToNamespaceEndpointsPtrOutputWithContext

func (o NamespaceEndpointsPtrOutput) ToNamespaceEndpointsPtrOutputWithContext(ctx context.Context) NamespaceEndpointsPtrOutput

func (NamespaceEndpointsPtrOutput) WebAddress

The address in the Temporal Cloud Web UI for the namespace

type NamespaceInput

type NamespaceInput interface {
	pulumi.Input

	ToNamespaceOutput() NamespaceOutput
	ToNamespaceOutputWithContext(ctx context.Context) NamespaceOutput
}

type NamespaceMap

type NamespaceMap map[string]NamespaceInput

func (NamespaceMap) ElementType

func (NamespaceMap) ElementType() reflect.Type

func (NamespaceMap) ToNamespaceMapOutput

func (i NamespaceMap) ToNamespaceMapOutput() NamespaceMapOutput

func (NamespaceMap) ToNamespaceMapOutputWithContext

func (i NamespaceMap) ToNamespaceMapOutputWithContext(ctx context.Context) NamespaceMapOutput

type NamespaceMapInput

type NamespaceMapInput interface {
	pulumi.Input

	ToNamespaceMapOutput() NamespaceMapOutput
	ToNamespaceMapOutputWithContext(context.Context) NamespaceMapOutput
}

NamespaceMapInput is an input type that accepts NamespaceMap and NamespaceMapOutput values. You can construct a concrete instance of `NamespaceMapInput` via:

NamespaceMap{ "key": NamespaceArgs{...} }

type NamespaceMapOutput

type NamespaceMapOutput struct{ *pulumi.OutputState }

func (NamespaceMapOutput) ElementType

func (NamespaceMapOutput) ElementType() reflect.Type

func (NamespaceMapOutput) MapIndex

func (NamespaceMapOutput) ToNamespaceMapOutput

func (o NamespaceMapOutput) ToNamespaceMapOutput() NamespaceMapOutput

func (NamespaceMapOutput) ToNamespaceMapOutputWithContext

func (o NamespaceMapOutput) ToNamespaceMapOutputWithContext(ctx context.Context) NamespaceMapOutput

type NamespaceOutput

type NamespaceOutput struct{ *pulumi.OutputState }

func (NamespaceOutput) AcceptedClientCa

func (o NamespaceOutput) AcceptedClientCa() pulumi.StringPtrOutput

The Base64-encoded CA cert in PEM format that clients use when authenticating with Temporal Cloud. This is a required field when a Namespace uses mTLS authentication.

func (NamespaceOutput) ApiKeyAuth

func (o NamespaceOutput) ApiKeyAuth() pulumi.BoolOutput

If true, Temporal Cloud will use API key authentication for this namespace. If false, mutual TLS (mTLS) authentication will be used.

func (NamespaceOutput) CertificateFilters

A list of filters to apply to client certificates when initiating a connection Temporal Cloud. If present, connections will only be allowed from client certificates whose distinguished name properties match at least one of the filters. Empty lists are not allowed, omit the attribute instead.

func (NamespaceOutput) CodecServer

A codec server is used by the Temporal Cloud UI to decode payloads for all users interacting with this namespace, even if the workflow history itself is encrypted.

func (NamespaceOutput) ElementType

func (NamespaceOutput) ElementType() reflect.Type

func (NamespaceOutput) Endpoints

The endpoints for the namespace.

func (NamespaceOutput) Name

The name of the namespace.

func (NamespaceOutput) Regions

func (NamespaceOutput) RetentionDays

func (o NamespaceOutput) RetentionDays() pulumi.IntOutput

The number of days to retain workflow history. Any changes to the retention period will be applied to all new running workflows.

func (NamespaceOutput) Timeouts

func (NamespaceOutput) ToNamespaceOutput

func (o NamespaceOutput) ToNamespaceOutput() NamespaceOutput

func (NamespaceOutput) ToNamespaceOutputWithContext

func (o NamespaceOutput) ToNamespaceOutputWithContext(ctx context.Context) NamespaceOutput

type NamespaceSearchAttribute

type NamespaceSearchAttribute struct {
	pulumi.CustomResourceState

	// The name of the search attribute.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the namespace to which this search attribute belongs.
	NamespaceId pulumi.StringOutput `pulumi:"namespaceId"`
	// The type of the search attribute. Must be one of `bool`, `datetime`, `double`, `int`, `keyword`, `keywordList` or `text`. (case-insensitive)
	Type pulumi.StringOutput `pulumi:"type"`
}

Create a [search attribute](https://docs.temporal.io/visibility#search-attribute) in a Temporal Cloud namespace. Note the limits on [quantity](https://docs.temporal.io/cloud/limits#number-of-custom-search-attributes) and [naming](https://docs.temporal.io/cloud/limits#custom-search-attribute-names).

## Import

Search Attributes can be imported to incorporate existing Namespace Search Attributes into your Terraform pipeline.

To import a Search Attribute, you need

- a resource configuration in your Terraform configuration file/module to accept the imported Search Attribute. In the example below, the placeholder is "temporalcloud_namespace_search_attribute" "saimport"

- the Namespace ID, which includes the Namespace Name and Account ID available at the top of the Namespace's page in the Temporal Cloud UI. In the example below, this is namespaceid.acctid

- the name of the Search Attribute, which is available in the Search Attribute configuration of Namespace's page in the Temporal Cloud UI. In the example below, this is searchAttr

```sh $ pulumi import temporalcloud:index/namespaceSearchAttribute:NamespaceSearchAttribute saimport namespaceid.acctid/searchAttr ```

func GetNamespaceSearchAttribute

func GetNamespaceSearchAttribute(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *NamespaceSearchAttributeState, opts ...pulumi.ResourceOption) (*NamespaceSearchAttribute, error)

GetNamespaceSearchAttribute gets an existing NamespaceSearchAttribute 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 NewNamespaceSearchAttribute

func NewNamespaceSearchAttribute(ctx *pulumi.Context,
	name string, args *NamespaceSearchAttributeArgs, opts ...pulumi.ResourceOption) (*NamespaceSearchAttribute, error)

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

func (*NamespaceSearchAttribute) ElementType

func (*NamespaceSearchAttribute) ElementType() reflect.Type

func (*NamespaceSearchAttribute) ToNamespaceSearchAttributeOutput

func (i *NamespaceSearchAttribute) ToNamespaceSearchAttributeOutput() NamespaceSearchAttributeOutput

func (*NamespaceSearchAttribute) ToNamespaceSearchAttributeOutputWithContext

func (i *NamespaceSearchAttribute) ToNamespaceSearchAttributeOutputWithContext(ctx context.Context) NamespaceSearchAttributeOutput

type NamespaceSearchAttributeArgs

type NamespaceSearchAttributeArgs struct {
	// The name of the search attribute.
	Name pulumi.StringPtrInput
	// The ID of the namespace to which this search attribute belongs.
	NamespaceId pulumi.StringInput
	// The type of the search attribute. Must be one of `bool`, `datetime`, `double`, `int`, `keyword`, `keywordList` or `text`. (case-insensitive)
	Type pulumi.StringInput
}

The set of arguments for constructing a NamespaceSearchAttribute resource.

func (NamespaceSearchAttributeArgs) ElementType

type NamespaceSearchAttributeArray

type NamespaceSearchAttributeArray []NamespaceSearchAttributeInput

func (NamespaceSearchAttributeArray) ElementType

func (NamespaceSearchAttributeArray) ToNamespaceSearchAttributeArrayOutput

func (i NamespaceSearchAttributeArray) ToNamespaceSearchAttributeArrayOutput() NamespaceSearchAttributeArrayOutput

func (NamespaceSearchAttributeArray) ToNamespaceSearchAttributeArrayOutputWithContext

func (i NamespaceSearchAttributeArray) ToNamespaceSearchAttributeArrayOutputWithContext(ctx context.Context) NamespaceSearchAttributeArrayOutput

type NamespaceSearchAttributeArrayInput

type NamespaceSearchAttributeArrayInput interface {
	pulumi.Input

	ToNamespaceSearchAttributeArrayOutput() NamespaceSearchAttributeArrayOutput
	ToNamespaceSearchAttributeArrayOutputWithContext(context.Context) NamespaceSearchAttributeArrayOutput
}

NamespaceSearchAttributeArrayInput is an input type that accepts NamespaceSearchAttributeArray and NamespaceSearchAttributeArrayOutput values. You can construct a concrete instance of `NamespaceSearchAttributeArrayInput` via:

NamespaceSearchAttributeArray{ NamespaceSearchAttributeArgs{...} }

type NamespaceSearchAttributeArrayOutput

type NamespaceSearchAttributeArrayOutput struct{ *pulumi.OutputState }

func (NamespaceSearchAttributeArrayOutput) ElementType

func (NamespaceSearchAttributeArrayOutput) Index

func (NamespaceSearchAttributeArrayOutput) ToNamespaceSearchAttributeArrayOutput

func (o NamespaceSearchAttributeArrayOutput) ToNamespaceSearchAttributeArrayOutput() NamespaceSearchAttributeArrayOutput

func (NamespaceSearchAttributeArrayOutput) ToNamespaceSearchAttributeArrayOutputWithContext

func (o NamespaceSearchAttributeArrayOutput) ToNamespaceSearchAttributeArrayOutputWithContext(ctx context.Context) NamespaceSearchAttributeArrayOutput

type NamespaceSearchAttributeInput

type NamespaceSearchAttributeInput interface {
	pulumi.Input

	ToNamespaceSearchAttributeOutput() NamespaceSearchAttributeOutput
	ToNamespaceSearchAttributeOutputWithContext(ctx context.Context) NamespaceSearchAttributeOutput
}

type NamespaceSearchAttributeMap

type NamespaceSearchAttributeMap map[string]NamespaceSearchAttributeInput

func (NamespaceSearchAttributeMap) ElementType

func (NamespaceSearchAttributeMap) ToNamespaceSearchAttributeMapOutput

func (i NamespaceSearchAttributeMap) ToNamespaceSearchAttributeMapOutput() NamespaceSearchAttributeMapOutput

func (NamespaceSearchAttributeMap) ToNamespaceSearchAttributeMapOutputWithContext

func (i NamespaceSearchAttributeMap) ToNamespaceSearchAttributeMapOutputWithContext(ctx context.Context) NamespaceSearchAttributeMapOutput

type NamespaceSearchAttributeMapInput

type NamespaceSearchAttributeMapInput interface {
	pulumi.Input

	ToNamespaceSearchAttributeMapOutput() NamespaceSearchAttributeMapOutput
	ToNamespaceSearchAttributeMapOutputWithContext(context.Context) NamespaceSearchAttributeMapOutput
}

NamespaceSearchAttributeMapInput is an input type that accepts NamespaceSearchAttributeMap and NamespaceSearchAttributeMapOutput values. You can construct a concrete instance of `NamespaceSearchAttributeMapInput` via:

NamespaceSearchAttributeMap{ "key": NamespaceSearchAttributeArgs{...} }

type NamespaceSearchAttributeMapOutput

type NamespaceSearchAttributeMapOutput struct{ *pulumi.OutputState }

func (NamespaceSearchAttributeMapOutput) ElementType

func (NamespaceSearchAttributeMapOutput) MapIndex

func (NamespaceSearchAttributeMapOutput) ToNamespaceSearchAttributeMapOutput

func (o NamespaceSearchAttributeMapOutput) ToNamespaceSearchAttributeMapOutput() NamespaceSearchAttributeMapOutput

func (NamespaceSearchAttributeMapOutput) ToNamespaceSearchAttributeMapOutputWithContext

func (o NamespaceSearchAttributeMapOutput) ToNamespaceSearchAttributeMapOutputWithContext(ctx context.Context) NamespaceSearchAttributeMapOutput

type NamespaceSearchAttributeOutput

type NamespaceSearchAttributeOutput struct{ *pulumi.OutputState }

func (NamespaceSearchAttributeOutput) ElementType

func (NamespaceSearchAttributeOutput) Name

The name of the search attribute.

func (NamespaceSearchAttributeOutput) NamespaceId

The ID of the namespace to which this search attribute belongs.

func (NamespaceSearchAttributeOutput) ToNamespaceSearchAttributeOutput

func (o NamespaceSearchAttributeOutput) ToNamespaceSearchAttributeOutput() NamespaceSearchAttributeOutput

func (NamespaceSearchAttributeOutput) ToNamespaceSearchAttributeOutputWithContext

func (o NamespaceSearchAttributeOutput) ToNamespaceSearchAttributeOutputWithContext(ctx context.Context) NamespaceSearchAttributeOutput

func (NamespaceSearchAttributeOutput) Type

The type of the search attribute. Must be one of `bool`, `datetime`, `double`, `int`, `keyword`, `keywordList` or `text`. (case-insensitive)

type NamespaceSearchAttributeState

type NamespaceSearchAttributeState struct {
	// The name of the search attribute.
	Name pulumi.StringPtrInput
	// The ID of the namespace to which this search attribute belongs.
	NamespaceId pulumi.StringPtrInput
	// The type of the search attribute. Must be one of `bool`, `datetime`, `double`, `int`, `keyword`, `keywordList` or `text`. (case-insensitive)
	Type pulumi.StringPtrInput
}

func (NamespaceSearchAttributeState) ElementType

type NamespaceState

type NamespaceState struct {
	// The Base64-encoded CA cert in PEM format that clients use when authenticating with Temporal Cloud. This is a required field when a Namespace uses mTLS authentication.
	AcceptedClientCa pulumi.StringPtrInput
	// If true, Temporal Cloud will use API key authentication for this namespace. If false, mutual TLS (mTLS) authentication will be used.
	ApiKeyAuth pulumi.BoolPtrInput
	// A list of filters to apply to client certificates when initiating a connection Temporal Cloud. If present, connections will only be allowed from client certificates whose distinguished name properties match at least one of the filters. Empty lists are not allowed, omit the attribute instead.
	CertificateFilters NamespaceCertificateFilterArrayInput
	// A codec server is used by the Temporal Cloud UI to decode payloads for all users interacting with this namespace, even if the workflow history itself is encrypted.
	CodecServer NamespaceCodecServerPtrInput
	// The endpoints for the namespace.
	Endpoints NamespaceEndpointsPtrInput
	// The name of the namespace.
	Name    pulumi.StringPtrInput
	Regions pulumi.StringArrayInput
	// The number of days to retain workflow history. Any changes to the retention period will be applied to all new running workflows.
	RetentionDays pulumi.IntPtrInput
	Timeouts      NamespaceTimeoutsPtrInput
}

func (NamespaceState) ElementType

func (NamespaceState) ElementType() reflect.Type

type NamespaceTimeouts

type NamespaceTimeouts 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 NamespaceTimeoutsArgs

type NamespaceTimeoutsArgs 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 (NamespaceTimeoutsArgs) ElementType

func (NamespaceTimeoutsArgs) ElementType() reflect.Type

func (NamespaceTimeoutsArgs) ToNamespaceTimeoutsOutput

func (i NamespaceTimeoutsArgs) ToNamespaceTimeoutsOutput() NamespaceTimeoutsOutput

func (NamespaceTimeoutsArgs) ToNamespaceTimeoutsOutputWithContext

func (i NamespaceTimeoutsArgs) ToNamespaceTimeoutsOutputWithContext(ctx context.Context) NamespaceTimeoutsOutput

func (NamespaceTimeoutsArgs) ToNamespaceTimeoutsPtrOutput

func (i NamespaceTimeoutsArgs) ToNamespaceTimeoutsPtrOutput() NamespaceTimeoutsPtrOutput

func (NamespaceTimeoutsArgs) ToNamespaceTimeoutsPtrOutputWithContext

func (i NamespaceTimeoutsArgs) ToNamespaceTimeoutsPtrOutputWithContext(ctx context.Context) NamespaceTimeoutsPtrOutput

type NamespaceTimeoutsInput

type NamespaceTimeoutsInput interface {
	pulumi.Input

	ToNamespaceTimeoutsOutput() NamespaceTimeoutsOutput
	ToNamespaceTimeoutsOutputWithContext(context.Context) NamespaceTimeoutsOutput
}

NamespaceTimeoutsInput is an input type that accepts NamespaceTimeoutsArgs and NamespaceTimeoutsOutput values. You can construct a concrete instance of `NamespaceTimeoutsInput` via:

NamespaceTimeoutsArgs{...}

type NamespaceTimeoutsOutput

type NamespaceTimeoutsOutput struct{ *pulumi.OutputState }

func (NamespaceTimeoutsOutput) 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 (NamespaceTimeoutsOutput) 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 (NamespaceTimeoutsOutput) ElementType

func (NamespaceTimeoutsOutput) ElementType() reflect.Type

func (NamespaceTimeoutsOutput) ToNamespaceTimeoutsOutput

func (o NamespaceTimeoutsOutput) ToNamespaceTimeoutsOutput() NamespaceTimeoutsOutput

func (NamespaceTimeoutsOutput) ToNamespaceTimeoutsOutputWithContext

func (o NamespaceTimeoutsOutput) ToNamespaceTimeoutsOutputWithContext(ctx context.Context) NamespaceTimeoutsOutput

func (NamespaceTimeoutsOutput) ToNamespaceTimeoutsPtrOutput

func (o NamespaceTimeoutsOutput) ToNamespaceTimeoutsPtrOutput() NamespaceTimeoutsPtrOutput

func (NamespaceTimeoutsOutput) ToNamespaceTimeoutsPtrOutputWithContext

func (o NamespaceTimeoutsOutput) ToNamespaceTimeoutsPtrOutputWithContext(ctx context.Context) NamespaceTimeoutsPtrOutput

type NamespaceTimeoutsPtrInput

type NamespaceTimeoutsPtrInput interface {
	pulumi.Input

	ToNamespaceTimeoutsPtrOutput() NamespaceTimeoutsPtrOutput
	ToNamespaceTimeoutsPtrOutputWithContext(context.Context) NamespaceTimeoutsPtrOutput
}

NamespaceTimeoutsPtrInput is an input type that accepts NamespaceTimeoutsArgs, NamespaceTimeoutsPtr and NamespaceTimeoutsPtrOutput values. You can construct a concrete instance of `NamespaceTimeoutsPtrInput` via:

        NamespaceTimeoutsArgs{...}

or:

        nil

type NamespaceTimeoutsPtrOutput

type NamespaceTimeoutsPtrOutput struct{ *pulumi.OutputState }

func (NamespaceTimeoutsPtrOutput) 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 (NamespaceTimeoutsPtrOutput) 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 (NamespaceTimeoutsPtrOutput) Elem

func (NamespaceTimeoutsPtrOutput) ElementType

func (NamespaceTimeoutsPtrOutput) ElementType() reflect.Type

func (NamespaceTimeoutsPtrOutput) ToNamespaceTimeoutsPtrOutput

func (o NamespaceTimeoutsPtrOutput) ToNamespaceTimeoutsPtrOutput() NamespaceTimeoutsPtrOutput

func (NamespaceTimeoutsPtrOutput) ToNamespaceTimeoutsPtrOutputWithContext

func (o NamespaceTimeoutsPtrOutput) ToNamespaceTimeoutsPtrOutputWithContext(ctx context.Context) NamespaceTimeoutsPtrOutput

type NexusEndpoint

type NexusEndpoint struct {
	pulumi.CustomResourceState

	// Namespace Id(s) that are allowed to call this Endpoint.
	AllowedCallerNamespaces pulumi.StringArrayOutput `pulumi:"allowedCallerNamespaces"`
	// The description for the Nexus endpoint.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// The name of the endpoint. Must be unique within an account and match `^[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9]$`
	Name     pulumi.StringOutput            `pulumi:"name"`
	Timeouts NexusEndpointTimeoutsPtrOutput `pulumi:"timeouts"`
	// A target spec for routing nexus requests to a specific cloud namespace worker.
	WorkerTarget NexusEndpointWorkerTargetOutput `pulumi:"workerTarget"`
}

Provisions a Temporal Cloud Nexus endpoint.

## Import

Nexus Endpoints can be imported to incorporate existing Nexus Endpoints into your Terraform pipeline.

To import a Nexus Endpoint, you need

- a resource configuration in your Terraform configuration file/module to accept the imported Nexus Endpoint. In the example below, the placeholder is "temporalcloud_nexus_endpoint" "nexus_endpoint"

- the Nexus Endpoint's ID, which is found using the Temporal Cloud CLI tcld nexus endpoint list. In the example below, this is 405f7da4224a43d99c211904ed9b3819

```sh $ pulumi import temporalcloud:index/nexusEndpoint:NexusEndpoint nexus_endpoint 405f7da4224a43d99c211904ed9b3819 ```

func GetNexusEndpoint

func GetNexusEndpoint(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *NexusEndpointState, opts ...pulumi.ResourceOption) (*NexusEndpoint, error)

GetNexusEndpoint gets an existing NexusEndpoint 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 NewNexusEndpoint

func NewNexusEndpoint(ctx *pulumi.Context,
	name string, args *NexusEndpointArgs, opts ...pulumi.ResourceOption) (*NexusEndpoint, error)

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

func (*NexusEndpoint) ElementType

func (*NexusEndpoint) ElementType() reflect.Type

func (*NexusEndpoint) ToNexusEndpointOutput

func (i *NexusEndpoint) ToNexusEndpointOutput() NexusEndpointOutput

func (*NexusEndpoint) ToNexusEndpointOutputWithContext

func (i *NexusEndpoint) ToNexusEndpointOutputWithContext(ctx context.Context) NexusEndpointOutput

type NexusEndpointArgs

type NexusEndpointArgs struct {
	// Namespace Id(s) that are allowed to call this Endpoint.
	AllowedCallerNamespaces pulumi.StringArrayInput
	// The description for the Nexus endpoint.
	Description pulumi.StringPtrInput
	// The name of the endpoint. Must be unique within an account and match `^[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9]$`
	Name     pulumi.StringPtrInput
	Timeouts NexusEndpointTimeoutsPtrInput
	// A target spec for routing nexus requests to a specific cloud namespace worker.
	WorkerTarget NexusEndpointWorkerTargetInput
}

The set of arguments for constructing a NexusEndpoint resource.

func (NexusEndpointArgs) ElementType

func (NexusEndpointArgs) ElementType() reflect.Type

type NexusEndpointArray

type NexusEndpointArray []NexusEndpointInput

func (NexusEndpointArray) ElementType

func (NexusEndpointArray) ElementType() reflect.Type

func (NexusEndpointArray) ToNexusEndpointArrayOutput

func (i NexusEndpointArray) ToNexusEndpointArrayOutput() NexusEndpointArrayOutput

func (NexusEndpointArray) ToNexusEndpointArrayOutputWithContext

func (i NexusEndpointArray) ToNexusEndpointArrayOutputWithContext(ctx context.Context) NexusEndpointArrayOutput

type NexusEndpointArrayInput

type NexusEndpointArrayInput interface {
	pulumi.Input

	ToNexusEndpointArrayOutput() NexusEndpointArrayOutput
	ToNexusEndpointArrayOutputWithContext(context.Context) NexusEndpointArrayOutput
}

NexusEndpointArrayInput is an input type that accepts NexusEndpointArray and NexusEndpointArrayOutput values. You can construct a concrete instance of `NexusEndpointArrayInput` via:

NexusEndpointArray{ NexusEndpointArgs{...} }

type NexusEndpointArrayOutput

type NexusEndpointArrayOutput struct{ *pulumi.OutputState }

func (NexusEndpointArrayOutput) ElementType

func (NexusEndpointArrayOutput) ElementType() reflect.Type

func (NexusEndpointArrayOutput) Index

func (NexusEndpointArrayOutput) ToNexusEndpointArrayOutput

func (o NexusEndpointArrayOutput) ToNexusEndpointArrayOutput() NexusEndpointArrayOutput

func (NexusEndpointArrayOutput) ToNexusEndpointArrayOutputWithContext

func (o NexusEndpointArrayOutput) ToNexusEndpointArrayOutputWithContext(ctx context.Context) NexusEndpointArrayOutput

type NexusEndpointInput

type NexusEndpointInput interface {
	pulumi.Input

	ToNexusEndpointOutput() NexusEndpointOutput
	ToNexusEndpointOutputWithContext(ctx context.Context) NexusEndpointOutput
}

type NexusEndpointMap

type NexusEndpointMap map[string]NexusEndpointInput

func (NexusEndpointMap) ElementType

func (NexusEndpointMap) ElementType() reflect.Type

func (NexusEndpointMap) ToNexusEndpointMapOutput

func (i NexusEndpointMap) ToNexusEndpointMapOutput() NexusEndpointMapOutput

func (NexusEndpointMap) ToNexusEndpointMapOutputWithContext

func (i NexusEndpointMap) ToNexusEndpointMapOutputWithContext(ctx context.Context) NexusEndpointMapOutput

type NexusEndpointMapInput

type NexusEndpointMapInput interface {
	pulumi.Input

	ToNexusEndpointMapOutput() NexusEndpointMapOutput
	ToNexusEndpointMapOutputWithContext(context.Context) NexusEndpointMapOutput
}

NexusEndpointMapInput is an input type that accepts NexusEndpointMap and NexusEndpointMapOutput values. You can construct a concrete instance of `NexusEndpointMapInput` via:

NexusEndpointMap{ "key": NexusEndpointArgs{...} }

type NexusEndpointMapOutput

type NexusEndpointMapOutput struct{ *pulumi.OutputState }

func (NexusEndpointMapOutput) ElementType

func (NexusEndpointMapOutput) ElementType() reflect.Type

func (NexusEndpointMapOutput) MapIndex

func (NexusEndpointMapOutput) ToNexusEndpointMapOutput

func (o NexusEndpointMapOutput) ToNexusEndpointMapOutput() NexusEndpointMapOutput

func (NexusEndpointMapOutput) ToNexusEndpointMapOutputWithContext

func (o NexusEndpointMapOutput) ToNexusEndpointMapOutputWithContext(ctx context.Context) NexusEndpointMapOutput

type NexusEndpointOutput

type NexusEndpointOutput struct{ *pulumi.OutputState }

func (NexusEndpointOutput) AllowedCallerNamespaces

func (o NexusEndpointOutput) AllowedCallerNamespaces() pulumi.StringArrayOutput

Namespace Id(s) that are allowed to call this Endpoint.

func (NexusEndpointOutput) Description

func (o NexusEndpointOutput) Description() pulumi.StringPtrOutput

The description for the Nexus endpoint.

func (NexusEndpointOutput) ElementType

func (NexusEndpointOutput) ElementType() reflect.Type

func (NexusEndpointOutput) Name

The name of the endpoint. Must be unique within an account and match `^[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9]$`

func (NexusEndpointOutput) Timeouts

func (NexusEndpointOutput) ToNexusEndpointOutput

func (o NexusEndpointOutput) ToNexusEndpointOutput() NexusEndpointOutput

func (NexusEndpointOutput) ToNexusEndpointOutputWithContext

func (o NexusEndpointOutput) ToNexusEndpointOutputWithContext(ctx context.Context) NexusEndpointOutput

func (NexusEndpointOutput) WorkerTarget

A target spec for routing nexus requests to a specific cloud namespace worker.

type NexusEndpointState

type NexusEndpointState struct {
	// Namespace Id(s) that are allowed to call this Endpoint.
	AllowedCallerNamespaces pulumi.StringArrayInput
	// The description for the Nexus endpoint.
	Description pulumi.StringPtrInput
	// The name of the endpoint. Must be unique within an account and match `^[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9]$`
	Name     pulumi.StringPtrInput
	Timeouts NexusEndpointTimeoutsPtrInput
	// A target spec for routing nexus requests to a specific cloud namespace worker.
	WorkerTarget NexusEndpointWorkerTargetPtrInput
}

func (NexusEndpointState) ElementType

func (NexusEndpointState) ElementType() reflect.Type

type NexusEndpointTimeouts

type NexusEndpointTimeouts 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 NexusEndpointTimeoutsArgs

type NexusEndpointTimeoutsArgs 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 (NexusEndpointTimeoutsArgs) ElementType

func (NexusEndpointTimeoutsArgs) ElementType() reflect.Type

func (NexusEndpointTimeoutsArgs) ToNexusEndpointTimeoutsOutput

func (i NexusEndpointTimeoutsArgs) ToNexusEndpointTimeoutsOutput() NexusEndpointTimeoutsOutput

func (NexusEndpointTimeoutsArgs) ToNexusEndpointTimeoutsOutputWithContext

func (i NexusEndpointTimeoutsArgs) ToNexusEndpointTimeoutsOutputWithContext(ctx context.Context) NexusEndpointTimeoutsOutput

func (NexusEndpointTimeoutsArgs) ToNexusEndpointTimeoutsPtrOutput

func (i NexusEndpointTimeoutsArgs) ToNexusEndpointTimeoutsPtrOutput() NexusEndpointTimeoutsPtrOutput

func (NexusEndpointTimeoutsArgs) ToNexusEndpointTimeoutsPtrOutputWithContext

func (i NexusEndpointTimeoutsArgs) ToNexusEndpointTimeoutsPtrOutputWithContext(ctx context.Context) NexusEndpointTimeoutsPtrOutput

type NexusEndpointTimeoutsInput

type NexusEndpointTimeoutsInput interface {
	pulumi.Input

	ToNexusEndpointTimeoutsOutput() NexusEndpointTimeoutsOutput
	ToNexusEndpointTimeoutsOutputWithContext(context.Context) NexusEndpointTimeoutsOutput
}

NexusEndpointTimeoutsInput is an input type that accepts NexusEndpointTimeoutsArgs and NexusEndpointTimeoutsOutput values. You can construct a concrete instance of `NexusEndpointTimeoutsInput` via:

NexusEndpointTimeoutsArgs{...}

type NexusEndpointTimeoutsOutput

type NexusEndpointTimeoutsOutput struct{ *pulumi.OutputState }

func (NexusEndpointTimeoutsOutput) 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 (NexusEndpointTimeoutsOutput) 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 (NexusEndpointTimeoutsOutput) ElementType

func (NexusEndpointTimeoutsOutput) ToNexusEndpointTimeoutsOutput

func (o NexusEndpointTimeoutsOutput) ToNexusEndpointTimeoutsOutput() NexusEndpointTimeoutsOutput

func (NexusEndpointTimeoutsOutput) ToNexusEndpointTimeoutsOutputWithContext

func (o NexusEndpointTimeoutsOutput) ToNexusEndpointTimeoutsOutputWithContext(ctx context.Context) NexusEndpointTimeoutsOutput

func (NexusEndpointTimeoutsOutput) ToNexusEndpointTimeoutsPtrOutput

func (o NexusEndpointTimeoutsOutput) ToNexusEndpointTimeoutsPtrOutput() NexusEndpointTimeoutsPtrOutput

func (NexusEndpointTimeoutsOutput) ToNexusEndpointTimeoutsPtrOutputWithContext

func (o NexusEndpointTimeoutsOutput) ToNexusEndpointTimeoutsPtrOutputWithContext(ctx context.Context) NexusEndpointTimeoutsPtrOutput

type NexusEndpointTimeoutsPtrInput

type NexusEndpointTimeoutsPtrInput interface {
	pulumi.Input

	ToNexusEndpointTimeoutsPtrOutput() NexusEndpointTimeoutsPtrOutput
	ToNexusEndpointTimeoutsPtrOutputWithContext(context.Context) NexusEndpointTimeoutsPtrOutput
}

NexusEndpointTimeoutsPtrInput is an input type that accepts NexusEndpointTimeoutsArgs, NexusEndpointTimeoutsPtr and NexusEndpointTimeoutsPtrOutput values. You can construct a concrete instance of `NexusEndpointTimeoutsPtrInput` via:

        NexusEndpointTimeoutsArgs{...}

or:

        nil

type NexusEndpointTimeoutsPtrOutput

type NexusEndpointTimeoutsPtrOutput struct{ *pulumi.OutputState }

func (NexusEndpointTimeoutsPtrOutput) 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 (NexusEndpointTimeoutsPtrOutput) 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 (NexusEndpointTimeoutsPtrOutput) Elem

func (NexusEndpointTimeoutsPtrOutput) ElementType

func (NexusEndpointTimeoutsPtrOutput) ToNexusEndpointTimeoutsPtrOutput

func (o NexusEndpointTimeoutsPtrOutput) ToNexusEndpointTimeoutsPtrOutput() NexusEndpointTimeoutsPtrOutput

func (NexusEndpointTimeoutsPtrOutput) ToNexusEndpointTimeoutsPtrOutputWithContext

func (o NexusEndpointTimeoutsPtrOutput) ToNexusEndpointTimeoutsPtrOutputWithContext(ctx context.Context) NexusEndpointTimeoutsPtrOutput

type NexusEndpointWorkerTarget

type NexusEndpointWorkerTarget struct {
	// The target cloud namespace to route requests to. Namespace must be in same account as the endpoint.
	NamespaceId string `pulumi:"namespaceId"`
	// The task queue on the cloud namespace to route requests to.
	TaskQueue string `pulumi:"taskQueue"`
}

type NexusEndpointWorkerTargetArgs

type NexusEndpointWorkerTargetArgs struct {
	// The target cloud namespace to route requests to. Namespace must be in same account as the endpoint.
	NamespaceId pulumi.StringInput `pulumi:"namespaceId"`
	// The task queue on the cloud namespace to route requests to.
	TaskQueue pulumi.StringInput `pulumi:"taskQueue"`
}

func (NexusEndpointWorkerTargetArgs) ElementType

func (NexusEndpointWorkerTargetArgs) ToNexusEndpointWorkerTargetOutput

func (i NexusEndpointWorkerTargetArgs) ToNexusEndpointWorkerTargetOutput() NexusEndpointWorkerTargetOutput

func (NexusEndpointWorkerTargetArgs) ToNexusEndpointWorkerTargetOutputWithContext

func (i NexusEndpointWorkerTargetArgs) ToNexusEndpointWorkerTargetOutputWithContext(ctx context.Context) NexusEndpointWorkerTargetOutput

func (NexusEndpointWorkerTargetArgs) ToNexusEndpointWorkerTargetPtrOutput

func (i NexusEndpointWorkerTargetArgs) ToNexusEndpointWorkerTargetPtrOutput() NexusEndpointWorkerTargetPtrOutput

func (NexusEndpointWorkerTargetArgs) ToNexusEndpointWorkerTargetPtrOutputWithContext

func (i NexusEndpointWorkerTargetArgs) ToNexusEndpointWorkerTargetPtrOutputWithContext(ctx context.Context) NexusEndpointWorkerTargetPtrOutput

type NexusEndpointWorkerTargetInput

type NexusEndpointWorkerTargetInput interface {
	pulumi.Input

	ToNexusEndpointWorkerTargetOutput() NexusEndpointWorkerTargetOutput
	ToNexusEndpointWorkerTargetOutputWithContext(context.Context) NexusEndpointWorkerTargetOutput
}

NexusEndpointWorkerTargetInput is an input type that accepts NexusEndpointWorkerTargetArgs and NexusEndpointWorkerTargetOutput values. You can construct a concrete instance of `NexusEndpointWorkerTargetInput` via:

NexusEndpointWorkerTargetArgs{...}

type NexusEndpointWorkerTargetOutput

type NexusEndpointWorkerTargetOutput struct{ *pulumi.OutputState }

func (NexusEndpointWorkerTargetOutput) ElementType

func (NexusEndpointWorkerTargetOutput) NamespaceId

The target cloud namespace to route requests to. Namespace must be in same account as the endpoint.

func (NexusEndpointWorkerTargetOutput) TaskQueue

The task queue on the cloud namespace to route requests to.

func (NexusEndpointWorkerTargetOutput) ToNexusEndpointWorkerTargetOutput

func (o NexusEndpointWorkerTargetOutput) ToNexusEndpointWorkerTargetOutput() NexusEndpointWorkerTargetOutput

func (NexusEndpointWorkerTargetOutput) ToNexusEndpointWorkerTargetOutputWithContext

func (o NexusEndpointWorkerTargetOutput) ToNexusEndpointWorkerTargetOutputWithContext(ctx context.Context) NexusEndpointWorkerTargetOutput

func (NexusEndpointWorkerTargetOutput) ToNexusEndpointWorkerTargetPtrOutput

func (o NexusEndpointWorkerTargetOutput) ToNexusEndpointWorkerTargetPtrOutput() NexusEndpointWorkerTargetPtrOutput

func (NexusEndpointWorkerTargetOutput) ToNexusEndpointWorkerTargetPtrOutputWithContext

func (o NexusEndpointWorkerTargetOutput) ToNexusEndpointWorkerTargetPtrOutputWithContext(ctx context.Context) NexusEndpointWorkerTargetPtrOutput

type NexusEndpointWorkerTargetPtrInput

type NexusEndpointWorkerTargetPtrInput interface {
	pulumi.Input

	ToNexusEndpointWorkerTargetPtrOutput() NexusEndpointWorkerTargetPtrOutput
	ToNexusEndpointWorkerTargetPtrOutputWithContext(context.Context) NexusEndpointWorkerTargetPtrOutput
}

NexusEndpointWorkerTargetPtrInput is an input type that accepts NexusEndpointWorkerTargetArgs, NexusEndpointWorkerTargetPtr and NexusEndpointWorkerTargetPtrOutput values. You can construct a concrete instance of `NexusEndpointWorkerTargetPtrInput` via:

        NexusEndpointWorkerTargetArgs{...}

or:

        nil

type NexusEndpointWorkerTargetPtrOutput

type NexusEndpointWorkerTargetPtrOutput struct{ *pulumi.OutputState }

func (NexusEndpointWorkerTargetPtrOutput) Elem

func (NexusEndpointWorkerTargetPtrOutput) ElementType

func (NexusEndpointWorkerTargetPtrOutput) NamespaceId

The target cloud namespace to route requests to. Namespace must be in same account as the endpoint.

func (NexusEndpointWorkerTargetPtrOutput) TaskQueue

The task queue on the cloud namespace to route requests to.

func (NexusEndpointWorkerTargetPtrOutput) ToNexusEndpointWorkerTargetPtrOutput

func (o NexusEndpointWorkerTargetPtrOutput) ToNexusEndpointWorkerTargetPtrOutput() NexusEndpointWorkerTargetPtrOutput

func (NexusEndpointWorkerTargetPtrOutput) ToNexusEndpointWorkerTargetPtrOutputWithContext

func (o NexusEndpointWorkerTargetPtrOutput) ToNexusEndpointWorkerTargetPtrOutputWithContext(ctx context.Context) NexusEndpointWorkerTargetPtrOutput

type Provider

type Provider struct {
	pulumi.ProviderResourceState

	// The ID of the account to operate on. Prevents accidental mutation of accounts other than that provided.
	AllowedAccountId pulumi.StringPtrOutput `pulumi:"allowedAccountId"`
	// The API key for Temporal Cloud. See [this documentation](https://docs.temporal.io/cloud/api-keys) for information on how
	// to obtain an API key.
	ApiKey pulumi.StringPtrOutput `pulumi:"apiKey"`
	// The endpoint for the Temporal Cloud API. Defaults to `saas-api.tmprl.cloud:443`.
	Endpoint pulumi.StringPtrOutput `pulumi:"endpoint"`
}

The provider type for the temporalcloud package. By default, resources use package-wide configuration settings, however an explicit `Provider` instance may be created and passed during resource construction to achieve fine-grained programmatic control over provider settings. See the [documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information.

func NewProvider

func NewProvider(ctx *pulumi.Context,
	name string, args *ProviderArgs, opts ...pulumi.ResourceOption) (*Provider, error)

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

func (*Provider) ElementType

func (*Provider) ElementType() reflect.Type

func (*Provider) ToProviderOutput

func (i *Provider) ToProviderOutput() ProviderOutput

func (*Provider) ToProviderOutputWithContext

func (i *Provider) ToProviderOutputWithContext(ctx context.Context) ProviderOutput

type ProviderArgs

type ProviderArgs struct {
	// If set to True, it allows for an insecure connection to the Temporal Cloud API. This should never be set to 'true' in
	// production and defaults to false.
	AllowInsecure pulumi.BoolPtrInput
	// The ID of the account to operate on. Prevents accidental mutation of accounts other than that provided.
	AllowedAccountId pulumi.StringPtrInput
	// The API key for Temporal Cloud. See [this documentation](https://docs.temporal.io/cloud/api-keys) for information on how
	// to obtain an API key.
	ApiKey pulumi.StringPtrInput
	// The endpoint for the Temporal Cloud API. Defaults to `saas-api.tmprl.cloud:443`.
	Endpoint pulumi.StringPtrInput
}

The set of arguments for constructing a Provider resource.

func (ProviderArgs) ElementType

func (ProviderArgs) ElementType() reflect.Type

type ProviderInput

type ProviderInput interface {
	pulumi.Input

	ToProviderOutput() ProviderOutput
	ToProviderOutputWithContext(ctx context.Context) ProviderOutput
}

type ProviderOutput

type ProviderOutput struct{ *pulumi.OutputState }

func (ProviderOutput) AllowedAccountId

func (o ProviderOutput) AllowedAccountId() pulumi.StringPtrOutput

The ID of the account to operate on. Prevents accidental mutation of accounts other than that provided.

func (ProviderOutput) ApiKey

The API key for Temporal Cloud. See [this documentation](https://docs.temporal.io/cloud/api-keys) for information on how to obtain an API key.

func (ProviderOutput) ElementType

func (ProviderOutput) ElementType() reflect.Type

func (ProviderOutput) Endpoint

func (o ProviderOutput) Endpoint() pulumi.StringPtrOutput

The endpoint for the Temporal Cloud API. Defaults to `saas-api.tmprl.cloud:443`.

func (ProviderOutput) ToProviderOutput

func (o ProviderOutput) ToProviderOutput() ProviderOutput

func (ProviderOutput) ToProviderOutputWithContext

func (o ProviderOutput) ToProviderOutputWithContext(ctx context.Context) ProviderOutput

type ServiceAccount

type ServiceAccount struct {
	pulumi.CustomResourceState

	// The role on the account. Must be one of admin, developer, or read (case-insensitive).
	AccountAccess pulumi.StringOutput `pulumi:"accountAccess"`
	// The name associated with the service account.
	Name pulumi.StringOutput `pulumi:"name"`
	// The set of namespace accesses. Empty sets are not allowed, omit the attribute instead. Service Accounts with an account*access role of admin cannot be assigned explicit permissions to namespaces. Admins implicitly receive access to all Namespaces.
	NamespaceAccesses ServiceAccountNamespaceAccessArrayOutput `pulumi:"namespaceAccesses"`
	// The current state of the Service Account.
	State    pulumi.StringOutput             `pulumi:"state"`
	Timeouts ServiceAccountTimeoutsPtrOutput `pulumi:"timeouts"`
}

Provisions a Temporal Cloud Service Account.

## Import

Service Accounts can be imported to incorporate existing Service Accounts into your Terraform pipeline.

To import a Service Account, you need

- a resource configuration in your Terraform configuration file/module to accept the imported Service Account. In the example below, the placeholder is "temporalcloud_service_account" "saimport"

- the Service Accounts's ID, which is found using the Temporal Cloud CLI tcld sa l. In the example below, this is e3cb94fbdbb845f480044d053d00665b

```sh $ pulumi import temporalcloud:index/serviceAccount:ServiceAccount saimport e3cb94fbdbb845f480044d053d00665b ```

func GetServiceAccount

func GetServiceAccount(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ServiceAccountState, opts ...pulumi.ResourceOption) (*ServiceAccount, error)

GetServiceAccount gets an existing ServiceAccount 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 NewServiceAccount

func NewServiceAccount(ctx *pulumi.Context,
	name string, args *ServiceAccountArgs, opts ...pulumi.ResourceOption) (*ServiceAccount, error)

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

func (*ServiceAccount) ElementType

func (*ServiceAccount) ElementType() reflect.Type

func (*ServiceAccount) ToServiceAccountOutput

func (i *ServiceAccount) ToServiceAccountOutput() ServiceAccountOutput

func (*ServiceAccount) ToServiceAccountOutputWithContext

func (i *ServiceAccount) ToServiceAccountOutputWithContext(ctx context.Context) ServiceAccountOutput

type ServiceAccountArgs

type ServiceAccountArgs struct {
	// The role on the account. Must be one of admin, developer, or read (case-insensitive).
	AccountAccess pulumi.StringInput
	// The name associated with the service account.
	Name pulumi.StringPtrInput
	// The set of namespace accesses. Empty sets are not allowed, omit the attribute instead. Service Accounts with an account*access role of admin cannot be assigned explicit permissions to namespaces. Admins implicitly receive access to all Namespaces.
	NamespaceAccesses ServiceAccountNamespaceAccessArrayInput
	Timeouts          ServiceAccountTimeoutsPtrInput
}

The set of arguments for constructing a ServiceAccount resource.

func (ServiceAccountArgs) ElementType

func (ServiceAccountArgs) ElementType() reflect.Type

type ServiceAccountArray

type ServiceAccountArray []ServiceAccountInput

func (ServiceAccountArray) ElementType

func (ServiceAccountArray) ElementType() reflect.Type

func (ServiceAccountArray) ToServiceAccountArrayOutput

func (i ServiceAccountArray) ToServiceAccountArrayOutput() ServiceAccountArrayOutput

func (ServiceAccountArray) ToServiceAccountArrayOutputWithContext

func (i ServiceAccountArray) ToServiceAccountArrayOutputWithContext(ctx context.Context) ServiceAccountArrayOutput

type ServiceAccountArrayInput

type ServiceAccountArrayInput interface {
	pulumi.Input

	ToServiceAccountArrayOutput() ServiceAccountArrayOutput
	ToServiceAccountArrayOutputWithContext(context.Context) ServiceAccountArrayOutput
}

ServiceAccountArrayInput is an input type that accepts ServiceAccountArray and ServiceAccountArrayOutput values. You can construct a concrete instance of `ServiceAccountArrayInput` via:

ServiceAccountArray{ ServiceAccountArgs{...} }

type ServiceAccountArrayOutput

type ServiceAccountArrayOutput struct{ *pulumi.OutputState }

func (ServiceAccountArrayOutput) ElementType

func (ServiceAccountArrayOutput) ElementType() reflect.Type

func (ServiceAccountArrayOutput) Index

func (ServiceAccountArrayOutput) ToServiceAccountArrayOutput

func (o ServiceAccountArrayOutput) ToServiceAccountArrayOutput() ServiceAccountArrayOutput

func (ServiceAccountArrayOutput) ToServiceAccountArrayOutputWithContext

func (o ServiceAccountArrayOutput) ToServiceAccountArrayOutputWithContext(ctx context.Context) ServiceAccountArrayOutput

type ServiceAccountInput

type ServiceAccountInput interface {
	pulumi.Input

	ToServiceAccountOutput() ServiceAccountOutput
	ToServiceAccountOutputWithContext(ctx context.Context) ServiceAccountOutput
}

type ServiceAccountMap

type ServiceAccountMap map[string]ServiceAccountInput

func (ServiceAccountMap) ElementType

func (ServiceAccountMap) ElementType() reflect.Type

func (ServiceAccountMap) ToServiceAccountMapOutput

func (i ServiceAccountMap) ToServiceAccountMapOutput() ServiceAccountMapOutput

func (ServiceAccountMap) ToServiceAccountMapOutputWithContext

func (i ServiceAccountMap) ToServiceAccountMapOutputWithContext(ctx context.Context) ServiceAccountMapOutput

type ServiceAccountMapInput

type ServiceAccountMapInput interface {
	pulumi.Input

	ToServiceAccountMapOutput() ServiceAccountMapOutput
	ToServiceAccountMapOutputWithContext(context.Context) ServiceAccountMapOutput
}

ServiceAccountMapInput is an input type that accepts ServiceAccountMap and ServiceAccountMapOutput values. You can construct a concrete instance of `ServiceAccountMapInput` via:

ServiceAccountMap{ "key": ServiceAccountArgs{...} }

type ServiceAccountMapOutput

type ServiceAccountMapOutput struct{ *pulumi.OutputState }

func (ServiceAccountMapOutput) ElementType

func (ServiceAccountMapOutput) ElementType() reflect.Type

func (ServiceAccountMapOutput) MapIndex

func (ServiceAccountMapOutput) ToServiceAccountMapOutput

func (o ServiceAccountMapOutput) ToServiceAccountMapOutput() ServiceAccountMapOutput

func (ServiceAccountMapOutput) ToServiceAccountMapOutputWithContext

func (o ServiceAccountMapOutput) ToServiceAccountMapOutputWithContext(ctx context.Context) ServiceAccountMapOutput

type ServiceAccountNamespaceAccess

type ServiceAccountNamespaceAccess struct {
	// The namespace to assign permissions to.
	NamespaceId string `pulumi:"namespaceId"`
	// The permission to assign. Must be one of admin, write, or read (case-insensitive)
	Permission string `pulumi:"permission"`
}

type ServiceAccountNamespaceAccessArgs

type ServiceAccountNamespaceAccessArgs struct {
	// The namespace to assign permissions to.
	NamespaceId pulumi.StringInput `pulumi:"namespaceId"`
	// The permission to assign. Must be one of admin, write, or read (case-insensitive)
	Permission pulumi.StringInput `pulumi:"permission"`
}

func (ServiceAccountNamespaceAccessArgs) ElementType

func (ServiceAccountNamespaceAccessArgs) ToServiceAccountNamespaceAccessOutput

func (i ServiceAccountNamespaceAccessArgs) ToServiceAccountNamespaceAccessOutput() ServiceAccountNamespaceAccessOutput

func (ServiceAccountNamespaceAccessArgs) ToServiceAccountNamespaceAccessOutputWithContext

func (i ServiceAccountNamespaceAccessArgs) ToServiceAccountNamespaceAccessOutputWithContext(ctx context.Context) ServiceAccountNamespaceAccessOutput

type ServiceAccountNamespaceAccessArray

type ServiceAccountNamespaceAccessArray []ServiceAccountNamespaceAccessInput

func (ServiceAccountNamespaceAccessArray) ElementType

func (ServiceAccountNamespaceAccessArray) ToServiceAccountNamespaceAccessArrayOutput

func (i ServiceAccountNamespaceAccessArray) ToServiceAccountNamespaceAccessArrayOutput() ServiceAccountNamespaceAccessArrayOutput

func (ServiceAccountNamespaceAccessArray) ToServiceAccountNamespaceAccessArrayOutputWithContext

func (i ServiceAccountNamespaceAccessArray) ToServiceAccountNamespaceAccessArrayOutputWithContext(ctx context.Context) ServiceAccountNamespaceAccessArrayOutput

type ServiceAccountNamespaceAccessArrayInput

type ServiceAccountNamespaceAccessArrayInput interface {
	pulumi.Input

	ToServiceAccountNamespaceAccessArrayOutput() ServiceAccountNamespaceAccessArrayOutput
	ToServiceAccountNamespaceAccessArrayOutputWithContext(context.Context) ServiceAccountNamespaceAccessArrayOutput
}

ServiceAccountNamespaceAccessArrayInput is an input type that accepts ServiceAccountNamespaceAccessArray and ServiceAccountNamespaceAccessArrayOutput values. You can construct a concrete instance of `ServiceAccountNamespaceAccessArrayInput` via:

ServiceAccountNamespaceAccessArray{ ServiceAccountNamespaceAccessArgs{...} }

type ServiceAccountNamespaceAccessArrayOutput

type ServiceAccountNamespaceAccessArrayOutput struct{ *pulumi.OutputState }

func (ServiceAccountNamespaceAccessArrayOutput) ElementType

func (ServiceAccountNamespaceAccessArrayOutput) Index

func (ServiceAccountNamespaceAccessArrayOutput) ToServiceAccountNamespaceAccessArrayOutput

func (o ServiceAccountNamespaceAccessArrayOutput) ToServiceAccountNamespaceAccessArrayOutput() ServiceAccountNamespaceAccessArrayOutput

func (ServiceAccountNamespaceAccessArrayOutput) ToServiceAccountNamespaceAccessArrayOutputWithContext

func (o ServiceAccountNamespaceAccessArrayOutput) ToServiceAccountNamespaceAccessArrayOutputWithContext(ctx context.Context) ServiceAccountNamespaceAccessArrayOutput

type ServiceAccountNamespaceAccessInput

type ServiceAccountNamespaceAccessInput interface {
	pulumi.Input

	ToServiceAccountNamespaceAccessOutput() ServiceAccountNamespaceAccessOutput
	ToServiceAccountNamespaceAccessOutputWithContext(context.Context) ServiceAccountNamespaceAccessOutput
}

ServiceAccountNamespaceAccessInput is an input type that accepts ServiceAccountNamespaceAccessArgs and ServiceAccountNamespaceAccessOutput values. You can construct a concrete instance of `ServiceAccountNamespaceAccessInput` via:

ServiceAccountNamespaceAccessArgs{...}

type ServiceAccountNamespaceAccessOutput

type ServiceAccountNamespaceAccessOutput struct{ *pulumi.OutputState }

func (ServiceAccountNamespaceAccessOutput) ElementType

func (ServiceAccountNamespaceAccessOutput) NamespaceId

The namespace to assign permissions to.

func (ServiceAccountNamespaceAccessOutput) Permission

The permission to assign. Must be one of admin, write, or read (case-insensitive)

func (ServiceAccountNamespaceAccessOutput) ToServiceAccountNamespaceAccessOutput

func (o ServiceAccountNamespaceAccessOutput) ToServiceAccountNamespaceAccessOutput() ServiceAccountNamespaceAccessOutput

func (ServiceAccountNamespaceAccessOutput) ToServiceAccountNamespaceAccessOutputWithContext

func (o ServiceAccountNamespaceAccessOutput) ToServiceAccountNamespaceAccessOutputWithContext(ctx context.Context) ServiceAccountNamespaceAccessOutput

type ServiceAccountOutput

type ServiceAccountOutput struct{ *pulumi.OutputState }

func (ServiceAccountOutput) AccountAccess

func (o ServiceAccountOutput) AccountAccess() pulumi.StringOutput

The role on the account. Must be one of admin, developer, or read (case-insensitive).

func (ServiceAccountOutput) ElementType

func (ServiceAccountOutput) ElementType() reflect.Type

func (ServiceAccountOutput) Name

The name associated with the service account.

func (ServiceAccountOutput) NamespaceAccesses

The set of namespace accesses. Empty sets are not allowed, omit the attribute instead. Service Accounts with an account*access role of admin cannot be assigned explicit permissions to namespaces. Admins implicitly receive access to all Namespaces.

func (ServiceAccountOutput) State

The current state of the Service Account.

func (ServiceAccountOutput) Timeouts

func (ServiceAccountOutput) ToServiceAccountOutput

func (o ServiceAccountOutput) ToServiceAccountOutput() ServiceAccountOutput

func (ServiceAccountOutput) ToServiceAccountOutputWithContext

func (o ServiceAccountOutput) ToServiceAccountOutputWithContext(ctx context.Context) ServiceAccountOutput

type ServiceAccountState

type ServiceAccountState struct {
	// The role on the account. Must be one of admin, developer, or read (case-insensitive).
	AccountAccess pulumi.StringPtrInput
	// The name associated with the service account.
	Name pulumi.StringPtrInput
	// The set of namespace accesses. Empty sets are not allowed, omit the attribute instead. Service Accounts with an account*access role of admin cannot be assigned explicit permissions to namespaces. Admins implicitly receive access to all Namespaces.
	NamespaceAccesses ServiceAccountNamespaceAccessArrayInput
	// The current state of the Service Account.
	State    pulumi.StringPtrInput
	Timeouts ServiceAccountTimeoutsPtrInput
}

func (ServiceAccountState) ElementType

func (ServiceAccountState) ElementType() reflect.Type

type ServiceAccountTimeouts

type ServiceAccountTimeouts 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 ServiceAccountTimeoutsArgs

type ServiceAccountTimeoutsArgs 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 (ServiceAccountTimeoutsArgs) ElementType

func (ServiceAccountTimeoutsArgs) ElementType() reflect.Type

func (ServiceAccountTimeoutsArgs) ToServiceAccountTimeoutsOutput

func (i ServiceAccountTimeoutsArgs) ToServiceAccountTimeoutsOutput() ServiceAccountTimeoutsOutput

func (ServiceAccountTimeoutsArgs) ToServiceAccountTimeoutsOutputWithContext

func (i ServiceAccountTimeoutsArgs) ToServiceAccountTimeoutsOutputWithContext(ctx context.Context) ServiceAccountTimeoutsOutput

func (ServiceAccountTimeoutsArgs) ToServiceAccountTimeoutsPtrOutput

func (i ServiceAccountTimeoutsArgs) ToServiceAccountTimeoutsPtrOutput() ServiceAccountTimeoutsPtrOutput

func (ServiceAccountTimeoutsArgs) ToServiceAccountTimeoutsPtrOutputWithContext

func (i ServiceAccountTimeoutsArgs) ToServiceAccountTimeoutsPtrOutputWithContext(ctx context.Context) ServiceAccountTimeoutsPtrOutput

type ServiceAccountTimeoutsInput

type ServiceAccountTimeoutsInput interface {
	pulumi.Input

	ToServiceAccountTimeoutsOutput() ServiceAccountTimeoutsOutput
	ToServiceAccountTimeoutsOutputWithContext(context.Context) ServiceAccountTimeoutsOutput
}

ServiceAccountTimeoutsInput is an input type that accepts ServiceAccountTimeoutsArgs and ServiceAccountTimeoutsOutput values. You can construct a concrete instance of `ServiceAccountTimeoutsInput` via:

ServiceAccountTimeoutsArgs{...}

type ServiceAccountTimeoutsOutput

type ServiceAccountTimeoutsOutput struct{ *pulumi.OutputState }

func (ServiceAccountTimeoutsOutput) 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 (ServiceAccountTimeoutsOutput) 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 (ServiceAccountTimeoutsOutput) ElementType

func (ServiceAccountTimeoutsOutput) ToServiceAccountTimeoutsOutput

func (o ServiceAccountTimeoutsOutput) ToServiceAccountTimeoutsOutput() ServiceAccountTimeoutsOutput

func (ServiceAccountTimeoutsOutput) ToServiceAccountTimeoutsOutputWithContext

func (o ServiceAccountTimeoutsOutput) ToServiceAccountTimeoutsOutputWithContext(ctx context.Context) ServiceAccountTimeoutsOutput

func (ServiceAccountTimeoutsOutput) ToServiceAccountTimeoutsPtrOutput

func (o ServiceAccountTimeoutsOutput) ToServiceAccountTimeoutsPtrOutput() ServiceAccountTimeoutsPtrOutput

func (ServiceAccountTimeoutsOutput) ToServiceAccountTimeoutsPtrOutputWithContext

func (o ServiceAccountTimeoutsOutput) ToServiceAccountTimeoutsPtrOutputWithContext(ctx context.Context) ServiceAccountTimeoutsPtrOutput

type ServiceAccountTimeoutsPtrInput

type ServiceAccountTimeoutsPtrInput interface {
	pulumi.Input

	ToServiceAccountTimeoutsPtrOutput() ServiceAccountTimeoutsPtrOutput
	ToServiceAccountTimeoutsPtrOutputWithContext(context.Context) ServiceAccountTimeoutsPtrOutput
}

ServiceAccountTimeoutsPtrInput is an input type that accepts ServiceAccountTimeoutsArgs, ServiceAccountTimeoutsPtr and ServiceAccountTimeoutsPtrOutput values. You can construct a concrete instance of `ServiceAccountTimeoutsPtrInput` via:

        ServiceAccountTimeoutsArgs{...}

or:

        nil

type ServiceAccountTimeoutsPtrOutput

type ServiceAccountTimeoutsPtrOutput struct{ *pulumi.OutputState }

func (ServiceAccountTimeoutsPtrOutput) 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 (ServiceAccountTimeoutsPtrOutput) 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 (ServiceAccountTimeoutsPtrOutput) Elem

func (ServiceAccountTimeoutsPtrOutput) ElementType

func (ServiceAccountTimeoutsPtrOutput) ToServiceAccountTimeoutsPtrOutput

func (o ServiceAccountTimeoutsPtrOutput) ToServiceAccountTimeoutsPtrOutput() ServiceAccountTimeoutsPtrOutput

func (ServiceAccountTimeoutsPtrOutput) ToServiceAccountTimeoutsPtrOutputWithContext

func (o ServiceAccountTimeoutsPtrOutput) ToServiceAccountTimeoutsPtrOutputWithContext(ctx context.Context) ServiceAccountTimeoutsPtrOutput

type User

type User struct {
	pulumi.CustomResourceState

	// The role on the account. Must be one of owner, admin, developer, or read (case-insensitive). owner is only valid for import and cannot be created, updated or deleted without Temporal support.
	AccountAccess pulumi.StringOutput `pulumi:"accountAccess"`
	// The email address for the user.
	Email pulumi.StringOutput `pulumi:"email"`
	// The set of namespace accesses. Empty sets are not allowed, omit the attribute instead. Users with account*access roles of owner or admin cannot be assigned explicit permissions to namespaces. They implicitly receive access to all Namespaces.
	NamespaceAccesses UserNamespaceAccessArrayOutput `pulumi:"namespaceAccesses"`
	// The current state of the user.
	State    pulumi.StringOutput   `pulumi:"state"`
	Timeouts UserTimeoutsPtrOutput `pulumi:"timeouts"`
}

Provisions a Temporal Cloud user.

## Import

Users can be imported to incorporate existing Users into your Terraform pipeline.

To import a User, you need

- a resource configuration in your Terraform configuration file/module to accept the imported User. In the example below, the placeholder is "temporalcloud_user" "user"

- the User's ID, which is found using the Temporal Cloud CLI tcld u l. In the example below, this is 72360058153949edb2f1d47019c1e85f

```sh $ pulumi import temporalcloud:index/user:User user 72360058153949edb2f1d47019c1e85f ```

func GetUser

func GetUser(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *UserState, opts ...pulumi.ResourceOption) (*User, error)

GetUser gets an existing User 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 NewUser

func NewUser(ctx *pulumi.Context,
	name string, args *UserArgs, opts ...pulumi.ResourceOption) (*User, error)

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

func (*User) ElementType

func (*User) ElementType() reflect.Type

func (*User) ToUserOutput

func (i *User) ToUserOutput() UserOutput

func (*User) ToUserOutputWithContext

func (i *User) ToUserOutputWithContext(ctx context.Context) UserOutput

type UserArgs

type UserArgs struct {
	// The role on the account. Must be one of owner, admin, developer, or read (case-insensitive). owner is only valid for import and cannot be created, updated or deleted without Temporal support.
	AccountAccess pulumi.StringInput
	// The email address for the user.
	Email pulumi.StringInput
	// The set of namespace accesses. Empty sets are not allowed, omit the attribute instead. Users with account*access roles of owner or admin cannot be assigned explicit permissions to namespaces. They implicitly receive access to all Namespaces.
	NamespaceAccesses UserNamespaceAccessArrayInput
	Timeouts          UserTimeoutsPtrInput
}

The set of arguments for constructing a User resource.

func (UserArgs) ElementType

func (UserArgs) ElementType() reflect.Type

type UserArray

type UserArray []UserInput

func (UserArray) ElementType

func (UserArray) ElementType() reflect.Type

func (UserArray) ToUserArrayOutput

func (i UserArray) ToUserArrayOutput() UserArrayOutput

func (UserArray) ToUserArrayOutputWithContext

func (i UserArray) ToUserArrayOutputWithContext(ctx context.Context) UserArrayOutput

type UserArrayInput

type UserArrayInput interface {
	pulumi.Input

	ToUserArrayOutput() UserArrayOutput
	ToUserArrayOutputWithContext(context.Context) UserArrayOutput
}

UserArrayInput is an input type that accepts UserArray and UserArrayOutput values. You can construct a concrete instance of `UserArrayInput` via:

UserArray{ UserArgs{...} }

type UserArrayOutput

type UserArrayOutput struct{ *pulumi.OutputState }

func (UserArrayOutput) ElementType

func (UserArrayOutput) ElementType() reflect.Type

func (UserArrayOutput) Index

func (UserArrayOutput) ToUserArrayOutput

func (o UserArrayOutput) ToUserArrayOutput() UserArrayOutput

func (UserArrayOutput) ToUserArrayOutputWithContext

func (o UserArrayOutput) ToUserArrayOutputWithContext(ctx context.Context) UserArrayOutput

type UserInput

type UserInput interface {
	pulumi.Input

	ToUserOutput() UserOutput
	ToUserOutputWithContext(ctx context.Context) UserOutput
}

type UserMap

type UserMap map[string]UserInput

func (UserMap) ElementType

func (UserMap) ElementType() reflect.Type

func (UserMap) ToUserMapOutput

func (i UserMap) ToUserMapOutput() UserMapOutput

func (UserMap) ToUserMapOutputWithContext

func (i UserMap) ToUserMapOutputWithContext(ctx context.Context) UserMapOutput

type UserMapInput

type UserMapInput interface {
	pulumi.Input

	ToUserMapOutput() UserMapOutput
	ToUserMapOutputWithContext(context.Context) UserMapOutput
}

UserMapInput is an input type that accepts UserMap and UserMapOutput values. You can construct a concrete instance of `UserMapInput` via:

UserMap{ "key": UserArgs{...} }

type UserMapOutput

type UserMapOutput struct{ *pulumi.OutputState }

func (UserMapOutput) ElementType

func (UserMapOutput) ElementType() reflect.Type

func (UserMapOutput) MapIndex

func (UserMapOutput) ToUserMapOutput

func (o UserMapOutput) ToUserMapOutput() UserMapOutput

func (UserMapOutput) ToUserMapOutputWithContext

func (o UserMapOutput) ToUserMapOutputWithContext(ctx context.Context) UserMapOutput

type UserNamespaceAccess

type UserNamespaceAccess struct {
	// The namespace to assign permissions to.
	NamespaceId string `pulumi:"namespaceId"`
	// The permission to assign. Must be one of admin, write, or read (case-insensitive)
	Permission string `pulumi:"permission"`
}

type UserNamespaceAccessArgs

type UserNamespaceAccessArgs struct {
	// The namespace to assign permissions to.
	NamespaceId pulumi.StringInput `pulumi:"namespaceId"`
	// The permission to assign. Must be one of admin, write, or read (case-insensitive)
	Permission pulumi.StringInput `pulumi:"permission"`
}

func (UserNamespaceAccessArgs) ElementType

func (UserNamespaceAccessArgs) ElementType() reflect.Type

func (UserNamespaceAccessArgs) ToUserNamespaceAccessOutput

func (i UserNamespaceAccessArgs) ToUserNamespaceAccessOutput() UserNamespaceAccessOutput

func (UserNamespaceAccessArgs) ToUserNamespaceAccessOutputWithContext

func (i UserNamespaceAccessArgs) ToUserNamespaceAccessOutputWithContext(ctx context.Context) UserNamespaceAccessOutput

type UserNamespaceAccessArray

type UserNamespaceAccessArray []UserNamespaceAccessInput

func (UserNamespaceAccessArray) ElementType

func (UserNamespaceAccessArray) ElementType() reflect.Type

func (UserNamespaceAccessArray) ToUserNamespaceAccessArrayOutput

func (i UserNamespaceAccessArray) ToUserNamespaceAccessArrayOutput() UserNamespaceAccessArrayOutput

func (UserNamespaceAccessArray) ToUserNamespaceAccessArrayOutputWithContext

func (i UserNamespaceAccessArray) ToUserNamespaceAccessArrayOutputWithContext(ctx context.Context) UserNamespaceAccessArrayOutput

type UserNamespaceAccessArrayInput

type UserNamespaceAccessArrayInput interface {
	pulumi.Input

	ToUserNamespaceAccessArrayOutput() UserNamespaceAccessArrayOutput
	ToUserNamespaceAccessArrayOutputWithContext(context.Context) UserNamespaceAccessArrayOutput
}

UserNamespaceAccessArrayInput is an input type that accepts UserNamespaceAccessArray and UserNamespaceAccessArrayOutput values. You can construct a concrete instance of `UserNamespaceAccessArrayInput` via:

UserNamespaceAccessArray{ UserNamespaceAccessArgs{...} }

type UserNamespaceAccessArrayOutput

type UserNamespaceAccessArrayOutput struct{ *pulumi.OutputState }

func (UserNamespaceAccessArrayOutput) ElementType

func (UserNamespaceAccessArrayOutput) Index

func (UserNamespaceAccessArrayOutput) ToUserNamespaceAccessArrayOutput

func (o UserNamespaceAccessArrayOutput) ToUserNamespaceAccessArrayOutput() UserNamespaceAccessArrayOutput

func (UserNamespaceAccessArrayOutput) ToUserNamespaceAccessArrayOutputWithContext

func (o UserNamespaceAccessArrayOutput) ToUserNamespaceAccessArrayOutputWithContext(ctx context.Context) UserNamespaceAccessArrayOutput

type UserNamespaceAccessInput

type UserNamespaceAccessInput interface {
	pulumi.Input

	ToUserNamespaceAccessOutput() UserNamespaceAccessOutput
	ToUserNamespaceAccessOutputWithContext(context.Context) UserNamespaceAccessOutput
}

UserNamespaceAccessInput is an input type that accepts UserNamespaceAccessArgs and UserNamespaceAccessOutput values. You can construct a concrete instance of `UserNamespaceAccessInput` via:

UserNamespaceAccessArgs{...}

type UserNamespaceAccessOutput

type UserNamespaceAccessOutput struct{ *pulumi.OutputState }

func (UserNamespaceAccessOutput) ElementType

func (UserNamespaceAccessOutput) ElementType() reflect.Type

func (UserNamespaceAccessOutput) NamespaceId

The namespace to assign permissions to.

func (UserNamespaceAccessOutput) Permission

The permission to assign. Must be one of admin, write, or read (case-insensitive)

func (UserNamespaceAccessOutput) ToUserNamespaceAccessOutput

func (o UserNamespaceAccessOutput) ToUserNamespaceAccessOutput() UserNamespaceAccessOutput

func (UserNamespaceAccessOutput) ToUserNamespaceAccessOutputWithContext

func (o UserNamespaceAccessOutput) ToUserNamespaceAccessOutputWithContext(ctx context.Context) UserNamespaceAccessOutput

type UserOutput

type UserOutput struct{ *pulumi.OutputState }

func (UserOutput) AccountAccess

func (o UserOutput) AccountAccess() pulumi.StringOutput

The role on the account. Must be one of owner, admin, developer, or read (case-insensitive). owner is only valid for import and cannot be created, updated or deleted without Temporal support.

func (UserOutput) ElementType

func (UserOutput) ElementType() reflect.Type

func (UserOutput) Email

func (o UserOutput) Email() pulumi.StringOutput

The email address for the user.

func (UserOutput) NamespaceAccesses

func (o UserOutput) NamespaceAccesses() UserNamespaceAccessArrayOutput

The set of namespace accesses. Empty sets are not allowed, omit the attribute instead. Users with account*access roles of owner or admin cannot be assigned explicit permissions to namespaces. They implicitly receive access to all Namespaces.

func (UserOutput) State

func (o UserOutput) State() pulumi.StringOutput

The current state of the user.

func (UserOutput) Timeouts

func (o UserOutput) Timeouts() UserTimeoutsPtrOutput

func (UserOutput) ToUserOutput

func (o UserOutput) ToUserOutput() UserOutput

func (UserOutput) ToUserOutputWithContext

func (o UserOutput) ToUserOutputWithContext(ctx context.Context) UserOutput

type UserState

type UserState struct {
	// The role on the account. Must be one of owner, admin, developer, or read (case-insensitive). owner is only valid for import and cannot be created, updated or deleted without Temporal support.
	AccountAccess pulumi.StringPtrInput
	// The email address for the user.
	Email pulumi.StringPtrInput
	// The set of namespace accesses. Empty sets are not allowed, omit the attribute instead. Users with account*access roles of owner or admin cannot be assigned explicit permissions to namespaces. They implicitly receive access to all Namespaces.
	NamespaceAccesses UserNamespaceAccessArrayInput
	// The current state of the user.
	State    pulumi.StringPtrInput
	Timeouts UserTimeoutsPtrInput
}

func (UserState) ElementType

func (UserState) ElementType() reflect.Type

type UserTimeouts

type UserTimeouts 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 UserTimeoutsArgs

type UserTimeoutsArgs 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 (UserTimeoutsArgs) ElementType

func (UserTimeoutsArgs) ElementType() reflect.Type

func (UserTimeoutsArgs) ToUserTimeoutsOutput

func (i UserTimeoutsArgs) ToUserTimeoutsOutput() UserTimeoutsOutput

func (UserTimeoutsArgs) ToUserTimeoutsOutputWithContext

func (i UserTimeoutsArgs) ToUserTimeoutsOutputWithContext(ctx context.Context) UserTimeoutsOutput

func (UserTimeoutsArgs) ToUserTimeoutsPtrOutput

func (i UserTimeoutsArgs) ToUserTimeoutsPtrOutput() UserTimeoutsPtrOutput

func (UserTimeoutsArgs) ToUserTimeoutsPtrOutputWithContext

func (i UserTimeoutsArgs) ToUserTimeoutsPtrOutputWithContext(ctx context.Context) UserTimeoutsPtrOutput

type UserTimeoutsInput

type UserTimeoutsInput interface {
	pulumi.Input

	ToUserTimeoutsOutput() UserTimeoutsOutput
	ToUserTimeoutsOutputWithContext(context.Context) UserTimeoutsOutput
}

UserTimeoutsInput is an input type that accepts UserTimeoutsArgs and UserTimeoutsOutput values. You can construct a concrete instance of `UserTimeoutsInput` via:

UserTimeoutsArgs{...}

type UserTimeoutsOutput

type UserTimeoutsOutput struct{ *pulumi.OutputState }

func (UserTimeoutsOutput) 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 (UserTimeoutsOutput) 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 (UserTimeoutsOutput) ElementType

func (UserTimeoutsOutput) ElementType() reflect.Type

func (UserTimeoutsOutput) ToUserTimeoutsOutput

func (o UserTimeoutsOutput) ToUserTimeoutsOutput() UserTimeoutsOutput

func (UserTimeoutsOutput) ToUserTimeoutsOutputWithContext

func (o UserTimeoutsOutput) ToUserTimeoutsOutputWithContext(ctx context.Context) UserTimeoutsOutput

func (UserTimeoutsOutput) ToUserTimeoutsPtrOutput

func (o UserTimeoutsOutput) ToUserTimeoutsPtrOutput() UserTimeoutsPtrOutput

func (UserTimeoutsOutput) ToUserTimeoutsPtrOutputWithContext

func (o UserTimeoutsOutput) ToUserTimeoutsPtrOutputWithContext(ctx context.Context) UserTimeoutsPtrOutput

type UserTimeoutsPtrInput

type UserTimeoutsPtrInput interface {
	pulumi.Input

	ToUserTimeoutsPtrOutput() UserTimeoutsPtrOutput
	ToUserTimeoutsPtrOutputWithContext(context.Context) UserTimeoutsPtrOutput
}

UserTimeoutsPtrInput is an input type that accepts UserTimeoutsArgs, UserTimeoutsPtr and UserTimeoutsPtrOutput values. You can construct a concrete instance of `UserTimeoutsPtrInput` via:

        UserTimeoutsArgs{...}

or:

        nil

type UserTimeoutsPtrOutput

type UserTimeoutsPtrOutput struct{ *pulumi.OutputState }

func (UserTimeoutsPtrOutput) 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 (UserTimeoutsPtrOutput) 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 (UserTimeoutsPtrOutput) Elem

func (UserTimeoutsPtrOutput) ElementType

func (UserTimeoutsPtrOutput) ElementType() reflect.Type

func (UserTimeoutsPtrOutput) ToUserTimeoutsPtrOutput

func (o UserTimeoutsPtrOutput) ToUserTimeoutsPtrOutput() UserTimeoutsPtrOutput

func (UserTimeoutsPtrOutput) ToUserTimeoutsPtrOutputWithContext

func (o UserTimeoutsPtrOutput) ToUserTimeoutsPtrOutputWithContext(ctx context.Context) UserTimeoutsPtrOutput

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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