okta

package
v6.5.0 Latest Latest
Warning

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

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

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AuthBackend 

type AuthBackend struct {
	pulumi.CustomResourceState

	// The mount accessor related to the auth mount. It is useful for integration with [Identity Secrets Engine](https://www.vaultproject.io/docs/secrets/identity/index.html).
	Accessor pulumi.StringOutput `pulumi:"accessor"`
	// The Okta url. Examples: oktapreview.com, okta.com
	BaseUrl pulumi.StringPtrOutput `pulumi:"baseUrl"`
	// When true, requests by Okta for a MFA check will be bypassed. This also disallows certain status checks on the account, such as whether the password is expired.
	BypassOktaMfa pulumi.BoolPtrOutput `pulumi:"bypassOktaMfa"`
	// The description of the auth backend
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// If set, opts out of mount migration on path updates.
	// See here for more info on [Mount Migration](https://www.vaultproject.io/docs/concepts/mount-migration)
	DisableRemount pulumi.BoolPtrOutput `pulumi:"disableRemount"`
	// Associate Okta groups with policies within Vault.
	// See below for more details.
	Groups AuthBackendGroupTypeArrayOutput `pulumi:"groups"`
	// Maximum duration after which authentication will be expired
	// [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).
	//
	// Deprecated: Deprecated. Please use `tokenMaxTtl` instead.
	MaxTtl pulumi.StringPtrOutput `pulumi:"maxTtl"`
	// The namespace to provision the resource in.
	// The value should not contain leading or trailing forward slashes.
	// The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
	// *Available only for Vault Enterprise*.
	Namespace pulumi.StringPtrOutput `pulumi:"namespace"`
	// The Okta organization. This will be the first part of the url `https://XXX.okta.com`
	Organization pulumi.StringOutput `pulumi:"organization"`
	// Path to mount the Okta auth backend. Default to path `okta`.
	Path pulumi.StringPtrOutput `pulumi:"path"`
	// The Okta API token. This is required to query Okta for user group membership.
	// If this is not supplied only locally configured groups will be enabled.
	Token pulumi.StringPtrOutput `pulumi:"token"`
	// Specifies the blocks of IP addresses which are allowed to use the generated token
	TokenBoundCidrs pulumi.StringArrayOutput `pulumi:"tokenBoundCidrs"`
	// Generated Token's Explicit Maximum TTL in seconds
	TokenExplicitMaxTtl pulumi.IntPtrOutput `pulumi:"tokenExplicitMaxTtl"`
	// The maximum lifetime of the generated token
	TokenMaxTtl pulumi.IntPtrOutput `pulumi:"tokenMaxTtl"`
	// If true, the 'default' policy will not automatically be added to generated tokens
	TokenNoDefaultPolicy pulumi.BoolPtrOutput `pulumi:"tokenNoDefaultPolicy"`
	// The maximum number of times a token may be used, a value of zero means unlimited
	TokenNumUses pulumi.IntPtrOutput `pulumi:"tokenNumUses"`
	// Generated Token's Period
	TokenPeriod pulumi.IntPtrOutput `pulumi:"tokenPeriod"`
	// Generated Token's Policies
	TokenPolicies pulumi.StringArrayOutput `pulumi:"tokenPolicies"`
	// The initial ttl of the token to generate in seconds
	TokenTtl pulumi.IntPtrOutput `pulumi:"tokenTtl"`
	// The type of token to generate, service or batch
	TokenType pulumi.StringPtrOutput `pulumi:"tokenType"`
	// Duration after which authentication will be expired.
	// [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).
	//
	// Deprecated: Deprecated. Please use `tokenTtl` instead.
	Ttl pulumi.StringPtrOutput `pulumi:"ttl"`
	// Associate Okta users with groups or policies within Vault.
	// See below for more details.
	Users AuthBackendUserTypeArrayOutput `pulumi:"users"`
}

Provides a resource for managing an [Okta auth backend within Vault](https://www.vaultproject.io/docs/auth/okta.html).

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-vault/sdk/v6/go/vault/okta"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := okta.NewAuthBackend(ctx, "example", &okta.AuthBackendArgs{
			Description:  pulumi.String("Demonstration of the Terraform Okta auth backend"),
			Organization: pulumi.String("example"),
			Token:        pulumi.String("something that should be kept secret"),
			Groups: okta.AuthBackendGroupTypeArray{
				&okta.AuthBackendGroupTypeArgs{
					GroupName: pulumi.String("foo"),
					Policies: pulumi.StringArray{
						pulumi.String("one"),
						pulumi.String("two"),
					},
				},
			},
			Users: okta.AuthBackendUserTypeArray{
				&okta.AuthBackendUserTypeArgs{
					Username: pulumi.String("bar"),
					Groups: pulumi.StringArray{
						pulumi.String("foo"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Okta authentication backends can be imported using its `path`, e.g.

```sh $ pulumi import vault:okta/authBackend:AuthBackend example okta ```

func GetAuthBackend 

func GetAuthBackend(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AuthBackendState, opts ...pulumi.ResourceOption) (*AuthBackend, error)

GetAuthBackend gets an existing AuthBackend 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 NewAuthBackend 

func NewAuthBackend(ctx *pulumi.Context,
	name string, args *AuthBackendArgs, opts ...pulumi.ResourceOption) (*AuthBackend, error)

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

func (*AuthBackend) ElementType 

func (*AuthBackend) ElementType() reflect.Type

func (*AuthBackend) ToAuthBackendOutput 

func (i *AuthBackend) ToAuthBackendOutput() AuthBackendOutput

func (*AuthBackend) ToAuthBackendOutputWithContext 

func (i *AuthBackend) ToAuthBackendOutputWithContext(ctx context.Context) AuthBackendOutput

type AuthBackendArgs 

type AuthBackendArgs struct {
	// The Okta url. Examples: oktapreview.com, okta.com
	BaseUrl pulumi.StringPtrInput
	// When true, requests by Okta for a MFA check will be bypassed. This also disallows certain status checks on the account, such as whether the password is expired.
	BypassOktaMfa pulumi.BoolPtrInput
	// The description of the auth backend
	Description pulumi.StringPtrInput
	// If set, opts out of mount migration on path updates.
	// See here for more info on [Mount Migration](https://www.vaultproject.io/docs/concepts/mount-migration)
	DisableRemount pulumi.BoolPtrInput
	// Associate Okta groups with policies within Vault.
	// See below for more details.
	Groups AuthBackendGroupTypeArrayInput
	// Maximum duration after which authentication will be expired
	// [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).
	//
	// Deprecated: Deprecated. Please use `tokenMaxTtl` instead.
	MaxTtl pulumi.StringPtrInput
	// The namespace to provision the resource in.
	// The value should not contain leading or trailing forward slashes.
	// The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
	// *Available only for Vault Enterprise*.
	Namespace pulumi.StringPtrInput
	// The Okta organization. This will be the first part of the url `https://XXX.okta.com`
	Organization pulumi.StringInput
	// Path to mount the Okta auth backend. Default to path `okta`.
	Path pulumi.StringPtrInput
	// The Okta API token. This is required to query Okta for user group membership.
	// If this is not supplied only locally configured groups will be enabled.
	Token pulumi.StringPtrInput
	// Specifies the blocks of IP addresses which are allowed to use the generated token
	TokenBoundCidrs pulumi.StringArrayInput
	// Generated Token's Explicit Maximum TTL in seconds
	TokenExplicitMaxTtl pulumi.IntPtrInput
	// The maximum lifetime of the generated token
	TokenMaxTtl pulumi.IntPtrInput
	// If true, the 'default' policy will not automatically be added to generated tokens
	TokenNoDefaultPolicy pulumi.BoolPtrInput
	// The maximum number of times a token may be used, a value of zero means unlimited
	TokenNumUses pulumi.IntPtrInput
	// Generated Token's Period
	TokenPeriod pulumi.IntPtrInput
	// Generated Token's Policies
	TokenPolicies pulumi.StringArrayInput
	// The initial ttl of the token to generate in seconds
	TokenTtl pulumi.IntPtrInput
	// The type of token to generate, service or batch
	TokenType pulumi.StringPtrInput
	// Duration after which authentication will be expired.
	// [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).
	//
	// Deprecated: Deprecated. Please use `tokenTtl` instead.
	Ttl pulumi.StringPtrInput
	// Associate Okta users with groups or policies within Vault.
	// See below for more details.
	Users AuthBackendUserTypeArrayInput
}

The set of arguments for constructing a AuthBackend resource.

func (AuthBackendArgs) ElementType 

func (AuthBackendArgs) ElementType() reflect.Type

type AuthBackendArray 

type AuthBackendArray []AuthBackendInput

func (AuthBackendArray) ElementType 

func (AuthBackendArray) ElementType() reflect.Type

func (AuthBackendArray) ToAuthBackendArrayOutput 

func (i AuthBackendArray) ToAuthBackendArrayOutput() AuthBackendArrayOutput

func (AuthBackendArray) ToAuthBackendArrayOutputWithContext 

func (i AuthBackendArray) ToAuthBackendArrayOutputWithContext(ctx context.Context) AuthBackendArrayOutput

type AuthBackendArrayInput 

type AuthBackendArrayInput interface {
	pulumi.Input

	ToAuthBackendArrayOutput() AuthBackendArrayOutput
	ToAuthBackendArrayOutputWithContext(context.Context) AuthBackendArrayOutput
}

AuthBackendArrayInput is an input type that accepts AuthBackendArray and AuthBackendArrayOutput values. You can construct a concrete instance of `AuthBackendArrayInput` via: 

AuthBackendArray{ AuthBackendArgs{...} }

type AuthBackendArrayOutput 

type AuthBackendArrayOutput struct{ *pulumi.OutputState }

func (AuthBackendArrayOutput) ElementType 

func (AuthBackendArrayOutput) ElementType() reflect.Type

func (AuthBackendArrayOutput) Index 

func (o AuthBackendArrayOutput) Index(i pulumi.IntInput) AuthBackendOutput

func (AuthBackendArrayOutput) ToAuthBackendArrayOutput 

func (o AuthBackendArrayOutput) ToAuthBackendArrayOutput() AuthBackendArrayOutput

func (AuthBackendArrayOutput) ToAuthBackendArrayOutputWithContext 

func (o AuthBackendArrayOutput) ToAuthBackendArrayOutputWithContext(ctx context.Context) AuthBackendArrayOutput

type AuthBackendGroup 

type AuthBackendGroup struct {
	pulumi.CustomResourceState

	// Name of the group within the Okta
	GroupName pulumi.StringOutput `pulumi:"groupName"`
	// The namespace to provision the resource in.
	// The value should not contain leading or trailing forward slashes.
	// The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
	// *Available only for Vault Enterprise*.
	Namespace pulumi.StringPtrOutput `pulumi:"namespace"`
	// The path where the Okta auth backend is mounted
	Path pulumi.StringOutput `pulumi:"path"`
	// Vault policies to associate with this group
	Policies pulumi.StringArrayOutput `pulumi:"policies"`
}

Provides a resource to create a group in an [Okta auth backend within Vault](https://www.vaultproject.io/docs/auth/okta.html).

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-vault/sdk/v6/go/vault/okta"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := okta.NewAuthBackend(ctx, "example", &okta.AuthBackendArgs{
			Path:         pulumi.String("group_okta"),
			Organization: pulumi.String("dummy"),
		})
		if err != nil {
			return err
		}
		_, err = okta.NewAuthBackendGroup(ctx, "foo", &okta.AuthBackendGroupArgs{
			Path:      example.Path,
			GroupName: pulumi.String("foo"),
			Policies: pulumi.StringArray{
				pulumi.String("one"),
				pulumi.String("two"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Okta authentication backend groups can be imported using the format `backend/groupName` e.g.

```sh $ pulumi import vault:okta/authBackendGroup:AuthBackendGroup foo okta/foo ```

func GetAuthBackendGroup 

func GetAuthBackendGroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AuthBackendGroupState, opts ...pulumi.ResourceOption) (*AuthBackendGroup, error)

GetAuthBackendGroup gets an existing AuthBackendGroup 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 NewAuthBackendGroup 

func NewAuthBackendGroup(ctx *pulumi.Context,
	name string, args *AuthBackendGroupArgs, opts ...pulumi.ResourceOption) (*AuthBackendGroup, error)

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

func (*AuthBackendGroup) ElementType 

func (*AuthBackendGroup) ElementType() reflect.Type

func (*AuthBackendGroup) ToAuthBackendGroupOutput 

func (i *AuthBackendGroup) ToAuthBackendGroupOutput() AuthBackendGroupOutput

func (*AuthBackendGroup) ToAuthBackendGroupOutputWithContext 

func (i *AuthBackendGroup) ToAuthBackendGroupOutputWithContext(ctx context.Context) AuthBackendGroupOutput

type AuthBackendGroupArgs 

type AuthBackendGroupArgs struct {
	// Name of the group within the Okta
	GroupName pulumi.StringInput
	// The namespace to provision the resource in.
	// The value should not contain leading or trailing forward slashes.
	// The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
	// *Available only for Vault Enterprise*.
	Namespace pulumi.StringPtrInput
	// The path where the Okta auth backend is mounted
	Path pulumi.StringInput
	// Vault policies to associate with this group
	Policies pulumi.StringArrayInput
}

The set of arguments for constructing a AuthBackendGroup resource.

func (AuthBackendGroupArgs) ElementType 

func (AuthBackendGroupArgs) ElementType() reflect.Type

type AuthBackendGroupArray 

type AuthBackendGroupArray []AuthBackendGroupInput

func (AuthBackendGroupArray) ElementType 

func (AuthBackendGroupArray) ElementType() reflect.Type

func (AuthBackendGroupArray) ToAuthBackendGroupArrayOutput 

func (i AuthBackendGroupArray) ToAuthBackendGroupArrayOutput() AuthBackendGroupArrayOutput

func (AuthBackendGroupArray) ToAuthBackendGroupArrayOutputWithContext 

func (i AuthBackendGroupArray) ToAuthBackendGroupArrayOutputWithContext(ctx context.Context) AuthBackendGroupArrayOutput

type AuthBackendGroupArrayInput 

type AuthBackendGroupArrayInput interface {
	pulumi.Input

	ToAuthBackendGroupArrayOutput() AuthBackendGroupArrayOutput
	ToAuthBackendGroupArrayOutputWithContext(context.Context) AuthBackendGroupArrayOutput
}

AuthBackendGroupArrayInput is an input type that accepts AuthBackendGroupArray and AuthBackendGroupArrayOutput values. You can construct a concrete instance of `AuthBackendGroupArrayInput` via: 

AuthBackendGroupArray{ AuthBackendGroupArgs{...} }

type AuthBackendGroupArrayOutput 

type AuthBackendGroupArrayOutput struct{ *pulumi.OutputState }

func (AuthBackendGroupArrayOutput) ElementType 

func (AuthBackendGroupArrayOutput) ElementType() reflect.Type

func (AuthBackendGroupArrayOutput) Index 

func (o AuthBackendGroupArrayOutput) Index(i pulumi.IntInput) AuthBackendGroupOutput

func (AuthBackendGroupArrayOutput) ToAuthBackendGroupArrayOutput 

func (o AuthBackendGroupArrayOutput) ToAuthBackendGroupArrayOutput() AuthBackendGroupArrayOutput

func (AuthBackendGroupArrayOutput) ToAuthBackendGroupArrayOutputWithContext 

func (o AuthBackendGroupArrayOutput) ToAuthBackendGroupArrayOutputWithContext(ctx context.Context) AuthBackendGroupArrayOutput

type AuthBackendGroupInput 

type AuthBackendGroupInput interface {
	pulumi.Input

	ToAuthBackendGroupOutput() AuthBackendGroupOutput
	ToAuthBackendGroupOutputWithContext(ctx context.Context) AuthBackendGroupOutput
}

type AuthBackendGroupMap 

type AuthBackendGroupMap map[string]AuthBackendGroupInput

func (AuthBackendGroupMap) ElementType 

func (AuthBackendGroupMap) ElementType() reflect.Type

func (AuthBackendGroupMap) ToAuthBackendGroupMapOutput 

func (i AuthBackendGroupMap) ToAuthBackendGroupMapOutput() AuthBackendGroupMapOutput

func (AuthBackendGroupMap) ToAuthBackendGroupMapOutputWithContext 

func (i AuthBackendGroupMap) ToAuthBackendGroupMapOutputWithContext(ctx context.Context) AuthBackendGroupMapOutput

type AuthBackendGroupMapInput 

type AuthBackendGroupMapInput interface {
	pulumi.Input

	ToAuthBackendGroupMapOutput() AuthBackendGroupMapOutput
	ToAuthBackendGroupMapOutputWithContext(context.Context) AuthBackendGroupMapOutput
}

AuthBackendGroupMapInput is an input type that accepts AuthBackendGroupMap and AuthBackendGroupMapOutput values. You can construct a concrete instance of `AuthBackendGroupMapInput` via: 

AuthBackendGroupMap{ "key": AuthBackendGroupArgs{...} }

type AuthBackendGroupMapOutput 

type AuthBackendGroupMapOutput struct{ *pulumi.OutputState }

func (AuthBackendGroupMapOutput) ElementType 

func (AuthBackendGroupMapOutput) ElementType() reflect.Type

func (AuthBackendGroupMapOutput) MapIndex 

func (o AuthBackendGroupMapOutput) MapIndex(k pulumi.StringInput) AuthBackendGroupOutput

func (AuthBackendGroupMapOutput) ToAuthBackendGroupMapOutput 

func (o AuthBackendGroupMapOutput) ToAuthBackendGroupMapOutput() AuthBackendGroupMapOutput

func (AuthBackendGroupMapOutput) ToAuthBackendGroupMapOutputWithContext 

func (o AuthBackendGroupMapOutput) ToAuthBackendGroupMapOutputWithContext(ctx context.Context) AuthBackendGroupMapOutput

type AuthBackendGroupOutput 

type AuthBackendGroupOutput struct{ *pulumi.OutputState }

func (AuthBackendGroupOutput) ElementType 

func (AuthBackendGroupOutput) ElementType() reflect.Type

func (AuthBackendGroupOutput) GroupName 

func (o AuthBackendGroupOutput) GroupName() pulumi.StringOutput

Name of the group within the Okta

func (AuthBackendGroupOutput) Namespace 

func (o AuthBackendGroupOutput) Namespace() pulumi.StringPtrOutput

The namespace to provision the resource in. The value should not contain leading or trailing forward slashes. The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace). *Available only for Vault Enterprise*.

func (AuthBackendGroupOutput) Path 

func (o AuthBackendGroupOutput) Path() pulumi.StringOutput

The path where the Okta auth backend is mounted

func (AuthBackendGroupOutput) Policies 

func (o AuthBackendGroupOutput) Policies() pulumi.StringArrayOutput

Vault policies to associate with this group

func (AuthBackendGroupOutput) ToAuthBackendGroupOutput 

func (o AuthBackendGroupOutput) ToAuthBackendGroupOutput() AuthBackendGroupOutput

func (AuthBackendGroupOutput) ToAuthBackendGroupOutputWithContext 

func (o AuthBackendGroupOutput) ToAuthBackendGroupOutputWithContext(ctx context.Context) AuthBackendGroupOutput

type AuthBackendGroupState 

type AuthBackendGroupState struct {
	// Name of the group within the Okta
	GroupName pulumi.StringPtrInput
	// The namespace to provision the resource in.
	// The value should not contain leading or trailing forward slashes.
	// The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
	// *Available only for Vault Enterprise*.
	Namespace pulumi.StringPtrInput
	// The path where the Okta auth backend is mounted
	Path pulumi.StringPtrInput
	// Vault policies to associate with this group
	Policies pulumi.StringArrayInput
}

func (AuthBackendGroupState) ElementType 

func (AuthBackendGroupState) ElementType() reflect.Type

type AuthBackendGroupType 

type AuthBackendGroupType struct {
	// Name of the Okta group
	GroupName string `pulumi:"groupName"`
	// Policies to associate with this group
	Policies []string `pulumi:"policies"`
}

type AuthBackendGroupTypeArgs 

type AuthBackendGroupTypeArgs struct {
	// Name of the Okta group
	GroupName pulumi.StringInput `pulumi:"groupName"`
	// Policies to associate with this group
	Policies pulumi.StringArrayInput `pulumi:"policies"`
}

func (AuthBackendGroupTypeArgs) ElementType 

func (AuthBackendGroupTypeArgs) ElementType() reflect.Type

func (AuthBackendGroupTypeArgs) ToAuthBackendGroupTypeOutput 

func (i AuthBackendGroupTypeArgs) ToAuthBackendGroupTypeOutput() AuthBackendGroupTypeOutput

func (AuthBackendGroupTypeArgs) ToAuthBackendGroupTypeOutputWithContext 

func (i AuthBackendGroupTypeArgs) ToAuthBackendGroupTypeOutputWithContext(ctx context.Context) AuthBackendGroupTypeOutput

type AuthBackendGroupTypeArray 

type AuthBackendGroupTypeArray []AuthBackendGroupTypeInput

func (AuthBackendGroupTypeArray) ElementType 

func (AuthBackendGroupTypeArray) ElementType() reflect.Type

func (AuthBackendGroupTypeArray) ToAuthBackendGroupTypeArrayOutput 

func (i AuthBackendGroupTypeArray) ToAuthBackendGroupTypeArrayOutput() AuthBackendGroupTypeArrayOutput

func (AuthBackendGroupTypeArray) ToAuthBackendGroupTypeArrayOutputWithContext 

func (i AuthBackendGroupTypeArray) ToAuthBackendGroupTypeArrayOutputWithContext(ctx context.Context) AuthBackendGroupTypeArrayOutput

type AuthBackendGroupTypeArrayInput 

type AuthBackendGroupTypeArrayInput interface {
	pulumi.Input

	ToAuthBackendGroupTypeArrayOutput() AuthBackendGroupTypeArrayOutput
	ToAuthBackendGroupTypeArrayOutputWithContext(context.Context) AuthBackendGroupTypeArrayOutput
}

AuthBackendGroupTypeArrayInput is an input type that accepts AuthBackendGroupTypeArray and AuthBackendGroupTypeArrayOutput values. You can construct a concrete instance of `AuthBackendGroupTypeArrayInput` via: 

AuthBackendGroupTypeArray{ AuthBackendGroupTypeArgs{...} }

type AuthBackendGroupTypeArrayOutput 

type AuthBackendGroupTypeArrayOutput struct{ *pulumi.OutputState }

func (AuthBackendGroupTypeArrayOutput) ElementType 

func (AuthBackendGroupTypeArrayOutput) ElementType() reflect.Type

func (AuthBackendGroupTypeArrayOutput) Index 

func (o AuthBackendGroupTypeArrayOutput) Index(i pulumi.IntInput) AuthBackendGroupTypeOutput

func (AuthBackendGroupTypeArrayOutput) ToAuthBackendGroupTypeArrayOutput 

func (o AuthBackendGroupTypeArrayOutput) ToAuthBackendGroupTypeArrayOutput() AuthBackendGroupTypeArrayOutput

func (AuthBackendGroupTypeArrayOutput) ToAuthBackendGroupTypeArrayOutputWithContext 

func (o AuthBackendGroupTypeArrayOutput) ToAuthBackendGroupTypeArrayOutputWithContext(ctx context.Context) AuthBackendGroupTypeArrayOutput

type AuthBackendGroupTypeInput 

type AuthBackendGroupTypeInput interface {
	pulumi.Input

	ToAuthBackendGroupTypeOutput() AuthBackendGroupTypeOutput
	ToAuthBackendGroupTypeOutputWithContext(context.Context) AuthBackendGroupTypeOutput
}

AuthBackendGroupTypeInput is an input type that accepts AuthBackendGroupTypeArgs and AuthBackendGroupTypeOutput values. You can construct a concrete instance of `AuthBackendGroupTypeInput` via: 

AuthBackendGroupTypeArgs{...}

type AuthBackendGroupTypeOutput 

type AuthBackendGroupTypeOutput struct{ *pulumi.OutputState }

func (AuthBackendGroupTypeOutput) ElementType 

func (AuthBackendGroupTypeOutput) ElementType() reflect.Type

func (AuthBackendGroupTypeOutput) GroupName 

func (o AuthBackendGroupTypeOutput) GroupName() pulumi.StringOutput

Name of the Okta group

func (AuthBackendGroupTypeOutput) Policies 

func (o AuthBackendGroupTypeOutput) Policies() pulumi.StringArrayOutput

Policies to associate with this group

func (AuthBackendGroupTypeOutput) ToAuthBackendGroupTypeOutput 

func (o AuthBackendGroupTypeOutput) ToAuthBackendGroupTypeOutput() AuthBackendGroupTypeOutput

func (AuthBackendGroupTypeOutput) ToAuthBackendGroupTypeOutputWithContext 

func (o AuthBackendGroupTypeOutput) ToAuthBackendGroupTypeOutputWithContext(ctx context.Context) AuthBackendGroupTypeOutput

type AuthBackendInput 

type AuthBackendInput interface {
	pulumi.Input

	ToAuthBackendOutput() AuthBackendOutput
	ToAuthBackendOutputWithContext(ctx context.Context) AuthBackendOutput
}

type AuthBackendMap 

type AuthBackendMap map[string]AuthBackendInput

func (AuthBackendMap) ElementType 

func (AuthBackendMap) ElementType() reflect.Type

func (AuthBackendMap) ToAuthBackendMapOutput 

func (i AuthBackendMap) ToAuthBackendMapOutput() AuthBackendMapOutput

func (AuthBackendMap) ToAuthBackendMapOutputWithContext 

func (i AuthBackendMap) ToAuthBackendMapOutputWithContext(ctx context.Context) AuthBackendMapOutput

type AuthBackendMapInput 

type AuthBackendMapInput interface {
	pulumi.Input

	ToAuthBackendMapOutput() AuthBackendMapOutput
	ToAuthBackendMapOutputWithContext(context.Context) AuthBackendMapOutput
}

AuthBackendMapInput is an input type that accepts AuthBackendMap and AuthBackendMapOutput values. You can construct a concrete instance of `AuthBackendMapInput` via: 

AuthBackendMap{ "key": AuthBackendArgs{...} }

type AuthBackendMapOutput 

type AuthBackendMapOutput struct{ *pulumi.OutputState }

func (AuthBackendMapOutput) ElementType 

func (AuthBackendMapOutput) ElementType() reflect.Type

func (AuthBackendMapOutput) MapIndex 

func (o AuthBackendMapOutput) MapIndex(k pulumi.StringInput) AuthBackendOutput

func (AuthBackendMapOutput) ToAuthBackendMapOutput 

func (o AuthBackendMapOutput) ToAuthBackendMapOutput() AuthBackendMapOutput

func (AuthBackendMapOutput) ToAuthBackendMapOutputWithContext 

func (o AuthBackendMapOutput) ToAuthBackendMapOutputWithContext(ctx context.Context) AuthBackendMapOutput

type AuthBackendOutput 

type AuthBackendOutput struct{ *pulumi.OutputState }

func (AuthBackendOutput) Accessor 

func (o AuthBackendOutput) Accessor() pulumi.StringOutput

The mount accessor related to the auth mount. It is useful for integration with [Identity Secrets Engine](https://www.vaultproject.io/docs/secrets/identity/index.html).

func (AuthBackendOutput) BaseUrl 

func (o AuthBackendOutput) BaseUrl() pulumi.StringPtrOutput

The Okta url. Examples: oktapreview.com, okta.com

func (AuthBackendOutput) BypassOktaMfa 

func (o AuthBackendOutput) BypassOktaMfa() pulumi.BoolPtrOutput

When true, requests by Okta for a MFA check will be bypassed. This also disallows certain status checks on the account, such as whether the password is expired.

func (AuthBackendOutput) Description 

func (o AuthBackendOutput) Description() pulumi.StringPtrOutput

The description of the auth backend

func (AuthBackendOutput) DisableRemount 

func (o AuthBackendOutput) DisableRemount() pulumi.BoolPtrOutput

If set, opts out of mount migration on path updates. See here for more info on [Mount Migration](https://www.vaultproject.io/docs/concepts/mount-migration)

func (AuthBackendOutput) ElementType 

func (AuthBackendOutput) ElementType() reflect.Type

func (AuthBackendOutput) Groups 

func (o AuthBackendOutput) Groups() AuthBackendGroupTypeArrayOutput

Associate Okta groups with policies within Vault. See below for more details.

func (AuthBackendOutput) MaxTtl deprecated 

func (o AuthBackendOutput) MaxTtl() pulumi.StringPtrOutput

Maximum duration after which authentication will be expired [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).

Deprecated: Deprecated. Please use `tokenMaxTtl` instead.

func (AuthBackendOutput) Namespace 

func (o AuthBackendOutput) Namespace() pulumi.StringPtrOutput

The namespace to provision the resource in. The value should not contain leading or trailing forward slashes. The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace). *Available only for Vault Enterprise*.

func (AuthBackendOutput) Organization 

func (o AuthBackendOutput) Organization() pulumi.StringOutput

The Okta organization. This will be the first part of the url `https://XXX.okta.com`

func (AuthBackendOutput) Path 

func (o AuthBackendOutput) Path() pulumi.StringPtrOutput

Path to mount the Okta auth backend. Default to path `okta`.

func (AuthBackendOutput) ToAuthBackendOutput 

func (o AuthBackendOutput) ToAuthBackendOutput() AuthBackendOutput

func (AuthBackendOutput) ToAuthBackendOutputWithContext 

func (o AuthBackendOutput) ToAuthBackendOutputWithContext(ctx context.Context) AuthBackendOutput

func (AuthBackendOutput) Token 

func (o AuthBackendOutput) Token() pulumi.StringPtrOutput

The Okta API token. This is required to query Okta for user group membership. If this is not supplied only locally configured groups will be enabled.

func (AuthBackendOutput) TokenBoundCidrs added in v6.2.0 

func (o AuthBackendOutput) TokenBoundCidrs() pulumi.StringArrayOutput

Specifies the blocks of IP addresses which are allowed to use the generated token

func (AuthBackendOutput) TokenExplicitMaxTtl added in v6.2.0 

func (o AuthBackendOutput) TokenExplicitMaxTtl() pulumi.IntPtrOutput

Generated Token's Explicit Maximum TTL in seconds

func (AuthBackendOutput) TokenMaxTtl added in v6.2.0 

func (o AuthBackendOutput) TokenMaxTtl() pulumi.IntPtrOutput

The maximum lifetime of the generated token

func (AuthBackendOutput) TokenNoDefaultPolicy added in v6.2.0 

func (o AuthBackendOutput) TokenNoDefaultPolicy() pulumi.BoolPtrOutput

If true, the 'default' policy will not automatically be added to generated tokens

func (AuthBackendOutput) TokenNumUses added in v6.2.0 

func (o AuthBackendOutput) TokenNumUses() pulumi.IntPtrOutput

The maximum number of times a token may be used, a value of zero means unlimited

func (AuthBackendOutput) TokenPeriod added in v6.2.0 

func (o AuthBackendOutput) TokenPeriod() pulumi.IntPtrOutput

Generated Token's Period

func (AuthBackendOutput) TokenPolicies added in v6.2.0 

func (o AuthBackendOutput) TokenPolicies() pulumi.StringArrayOutput

Generated Token's Policies

func (AuthBackendOutput) TokenTtl added in v6.2.0 

func (o AuthBackendOutput) TokenTtl() pulumi.IntPtrOutput

The initial ttl of the token to generate in seconds

func (AuthBackendOutput) TokenType added in v6.2.0 

func (o AuthBackendOutput) TokenType() pulumi.StringPtrOutput

The type of token to generate, service or batch

func (AuthBackendOutput) Ttl deprecated 

func (o AuthBackendOutput) Ttl() pulumi.StringPtrOutput

Duration after which authentication will be expired. [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).

Deprecated: Deprecated. Please use `tokenTtl` instead.

func (AuthBackendOutput) Users 

func (o AuthBackendOutput) Users() AuthBackendUserTypeArrayOutput

Associate Okta users with groups or policies within Vault. See below for more details.

type AuthBackendState 

type AuthBackendState struct {
	// The mount accessor related to the auth mount. It is useful for integration with [Identity Secrets Engine](https://www.vaultproject.io/docs/secrets/identity/index.html).
	Accessor pulumi.StringPtrInput
	// The Okta url. Examples: oktapreview.com, okta.com
	BaseUrl pulumi.StringPtrInput
	// When true, requests by Okta for a MFA check will be bypassed. This also disallows certain status checks on the account, such as whether the password is expired.
	BypassOktaMfa pulumi.BoolPtrInput
	// The description of the auth backend
	Description pulumi.StringPtrInput
	// If set, opts out of mount migration on path updates.
	// See here for more info on [Mount Migration](https://www.vaultproject.io/docs/concepts/mount-migration)
	DisableRemount pulumi.BoolPtrInput
	// Associate Okta groups with policies within Vault.
	// See below for more details.
	Groups AuthBackendGroupTypeArrayInput
	// Maximum duration after which authentication will be expired
	// [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).
	//
	// Deprecated: Deprecated. Please use `tokenMaxTtl` instead.
	MaxTtl pulumi.StringPtrInput
	// The namespace to provision the resource in.
	// The value should not contain leading or trailing forward slashes.
	// The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
	// *Available only for Vault Enterprise*.
	Namespace pulumi.StringPtrInput
	// The Okta organization. This will be the first part of the url `https://XXX.okta.com`
	Organization pulumi.StringPtrInput
	// Path to mount the Okta auth backend. Default to path `okta`.
	Path pulumi.StringPtrInput
	// The Okta API token. This is required to query Okta for user group membership.
	// If this is not supplied only locally configured groups will be enabled.
	Token pulumi.StringPtrInput
	// Specifies the blocks of IP addresses which are allowed to use the generated token
	TokenBoundCidrs pulumi.StringArrayInput
	// Generated Token's Explicit Maximum TTL in seconds
	TokenExplicitMaxTtl pulumi.IntPtrInput
	// The maximum lifetime of the generated token
	TokenMaxTtl pulumi.IntPtrInput
	// If true, the 'default' policy will not automatically be added to generated tokens
	TokenNoDefaultPolicy pulumi.BoolPtrInput
	// The maximum number of times a token may be used, a value of zero means unlimited
	TokenNumUses pulumi.IntPtrInput
	// Generated Token's Period
	TokenPeriod pulumi.IntPtrInput
	// Generated Token's Policies
	TokenPolicies pulumi.StringArrayInput
	// The initial ttl of the token to generate in seconds
	TokenTtl pulumi.IntPtrInput
	// The type of token to generate, service or batch
	TokenType pulumi.StringPtrInput
	// Duration after which authentication will be expired.
	// [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).
	//
	// Deprecated: Deprecated. Please use `tokenTtl` instead.
	Ttl pulumi.StringPtrInput
	// Associate Okta users with groups or policies within Vault.
	// See below for more details.
	Users AuthBackendUserTypeArrayInput
}

func (AuthBackendState) ElementType 

func (AuthBackendState) ElementType() reflect.Type

type AuthBackendUser 

type AuthBackendUser struct {
	pulumi.CustomResourceState

	// List of Okta groups to associate with this user
	Groups pulumi.StringArrayOutput `pulumi:"groups"`
	// The namespace to provision the resource in.
	// The value should not contain leading or trailing forward slashes.
	// The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
	// *Available only for Vault Enterprise*.
	Namespace pulumi.StringPtrOutput `pulumi:"namespace"`
	// The path where the Okta auth backend is mounted
	Path pulumi.StringOutput `pulumi:"path"`
	// List of Vault policies to associate with this user
	Policies pulumi.StringArrayOutput `pulumi:"policies"`
	// Name of the user within Okta
	Username pulumi.StringOutput `pulumi:"username"`
}

Provides a resource to create a user in an [Okta auth backend within Vault](https://www.vaultproject.io/docs/auth/okta.html).

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-vault/sdk/v6/go/vault/okta"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := okta.NewAuthBackend(ctx, "example", &okta.AuthBackendArgs{
			Path:         pulumi.String("user_okta"),
			Organization: pulumi.String("dummy"),
		})
		if err != nil {
			return err
		}
		_, err = okta.NewAuthBackendUser(ctx, "foo", &okta.AuthBackendUserArgs{
			Path:     example.Path,
			Username: pulumi.String("foo"),
			Groups: pulumi.StringArray{
				pulumi.String("one"),
				pulumi.String("two"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Okta authentication backend users can be imported using its `path/user` ID format, e.g.

```sh $ pulumi import vault:okta/authBackendUser:AuthBackendUser example okta/foo ```

func GetAuthBackendUser 

func GetAuthBackendUser(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AuthBackendUserState, opts ...pulumi.ResourceOption) (*AuthBackendUser, error)

GetAuthBackendUser gets an existing AuthBackendUser 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 NewAuthBackendUser 

func NewAuthBackendUser(ctx *pulumi.Context,
	name string, args *AuthBackendUserArgs, opts ...pulumi.ResourceOption) (*AuthBackendUser, error)

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

func (*AuthBackendUser) ElementType 

func (*AuthBackendUser) ElementType() reflect.Type

func (*AuthBackendUser) ToAuthBackendUserOutput 

func (i *AuthBackendUser) ToAuthBackendUserOutput() AuthBackendUserOutput

func (*AuthBackendUser) ToAuthBackendUserOutputWithContext 

func (i *AuthBackendUser) ToAuthBackendUserOutputWithContext(ctx context.Context) AuthBackendUserOutput

type AuthBackendUserArgs 

type AuthBackendUserArgs struct {
	// List of Okta groups to associate with this user
	Groups pulumi.StringArrayInput
	// The namespace to provision the resource in.
	// The value should not contain leading or trailing forward slashes.
	// The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
	// *Available only for Vault Enterprise*.
	Namespace pulumi.StringPtrInput
	// The path where the Okta auth backend is mounted
	Path pulumi.StringInput
	// List of Vault policies to associate with this user
	Policies pulumi.StringArrayInput
	// Name of the user within Okta
	Username pulumi.StringInput
}

The set of arguments for constructing a AuthBackendUser resource.

func (AuthBackendUserArgs) ElementType 

func (AuthBackendUserArgs) ElementType() reflect.Type

type AuthBackendUserArray 

type AuthBackendUserArray []AuthBackendUserInput

func (AuthBackendUserArray) ElementType 

func (AuthBackendUserArray) ElementType() reflect.Type

func (AuthBackendUserArray) ToAuthBackendUserArrayOutput 

func (i AuthBackendUserArray) ToAuthBackendUserArrayOutput() AuthBackendUserArrayOutput

func (AuthBackendUserArray) ToAuthBackendUserArrayOutputWithContext 

func (i AuthBackendUserArray) ToAuthBackendUserArrayOutputWithContext(ctx context.Context) AuthBackendUserArrayOutput

type AuthBackendUserArrayInput 

type AuthBackendUserArrayInput interface {
	pulumi.Input

	ToAuthBackendUserArrayOutput() AuthBackendUserArrayOutput
	ToAuthBackendUserArrayOutputWithContext(context.Context) AuthBackendUserArrayOutput
}

AuthBackendUserArrayInput is an input type that accepts AuthBackendUserArray and AuthBackendUserArrayOutput values. You can construct a concrete instance of `AuthBackendUserArrayInput` via: 

AuthBackendUserArray{ AuthBackendUserArgs{...} }

type AuthBackendUserArrayOutput 

type AuthBackendUserArrayOutput struct{ *pulumi.OutputState }

func (AuthBackendUserArrayOutput) ElementType 

func (AuthBackendUserArrayOutput) ElementType() reflect.Type

func (AuthBackendUserArrayOutput) Index 

func (o AuthBackendUserArrayOutput) Index(i pulumi.IntInput) AuthBackendUserOutput

func (AuthBackendUserArrayOutput) ToAuthBackendUserArrayOutput 

func (o AuthBackendUserArrayOutput) ToAuthBackendUserArrayOutput() AuthBackendUserArrayOutput

func (AuthBackendUserArrayOutput) ToAuthBackendUserArrayOutputWithContext 

func (o AuthBackendUserArrayOutput) ToAuthBackendUserArrayOutputWithContext(ctx context.Context) AuthBackendUserArrayOutput

type AuthBackendUserInput 

type AuthBackendUserInput interface {
	pulumi.Input

	ToAuthBackendUserOutput() AuthBackendUserOutput
	ToAuthBackendUserOutputWithContext(ctx context.Context) AuthBackendUserOutput
}

type AuthBackendUserMap 

type AuthBackendUserMap map[string]AuthBackendUserInput

func (AuthBackendUserMap) ElementType 

func (AuthBackendUserMap) ElementType() reflect.Type

func (AuthBackendUserMap) ToAuthBackendUserMapOutput 

func (i AuthBackendUserMap) ToAuthBackendUserMapOutput() AuthBackendUserMapOutput

func (AuthBackendUserMap) ToAuthBackendUserMapOutputWithContext 

func (i AuthBackendUserMap) ToAuthBackendUserMapOutputWithContext(ctx context.Context) AuthBackendUserMapOutput

type AuthBackendUserMapInput 

type AuthBackendUserMapInput interface {
	pulumi.Input

	ToAuthBackendUserMapOutput() AuthBackendUserMapOutput
	ToAuthBackendUserMapOutputWithContext(context.Context) AuthBackendUserMapOutput
}

AuthBackendUserMapInput is an input type that accepts AuthBackendUserMap and AuthBackendUserMapOutput values. You can construct a concrete instance of `AuthBackendUserMapInput` via: 

AuthBackendUserMap{ "key": AuthBackendUserArgs{...} }

type AuthBackendUserMapOutput 

type AuthBackendUserMapOutput struct{ *pulumi.OutputState }

func (AuthBackendUserMapOutput) ElementType 

func (AuthBackendUserMapOutput) ElementType() reflect.Type

func (AuthBackendUserMapOutput) MapIndex 

func (o AuthBackendUserMapOutput) MapIndex(k pulumi.StringInput) AuthBackendUserOutput

func (AuthBackendUserMapOutput) ToAuthBackendUserMapOutput 

func (o AuthBackendUserMapOutput) ToAuthBackendUserMapOutput() AuthBackendUserMapOutput

func (AuthBackendUserMapOutput) ToAuthBackendUserMapOutputWithContext 

func (o AuthBackendUserMapOutput) ToAuthBackendUserMapOutputWithContext(ctx context.Context) AuthBackendUserMapOutput

type AuthBackendUserOutput 

type AuthBackendUserOutput struct{ *pulumi.OutputState }

func (AuthBackendUserOutput) ElementType 

func (AuthBackendUserOutput) ElementType() reflect.Type

func (AuthBackendUserOutput) Groups 

func (o AuthBackendUserOutput) Groups() pulumi.StringArrayOutput

List of Okta groups to associate with this user

func (AuthBackendUserOutput) Namespace 

func (o AuthBackendUserOutput) Namespace() pulumi.StringPtrOutput

The namespace to provision the resource in. The value should not contain leading or trailing forward slashes. The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace). *Available only for Vault Enterprise*.

func (AuthBackendUserOutput) Path 

func (o AuthBackendUserOutput) Path() pulumi.StringOutput

The path where the Okta auth backend is mounted

func (AuthBackendUserOutput) Policies 

func (o AuthBackendUserOutput) Policies() pulumi.StringArrayOutput

List of Vault policies to associate with this user

func (AuthBackendUserOutput) ToAuthBackendUserOutput 

func (o AuthBackendUserOutput) ToAuthBackendUserOutput() AuthBackendUserOutput

func (AuthBackendUserOutput) ToAuthBackendUserOutputWithContext 

func (o AuthBackendUserOutput) ToAuthBackendUserOutputWithContext(ctx context.Context) AuthBackendUserOutput

func (AuthBackendUserOutput) Username 

func (o AuthBackendUserOutput) Username() pulumi.StringOutput

Name of the user within Okta

type AuthBackendUserState 

type AuthBackendUserState struct {
	// List of Okta groups to associate with this user
	Groups pulumi.StringArrayInput
	// The namespace to provision the resource in.
	// The value should not contain leading or trailing forward slashes.
	// The `namespace` is always relative to the provider's configured [namespace](https://www.terraform.io/docs/providers/vault/index.html#namespace).
	// *Available only for Vault Enterprise*.
	Namespace pulumi.StringPtrInput
	// The path where the Okta auth backend is mounted
	Path pulumi.StringPtrInput
	// List of Vault policies to associate with this user
	Policies pulumi.StringArrayInput
	// Name of the user within Okta
	Username pulumi.StringPtrInput
}

func (AuthBackendUserState) ElementType 

func (AuthBackendUserState) ElementType() reflect.Type

type AuthBackendUserType 

type AuthBackendUserType struct {
	// Groups within the Okta auth backend to associate with this user
	Groups []string `pulumi:"groups"`
	// Policies to associate with this user
	Policies []string `pulumi:"policies"`
	// Name of the user within Okta
	Username string `pulumi:"username"`
}

type AuthBackendUserTypeArgs 

type AuthBackendUserTypeArgs struct {
	// Groups within the Okta auth backend to associate with this user
	Groups pulumi.StringArrayInput `pulumi:"groups"`
	// Policies to associate with this user
	Policies pulumi.StringArrayInput `pulumi:"policies"`
	// Name of the user within Okta
	Username pulumi.StringInput `pulumi:"username"`
}

func (AuthBackendUserTypeArgs) ElementType 

func (AuthBackendUserTypeArgs) ElementType() reflect.Type

func (AuthBackendUserTypeArgs) ToAuthBackendUserTypeOutput 

func (i AuthBackendUserTypeArgs) ToAuthBackendUserTypeOutput() AuthBackendUserTypeOutput

func (AuthBackendUserTypeArgs) ToAuthBackendUserTypeOutputWithContext 

func (i AuthBackendUserTypeArgs) ToAuthBackendUserTypeOutputWithContext(ctx context.Context) AuthBackendUserTypeOutput

type AuthBackendUserTypeArray 

type AuthBackendUserTypeArray []AuthBackendUserTypeInput

func (AuthBackendUserTypeArray) ElementType 

func (AuthBackendUserTypeArray) ElementType() reflect.Type

func (AuthBackendUserTypeArray) ToAuthBackendUserTypeArrayOutput 

func (i AuthBackendUserTypeArray) ToAuthBackendUserTypeArrayOutput() AuthBackendUserTypeArrayOutput

func (AuthBackendUserTypeArray) ToAuthBackendUserTypeArrayOutputWithContext 

func (i AuthBackendUserTypeArray) ToAuthBackendUserTypeArrayOutputWithContext(ctx context.Context) AuthBackendUserTypeArrayOutput

type AuthBackendUserTypeArrayInput 

type AuthBackendUserTypeArrayInput interface {
	pulumi.Input

	ToAuthBackendUserTypeArrayOutput() AuthBackendUserTypeArrayOutput
	ToAuthBackendUserTypeArrayOutputWithContext(context.Context) AuthBackendUserTypeArrayOutput
}

AuthBackendUserTypeArrayInput is an input type that accepts AuthBackendUserTypeArray and AuthBackendUserTypeArrayOutput values. You can construct a concrete instance of `AuthBackendUserTypeArrayInput` via: 

AuthBackendUserTypeArray{ AuthBackendUserTypeArgs{...} }

type AuthBackendUserTypeArrayOutput 

type AuthBackendUserTypeArrayOutput struct{ *pulumi.OutputState }

func (AuthBackendUserTypeArrayOutput) ElementType 

func (AuthBackendUserTypeArrayOutput) ElementType() reflect.Type

func (AuthBackendUserTypeArrayOutput) Index 

func (o AuthBackendUserTypeArrayOutput) Index(i pulumi.IntInput) AuthBackendUserTypeOutput

func (AuthBackendUserTypeArrayOutput) ToAuthBackendUserTypeArrayOutput 

func (o AuthBackendUserTypeArrayOutput) ToAuthBackendUserTypeArrayOutput() AuthBackendUserTypeArrayOutput

func (AuthBackendUserTypeArrayOutput) ToAuthBackendUserTypeArrayOutputWithContext 

func (o AuthBackendUserTypeArrayOutput) ToAuthBackendUserTypeArrayOutputWithContext(ctx context.Context) AuthBackendUserTypeArrayOutput

type AuthBackendUserTypeInput 

type AuthBackendUserTypeInput interface {
	pulumi.Input

	ToAuthBackendUserTypeOutput() AuthBackendUserTypeOutput
	ToAuthBackendUserTypeOutputWithContext(context.Context) AuthBackendUserTypeOutput
}

AuthBackendUserTypeInput is an input type that accepts AuthBackendUserTypeArgs and AuthBackendUserTypeOutput values. You can construct a concrete instance of `AuthBackendUserTypeInput` via: 

AuthBackendUserTypeArgs{...}

type AuthBackendUserTypeOutput 

type AuthBackendUserTypeOutput struct{ *pulumi.OutputState }

func (AuthBackendUserTypeOutput) ElementType 

func (AuthBackendUserTypeOutput) ElementType() reflect.Type

func (AuthBackendUserTypeOutput) Groups 

func (o AuthBackendUserTypeOutput) Groups() pulumi.StringArrayOutput

Groups within the Okta auth backend to associate with this user

func (AuthBackendUserTypeOutput) Policies 

func (o AuthBackendUserTypeOutput) Policies() pulumi.StringArrayOutput

Policies to associate with this user

func (AuthBackendUserTypeOutput) ToAuthBackendUserTypeOutput 

func (o AuthBackendUserTypeOutput) ToAuthBackendUserTypeOutput() AuthBackendUserTypeOutput

func (AuthBackendUserTypeOutput) ToAuthBackendUserTypeOutputWithContext 

func (o AuthBackendUserTypeOutput) ToAuthBackendUserTypeOutputWithContext(ctx context.Context) AuthBackendUserTypeOutput

func (AuthBackendUserTypeOutput) Username 

func (o AuthBackendUserTypeOutput) Username() pulumi.StringOutput

Name of the user within Okta

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.