minio

package
v2.0.0-...-5b3ed3f Latest Latest
Warning

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

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

Documentation

Overview

A Pulumi package for creating and managing minio cloud resources.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type GetIamPolicyDocumentArgs 

type GetIamPolicyDocumentArgs struct {
	OverrideJson *string                         `pulumi:"overrideJson"`
	PolicyId     *string                         `pulumi:"policyId"`
	SourceJson   *string                         `pulumi:"sourceJson"`
	Statements   []GetIamPolicyDocumentStatement `pulumi:"statements"`
	Version      *string                         `pulumi:"version"`
}

A collection of arguments for invoking getIamPolicyDocument.

type GetIamPolicyDocumentOutputArgs 

type GetIamPolicyDocumentOutputArgs struct {
	OverrideJson pulumi.StringPtrInput                   `pulumi:"overrideJson"`
	PolicyId     pulumi.StringPtrInput                   `pulumi:"policyId"`
	SourceJson   pulumi.StringPtrInput                   `pulumi:"sourceJson"`
	Statements   GetIamPolicyDocumentStatementArrayInput `pulumi:"statements"`
	Version      pulumi.StringPtrInput                   `pulumi:"version"`
}

A collection of arguments for invoking getIamPolicyDocument.

func (GetIamPolicyDocumentOutputArgs) ElementType 

func (GetIamPolicyDocumentOutputArgs) ElementType() reflect.Type

type GetIamPolicyDocumentResult 

type GetIamPolicyDocumentResult struct {
	// The provider-assigned unique ID for this managed resource.
	Id           string                          `pulumi:"id"`
	Json         string                          `pulumi:"json"`
	OverrideJson *string                         `pulumi:"overrideJson"`
	PolicyId     *string                         `pulumi:"policyId"`
	SourceJson   *string                         `pulumi:"sourceJson"`
	Statements   []GetIamPolicyDocumentStatement `pulumi:"statements"`
	Version      *string                         `pulumi:"version"`
}

A collection of values returned by getIamPolicyDocument.

func GetIamPolicyDocument 

func GetIamPolicyDocument(ctx *pulumi.Context, args *GetIamPolicyDocumentArgs, opts ...pulumi.InvokeOption) (*GetIamPolicyDocumentResult, error)

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-minio/sdk/v2/go/minio"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := minio.GetIamPolicyDocument(ctx, &minio.GetIamPolicyDocumentArgs{
			Statements: pulumi.Array{
				minio.GetIamPolicyDocumentStatement{
					Sid: pulumi.StringRef("1"),
					Actions: []string{
						"s3:ListAllMyBuckets",
						"s3:GetBucketLocation",
					},
					Resources: []string{
						"arn:aws:s3:::*",
					},
				},
				minio.GetIamPolicyDocumentStatement{
					Actions: []string{
						"s3:ListBucket",
					},
					Resources: []string{
						"arn:aws:s3:::state-terraform-s3",
					},
					Conditions: []minio.GetIamPolicyDocumentStatementCondition{
						{
							Test:     "StringLike",
							Variable: "s3:prefix",
							Values: []string{
								"",
								"home/",
							},
						},
					},
				},
				minio.GetIamPolicyDocumentStatement{
					Actions: []string{
						"s3:PutObject",
					},
					Resources: []string{
						"arn:aws:s3:::state-terraform-s3",
						"arn:aws:s3:::state-terraform-s3/*",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = minio.NewIamPolicy(ctx, "testPolicy", &minio.IamPolicyArgs{
			Policy: *pulumi.String(example.Json),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

type GetIamPolicyDocumentResultOutput 

type GetIamPolicyDocumentResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getIamPolicyDocument.

func GetIamPolicyDocumentOutput 

func GetIamPolicyDocumentOutput(ctx *pulumi.Context, args GetIamPolicyDocumentOutputArgs, opts ...pulumi.InvokeOption) GetIamPolicyDocumentResultOutput

func (GetIamPolicyDocumentResultOutput) ElementType 

func (GetIamPolicyDocumentResultOutput) ElementType() reflect.Type

func (GetIamPolicyDocumentResultOutput) Id 

func (o GetIamPolicyDocumentResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetIamPolicyDocumentResultOutput) Json 

func (o GetIamPolicyDocumentResultOutput) Json() pulumi.StringOutput

func (GetIamPolicyDocumentResultOutput) OverrideJson 

func (o GetIamPolicyDocumentResultOutput) OverrideJson() pulumi.StringPtrOutput

func (GetIamPolicyDocumentResultOutput) PolicyId 

func (o GetIamPolicyDocumentResultOutput) PolicyId() pulumi.StringPtrOutput

func (GetIamPolicyDocumentResultOutput) SourceJson 

func (o GetIamPolicyDocumentResultOutput) SourceJson() pulumi.StringPtrOutput

func (GetIamPolicyDocumentResultOutput) Statements 

func (o GetIamPolicyDocumentResultOutput) Statements() GetIamPolicyDocumentStatementArrayOutput

func (GetIamPolicyDocumentResultOutput) ToGetIamPolicyDocumentResultOutput 

func (o GetIamPolicyDocumentResultOutput) ToGetIamPolicyDocumentResultOutput() GetIamPolicyDocumentResultOutput

func (GetIamPolicyDocumentResultOutput) ToGetIamPolicyDocumentResultOutputWithContext 

func (o GetIamPolicyDocumentResultOutput) ToGetIamPolicyDocumentResultOutputWithContext(ctx context.Context) GetIamPolicyDocumentResultOutput

func (GetIamPolicyDocumentResultOutput) Version 

func (o GetIamPolicyDocumentResultOutput) Version() pulumi.StringPtrOutput

type GetIamPolicyDocumentStatement 

type GetIamPolicyDocumentStatement struct {
	Actions    []string                                 `pulumi:"actions"`
	Conditions []GetIamPolicyDocumentStatementCondition `pulumi:"conditions"`
	Effect     *string                                  `pulumi:"effect"`
	Principal  *string                                  `pulumi:"principal"`
	Resources  []string                                 `pulumi:"resources"`
	Sid        *string                                  `pulumi:"sid"`
}

type GetIamPolicyDocumentStatementArgs 

type GetIamPolicyDocumentStatementArgs struct {
	Actions    pulumi.StringArrayInput                          `pulumi:"actions"`
	Conditions GetIamPolicyDocumentStatementConditionArrayInput `pulumi:"conditions"`
	Effect     pulumi.StringPtrInput                            `pulumi:"effect"`
	Principal  pulumi.StringPtrInput                            `pulumi:"principal"`
	Resources  pulumi.StringArrayInput                          `pulumi:"resources"`
	Sid        pulumi.StringPtrInput                            `pulumi:"sid"`
}

func (GetIamPolicyDocumentStatementArgs) ElementType 

func (GetIamPolicyDocumentStatementArgs) ElementType() reflect.Type

func (GetIamPolicyDocumentStatementArgs) ToGetIamPolicyDocumentStatementOutput 

func (i GetIamPolicyDocumentStatementArgs) ToGetIamPolicyDocumentStatementOutput() GetIamPolicyDocumentStatementOutput

func (GetIamPolicyDocumentStatementArgs) ToGetIamPolicyDocumentStatementOutputWithContext 

func (i GetIamPolicyDocumentStatementArgs) ToGetIamPolicyDocumentStatementOutputWithContext(ctx context.Context) GetIamPolicyDocumentStatementOutput

type GetIamPolicyDocumentStatementArray 

type GetIamPolicyDocumentStatementArray []GetIamPolicyDocumentStatementInput

func (GetIamPolicyDocumentStatementArray) ElementType 

func (GetIamPolicyDocumentStatementArray) ElementType() reflect.Type

func (GetIamPolicyDocumentStatementArray) ToGetIamPolicyDocumentStatementArrayOutput 

func (i GetIamPolicyDocumentStatementArray) ToGetIamPolicyDocumentStatementArrayOutput() GetIamPolicyDocumentStatementArrayOutput

func (GetIamPolicyDocumentStatementArray) ToGetIamPolicyDocumentStatementArrayOutputWithContext 

func (i GetIamPolicyDocumentStatementArray) ToGetIamPolicyDocumentStatementArrayOutputWithContext(ctx context.Context) GetIamPolicyDocumentStatementArrayOutput

type GetIamPolicyDocumentStatementArrayInput 

type GetIamPolicyDocumentStatementArrayInput interface {
	pulumi.Input

	ToGetIamPolicyDocumentStatementArrayOutput() GetIamPolicyDocumentStatementArrayOutput
	ToGetIamPolicyDocumentStatementArrayOutputWithContext(context.Context) GetIamPolicyDocumentStatementArrayOutput
}

GetIamPolicyDocumentStatementArrayInput is an input type that accepts GetIamPolicyDocumentStatementArray and GetIamPolicyDocumentStatementArrayOutput values. You can construct a concrete instance of `GetIamPolicyDocumentStatementArrayInput` via: 

GetIamPolicyDocumentStatementArray{ GetIamPolicyDocumentStatementArgs{...} }

type GetIamPolicyDocumentStatementArrayOutput 

type GetIamPolicyDocumentStatementArrayOutput struct{ *pulumi.OutputState }

func (GetIamPolicyDocumentStatementArrayOutput) ElementType 

func (GetIamPolicyDocumentStatementArrayOutput) ElementType() reflect.Type

func (GetIamPolicyDocumentStatementArrayOutput) Index 

func (o GetIamPolicyDocumentStatementArrayOutput) Index(i pulumi.IntInput) GetIamPolicyDocumentStatementOutput

func (GetIamPolicyDocumentStatementArrayOutput) ToGetIamPolicyDocumentStatementArrayOutput 

func (o GetIamPolicyDocumentStatementArrayOutput) ToGetIamPolicyDocumentStatementArrayOutput() GetIamPolicyDocumentStatementArrayOutput

func (GetIamPolicyDocumentStatementArrayOutput) ToGetIamPolicyDocumentStatementArrayOutputWithContext 

func (o GetIamPolicyDocumentStatementArrayOutput) ToGetIamPolicyDocumentStatementArrayOutputWithContext(ctx context.Context) GetIamPolicyDocumentStatementArrayOutput

type GetIamPolicyDocumentStatementCondition 

type GetIamPolicyDocumentStatementCondition struct {
	Test     string   `pulumi:"test"`
	Values   []string `pulumi:"values"`
	Variable string   `pulumi:"variable"`
}

type GetIamPolicyDocumentStatementConditionArgs 

type GetIamPolicyDocumentStatementConditionArgs struct {
	Test     pulumi.StringInput      `pulumi:"test"`
	Values   pulumi.StringArrayInput `pulumi:"values"`
	Variable pulumi.StringInput      `pulumi:"variable"`
}

func (GetIamPolicyDocumentStatementConditionArgs) ElementType 

func (GetIamPolicyDocumentStatementConditionArgs) ElementType() reflect.Type

func (GetIamPolicyDocumentStatementConditionArgs) ToGetIamPolicyDocumentStatementConditionOutput 

func (i GetIamPolicyDocumentStatementConditionArgs) ToGetIamPolicyDocumentStatementConditionOutput() GetIamPolicyDocumentStatementConditionOutput

func (GetIamPolicyDocumentStatementConditionArgs) ToGetIamPolicyDocumentStatementConditionOutputWithContext 

func (i GetIamPolicyDocumentStatementConditionArgs) ToGetIamPolicyDocumentStatementConditionOutputWithContext(ctx context.Context) GetIamPolicyDocumentStatementConditionOutput

type GetIamPolicyDocumentStatementConditionArray 

type GetIamPolicyDocumentStatementConditionArray []GetIamPolicyDocumentStatementConditionInput

func (GetIamPolicyDocumentStatementConditionArray) ElementType 

func (GetIamPolicyDocumentStatementConditionArray) ElementType() reflect.Type

func (GetIamPolicyDocumentStatementConditionArray) ToGetIamPolicyDocumentStatementConditionArrayOutput 

func (i GetIamPolicyDocumentStatementConditionArray) ToGetIamPolicyDocumentStatementConditionArrayOutput() GetIamPolicyDocumentStatementConditionArrayOutput

func (GetIamPolicyDocumentStatementConditionArray) ToGetIamPolicyDocumentStatementConditionArrayOutputWithContext 

func (i GetIamPolicyDocumentStatementConditionArray) ToGetIamPolicyDocumentStatementConditionArrayOutputWithContext(ctx context.Context) GetIamPolicyDocumentStatementConditionArrayOutput

type GetIamPolicyDocumentStatementConditionArrayInput 

type GetIamPolicyDocumentStatementConditionArrayInput interface {
	pulumi.Input

	ToGetIamPolicyDocumentStatementConditionArrayOutput() GetIamPolicyDocumentStatementConditionArrayOutput
	ToGetIamPolicyDocumentStatementConditionArrayOutputWithContext(context.Context) GetIamPolicyDocumentStatementConditionArrayOutput
}

GetIamPolicyDocumentStatementConditionArrayInput is an input type that accepts GetIamPolicyDocumentStatementConditionArray and GetIamPolicyDocumentStatementConditionArrayOutput values. You can construct a concrete instance of `GetIamPolicyDocumentStatementConditionArrayInput` via: 

GetIamPolicyDocumentStatementConditionArray{ GetIamPolicyDocumentStatementConditionArgs{...} }

type GetIamPolicyDocumentStatementConditionArrayOutput 

type GetIamPolicyDocumentStatementConditionArrayOutput struct{ *pulumi.OutputState }

func (GetIamPolicyDocumentStatementConditionArrayOutput) ElementType 

func (GetIamPolicyDocumentStatementConditionArrayOutput) ElementType() reflect.Type

func (GetIamPolicyDocumentStatementConditionArrayOutput) Index 

func (o GetIamPolicyDocumentStatementConditionArrayOutput) Index(i pulumi.IntInput) GetIamPolicyDocumentStatementConditionOutput

func (GetIamPolicyDocumentStatementConditionArrayOutput) ToGetIamPolicyDocumentStatementConditionArrayOutput 

func (o GetIamPolicyDocumentStatementConditionArrayOutput) ToGetIamPolicyDocumentStatementConditionArrayOutput() GetIamPolicyDocumentStatementConditionArrayOutput

func (GetIamPolicyDocumentStatementConditionArrayOutput) ToGetIamPolicyDocumentStatementConditionArrayOutputWithContext 

func (o GetIamPolicyDocumentStatementConditionArrayOutput) ToGetIamPolicyDocumentStatementConditionArrayOutputWithContext(ctx context.Context) GetIamPolicyDocumentStatementConditionArrayOutput

type GetIamPolicyDocumentStatementConditionInput 

type GetIamPolicyDocumentStatementConditionInput interface {
	pulumi.Input

	ToGetIamPolicyDocumentStatementConditionOutput() GetIamPolicyDocumentStatementConditionOutput
	ToGetIamPolicyDocumentStatementConditionOutputWithContext(context.Context) GetIamPolicyDocumentStatementConditionOutput
}

GetIamPolicyDocumentStatementConditionInput is an input type that accepts GetIamPolicyDocumentStatementConditionArgs and GetIamPolicyDocumentStatementConditionOutput values. You can construct a concrete instance of `GetIamPolicyDocumentStatementConditionInput` via: 

GetIamPolicyDocumentStatementConditionArgs{...}

type GetIamPolicyDocumentStatementConditionOutput 

type GetIamPolicyDocumentStatementConditionOutput struct{ *pulumi.OutputState }

func (GetIamPolicyDocumentStatementConditionOutput) ElementType 

func (GetIamPolicyDocumentStatementConditionOutput) ElementType() reflect.Type

func (GetIamPolicyDocumentStatementConditionOutput) Test 

func (o GetIamPolicyDocumentStatementConditionOutput) Test() pulumi.StringOutput

func (GetIamPolicyDocumentStatementConditionOutput) ToGetIamPolicyDocumentStatementConditionOutput 

func (o GetIamPolicyDocumentStatementConditionOutput) ToGetIamPolicyDocumentStatementConditionOutput() GetIamPolicyDocumentStatementConditionOutput

func (GetIamPolicyDocumentStatementConditionOutput) ToGetIamPolicyDocumentStatementConditionOutputWithContext 

func (o GetIamPolicyDocumentStatementConditionOutput) ToGetIamPolicyDocumentStatementConditionOutputWithContext(ctx context.Context) GetIamPolicyDocumentStatementConditionOutput

func (GetIamPolicyDocumentStatementConditionOutput) Values 

func (o GetIamPolicyDocumentStatementConditionOutput) Values() pulumi.StringArrayOutput

func (GetIamPolicyDocumentStatementConditionOutput) Variable 

func (o GetIamPolicyDocumentStatementConditionOutput) Variable() pulumi.StringOutput

type GetIamPolicyDocumentStatementInput 

type GetIamPolicyDocumentStatementInput interface {
	pulumi.Input

	ToGetIamPolicyDocumentStatementOutput() GetIamPolicyDocumentStatementOutput
	ToGetIamPolicyDocumentStatementOutputWithContext(context.Context) GetIamPolicyDocumentStatementOutput
}

GetIamPolicyDocumentStatementInput is an input type that accepts GetIamPolicyDocumentStatementArgs and GetIamPolicyDocumentStatementOutput values. You can construct a concrete instance of `GetIamPolicyDocumentStatementInput` via: 

GetIamPolicyDocumentStatementArgs{...}

type GetIamPolicyDocumentStatementOutput 

type GetIamPolicyDocumentStatementOutput struct{ *pulumi.OutputState }

func (GetIamPolicyDocumentStatementOutput) Actions 

func (o GetIamPolicyDocumentStatementOutput) Actions() pulumi.StringArrayOutput

func (GetIamPolicyDocumentStatementOutput) Conditions 

func (o GetIamPolicyDocumentStatementOutput) Conditions() GetIamPolicyDocumentStatementConditionArrayOutput

func (GetIamPolicyDocumentStatementOutput) Effect 

func (o GetIamPolicyDocumentStatementOutput) Effect() pulumi.StringPtrOutput

func (GetIamPolicyDocumentStatementOutput) ElementType 

func (GetIamPolicyDocumentStatementOutput) ElementType() reflect.Type

func (GetIamPolicyDocumentStatementOutput) Principal 

func (o GetIamPolicyDocumentStatementOutput) Principal() pulumi.StringPtrOutput

func (GetIamPolicyDocumentStatementOutput) Resources 

func (o GetIamPolicyDocumentStatementOutput) Resources() pulumi.StringArrayOutput

func (GetIamPolicyDocumentStatementOutput) Sid 

func (o GetIamPolicyDocumentStatementOutput) Sid() pulumi.StringPtrOutput

func (GetIamPolicyDocumentStatementOutput) ToGetIamPolicyDocumentStatementOutput 

func (o GetIamPolicyDocumentStatementOutput) ToGetIamPolicyDocumentStatementOutput() GetIamPolicyDocumentStatementOutput

func (GetIamPolicyDocumentStatementOutput) ToGetIamPolicyDocumentStatementOutputWithContext 

func (o GetIamPolicyDocumentStatementOutput) ToGetIamPolicyDocumentStatementOutputWithContext(ctx context.Context) GetIamPolicyDocumentStatementOutput

type IamGroup 

type IamGroup struct {
	pulumi.CustomResourceState

	// Disable group
	DisableGroup pulumi.BoolPtrOutput `pulumi:"disableGroup"`
	// Delete group even if it has non-Terraform-managed members
	ForceDestroy pulumi.BoolPtrOutput `pulumi:"forceDestroy"`
	GroupName    pulumi.StringOutput  `pulumi:"groupName"`
	Name         pulumi.StringOutput  `pulumi:"name"`
}

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-minio/sdk/v2/go/minio"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		developer, err := minio.NewIamGroup(ctx, "developer", nil)
		if err != nil {
			return err
		}
		ctx.Export("minioUserGroup", developer.GroupName)
		return nil
	})
}

```

func GetIamGroup 

func GetIamGroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IamGroupState, opts ...pulumi.ResourceOption) (*IamGroup, error)

GetIamGroup gets an existing IamGroup 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 NewIamGroup 

func NewIamGroup(ctx *pulumi.Context,
	name string, args *IamGroupArgs, opts ...pulumi.ResourceOption) (*IamGroup, error)

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

func (*IamGroup) ElementType 

func (*IamGroup) ElementType() reflect.Type

func (*IamGroup) ToIamGroupOutput 

func (i *IamGroup) ToIamGroupOutput() IamGroupOutput

func (*IamGroup) ToIamGroupOutputWithContext 

func (i *IamGroup) ToIamGroupOutputWithContext(ctx context.Context) IamGroupOutput

type IamGroupArgs 

type IamGroupArgs struct {
	// Disable group
	DisableGroup pulumi.BoolPtrInput
	// Delete group even if it has non-Terraform-managed members
	ForceDestroy pulumi.BoolPtrInput
	Name         pulumi.StringPtrInput
}

The set of arguments for constructing a IamGroup resource.

func (IamGroupArgs) ElementType 

func (IamGroupArgs) ElementType() reflect.Type

type IamGroupArray 

type IamGroupArray []IamGroupInput

func (IamGroupArray) ElementType 

func (IamGroupArray) ElementType() reflect.Type

func (IamGroupArray) ToIamGroupArrayOutput 

func (i IamGroupArray) ToIamGroupArrayOutput() IamGroupArrayOutput

func (IamGroupArray) ToIamGroupArrayOutputWithContext 

func (i IamGroupArray) ToIamGroupArrayOutputWithContext(ctx context.Context) IamGroupArrayOutput

type IamGroupArrayInput 

type IamGroupArrayInput interface {
	pulumi.Input

	ToIamGroupArrayOutput() IamGroupArrayOutput
	ToIamGroupArrayOutputWithContext(context.Context) IamGroupArrayOutput
}

IamGroupArrayInput is an input type that accepts IamGroupArray and IamGroupArrayOutput values. You can construct a concrete instance of `IamGroupArrayInput` via: 

IamGroupArray{ IamGroupArgs{...} }

type IamGroupArrayOutput 

type IamGroupArrayOutput struct{ *pulumi.OutputState }

func (IamGroupArrayOutput) ElementType 

func (IamGroupArrayOutput) ElementType() reflect.Type

func (IamGroupArrayOutput) Index 

func (o IamGroupArrayOutput) Index(i pulumi.IntInput) IamGroupOutput

func (IamGroupArrayOutput) ToIamGroupArrayOutput 

func (o IamGroupArrayOutput) ToIamGroupArrayOutput() IamGroupArrayOutput

func (IamGroupArrayOutput) ToIamGroupArrayOutputWithContext 

func (o IamGroupArrayOutput) ToIamGroupArrayOutputWithContext(ctx context.Context) IamGroupArrayOutput

type IamGroupInput 

type IamGroupInput interface {
	pulumi.Input

	ToIamGroupOutput() IamGroupOutput
	ToIamGroupOutputWithContext(ctx context.Context) IamGroupOutput
}

type IamGroupMap 

type IamGroupMap map[string]IamGroupInput

func (IamGroupMap) ElementType 

func (IamGroupMap) ElementType() reflect.Type

func (IamGroupMap) ToIamGroupMapOutput 

func (i IamGroupMap) ToIamGroupMapOutput() IamGroupMapOutput

func (IamGroupMap) ToIamGroupMapOutputWithContext 

func (i IamGroupMap) ToIamGroupMapOutputWithContext(ctx context.Context) IamGroupMapOutput

type IamGroupMapInput 

type IamGroupMapInput interface {
	pulumi.Input

	ToIamGroupMapOutput() IamGroupMapOutput
	ToIamGroupMapOutputWithContext(context.Context) IamGroupMapOutput
}

IamGroupMapInput is an input type that accepts IamGroupMap and IamGroupMapOutput values. You can construct a concrete instance of `IamGroupMapInput` via: 

IamGroupMap{ "key": IamGroupArgs{...} }

type IamGroupMapOutput 

type IamGroupMapOutput struct{ *pulumi.OutputState }

func (IamGroupMapOutput) ElementType 

func (IamGroupMapOutput) ElementType() reflect.Type

func (IamGroupMapOutput) MapIndex 

func (o IamGroupMapOutput) MapIndex(k pulumi.StringInput) IamGroupOutput

func (IamGroupMapOutput) ToIamGroupMapOutput 

func (o IamGroupMapOutput) ToIamGroupMapOutput() IamGroupMapOutput

func (IamGroupMapOutput) ToIamGroupMapOutputWithContext 

func (o IamGroupMapOutput) ToIamGroupMapOutputWithContext(ctx context.Context) IamGroupMapOutput

type IamGroupMembership 

type IamGroupMembership struct {
	pulumi.CustomResourceState

	// Group name to add users
	Group pulumi.StringOutput `pulumi:"group"`
	// Name of group membership
	Name pulumi.StringOutput `pulumi:"name"`
	// Add user or list of users such as a group membership
	Users pulumi.StringArrayOutput `pulumi:"users"`
}

func GetIamGroupMembership 

func GetIamGroupMembership(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IamGroupMembershipState, opts ...pulumi.ResourceOption) (*IamGroupMembership, error)

GetIamGroupMembership gets an existing IamGroupMembership 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 NewIamGroupMembership 

func NewIamGroupMembership(ctx *pulumi.Context,
	name string, args *IamGroupMembershipArgs, opts ...pulumi.ResourceOption) (*IamGroupMembership, error)

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

func (*IamGroupMembership) ElementType 

func (*IamGroupMembership) ElementType() reflect.Type

func (*IamGroupMembership) ToIamGroupMembershipOutput 

func (i *IamGroupMembership) ToIamGroupMembershipOutput() IamGroupMembershipOutput

func (*IamGroupMembership) ToIamGroupMembershipOutputWithContext 

func (i *IamGroupMembership) ToIamGroupMembershipOutputWithContext(ctx context.Context) IamGroupMembershipOutput

type IamGroupMembershipArgs 

type IamGroupMembershipArgs struct {
	// Group name to add users
	Group pulumi.StringInput
	// Name of group membership
	Name pulumi.StringPtrInput
	// Add user or list of users such as a group membership
	Users pulumi.StringArrayInput
}

The set of arguments for constructing a IamGroupMembership resource.

func (IamGroupMembershipArgs) ElementType 

func (IamGroupMembershipArgs) ElementType() reflect.Type

type IamGroupMembershipArray 

type IamGroupMembershipArray []IamGroupMembershipInput

func (IamGroupMembershipArray) ElementType 

func (IamGroupMembershipArray) ElementType() reflect.Type

func (IamGroupMembershipArray) ToIamGroupMembershipArrayOutput 

func (i IamGroupMembershipArray) ToIamGroupMembershipArrayOutput() IamGroupMembershipArrayOutput

func (IamGroupMembershipArray) ToIamGroupMembershipArrayOutputWithContext 

func (i IamGroupMembershipArray) ToIamGroupMembershipArrayOutputWithContext(ctx context.Context) IamGroupMembershipArrayOutput

type IamGroupMembershipArrayInput 

type IamGroupMembershipArrayInput interface {
	pulumi.Input

	ToIamGroupMembershipArrayOutput() IamGroupMembershipArrayOutput
	ToIamGroupMembershipArrayOutputWithContext(context.Context) IamGroupMembershipArrayOutput
}

IamGroupMembershipArrayInput is an input type that accepts IamGroupMembershipArray and IamGroupMembershipArrayOutput values. You can construct a concrete instance of `IamGroupMembershipArrayInput` via: 

IamGroupMembershipArray{ IamGroupMembershipArgs{...} }

type IamGroupMembershipArrayOutput 

type IamGroupMembershipArrayOutput struct{ *pulumi.OutputState }

func (IamGroupMembershipArrayOutput) ElementType 

func (IamGroupMembershipArrayOutput) ElementType() reflect.Type

func (IamGroupMembershipArrayOutput) Index 

func (o IamGroupMembershipArrayOutput) Index(i pulumi.IntInput) IamGroupMembershipOutput

func (IamGroupMembershipArrayOutput) ToIamGroupMembershipArrayOutput 

func (o IamGroupMembershipArrayOutput) ToIamGroupMembershipArrayOutput() IamGroupMembershipArrayOutput

func (IamGroupMembershipArrayOutput) ToIamGroupMembershipArrayOutputWithContext 

func (o IamGroupMembershipArrayOutput) ToIamGroupMembershipArrayOutputWithContext(ctx context.Context) IamGroupMembershipArrayOutput

type IamGroupMembershipInput 

type IamGroupMembershipInput interface {
	pulumi.Input

	ToIamGroupMembershipOutput() IamGroupMembershipOutput
	ToIamGroupMembershipOutputWithContext(ctx context.Context) IamGroupMembershipOutput
}

type IamGroupMembershipMap 

type IamGroupMembershipMap map[string]IamGroupMembershipInput

func (IamGroupMembershipMap) ElementType 

func (IamGroupMembershipMap) ElementType() reflect.Type

func (IamGroupMembershipMap) ToIamGroupMembershipMapOutput 

func (i IamGroupMembershipMap) ToIamGroupMembershipMapOutput() IamGroupMembershipMapOutput

func (IamGroupMembershipMap) ToIamGroupMembershipMapOutputWithContext 

func (i IamGroupMembershipMap) ToIamGroupMembershipMapOutputWithContext(ctx context.Context) IamGroupMembershipMapOutput

type IamGroupMembershipMapInput 

type IamGroupMembershipMapInput interface {
	pulumi.Input

	ToIamGroupMembershipMapOutput() IamGroupMembershipMapOutput
	ToIamGroupMembershipMapOutputWithContext(context.Context) IamGroupMembershipMapOutput
}

IamGroupMembershipMapInput is an input type that accepts IamGroupMembershipMap and IamGroupMembershipMapOutput values. You can construct a concrete instance of `IamGroupMembershipMapInput` via: 

IamGroupMembershipMap{ "key": IamGroupMembershipArgs{...} }

type IamGroupMembershipMapOutput 

type IamGroupMembershipMapOutput struct{ *pulumi.OutputState }

func (IamGroupMembershipMapOutput) ElementType 

func (IamGroupMembershipMapOutput) ElementType() reflect.Type

func (IamGroupMembershipMapOutput) MapIndex 

func (o IamGroupMembershipMapOutput) MapIndex(k pulumi.StringInput) IamGroupMembershipOutput

func (IamGroupMembershipMapOutput) ToIamGroupMembershipMapOutput 

func (o IamGroupMembershipMapOutput) ToIamGroupMembershipMapOutput() IamGroupMembershipMapOutput

func (IamGroupMembershipMapOutput) ToIamGroupMembershipMapOutputWithContext 

func (o IamGroupMembershipMapOutput) ToIamGroupMembershipMapOutputWithContext(ctx context.Context) IamGroupMembershipMapOutput

type IamGroupMembershipOutput 

type IamGroupMembershipOutput struct{ *pulumi.OutputState }

func (IamGroupMembershipOutput) ElementType 

func (IamGroupMembershipOutput) ElementType() reflect.Type

func (IamGroupMembershipOutput) Group 

func (o IamGroupMembershipOutput) Group() pulumi.StringOutput

Group name to add users

func (IamGroupMembershipOutput) Name 

func (o IamGroupMembershipOutput) Name() pulumi.StringOutput

Name of group membership

func (IamGroupMembershipOutput) ToIamGroupMembershipOutput 

func (o IamGroupMembershipOutput) ToIamGroupMembershipOutput() IamGroupMembershipOutput

func (IamGroupMembershipOutput) ToIamGroupMembershipOutputWithContext 

func (o IamGroupMembershipOutput) ToIamGroupMembershipOutputWithContext(ctx context.Context) IamGroupMembershipOutput

func (IamGroupMembershipOutput) Users 

func (o IamGroupMembershipOutput) Users() pulumi.StringArrayOutput

Add user or list of users such as a group membership

type IamGroupMembershipState 

type IamGroupMembershipState struct {
	// Group name to add users
	Group pulumi.StringPtrInput
	// Name of group membership
	Name pulumi.StringPtrInput
	// Add user or list of users such as a group membership
	Users pulumi.StringArrayInput
}

func (IamGroupMembershipState) ElementType 

func (IamGroupMembershipState) ElementType() reflect.Type

type IamGroupOutput 

type IamGroupOutput struct{ *pulumi.OutputState }

func (IamGroupOutput) DisableGroup 

func (o IamGroupOutput) DisableGroup() pulumi.BoolPtrOutput

Disable group

func (IamGroupOutput) ElementType 

func (IamGroupOutput) ElementType() reflect.Type

func (IamGroupOutput) ForceDestroy 

func (o IamGroupOutput) ForceDestroy() pulumi.BoolPtrOutput

Delete group even if it has non-Terraform-managed members

func (IamGroupOutput) GroupName 

func (o IamGroupOutput) GroupName() pulumi.StringOutput

func (IamGroupOutput) Name 

func (o IamGroupOutput) Name() pulumi.StringOutput

func (IamGroupOutput) ToIamGroupOutput 

func (o IamGroupOutput) ToIamGroupOutput() IamGroupOutput

func (IamGroupOutput) ToIamGroupOutputWithContext 

func (o IamGroupOutput) ToIamGroupOutputWithContext(ctx context.Context) IamGroupOutput

type IamGroupPolicy 

type IamGroupPolicy struct {
	pulumi.CustomResourceState

	Group      pulumi.StringOutput    `pulumi:"group"`
	Name       pulumi.StringOutput    `pulumi:"name"`
	NamePrefix pulumi.StringPtrOutput `pulumi:"namePrefix"`
	Policy     pulumi.StringOutput    `pulumi:"policy"`
}

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-minio/sdk/v2/go/minio"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		developer, err := minio.NewIamGroup(ctx, "developer", nil)
		if err != nil {
			return err
		}
		_, err = minio.NewIamGroupPolicy(ctx, "testPolicy", &minio.IamGroupPolicyArgs{
			Group: developer.ID(),
			Policy: pulumi.String(`{
  "Version":"2012-10-17",
  "Statement": [
    {
      "Sid":"ListAllBucket",
      "Effect": "Allow",
      "Action": ["s3:PutObject"],
      "Principal":"*",
      "Resource": "arn:aws:s3:::state-terraform-s3/*"
    }
  ]
}

`), 

		})
		if err != nil {
			return err
		}
		ctx.Export("minioName", minio_iam_group_membership.Developer.Id)
		ctx.Export("minioPolicy", minio_iam_group_membership.Developer.Policy)
		ctx.Export("minioGroup", minio_iam_group_membership.Developer.Group)
		return nil
	})
}

```

func GetIamGroupPolicy 

func GetIamGroupPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IamGroupPolicyState, opts ...pulumi.ResourceOption) (*IamGroupPolicy, error)

GetIamGroupPolicy gets an existing IamGroupPolicy 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 NewIamGroupPolicy 

func NewIamGroupPolicy(ctx *pulumi.Context,
	name string, args *IamGroupPolicyArgs, opts ...pulumi.ResourceOption) (*IamGroupPolicy, error)

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

func (*IamGroupPolicy) ElementType 

func (*IamGroupPolicy) ElementType() reflect.Type

func (*IamGroupPolicy) ToIamGroupPolicyOutput 

func (i *IamGroupPolicy) ToIamGroupPolicyOutput() IamGroupPolicyOutput

func (*IamGroupPolicy) ToIamGroupPolicyOutputWithContext 

func (i *IamGroupPolicy) ToIamGroupPolicyOutputWithContext(ctx context.Context) IamGroupPolicyOutput

type IamGroupPolicyArgs 

type IamGroupPolicyArgs struct {
	Group      pulumi.StringInput
	Name       pulumi.StringPtrInput
	NamePrefix pulumi.StringPtrInput
	Policy     pulumi.StringInput
}

The set of arguments for constructing a IamGroupPolicy resource.

func (IamGroupPolicyArgs) ElementType 

func (IamGroupPolicyArgs) ElementType() reflect.Type

type IamGroupPolicyArray 

type IamGroupPolicyArray []IamGroupPolicyInput

func (IamGroupPolicyArray) ElementType 

func (IamGroupPolicyArray) ElementType() reflect.Type

func (IamGroupPolicyArray) ToIamGroupPolicyArrayOutput 

func (i IamGroupPolicyArray) ToIamGroupPolicyArrayOutput() IamGroupPolicyArrayOutput

func (IamGroupPolicyArray) ToIamGroupPolicyArrayOutputWithContext 

func (i IamGroupPolicyArray) ToIamGroupPolicyArrayOutputWithContext(ctx context.Context) IamGroupPolicyArrayOutput

type IamGroupPolicyArrayInput 

type IamGroupPolicyArrayInput interface {
	pulumi.Input

	ToIamGroupPolicyArrayOutput() IamGroupPolicyArrayOutput
	ToIamGroupPolicyArrayOutputWithContext(context.Context) IamGroupPolicyArrayOutput
}

IamGroupPolicyArrayInput is an input type that accepts IamGroupPolicyArray and IamGroupPolicyArrayOutput values. You can construct a concrete instance of `IamGroupPolicyArrayInput` via: 

IamGroupPolicyArray{ IamGroupPolicyArgs{...} }

type IamGroupPolicyArrayOutput 

type IamGroupPolicyArrayOutput struct{ *pulumi.OutputState }

func (IamGroupPolicyArrayOutput) ElementType 

func (IamGroupPolicyArrayOutput) ElementType() reflect.Type

func (IamGroupPolicyArrayOutput) Index 

func (o IamGroupPolicyArrayOutput) Index(i pulumi.IntInput) IamGroupPolicyOutput

func (IamGroupPolicyArrayOutput) ToIamGroupPolicyArrayOutput 

func (o IamGroupPolicyArrayOutput) ToIamGroupPolicyArrayOutput() IamGroupPolicyArrayOutput

func (IamGroupPolicyArrayOutput) ToIamGroupPolicyArrayOutputWithContext 

func (o IamGroupPolicyArrayOutput) ToIamGroupPolicyArrayOutputWithContext(ctx context.Context) IamGroupPolicyArrayOutput

type IamGroupPolicyAttachment 

type IamGroupPolicyAttachment struct {
	pulumi.CustomResourceState

	GroupName  pulumi.StringOutput `pulumi:"groupName"`
	PolicyName pulumi.StringOutput `pulumi:"policyName"`
}

func GetIamGroupPolicyAttachment 

func GetIamGroupPolicyAttachment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IamGroupPolicyAttachmentState, opts ...pulumi.ResourceOption) (*IamGroupPolicyAttachment, error)

GetIamGroupPolicyAttachment gets an existing IamGroupPolicyAttachment 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 NewIamGroupPolicyAttachment 

func NewIamGroupPolicyAttachment(ctx *pulumi.Context,
	name string, args *IamGroupPolicyAttachmentArgs, opts ...pulumi.ResourceOption) (*IamGroupPolicyAttachment, error)

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

func (*IamGroupPolicyAttachment) ElementType 

func (*IamGroupPolicyAttachment) ElementType() reflect.Type

func (*IamGroupPolicyAttachment) ToIamGroupPolicyAttachmentOutput 

func (i *IamGroupPolicyAttachment) ToIamGroupPolicyAttachmentOutput() IamGroupPolicyAttachmentOutput

func (*IamGroupPolicyAttachment) ToIamGroupPolicyAttachmentOutputWithContext 

func (i *IamGroupPolicyAttachment) ToIamGroupPolicyAttachmentOutputWithContext(ctx context.Context) IamGroupPolicyAttachmentOutput

type IamGroupPolicyAttachmentArgs 

type IamGroupPolicyAttachmentArgs struct {
	GroupName  pulumi.StringInput
	PolicyName pulumi.StringInput
}

The set of arguments for constructing a IamGroupPolicyAttachment resource.

func (IamGroupPolicyAttachmentArgs) ElementType 

func (IamGroupPolicyAttachmentArgs) ElementType() reflect.Type

type IamGroupPolicyAttachmentArray 

type IamGroupPolicyAttachmentArray []IamGroupPolicyAttachmentInput

func (IamGroupPolicyAttachmentArray) ElementType 

func (IamGroupPolicyAttachmentArray) ElementType() reflect.Type

func (IamGroupPolicyAttachmentArray) ToIamGroupPolicyAttachmentArrayOutput 

func (i IamGroupPolicyAttachmentArray) ToIamGroupPolicyAttachmentArrayOutput() IamGroupPolicyAttachmentArrayOutput

func (IamGroupPolicyAttachmentArray) ToIamGroupPolicyAttachmentArrayOutputWithContext 

func (i IamGroupPolicyAttachmentArray) ToIamGroupPolicyAttachmentArrayOutputWithContext(ctx context.Context) IamGroupPolicyAttachmentArrayOutput

type IamGroupPolicyAttachmentArrayInput 

type IamGroupPolicyAttachmentArrayInput interface {
	pulumi.Input

	ToIamGroupPolicyAttachmentArrayOutput() IamGroupPolicyAttachmentArrayOutput
	ToIamGroupPolicyAttachmentArrayOutputWithContext(context.Context) IamGroupPolicyAttachmentArrayOutput
}

IamGroupPolicyAttachmentArrayInput is an input type that accepts IamGroupPolicyAttachmentArray and IamGroupPolicyAttachmentArrayOutput values. You can construct a concrete instance of `IamGroupPolicyAttachmentArrayInput` via: 

IamGroupPolicyAttachmentArray{ IamGroupPolicyAttachmentArgs{...} }

type IamGroupPolicyAttachmentArrayOutput 

type IamGroupPolicyAttachmentArrayOutput struct{ *pulumi.OutputState }

func (IamGroupPolicyAttachmentArrayOutput) ElementType 

func (IamGroupPolicyAttachmentArrayOutput) ElementType() reflect.Type

func (IamGroupPolicyAttachmentArrayOutput) Index 

func (o IamGroupPolicyAttachmentArrayOutput) Index(i pulumi.IntInput) IamGroupPolicyAttachmentOutput

func (IamGroupPolicyAttachmentArrayOutput) ToIamGroupPolicyAttachmentArrayOutput 

func (o IamGroupPolicyAttachmentArrayOutput) ToIamGroupPolicyAttachmentArrayOutput() IamGroupPolicyAttachmentArrayOutput

func (IamGroupPolicyAttachmentArrayOutput) ToIamGroupPolicyAttachmentArrayOutputWithContext 

func (o IamGroupPolicyAttachmentArrayOutput) ToIamGroupPolicyAttachmentArrayOutputWithContext(ctx context.Context) IamGroupPolicyAttachmentArrayOutput

type IamGroupPolicyAttachmentInput 

type IamGroupPolicyAttachmentInput interface {
	pulumi.Input

	ToIamGroupPolicyAttachmentOutput() IamGroupPolicyAttachmentOutput
	ToIamGroupPolicyAttachmentOutputWithContext(ctx context.Context) IamGroupPolicyAttachmentOutput
}

type IamGroupPolicyAttachmentMap 

type IamGroupPolicyAttachmentMap map[string]IamGroupPolicyAttachmentInput

func (IamGroupPolicyAttachmentMap) ElementType 

func (IamGroupPolicyAttachmentMap) ElementType() reflect.Type

func (IamGroupPolicyAttachmentMap) ToIamGroupPolicyAttachmentMapOutput 

func (i IamGroupPolicyAttachmentMap) ToIamGroupPolicyAttachmentMapOutput() IamGroupPolicyAttachmentMapOutput

func (IamGroupPolicyAttachmentMap) ToIamGroupPolicyAttachmentMapOutputWithContext 

func (i IamGroupPolicyAttachmentMap) ToIamGroupPolicyAttachmentMapOutputWithContext(ctx context.Context) IamGroupPolicyAttachmentMapOutput

type IamGroupPolicyAttachmentMapInput 

type IamGroupPolicyAttachmentMapInput interface {
	pulumi.Input

	ToIamGroupPolicyAttachmentMapOutput() IamGroupPolicyAttachmentMapOutput
	ToIamGroupPolicyAttachmentMapOutputWithContext(context.Context) IamGroupPolicyAttachmentMapOutput
}

IamGroupPolicyAttachmentMapInput is an input type that accepts IamGroupPolicyAttachmentMap and IamGroupPolicyAttachmentMapOutput values. You can construct a concrete instance of `IamGroupPolicyAttachmentMapInput` via: 

IamGroupPolicyAttachmentMap{ "key": IamGroupPolicyAttachmentArgs{...} }

type IamGroupPolicyAttachmentMapOutput 

type IamGroupPolicyAttachmentMapOutput struct{ *pulumi.OutputState }

func (IamGroupPolicyAttachmentMapOutput) ElementType 

func (IamGroupPolicyAttachmentMapOutput) ElementType() reflect.Type

func (IamGroupPolicyAttachmentMapOutput) MapIndex 

func (o IamGroupPolicyAttachmentMapOutput) MapIndex(k pulumi.StringInput) IamGroupPolicyAttachmentOutput

func (IamGroupPolicyAttachmentMapOutput) ToIamGroupPolicyAttachmentMapOutput 

func (o IamGroupPolicyAttachmentMapOutput) ToIamGroupPolicyAttachmentMapOutput() IamGroupPolicyAttachmentMapOutput

func (IamGroupPolicyAttachmentMapOutput) ToIamGroupPolicyAttachmentMapOutputWithContext 

func (o IamGroupPolicyAttachmentMapOutput) ToIamGroupPolicyAttachmentMapOutputWithContext(ctx context.Context) IamGroupPolicyAttachmentMapOutput

type IamGroupPolicyAttachmentOutput 

type IamGroupPolicyAttachmentOutput struct{ *pulumi.OutputState }

func (IamGroupPolicyAttachmentOutput) ElementType 

func (IamGroupPolicyAttachmentOutput) ElementType() reflect.Type

func (IamGroupPolicyAttachmentOutput) GroupName 

func (o IamGroupPolicyAttachmentOutput) GroupName() pulumi.StringOutput

func (IamGroupPolicyAttachmentOutput) PolicyName 

func (o IamGroupPolicyAttachmentOutput) PolicyName() pulumi.StringOutput

func (IamGroupPolicyAttachmentOutput) ToIamGroupPolicyAttachmentOutput 

func (o IamGroupPolicyAttachmentOutput) ToIamGroupPolicyAttachmentOutput() IamGroupPolicyAttachmentOutput

func (IamGroupPolicyAttachmentOutput) ToIamGroupPolicyAttachmentOutputWithContext 

func (o IamGroupPolicyAttachmentOutput) ToIamGroupPolicyAttachmentOutputWithContext(ctx context.Context) IamGroupPolicyAttachmentOutput

type IamGroupPolicyAttachmentState 

type IamGroupPolicyAttachmentState struct {
	GroupName  pulumi.StringPtrInput
	PolicyName pulumi.StringPtrInput
}

func (IamGroupPolicyAttachmentState) ElementType 

func (IamGroupPolicyAttachmentState) ElementType() reflect.Type

type IamGroupPolicyInput 

type IamGroupPolicyInput interface {
	pulumi.Input

	ToIamGroupPolicyOutput() IamGroupPolicyOutput
	ToIamGroupPolicyOutputWithContext(ctx context.Context) IamGroupPolicyOutput
}

type IamGroupPolicyMap 

type IamGroupPolicyMap map[string]IamGroupPolicyInput

func (IamGroupPolicyMap) ElementType 

func (IamGroupPolicyMap) ElementType() reflect.Type

func (IamGroupPolicyMap) ToIamGroupPolicyMapOutput 

func (i IamGroupPolicyMap) ToIamGroupPolicyMapOutput() IamGroupPolicyMapOutput

func (IamGroupPolicyMap) ToIamGroupPolicyMapOutputWithContext 

func (i IamGroupPolicyMap) ToIamGroupPolicyMapOutputWithContext(ctx context.Context) IamGroupPolicyMapOutput

type IamGroupPolicyMapInput 

type IamGroupPolicyMapInput interface {
	pulumi.Input

	ToIamGroupPolicyMapOutput() IamGroupPolicyMapOutput
	ToIamGroupPolicyMapOutputWithContext(context.Context) IamGroupPolicyMapOutput
}

IamGroupPolicyMapInput is an input type that accepts IamGroupPolicyMap and IamGroupPolicyMapOutput values. You can construct a concrete instance of `IamGroupPolicyMapInput` via: 

IamGroupPolicyMap{ "key": IamGroupPolicyArgs{...} }

type IamGroupPolicyMapOutput 

type IamGroupPolicyMapOutput struct{ *pulumi.OutputState }

func (IamGroupPolicyMapOutput) ElementType 

func (IamGroupPolicyMapOutput) ElementType() reflect.Type

func (IamGroupPolicyMapOutput) MapIndex 

func (o IamGroupPolicyMapOutput) MapIndex(k pulumi.StringInput) IamGroupPolicyOutput

func (IamGroupPolicyMapOutput) ToIamGroupPolicyMapOutput 

func (o IamGroupPolicyMapOutput) ToIamGroupPolicyMapOutput() IamGroupPolicyMapOutput

func (IamGroupPolicyMapOutput) ToIamGroupPolicyMapOutputWithContext 

func (o IamGroupPolicyMapOutput) ToIamGroupPolicyMapOutputWithContext(ctx context.Context) IamGroupPolicyMapOutput

type IamGroupPolicyOutput 

type IamGroupPolicyOutput struct{ *pulumi.OutputState }

func (IamGroupPolicyOutput) ElementType 

func (IamGroupPolicyOutput) ElementType() reflect.Type

func (IamGroupPolicyOutput) Group 

func (o IamGroupPolicyOutput) Group() pulumi.StringOutput

func (IamGroupPolicyOutput) Name 

func (o IamGroupPolicyOutput) Name() pulumi.StringOutput

func (IamGroupPolicyOutput) NamePrefix 

func (o IamGroupPolicyOutput) NamePrefix() pulumi.StringPtrOutput

func (IamGroupPolicyOutput) Policy 

func (o IamGroupPolicyOutput) Policy() pulumi.StringOutput

func (IamGroupPolicyOutput) ToIamGroupPolicyOutput 

func (o IamGroupPolicyOutput) ToIamGroupPolicyOutput() IamGroupPolicyOutput

func (IamGroupPolicyOutput) ToIamGroupPolicyOutputWithContext 

func (o IamGroupPolicyOutput) ToIamGroupPolicyOutputWithContext(ctx context.Context) IamGroupPolicyOutput

type IamGroupPolicyState 

type IamGroupPolicyState struct {
	Group      pulumi.StringPtrInput
	Name       pulumi.StringPtrInput
	NamePrefix pulumi.StringPtrInput
	Policy     pulumi.StringPtrInput
}

func (IamGroupPolicyState) ElementType 

func (IamGroupPolicyState) ElementType() reflect.Type

type IamGroupState 

type IamGroupState struct {
	// Disable group
	DisableGroup pulumi.BoolPtrInput
	// Delete group even if it has non-Terraform-managed members
	ForceDestroy pulumi.BoolPtrInput
	GroupName    pulumi.StringPtrInput
	Name         pulumi.StringPtrInput
}

func (IamGroupState) ElementType 

func (IamGroupState) ElementType() reflect.Type

type IamGroupUserAttachment 

type IamGroupUserAttachment struct {
	pulumi.CustomResourceState

	GroupName pulumi.StringOutput `pulumi:"groupName"`
	UserName  pulumi.StringOutput `pulumi:"userName"`
}

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-minio/sdk/v2/go/minio"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := minio.NewIamGroup(ctx, "developerIamGroup", nil)
		if err != nil {
			return err
		}
		userOne, err := minio.NewIamUser(ctx, "userOne", nil)
		if err != nil {
			return err
		}
		developerIamGroupUserAttachment, err := minio.NewIamGroupUserAttachment(ctx, "developerIamGroupUserAttachment", &minio.IamGroupUserAttachmentArgs{
			GroupName: pulumi.Any(minio_iam_group.Group.Name),
			UserName:  userOne.Name,
		})
		if err != nil {
			return err
		}
		ctx.Export("minioName", developerIamGroupUserAttachment.ID())
		ctx.Export("minioUsers", developerIamGroupUserAttachment.GroupName)
		ctx.Export("minioGroup", developerIamGroupUserAttachment.UserName)
		return nil
	})
}

```

func GetIamGroupUserAttachment 

func GetIamGroupUserAttachment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IamGroupUserAttachmentState, opts ...pulumi.ResourceOption) (*IamGroupUserAttachment, error)

GetIamGroupUserAttachment gets an existing IamGroupUserAttachment 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 NewIamGroupUserAttachment 

func NewIamGroupUserAttachment(ctx *pulumi.Context,
	name string, args *IamGroupUserAttachmentArgs, opts ...pulumi.ResourceOption) (*IamGroupUserAttachment, error)

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

func (*IamGroupUserAttachment) ElementType 

func (*IamGroupUserAttachment) ElementType() reflect.Type

func (*IamGroupUserAttachment) ToIamGroupUserAttachmentOutput 

func (i *IamGroupUserAttachment) ToIamGroupUserAttachmentOutput() IamGroupUserAttachmentOutput

func (*IamGroupUserAttachment) ToIamGroupUserAttachmentOutputWithContext 

func (i *IamGroupUserAttachment) ToIamGroupUserAttachmentOutputWithContext(ctx context.Context) IamGroupUserAttachmentOutput

type IamGroupUserAttachmentArgs 

type IamGroupUserAttachmentArgs struct {
	GroupName pulumi.StringInput
	UserName  pulumi.StringInput
}

The set of arguments for constructing a IamGroupUserAttachment resource.

func (IamGroupUserAttachmentArgs) ElementType 

func (IamGroupUserAttachmentArgs) ElementType() reflect.Type

type IamGroupUserAttachmentArray 

type IamGroupUserAttachmentArray []IamGroupUserAttachmentInput

func (IamGroupUserAttachmentArray) ElementType 

func (IamGroupUserAttachmentArray) ElementType() reflect.Type

func (IamGroupUserAttachmentArray) ToIamGroupUserAttachmentArrayOutput 

func (i IamGroupUserAttachmentArray) ToIamGroupUserAttachmentArrayOutput() IamGroupUserAttachmentArrayOutput

func (IamGroupUserAttachmentArray) ToIamGroupUserAttachmentArrayOutputWithContext 

func (i IamGroupUserAttachmentArray) ToIamGroupUserAttachmentArrayOutputWithContext(ctx context.Context) IamGroupUserAttachmentArrayOutput

type IamGroupUserAttachmentArrayInput 

type IamGroupUserAttachmentArrayInput interface {
	pulumi.Input

	ToIamGroupUserAttachmentArrayOutput() IamGroupUserAttachmentArrayOutput
	ToIamGroupUserAttachmentArrayOutputWithContext(context.Context) IamGroupUserAttachmentArrayOutput
}

IamGroupUserAttachmentArrayInput is an input type that accepts IamGroupUserAttachmentArray and IamGroupUserAttachmentArrayOutput values. You can construct a concrete instance of `IamGroupUserAttachmentArrayInput` via: 

IamGroupUserAttachmentArray{ IamGroupUserAttachmentArgs{...} }

type IamGroupUserAttachmentArrayOutput 

type IamGroupUserAttachmentArrayOutput struct{ *pulumi.OutputState }

func (IamGroupUserAttachmentArrayOutput) ElementType 

func (IamGroupUserAttachmentArrayOutput) ElementType() reflect.Type

func (IamGroupUserAttachmentArrayOutput) Index 

func (o IamGroupUserAttachmentArrayOutput) Index(i pulumi.IntInput) IamGroupUserAttachmentOutput

func (IamGroupUserAttachmentArrayOutput) ToIamGroupUserAttachmentArrayOutput 

func (o IamGroupUserAttachmentArrayOutput) ToIamGroupUserAttachmentArrayOutput() IamGroupUserAttachmentArrayOutput

func (IamGroupUserAttachmentArrayOutput) ToIamGroupUserAttachmentArrayOutputWithContext 

func (o IamGroupUserAttachmentArrayOutput) ToIamGroupUserAttachmentArrayOutputWithContext(ctx context.Context) IamGroupUserAttachmentArrayOutput

type IamGroupUserAttachmentInput 

type IamGroupUserAttachmentInput interface {
	pulumi.Input

	ToIamGroupUserAttachmentOutput() IamGroupUserAttachmentOutput
	ToIamGroupUserAttachmentOutputWithContext(ctx context.Context) IamGroupUserAttachmentOutput
}

type IamGroupUserAttachmentMap 

type IamGroupUserAttachmentMap map[string]IamGroupUserAttachmentInput

func (IamGroupUserAttachmentMap) ElementType 

func (IamGroupUserAttachmentMap) ElementType() reflect.Type

func (IamGroupUserAttachmentMap) ToIamGroupUserAttachmentMapOutput 

func (i IamGroupUserAttachmentMap) ToIamGroupUserAttachmentMapOutput() IamGroupUserAttachmentMapOutput

func (IamGroupUserAttachmentMap) ToIamGroupUserAttachmentMapOutputWithContext 

func (i IamGroupUserAttachmentMap) ToIamGroupUserAttachmentMapOutputWithContext(ctx context.Context) IamGroupUserAttachmentMapOutput

type IamGroupUserAttachmentMapInput 

type IamGroupUserAttachmentMapInput interface {
	pulumi.Input

	ToIamGroupUserAttachmentMapOutput() IamGroupUserAttachmentMapOutput
	ToIamGroupUserAttachmentMapOutputWithContext(context.Context) IamGroupUserAttachmentMapOutput
}

IamGroupUserAttachmentMapInput is an input type that accepts IamGroupUserAttachmentMap and IamGroupUserAttachmentMapOutput values. You can construct a concrete instance of `IamGroupUserAttachmentMapInput` via: 

IamGroupUserAttachmentMap{ "key": IamGroupUserAttachmentArgs{...} }

type IamGroupUserAttachmentMapOutput 

type IamGroupUserAttachmentMapOutput struct{ *pulumi.OutputState }

func (IamGroupUserAttachmentMapOutput) ElementType 

func (IamGroupUserAttachmentMapOutput) ElementType() reflect.Type

func (IamGroupUserAttachmentMapOutput) MapIndex 

func (o IamGroupUserAttachmentMapOutput) MapIndex(k pulumi.StringInput) IamGroupUserAttachmentOutput

func (IamGroupUserAttachmentMapOutput) ToIamGroupUserAttachmentMapOutput 

func (o IamGroupUserAttachmentMapOutput) ToIamGroupUserAttachmentMapOutput() IamGroupUserAttachmentMapOutput

func (IamGroupUserAttachmentMapOutput) ToIamGroupUserAttachmentMapOutputWithContext 

func (o IamGroupUserAttachmentMapOutput) ToIamGroupUserAttachmentMapOutputWithContext(ctx context.Context) IamGroupUserAttachmentMapOutput

type IamGroupUserAttachmentOutput 

type IamGroupUserAttachmentOutput struct{ *pulumi.OutputState }

func (IamGroupUserAttachmentOutput) ElementType 

func (IamGroupUserAttachmentOutput) ElementType() reflect.Type

func (IamGroupUserAttachmentOutput) GroupName 

func (o IamGroupUserAttachmentOutput) GroupName() pulumi.StringOutput

func (IamGroupUserAttachmentOutput) ToIamGroupUserAttachmentOutput 

func (o IamGroupUserAttachmentOutput) ToIamGroupUserAttachmentOutput() IamGroupUserAttachmentOutput

func (IamGroupUserAttachmentOutput) ToIamGroupUserAttachmentOutputWithContext 

func (o IamGroupUserAttachmentOutput) ToIamGroupUserAttachmentOutputWithContext(ctx context.Context) IamGroupUserAttachmentOutput

func (IamGroupUserAttachmentOutput) UserName 

func (o IamGroupUserAttachmentOutput) UserName() pulumi.StringOutput

type IamGroupUserAttachmentState 

type IamGroupUserAttachmentState struct {
	GroupName pulumi.StringPtrInput
	UserName  pulumi.StringPtrInput
}

func (IamGroupUserAttachmentState) ElementType 

func (IamGroupUserAttachmentState) ElementType() reflect.Type

type IamPolicy 

type IamPolicy struct {
	pulumi.CustomResourceState

	Name       pulumi.StringOutput    `pulumi:"name"`
	NamePrefix pulumi.StringPtrOutput `pulumi:"namePrefix"`
	Policy     pulumi.StringOutput    `pulumi:"policy"`
}

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-minio/sdk/v2/go/minio"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testPolicy, err := minio.NewIamPolicy(ctx, "testPolicy", &minio.IamPolicyArgs{
			Policy: pulumi.String(`{
  "Version":"2012-10-17",
  "Statement": [
    {
      "Sid":"ListAllBucket",
      "Effect": "Allow",
      "Action": ["s3:PutObject"],
      "Principal":"*",
      "Resource": "arn:aws:s3:::state-terraform-s3/*"
    }
  ]
}

`), 

		})
		if err != nil {
			return err
		}
		ctx.Export("minioId", testPolicy.ID())
		ctx.Export("minioPolicy", testPolicy.Policy)
		return nil
	})
}

```

func GetIamPolicy 

func GetIamPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IamPolicyState, opts ...pulumi.ResourceOption) (*IamPolicy, error)

GetIamPolicy gets an existing IamPolicy 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 NewIamPolicy 

func NewIamPolicy(ctx *pulumi.Context,
	name string, args *IamPolicyArgs, opts ...pulumi.ResourceOption) (*IamPolicy, error)

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

func (*IamPolicy) ElementType 

func (*IamPolicy) ElementType() reflect.Type

func (*IamPolicy) ToIamPolicyOutput 

func (i *IamPolicy) ToIamPolicyOutput() IamPolicyOutput

func (*IamPolicy) ToIamPolicyOutputWithContext 

func (i *IamPolicy) ToIamPolicyOutputWithContext(ctx context.Context) IamPolicyOutput

type IamPolicyArgs 

type IamPolicyArgs struct {
	Name       pulumi.StringPtrInput
	NamePrefix pulumi.StringPtrInput
	Policy     pulumi.StringInput
}

The set of arguments for constructing a IamPolicy resource.

func (IamPolicyArgs) ElementType 

func (IamPolicyArgs) ElementType() reflect.Type

type IamPolicyArray 

type IamPolicyArray []IamPolicyInput

func (IamPolicyArray) ElementType 

func (IamPolicyArray) ElementType() reflect.Type

func (IamPolicyArray) ToIamPolicyArrayOutput 

func (i IamPolicyArray) ToIamPolicyArrayOutput() IamPolicyArrayOutput

func (IamPolicyArray) ToIamPolicyArrayOutputWithContext 

func (i IamPolicyArray) ToIamPolicyArrayOutputWithContext(ctx context.Context) IamPolicyArrayOutput

type IamPolicyArrayInput 

type IamPolicyArrayInput interface {
	pulumi.Input

	ToIamPolicyArrayOutput() IamPolicyArrayOutput
	ToIamPolicyArrayOutputWithContext(context.Context) IamPolicyArrayOutput
}

IamPolicyArrayInput is an input type that accepts IamPolicyArray and IamPolicyArrayOutput values. You can construct a concrete instance of `IamPolicyArrayInput` via: 

IamPolicyArray{ IamPolicyArgs{...} }

type IamPolicyArrayOutput 

type IamPolicyArrayOutput struct{ *pulumi.OutputState }

func (IamPolicyArrayOutput) ElementType 

func (IamPolicyArrayOutput) ElementType() reflect.Type

func (IamPolicyArrayOutput) Index 

func (o IamPolicyArrayOutput) Index(i pulumi.IntInput) IamPolicyOutput

func (IamPolicyArrayOutput) ToIamPolicyArrayOutput 

func (o IamPolicyArrayOutput) ToIamPolicyArrayOutput() IamPolicyArrayOutput

func (IamPolicyArrayOutput) ToIamPolicyArrayOutputWithContext 

func (o IamPolicyArrayOutput) ToIamPolicyArrayOutputWithContext(ctx context.Context) IamPolicyArrayOutput

type IamPolicyInput 

type IamPolicyInput interface {
	pulumi.Input

	ToIamPolicyOutput() IamPolicyOutput
	ToIamPolicyOutputWithContext(ctx context.Context) IamPolicyOutput
}

type IamPolicyMap 

type IamPolicyMap map[string]IamPolicyInput

func (IamPolicyMap) ElementType 

func (IamPolicyMap) ElementType() reflect.Type

func (IamPolicyMap) ToIamPolicyMapOutput 

func (i IamPolicyMap) ToIamPolicyMapOutput() IamPolicyMapOutput

func (IamPolicyMap) ToIamPolicyMapOutputWithContext 

func (i IamPolicyMap) ToIamPolicyMapOutputWithContext(ctx context.Context) IamPolicyMapOutput

type IamPolicyMapInput 

type IamPolicyMapInput interface {
	pulumi.Input

	ToIamPolicyMapOutput() IamPolicyMapOutput
	ToIamPolicyMapOutputWithContext(context.Context) IamPolicyMapOutput
}

IamPolicyMapInput is an input type that accepts IamPolicyMap and IamPolicyMapOutput values. You can construct a concrete instance of `IamPolicyMapInput` via: 

IamPolicyMap{ "key": IamPolicyArgs{...} }

type IamPolicyMapOutput 

type IamPolicyMapOutput struct{ *pulumi.OutputState }

func (IamPolicyMapOutput) ElementType 

func (IamPolicyMapOutput) ElementType() reflect.Type

func (IamPolicyMapOutput) MapIndex 

func (o IamPolicyMapOutput) MapIndex(k pulumi.StringInput) IamPolicyOutput

func (IamPolicyMapOutput) ToIamPolicyMapOutput 

func (o IamPolicyMapOutput) ToIamPolicyMapOutput() IamPolicyMapOutput

func (IamPolicyMapOutput) ToIamPolicyMapOutputWithContext 

func (o IamPolicyMapOutput) ToIamPolicyMapOutputWithContext(ctx context.Context) IamPolicyMapOutput

type IamPolicyOutput 

type IamPolicyOutput struct{ *pulumi.OutputState }

func (IamPolicyOutput) ElementType 

func (IamPolicyOutput) ElementType() reflect.Type

func (IamPolicyOutput) Name 

func (o IamPolicyOutput) Name() pulumi.StringOutput

func (IamPolicyOutput) NamePrefix 

func (o IamPolicyOutput) NamePrefix() pulumi.StringPtrOutput

func (IamPolicyOutput) Policy 

func (o IamPolicyOutput) Policy() pulumi.StringOutput

func (IamPolicyOutput) ToIamPolicyOutput 

func (o IamPolicyOutput) ToIamPolicyOutput() IamPolicyOutput

func (IamPolicyOutput) ToIamPolicyOutputWithContext 

func (o IamPolicyOutput) ToIamPolicyOutputWithContext(ctx context.Context) IamPolicyOutput

type IamPolicyState 

type IamPolicyState struct {
	Name       pulumi.StringPtrInput
	NamePrefix pulumi.StringPtrInput
	Policy     pulumi.StringPtrInput
}

func (IamPolicyState) ElementType 

func (IamPolicyState) ElementType() reflect.Type

type IamServiceAccount 

type IamServiceAccount struct {
	pulumi.CustomResourceState

	AccessKey pulumi.StringOutput `pulumi:"accessKey"`
	// Disable service account
	DisableUser pulumi.BoolPtrOutput `pulumi:"disableUser"`
	// policy of service account
	Policy     pulumi.StringPtrOutput `pulumi:"policy"`
	SecretKey  pulumi.StringOutput    `pulumi:"secretKey"`
	Status     pulumi.StringOutput    `pulumi:"status"`
	TargetUser pulumi.StringOutput    `pulumi:"targetUser"`
	// rotate secret key
	UpdateSecret pulumi.BoolPtrOutput `pulumi:"updateSecret"`
}

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-minio/sdk/v2/go/minio"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := minio.NewIamUser(ctx, "test", &minio.IamUserArgs{
			ForceDestroy: pulumi.Bool(true),
			Tags: pulumi.Map{
				"tag-key": pulumi.Any("tag-value"),
			},
		})
		if err != nil {
			return err
		}
		testServiceAccount, err := minio.NewIamServiceAccount(ctx, "testServiceAccount", &minio.IamServiceAccountArgs{
			TargetUser: test.Name,
		})
		if err != nil {
			return err
		}
		ctx.Export("minioUser", testServiceAccount.AccessKey)
		ctx.Export("minioPassword", testServiceAccount.SecretKey)
		return nil
	})
}

```

func GetIamServiceAccount 

func GetIamServiceAccount(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IamServiceAccountState, opts ...pulumi.ResourceOption) (*IamServiceAccount, error)

GetIamServiceAccount gets an existing IamServiceAccount 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 NewIamServiceAccount 

func NewIamServiceAccount(ctx *pulumi.Context,
	name string, args *IamServiceAccountArgs, opts ...pulumi.ResourceOption) (*IamServiceAccount, error)

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

func (*IamServiceAccount) ElementType 

func (*IamServiceAccount) ElementType() reflect.Type

func (*IamServiceAccount) ToIamServiceAccountOutput 

func (i *IamServiceAccount) ToIamServiceAccountOutput() IamServiceAccountOutput

func (*IamServiceAccount) ToIamServiceAccountOutputWithContext 

func (i *IamServiceAccount) ToIamServiceAccountOutputWithContext(ctx context.Context) IamServiceAccountOutput

type IamServiceAccountArgs 

type IamServiceAccountArgs struct {
	// Disable service account
	DisableUser pulumi.BoolPtrInput
	// policy of service account
	Policy     pulumi.StringPtrInput
	TargetUser pulumi.StringInput
	// rotate secret key
	UpdateSecret pulumi.BoolPtrInput
}

The set of arguments for constructing a IamServiceAccount resource.

func (IamServiceAccountArgs) ElementType 

func (IamServiceAccountArgs) ElementType() reflect.Type

type IamServiceAccountArray 

type IamServiceAccountArray []IamServiceAccountInput

func (IamServiceAccountArray) ElementType 

func (IamServiceAccountArray) ElementType() reflect.Type

func (IamServiceAccountArray) ToIamServiceAccountArrayOutput 

func (i IamServiceAccountArray) ToIamServiceAccountArrayOutput() IamServiceAccountArrayOutput

func (IamServiceAccountArray) ToIamServiceAccountArrayOutputWithContext 

func (i IamServiceAccountArray) ToIamServiceAccountArrayOutputWithContext(ctx context.Context) IamServiceAccountArrayOutput

type IamServiceAccountArrayInput 

type IamServiceAccountArrayInput interface {
	pulumi.Input

	ToIamServiceAccountArrayOutput() IamServiceAccountArrayOutput
	ToIamServiceAccountArrayOutputWithContext(context.Context) IamServiceAccountArrayOutput
}

IamServiceAccountArrayInput is an input type that accepts IamServiceAccountArray and IamServiceAccountArrayOutput values. You can construct a concrete instance of `IamServiceAccountArrayInput` via: 

IamServiceAccountArray{ IamServiceAccountArgs{...} }

type IamServiceAccountArrayOutput 

type IamServiceAccountArrayOutput struct{ *pulumi.OutputState }

func (IamServiceAccountArrayOutput) ElementType 

func (IamServiceAccountArrayOutput) ElementType() reflect.Type

func (IamServiceAccountArrayOutput) Index 

func (o IamServiceAccountArrayOutput) Index(i pulumi.IntInput) IamServiceAccountOutput

func (IamServiceAccountArrayOutput) ToIamServiceAccountArrayOutput 

func (o IamServiceAccountArrayOutput) ToIamServiceAccountArrayOutput() IamServiceAccountArrayOutput

func (IamServiceAccountArrayOutput) ToIamServiceAccountArrayOutputWithContext 

func (o IamServiceAccountArrayOutput) ToIamServiceAccountArrayOutputWithContext(ctx context.Context) IamServiceAccountArrayOutput

type IamServiceAccountInput 

type IamServiceAccountInput interface {
	pulumi.Input

	ToIamServiceAccountOutput() IamServiceAccountOutput
	ToIamServiceAccountOutputWithContext(ctx context.Context) IamServiceAccountOutput
}

type IamServiceAccountMap 

type IamServiceAccountMap map[string]IamServiceAccountInput

func (IamServiceAccountMap) ElementType 

func (IamServiceAccountMap) ElementType() reflect.Type

func (IamServiceAccountMap) ToIamServiceAccountMapOutput 

func (i IamServiceAccountMap) ToIamServiceAccountMapOutput() IamServiceAccountMapOutput

func (IamServiceAccountMap) ToIamServiceAccountMapOutputWithContext 

func (i IamServiceAccountMap) ToIamServiceAccountMapOutputWithContext(ctx context.Context) IamServiceAccountMapOutput

type IamServiceAccountMapInput 

type IamServiceAccountMapInput interface {
	pulumi.Input

	ToIamServiceAccountMapOutput() IamServiceAccountMapOutput
	ToIamServiceAccountMapOutputWithContext(context.Context) IamServiceAccountMapOutput
}

IamServiceAccountMapInput is an input type that accepts IamServiceAccountMap and IamServiceAccountMapOutput values. You can construct a concrete instance of `IamServiceAccountMapInput` via: 

IamServiceAccountMap{ "key": IamServiceAccountArgs{...} }

type IamServiceAccountMapOutput 

type IamServiceAccountMapOutput struct{ *pulumi.OutputState }

func (IamServiceAccountMapOutput) ElementType 

func (IamServiceAccountMapOutput) ElementType() reflect.Type

func (IamServiceAccountMapOutput) MapIndex 

func (o IamServiceAccountMapOutput) MapIndex(k pulumi.StringInput) IamServiceAccountOutput

func (IamServiceAccountMapOutput) ToIamServiceAccountMapOutput 

func (o IamServiceAccountMapOutput) ToIamServiceAccountMapOutput() IamServiceAccountMapOutput

func (IamServiceAccountMapOutput) ToIamServiceAccountMapOutputWithContext 

func (o IamServiceAccountMapOutput) ToIamServiceAccountMapOutputWithContext(ctx context.Context) IamServiceAccountMapOutput

type IamServiceAccountOutput 

type IamServiceAccountOutput struct{ *pulumi.OutputState }

func (IamServiceAccountOutput) AccessKey 

func (o IamServiceAccountOutput) AccessKey() pulumi.StringOutput

func (IamServiceAccountOutput) DisableUser 

func (o IamServiceAccountOutput) DisableUser() pulumi.BoolPtrOutput

Disable service account

func (IamServiceAccountOutput) ElementType 

func (IamServiceAccountOutput) ElementType() reflect.Type

func (IamServiceAccountOutput) Policy 

func (o IamServiceAccountOutput) Policy() pulumi.StringPtrOutput

policy of service account

func (IamServiceAccountOutput) SecretKey 

func (o IamServiceAccountOutput) SecretKey() pulumi.StringOutput

func (IamServiceAccountOutput) Status 

func (o IamServiceAccountOutput) Status() pulumi.StringOutput

func (IamServiceAccountOutput) TargetUser 

func (o IamServiceAccountOutput) TargetUser() pulumi.StringOutput

func (IamServiceAccountOutput) ToIamServiceAccountOutput 

func (o IamServiceAccountOutput) ToIamServiceAccountOutput() IamServiceAccountOutput

func (IamServiceAccountOutput) ToIamServiceAccountOutputWithContext 

func (o IamServiceAccountOutput) ToIamServiceAccountOutputWithContext(ctx context.Context) IamServiceAccountOutput

func (IamServiceAccountOutput) UpdateSecret 

func (o IamServiceAccountOutput) UpdateSecret() pulumi.BoolPtrOutput

rotate secret key

type IamServiceAccountState 

type IamServiceAccountState struct {
	AccessKey pulumi.StringPtrInput
	// Disable service account
	DisableUser pulumi.BoolPtrInput
	// policy of service account
	Policy     pulumi.StringPtrInput
	SecretKey  pulumi.StringPtrInput
	Status     pulumi.StringPtrInput
	TargetUser pulumi.StringPtrInput
	// rotate secret key
	UpdateSecret pulumi.BoolPtrInput
}

func (IamServiceAccountState) ElementType 

func (IamServiceAccountState) ElementType() reflect.Type

type IamUser 

type IamUser struct {
	pulumi.CustomResourceState

	// Disable user
	DisableUser pulumi.BoolPtrOutput `pulumi:"disableUser"`
	// Delete user even if it has non-Terraform-managed IAM access keys
	ForceDestroy pulumi.BoolPtrOutput `pulumi:"forceDestroy"`
	Name         pulumi.StringOutput  `pulumi:"name"`
	Secret       pulumi.StringOutput  `pulumi:"secret"`
	Status       pulumi.StringOutput  `pulumi:"status"`
	Tags         pulumi.MapOutput     `pulumi:"tags"`
	// Rotate Minio User Secret Key
	UpdateSecret pulumi.BoolPtrOutput `pulumi:"updateSecret"`
}

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-minio/sdk/v2/go/minio"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testIamUser, err := minio.NewIamUser(ctx, "testIamUser", &minio.IamUserArgs{
			ForceDestroy: pulumi.Bool(true),
			Tags: pulumi.Map{
				"tag-key": pulumi.Any("tag-value"),
			},
		})
		if err != nil {
			return err
		}
		ctx.Export("test", testIamUser.ID())
		ctx.Export("status", testIamUser.Status)
		ctx.Export("secret", testIamUser.Secret)
		return nil
	})
}

```

func GetIamUser 

func GetIamUser(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IamUserState, opts ...pulumi.ResourceOption) (*IamUser, error)

GetIamUser gets an existing IamUser 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 NewIamUser 

func NewIamUser(ctx *pulumi.Context,
	name string, args *IamUserArgs, opts ...pulumi.ResourceOption) (*IamUser, error)

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

func (*IamUser) ElementType 

func (*IamUser) ElementType() reflect.Type

func (*IamUser) ToIamUserOutput 

func (i *IamUser) ToIamUserOutput() IamUserOutput

func (*IamUser) ToIamUserOutputWithContext 

func (i *IamUser) ToIamUserOutputWithContext(ctx context.Context) IamUserOutput

type IamUserArgs 

type IamUserArgs struct {
	// Disable user
	DisableUser pulumi.BoolPtrInput
	// Delete user even if it has non-Terraform-managed IAM access keys
	ForceDestroy pulumi.BoolPtrInput
	Name         pulumi.StringPtrInput
	Secret       pulumi.StringPtrInput
	Tags         pulumi.MapInput
	// Rotate Minio User Secret Key
	UpdateSecret pulumi.BoolPtrInput
}

The set of arguments for constructing a IamUser resource.

func (IamUserArgs) ElementType 

func (IamUserArgs) ElementType() reflect.Type

type IamUserArray 

type IamUserArray []IamUserInput

func (IamUserArray) ElementType 

func (IamUserArray) ElementType() reflect.Type

func (IamUserArray) ToIamUserArrayOutput 

func (i IamUserArray) ToIamUserArrayOutput() IamUserArrayOutput

func (IamUserArray) ToIamUserArrayOutputWithContext 

func (i IamUserArray) ToIamUserArrayOutputWithContext(ctx context.Context) IamUserArrayOutput

type IamUserArrayInput 

type IamUserArrayInput interface {
	pulumi.Input

	ToIamUserArrayOutput() IamUserArrayOutput
	ToIamUserArrayOutputWithContext(context.Context) IamUserArrayOutput
}

IamUserArrayInput is an input type that accepts IamUserArray and IamUserArrayOutput values. You can construct a concrete instance of `IamUserArrayInput` via: 

IamUserArray{ IamUserArgs{...} }

type IamUserArrayOutput 

type IamUserArrayOutput struct{ *pulumi.OutputState }

func (IamUserArrayOutput) ElementType 

func (IamUserArrayOutput) ElementType() reflect.Type

func (IamUserArrayOutput) Index 

func (o IamUserArrayOutput) Index(i pulumi.IntInput) IamUserOutput

func (IamUserArrayOutput) ToIamUserArrayOutput 

func (o IamUserArrayOutput) ToIamUserArrayOutput() IamUserArrayOutput

func (IamUserArrayOutput) ToIamUserArrayOutputWithContext 

func (o IamUserArrayOutput) ToIamUserArrayOutputWithContext(ctx context.Context) IamUserArrayOutput

type IamUserInput 

type IamUserInput interface {
	pulumi.Input

	ToIamUserOutput() IamUserOutput
	ToIamUserOutputWithContext(ctx context.Context) IamUserOutput
}

type IamUserMap 

type IamUserMap map[string]IamUserInput

func (IamUserMap) ElementType 

func (IamUserMap) ElementType() reflect.Type

func (IamUserMap) ToIamUserMapOutput 

func (i IamUserMap) ToIamUserMapOutput() IamUserMapOutput

func (IamUserMap) ToIamUserMapOutputWithContext 

func (i IamUserMap) ToIamUserMapOutputWithContext(ctx context.Context) IamUserMapOutput

type IamUserMapInput 

type IamUserMapInput interface {
	pulumi.Input

	ToIamUserMapOutput() IamUserMapOutput
	ToIamUserMapOutputWithContext(context.Context) IamUserMapOutput
}

IamUserMapInput is an input type that accepts IamUserMap and IamUserMapOutput values. You can construct a concrete instance of `IamUserMapInput` via: 

IamUserMap{ "key": IamUserArgs{...} }

type IamUserMapOutput 

type IamUserMapOutput struct{ *pulumi.OutputState }

func (IamUserMapOutput) ElementType 

func (IamUserMapOutput) ElementType() reflect.Type

func (IamUserMapOutput) MapIndex 

func (o IamUserMapOutput) MapIndex(k pulumi.StringInput) IamUserOutput

func (IamUserMapOutput) ToIamUserMapOutput 

func (o IamUserMapOutput) ToIamUserMapOutput() IamUserMapOutput

func (IamUserMapOutput) ToIamUserMapOutputWithContext 

func (o IamUserMapOutput) ToIamUserMapOutputWithContext(ctx context.Context) IamUserMapOutput

type IamUserOutput 

type IamUserOutput struct{ *pulumi.OutputState }

func (IamUserOutput) DisableUser 

func (o IamUserOutput) DisableUser() pulumi.BoolPtrOutput

Disable user

func (IamUserOutput) ElementType 

func (IamUserOutput) ElementType() reflect.Type

func (IamUserOutput) ForceDestroy 

func (o IamUserOutput) ForceDestroy() pulumi.BoolPtrOutput

Delete user even if it has non-Terraform-managed IAM access keys

func (IamUserOutput) Name 

func (o IamUserOutput) Name() pulumi.StringOutput

func (IamUserOutput) Secret 

func (o IamUserOutput) Secret() pulumi.StringOutput

func (IamUserOutput) Status 

func (o IamUserOutput) Status() pulumi.StringOutput

func (IamUserOutput) Tags 

func (o IamUserOutput) Tags() pulumi.MapOutput

func (IamUserOutput) ToIamUserOutput 

func (o IamUserOutput) ToIamUserOutput() IamUserOutput

func (IamUserOutput) ToIamUserOutputWithContext 

func (o IamUserOutput) ToIamUserOutputWithContext(ctx context.Context) IamUserOutput

func (IamUserOutput) UpdateSecret 

func (o IamUserOutput) UpdateSecret() pulumi.BoolPtrOutput

Rotate Minio User Secret Key

type IamUserPolicyAttachment 

type IamUserPolicyAttachment struct {
	pulumi.CustomResourceState

	PolicyName pulumi.StringOutput `pulumi:"policyName"`
	UserName   pulumi.StringOutput `pulumi:"userName"`
}

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-minio/sdk/v2/go/minio"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testUser, err := minio.NewIamUser(ctx, "testUser", nil)
		if err != nil {
			return err
		}
		testPolicy, err := minio.NewIamPolicy(ctx, "testPolicy", &minio.IamPolicyArgs{
			Policy: pulumi.String(`{
  "Version":"2012-10-17",
  "Statement": [
    {
      "Sid":"ListAllBucket",
      "Effect": "Allow",
      "Action": ["s3:PutObject"],
      "Principal":"*",
      "Resource": "arn:aws:s3:::state-terraform-s3/*"
    }
  ]
}

`), 

		})
		if err != nil {
			return err
		}
		developerIamUserPolicyAttachment, err := minio.NewIamUserPolicyAttachment(ctx, "developerIamUserPolicyAttachment", &minio.IamUserPolicyAttachmentArgs{
			UserName:   testUser.ID(),
			PolicyName: testPolicy.ID(),
		})
		if err != nil {
			return err
		}
		ctx.Export("minioName", developerIamUserPolicyAttachment.ID())
		ctx.Export("minioUsers", developerIamUserPolicyAttachment.UserName)
		ctx.Export("minioGroup", developerIamUserPolicyAttachment.PolicyName)
		_, err = minio.NewIamUserPolicyAttachment(ctx, "developerIndex/iamUserPolicyAttachmentIamUserPolicyAttachment", &minio.IamUserPolicyAttachmentArgs{
			UserName:   pulumi.String("CN=My User,OU=Unit,DC=example,DC=com"),
			PolicyName: testPolicy.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetIamUserPolicyAttachment 

func GetIamUserPolicyAttachment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IamUserPolicyAttachmentState, opts ...pulumi.ResourceOption) (*IamUserPolicyAttachment, error)

GetIamUserPolicyAttachment gets an existing IamUserPolicyAttachment 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 NewIamUserPolicyAttachment 

func NewIamUserPolicyAttachment(ctx *pulumi.Context,
	name string, args *IamUserPolicyAttachmentArgs, opts ...pulumi.ResourceOption) (*IamUserPolicyAttachment, error)

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

func (*IamUserPolicyAttachment) ElementType 

func (*IamUserPolicyAttachment) ElementType() reflect.Type

func (*IamUserPolicyAttachment) ToIamUserPolicyAttachmentOutput 

func (i *IamUserPolicyAttachment) ToIamUserPolicyAttachmentOutput() IamUserPolicyAttachmentOutput

func (*IamUserPolicyAttachment) ToIamUserPolicyAttachmentOutputWithContext 

func (i *IamUserPolicyAttachment) ToIamUserPolicyAttachmentOutputWithContext(ctx context.Context) IamUserPolicyAttachmentOutput

type IamUserPolicyAttachmentArgs 

type IamUserPolicyAttachmentArgs struct {
	PolicyName pulumi.StringInput
	UserName   pulumi.StringInput
}

The set of arguments for constructing a IamUserPolicyAttachment resource.

func (IamUserPolicyAttachmentArgs) ElementType 

func (IamUserPolicyAttachmentArgs) ElementType() reflect.Type

type IamUserPolicyAttachmentArray 

type IamUserPolicyAttachmentArray []IamUserPolicyAttachmentInput

func (IamUserPolicyAttachmentArray) ElementType 

func (IamUserPolicyAttachmentArray) ElementType() reflect.Type

func (IamUserPolicyAttachmentArray) ToIamUserPolicyAttachmentArrayOutput 

func (i IamUserPolicyAttachmentArray) ToIamUserPolicyAttachmentArrayOutput() IamUserPolicyAttachmentArrayOutput

func (IamUserPolicyAttachmentArray) ToIamUserPolicyAttachmentArrayOutputWithContext 

func (i IamUserPolicyAttachmentArray) ToIamUserPolicyAttachmentArrayOutputWithContext(ctx context.Context) IamUserPolicyAttachmentArrayOutput

type IamUserPolicyAttachmentArrayInput 

type IamUserPolicyAttachmentArrayInput interface {
	pulumi.Input

	ToIamUserPolicyAttachmentArrayOutput() IamUserPolicyAttachmentArrayOutput
	ToIamUserPolicyAttachmentArrayOutputWithContext(context.Context) IamUserPolicyAttachmentArrayOutput
}

IamUserPolicyAttachmentArrayInput is an input type that accepts IamUserPolicyAttachmentArray and IamUserPolicyAttachmentArrayOutput values. You can construct a concrete instance of `IamUserPolicyAttachmentArrayInput` via: 

IamUserPolicyAttachmentArray{ IamUserPolicyAttachmentArgs{...} }

type IamUserPolicyAttachmentArrayOutput 

type IamUserPolicyAttachmentArrayOutput struct{ *pulumi.OutputState }

func (IamUserPolicyAttachmentArrayOutput) ElementType 

func (IamUserPolicyAttachmentArrayOutput) ElementType() reflect.Type

func (IamUserPolicyAttachmentArrayOutput) Index 

func (o IamUserPolicyAttachmentArrayOutput) Index(i pulumi.IntInput) IamUserPolicyAttachmentOutput

func (IamUserPolicyAttachmentArrayOutput) ToIamUserPolicyAttachmentArrayOutput 

func (o IamUserPolicyAttachmentArrayOutput) ToIamUserPolicyAttachmentArrayOutput() IamUserPolicyAttachmentArrayOutput

func (IamUserPolicyAttachmentArrayOutput) ToIamUserPolicyAttachmentArrayOutputWithContext 

func (o IamUserPolicyAttachmentArrayOutput) ToIamUserPolicyAttachmentArrayOutputWithContext(ctx context.Context) IamUserPolicyAttachmentArrayOutput

type IamUserPolicyAttachmentInput 

type IamUserPolicyAttachmentInput interface {
	pulumi.Input

	ToIamUserPolicyAttachmentOutput() IamUserPolicyAttachmentOutput
	ToIamUserPolicyAttachmentOutputWithContext(ctx context.Context) IamUserPolicyAttachmentOutput
}

type IamUserPolicyAttachmentMap 

type IamUserPolicyAttachmentMap map[string]IamUserPolicyAttachmentInput

func (IamUserPolicyAttachmentMap) ElementType 

func (IamUserPolicyAttachmentMap) ElementType() reflect.Type

func (IamUserPolicyAttachmentMap) ToIamUserPolicyAttachmentMapOutput 

func (i IamUserPolicyAttachmentMap) ToIamUserPolicyAttachmentMapOutput() IamUserPolicyAttachmentMapOutput

func (IamUserPolicyAttachmentMap) ToIamUserPolicyAttachmentMapOutputWithContext 

func (i IamUserPolicyAttachmentMap) ToIamUserPolicyAttachmentMapOutputWithContext(ctx context.Context) IamUserPolicyAttachmentMapOutput

type IamUserPolicyAttachmentMapInput 

type IamUserPolicyAttachmentMapInput interface {
	pulumi.Input

	ToIamUserPolicyAttachmentMapOutput() IamUserPolicyAttachmentMapOutput
	ToIamUserPolicyAttachmentMapOutputWithContext(context.Context) IamUserPolicyAttachmentMapOutput
}

IamUserPolicyAttachmentMapInput is an input type that accepts IamUserPolicyAttachmentMap and IamUserPolicyAttachmentMapOutput values. You can construct a concrete instance of `IamUserPolicyAttachmentMapInput` via: 

IamUserPolicyAttachmentMap{ "key": IamUserPolicyAttachmentArgs{...} }

type IamUserPolicyAttachmentMapOutput 

type IamUserPolicyAttachmentMapOutput struct{ *pulumi.OutputState }

func (IamUserPolicyAttachmentMapOutput) ElementType 

func (IamUserPolicyAttachmentMapOutput) ElementType() reflect.Type

func (IamUserPolicyAttachmentMapOutput) MapIndex 

func (o IamUserPolicyAttachmentMapOutput) MapIndex(k pulumi.StringInput) IamUserPolicyAttachmentOutput

func (IamUserPolicyAttachmentMapOutput) ToIamUserPolicyAttachmentMapOutput 

func (o IamUserPolicyAttachmentMapOutput) ToIamUserPolicyAttachmentMapOutput() IamUserPolicyAttachmentMapOutput

func (IamUserPolicyAttachmentMapOutput) ToIamUserPolicyAttachmentMapOutputWithContext 

func (o IamUserPolicyAttachmentMapOutput) ToIamUserPolicyAttachmentMapOutputWithContext(ctx context.Context) IamUserPolicyAttachmentMapOutput

type IamUserPolicyAttachmentOutput 

type IamUserPolicyAttachmentOutput struct{ *pulumi.OutputState }

func (IamUserPolicyAttachmentOutput) ElementType 

func (IamUserPolicyAttachmentOutput) ElementType() reflect.Type

func (IamUserPolicyAttachmentOutput) PolicyName 

func (o IamUserPolicyAttachmentOutput) PolicyName() pulumi.StringOutput

func (IamUserPolicyAttachmentOutput) ToIamUserPolicyAttachmentOutput 

func (o IamUserPolicyAttachmentOutput) ToIamUserPolicyAttachmentOutput() IamUserPolicyAttachmentOutput

func (IamUserPolicyAttachmentOutput) ToIamUserPolicyAttachmentOutputWithContext 

func (o IamUserPolicyAttachmentOutput) ToIamUserPolicyAttachmentOutputWithContext(ctx context.Context) IamUserPolicyAttachmentOutput

func (IamUserPolicyAttachmentOutput) UserName 

func (o IamUserPolicyAttachmentOutput) UserName() pulumi.StringOutput

type IamUserPolicyAttachmentState 

type IamUserPolicyAttachmentState struct {
	PolicyName pulumi.StringPtrInput
	UserName   pulumi.StringPtrInput
}

func (IamUserPolicyAttachmentState) ElementType 

func (IamUserPolicyAttachmentState) ElementType() reflect.Type

type IamUserState 

type IamUserState struct {
	// Disable user
	DisableUser pulumi.BoolPtrInput
	// Delete user even if it has non-Terraform-managed IAM access keys
	ForceDestroy pulumi.BoolPtrInput
	Name         pulumi.StringPtrInput
	Secret       pulumi.StringPtrInput
	Status       pulumi.StringPtrInput
	Tags         pulumi.MapInput
	// Rotate Minio User Secret Key
	UpdateSecret pulumi.BoolPtrInput
}

func (IamUserState) ElementType 

func (IamUserState) ElementType() reflect.Type

type IlmPolicy 

type IlmPolicy struct {
	pulumi.CustomResourceState

	Bucket pulumi.StringOutput      `pulumi:"bucket"`
	Rules  IlmPolicyRuleArrayOutput `pulumi:"rules"`
}

`IlmPolicy` handles lifecycle settings for a given `S3Bucket`.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-minio/sdk/v2/go/minio"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		bucket, err := minio.NewS3Bucket(ctx, "bucket", &minio.S3BucketArgs{
			Bucket: pulumi.String("bucket"),
		})
		if err != nil {
			return err
		}
		_, err = minio.NewIlmPolicy(ctx, "bucket-lifecycle-rules", &minio.IlmPolicyArgs{
			Bucket: bucket.Bucket,
			Rules: minio.IlmPolicyRuleArray{
				&minio.IlmPolicyRuleArgs{
					Id:         pulumi.String("expire-7d"),
					Expiration: pulumi.String("7d"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetIlmPolicy 

func GetIlmPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *IlmPolicyState, opts ...pulumi.ResourceOption) (*IlmPolicy, error)

GetIlmPolicy gets an existing IlmPolicy 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 NewIlmPolicy 

func NewIlmPolicy(ctx *pulumi.Context,
	name string, args *IlmPolicyArgs, opts ...pulumi.ResourceOption) (*IlmPolicy, error)

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

func (*IlmPolicy) ElementType 

func (*IlmPolicy) ElementType() reflect.Type

func (*IlmPolicy) ToIlmPolicyOutput 

func (i *IlmPolicy) ToIlmPolicyOutput() IlmPolicyOutput

func (*IlmPolicy) ToIlmPolicyOutputWithContext 

func (i *IlmPolicy) ToIlmPolicyOutputWithContext(ctx context.Context) IlmPolicyOutput

type IlmPolicyArgs 

type IlmPolicyArgs struct {
	Bucket pulumi.StringInput
	Rules  IlmPolicyRuleArrayInput
}

The set of arguments for constructing a IlmPolicy resource.

func (IlmPolicyArgs) ElementType 

func (IlmPolicyArgs) ElementType() reflect.Type

type IlmPolicyArray 

type IlmPolicyArray []IlmPolicyInput

func (IlmPolicyArray) ElementType 

func (IlmPolicyArray) ElementType() reflect.Type

func (IlmPolicyArray) ToIlmPolicyArrayOutput 

func (i IlmPolicyArray) ToIlmPolicyArrayOutput() IlmPolicyArrayOutput

func (IlmPolicyArray) ToIlmPolicyArrayOutputWithContext 

func (i IlmPolicyArray) ToIlmPolicyArrayOutputWithContext(ctx context.Context) IlmPolicyArrayOutput

type IlmPolicyArrayInput 

type IlmPolicyArrayInput interface {
	pulumi.Input

	ToIlmPolicyArrayOutput() IlmPolicyArrayOutput
	ToIlmPolicyArrayOutputWithContext(context.Context) IlmPolicyArrayOutput
}

IlmPolicyArrayInput is an input type that accepts IlmPolicyArray and IlmPolicyArrayOutput values. You can construct a concrete instance of `IlmPolicyArrayInput` via: 

IlmPolicyArray{ IlmPolicyArgs{...} }

type IlmPolicyArrayOutput 

type IlmPolicyArrayOutput struct{ *pulumi.OutputState }

func (IlmPolicyArrayOutput) ElementType 

func (IlmPolicyArrayOutput) ElementType() reflect.Type

func (IlmPolicyArrayOutput) Index 

func (o IlmPolicyArrayOutput) Index(i pulumi.IntInput) IlmPolicyOutput

func (IlmPolicyArrayOutput) ToIlmPolicyArrayOutput 

func (o IlmPolicyArrayOutput) ToIlmPolicyArrayOutput() IlmPolicyArrayOutput

func (IlmPolicyArrayOutput) ToIlmPolicyArrayOutputWithContext 

func (o IlmPolicyArrayOutput) ToIlmPolicyArrayOutputWithContext(ctx context.Context) IlmPolicyArrayOutput

type IlmPolicyInput 

type IlmPolicyInput interface {
	pulumi.Input

	ToIlmPolicyOutput() IlmPolicyOutput
	ToIlmPolicyOutputWithContext(ctx context.Context) IlmPolicyOutput
}

type IlmPolicyMap 

type IlmPolicyMap map[string]IlmPolicyInput

func (IlmPolicyMap) ElementType 

func (IlmPolicyMap) ElementType() reflect.Type

func (IlmPolicyMap) ToIlmPolicyMapOutput 

func (i IlmPolicyMap) ToIlmPolicyMapOutput() IlmPolicyMapOutput

func (IlmPolicyMap) ToIlmPolicyMapOutputWithContext 

func (i IlmPolicyMap) ToIlmPolicyMapOutputWithContext(ctx context.Context) IlmPolicyMapOutput

type IlmPolicyMapInput 

type IlmPolicyMapInput interface {
	pulumi.Input

	ToIlmPolicyMapOutput() IlmPolicyMapOutput
	ToIlmPolicyMapOutputWithContext(context.Context) IlmPolicyMapOutput
}

IlmPolicyMapInput is an input type that accepts IlmPolicyMap and IlmPolicyMapOutput values. You can construct a concrete instance of `IlmPolicyMapInput` via: 

IlmPolicyMap{ "key": IlmPolicyArgs{...} }

type IlmPolicyMapOutput 

type IlmPolicyMapOutput struct{ *pulumi.OutputState }

func (IlmPolicyMapOutput) ElementType 

func (IlmPolicyMapOutput) ElementType() reflect.Type

func (IlmPolicyMapOutput) MapIndex 

func (o IlmPolicyMapOutput) MapIndex(k pulumi.StringInput) IlmPolicyOutput

func (IlmPolicyMapOutput) ToIlmPolicyMapOutput 

func (o IlmPolicyMapOutput) ToIlmPolicyMapOutput() IlmPolicyMapOutput

func (IlmPolicyMapOutput) ToIlmPolicyMapOutputWithContext 

func (o IlmPolicyMapOutput) ToIlmPolicyMapOutputWithContext(ctx context.Context) IlmPolicyMapOutput

type IlmPolicyOutput 

type IlmPolicyOutput struct{ *pulumi.OutputState }

func (IlmPolicyOutput) Bucket 

func (o IlmPolicyOutput) Bucket() pulumi.StringOutput

func (IlmPolicyOutput) ElementType 

func (IlmPolicyOutput) ElementType() reflect.Type

func (IlmPolicyOutput) Rules 

func (o IlmPolicyOutput) Rules() IlmPolicyRuleArrayOutput

func (IlmPolicyOutput) ToIlmPolicyOutput 

func (o IlmPolicyOutput) ToIlmPolicyOutput() IlmPolicyOutput

func (IlmPolicyOutput) ToIlmPolicyOutputWithContext 

func (o IlmPolicyOutput) ToIlmPolicyOutputWithContext(ctx context.Context) IlmPolicyOutput

type IlmPolicyRule 

type IlmPolicyRule struct {
	Expiration *string `pulumi:"expiration"`
	Filter     *string `pulumi:"filter"`
	// The ID of this resource.
	Id                              string                 `pulumi:"id"`
	NoncurrentVersionExpirationDays *int                   `pulumi:"noncurrentVersionExpirationDays"`
	Status                          *string                `pulumi:"status"`
	Tags                            map[string]interface{} `pulumi:"tags"`
}

type IlmPolicyRuleArgs 

type IlmPolicyRuleArgs struct {
	Expiration pulumi.StringPtrInput `pulumi:"expiration"`
	Filter     pulumi.StringPtrInput `pulumi:"filter"`
	// The ID of this resource.
	Id                              pulumi.StringInput    `pulumi:"id"`
	NoncurrentVersionExpirationDays pulumi.IntPtrInput    `pulumi:"noncurrentVersionExpirationDays"`
	Status                          pulumi.StringPtrInput `pulumi:"status"`
	Tags                            pulumi.MapInput       `pulumi:"tags"`
}

func (IlmPolicyRuleArgs) ElementType 

func (IlmPolicyRuleArgs) ElementType() reflect.Type

func (IlmPolicyRuleArgs) ToIlmPolicyRuleOutput 

func (i IlmPolicyRuleArgs) ToIlmPolicyRuleOutput() IlmPolicyRuleOutput

func (IlmPolicyRuleArgs) ToIlmPolicyRuleOutputWithContext 

func (i IlmPolicyRuleArgs) ToIlmPolicyRuleOutputWithContext(ctx context.Context) IlmPolicyRuleOutput

type IlmPolicyRuleArray 

type IlmPolicyRuleArray []IlmPolicyRuleInput

func (IlmPolicyRuleArray) ElementType 

func (IlmPolicyRuleArray) ElementType() reflect.Type

func (IlmPolicyRuleArray) ToIlmPolicyRuleArrayOutput 

func (i IlmPolicyRuleArray) ToIlmPolicyRuleArrayOutput() IlmPolicyRuleArrayOutput

func (IlmPolicyRuleArray) ToIlmPolicyRuleArrayOutputWithContext 

func (i IlmPolicyRuleArray) ToIlmPolicyRuleArrayOutputWithContext(ctx context.Context) IlmPolicyRuleArrayOutput

type IlmPolicyRuleArrayInput 

type IlmPolicyRuleArrayInput interface {
	pulumi.Input

	ToIlmPolicyRuleArrayOutput() IlmPolicyRuleArrayOutput
	ToIlmPolicyRuleArrayOutputWithContext(context.Context) IlmPolicyRuleArrayOutput
}

IlmPolicyRuleArrayInput is an input type that accepts IlmPolicyRuleArray and IlmPolicyRuleArrayOutput values. You can construct a concrete instance of `IlmPolicyRuleArrayInput` via: 

IlmPolicyRuleArray{ IlmPolicyRuleArgs{...} }

type IlmPolicyRuleArrayOutput 

type IlmPolicyRuleArrayOutput struct{ *pulumi.OutputState }

func (IlmPolicyRuleArrayOutput) ElementType 

func (IlmPolicyRuleArrayOutput) ElementType() reflect.Type

func (IlmPolicyRuleArrayOutput) Index 

func (o IlmPolicyRuleArrayOutput) Index(i pulumi.IntInput) IlmPolicyRuleOutput

func (IlmPolicyRuleArrayOutput) ToIlmPolicyRuleArrayOutput 

func (o IlmPolicyRuleArrayOutput) ToIlmPolicyRuleArrayOutput() IlmPolicyRuleArrayOutput

func (IlmPolicyRuleArrayOutput) ToIlmPolicyRuleArrayOutputWithContext 

func (o IlmPolicyRuleArrayOutput) ToIlmPolicyRuleArrayOutputWithContext(ctx context.Context) IlmPolicyRuleArrayOutput

type IlmPolicyRuleInput 

type IlmPolicyRuleInput interface {
	pulumi.Input

	ToIlmPolicyRuleOutput() IlmPolicyRuleOutput
	ToIlmPolicyRuleOutputWithContext(context.Context) IlmPolicyRuleOutput
}

IlmPolicyRuleInput is an input type that accepts IlmPolicyRuleArgs and IlmPolicyRuleOutput values. You can construct a concrete instance of `IlmPolicyRuleInput` via: 

IlmPolicyRuleArgs{...}

type IlmPolicyRuleOutput 

type IlmPolicyRuleOutput struct{ *pulumi.OutputState }

func (IlmPolicyRuleOutput) ElementType 

func (IlmPolicyRuleOutput) ElementType() reflect.Type

func (IlmPolicyRuleOutput) Expiration 

func (o IlmPolicyRuleOutput) Expiration() pulumi.StringPtrOutput

func (IlmPolicyRuleOutput) Filter 

func (o IlmPolicyRuleOutput) Filter() pulumi.StringPtrOutput

func (IlmPolicyRuleOutput) Id 

func (o IlmPolicyRuleOutput) Id() pulumi.StringOutput

The ID of this resource.

func (IlmPolicyRuleOutput) NoncurrentVersionExpirationDays 

func (o IlmPolicyRuleOutput) NoncurrentVersionExpirationDays() pulumi.IntPtrOutput

func (IlmPolicyRuleOutput) Status 

func (o IlmPolicyRuleOutput) Status() pulumi.StringPtrOutput

func (IlmPolicyRuleOutput) Tags 

func (o IlmPolicyRuleOutput) Tags() pulumi.MapOutput

func (IlmPolicyRuleOutput) ToIlmPolicyRuleOutput 

func (o IlmPolicyRuleOutput) ToIlmPolicyRuleOutput() IlmPolicyRuleOutput

func (IlmPolicyRuleOutput) ToIlmPolicyRuleOutputWithContext 

func (o IlmPolicyRuleOutput) ToIlmPolicyRuleOutputWithContext(ctx context.Context) IlmPolicyRuleOutput

type IlmPolicyState 

type IlmPolicyState struct {
	Bucket pulumi.StringPtrInput
	Rules  IlmPolicyRuleArrayInput
}

func (IlmPolicyState) ElementType 

func (IlmPolicyState) ElementType() reflect.Type

type KmsKey 

type KmsKey struct {
	pulumi.CustomResourceState

	KeyId pulumi.StringOutput `pulumi:"keyId"`
}

func GetKmsKey 

func GetKmsKey(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *KmsKeyState, opts ...pulumi.ResourceOption) (*KmsKey, error)

GetKmsKey gets an existing KmsKey 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 NewKmsKey 

func NewKmsKey(ctx *pulumi.Context,
	name string, args *KmsKeyArgs, opts ...pulumi.ResourceOption) (*KmsKey, error)

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

func (*KmsKey) ElementType 

func (*KmsKey) ElementType() reflect.Type

func (*KmsKey) ToKmsKeyOutput 

func (i *KmsKey) ToKmsKeyOutput() KmsKeyOutput

func (*KmsKey) ToKmsKeyOutputWithContext 

func (i *KmsKey) ToKmsKeyOutputWithContext(ctx context.Context) KmsKeyOutput

type KmsKeyArgs 

type KmsKeyArgs struct {
	KeyId pulumi.StringInput
}

The set of arguments for constructing a KmsKey resource.

func (KmsKeyArgs) ElementType 

func (KmsKeyArgs) ElementType() reflect.Type

type KmsKeyArray 

type KmsKeyArray []KmsKeyInput

func (KmsKeyArray) ElementType 

func (KmsKeyArray) ElementType() reflect.Type

func (KmsKeyArray) ToKmsKeyArrayOutput 

func (i KmsKeyArray) ToKmsKeyArrayOutput() KmsKeyArrayOutput

func (KmsKeyArray) ToKmsKeyArrayOutputWithContext 

func (i KmsKeyArray) ToKmsKeyArrayOutputWithContext(ctx context.Context) KmsKeyArrayOutput

type KmsKeyArrayInput 

type KmsKeyArrayInput interface {
	pulumi.Input

	ToKmsKeyArrayOutput() KmsKeyArrayOutput
	ToKmsKeyArrayOutputWithContext(context.Context) KmsKeyArrayOutput
}

KmsKeyArrayInput is an input type that accepts KmsKeyArray and KmsKeyArrayOutput values. You can construct a concrete instance of `KmsKeyArrayInput` via: 

KmsKeyArray{ KmsKeyArgs{...} }

type KmsKeyArrayOutput 

type KmsKeyArrayOutput struct{ *pulumi.OutputState }

func (KmsKeyArrayOutput) ElementType 

func (KmsKeyArrayOutput) ElementType() reflect.Type

func (KmsKeyArrayOutput) Index 

func (o KmsKeyArrayOutput) Index(i pulumi.IntInput) KmsKeyOutput

func (KmsKeyArrayOutput) ToKmsKeyArrayOutput 

func (o KmsKeyArrayOutput) ToKmsKeyArrayOutput() KmsKeyArrayOutput

func (KmsKeyArrayOutput) ToKmsKeyArrayOutputWithContext 

func (o KmsKeyArrayOutput) ToKmsKeyArrayOutputWithContext(ctx context.Context) KmsKeyArrayOutput

type KmsKeyInput 

type KmsKeyInput interface {
	pulumi.Input

	ToKmsKeyOutput() KmsKeyOutput
	ToKmsKeyOutputWithContext(ctx context.Context) KmsKeyOutput
}

type KmsKeyMap 

type KmsKeyMap map[string]KmsKeyInput

func (KmsKeyMap) ElementType 

func (KmsKeyMap) ElementType() reflect.Type

func (KmsKeyMap) ToKmsKeyMapOutput 

func (i KmsKeyMap) ToKmsKeyMapOutput() KmsKeyMapOutput

func (KmsKeyMap) ToKmsKeyMapOutputWithContext 

func (i KmsKeyMap) ToKmsKeyMapOutputWithContext(ctx context.Context) KmsKeyMapOutput

type KmsKeyMapInput 

type KmsKeyMapInput interface {
	pulumi.Input

	ToKmsKeyMapOutput() KmsKeyMapOutput
	ToKmsKeyMapOutputWithContext(context.Context) KmsKeyMapOutput
}

KmsKeyMapInput is an input type that accepts KmsKeyMap and KmsKeyMapOutput values. You can construct a concrete instance of `KmsKeyMapInput` via: 

KmsKeyMap{ "key": KmsKeyArgs{...} }

type KmsKeyMapOutput 

type KmsKeyMapOutput struct{ *pulumi.OutputState }

func (KmsKeyMapOutput) ElementType 

func (KmsKeyMapOutput) ElementType() reflect.Type

func (KmsKeyMapOutput) MapIndex 

func (o KmsKeyMapOutput) MapIndex(k pulumi.StringInput) KmsKeyOutput

func (KmsKeyMapOutput) ToKmsKeyMapOutput 

func (o KmsKeyMapOutput) ToKmsKeyMapOutput() KmsKeyMapOutput

func (KmsKeyMapOutput) ToKmsKeyMapOutputWithContext 

func (o KmsKeyMapOutput) ToKmsKeyMapOutputWithContext(ctx context.Context) KmsKeyMapOutput

type KmsKeyOutput 

type KmsKeyOutput struct{ *pulumi.OutputState }

func (KmsKeyOutput) ElementType 

func (KmsKeyOutput) ElementType() reflect.Type

func (KmsKeyOutput) KeyId 

func (o KmsKeyOutput) KeyId() pulumi.StringOutput

func (KmsKeyOutput) ToKmsKeyOutput 

func (o KmsKeyOutput) ToKmsKeyOutput() KmsKeyOutput

func (KmsKeyOutput) ToKmsKeyOutputWithContext 

func (o KmsKeyOutput) ToKmsKeyOutputWithContext(ctx context.Context) KmsKeyOutput

type KmsKeyState 

type KmsKeyState struct {
	KeyId pulumi.StringPtrInput
}

func (KmsKeyState) ElementType 

func (KmsKeyState) ElementType() reflect.Type

type Provider 

type Provider struct {
	pulumi.ProviderResourceState

	// Minio Access Key
	//
	// Deprecated: use minio_user instead
	MinioAccessKey pulumi.StringPtrOutput `pulumi:"minioAccessKey"`
	// Minio API Version (type: string, options: v2 or v4, default: v4)
	MinioApiVersion pulumi.StringPtrOutput `pulumi:"minioApiVersion"`
	MinioCacertFile pulumi.StringPtrOutput `pulumi:"minioCacertFile"`
	MinioCertFile   pulumi.StringPtrOutput `pulumi:"minioCertFile"`
	MinioKeyFile    pulumi.StringPtrOutput `pulumi:"minioKeyFile"`
	// Minio Password
	MinioPassword pulumi.StringPtrOutput `pulumi:"minioPassword"`
	// Minio Region (default: us-east-1)
	MinioRegion pulumi.StringPtrOutput `pulumi:"minioRegion"`
	// Minio Secret Key
	//
	// Deprecated: use minio_password instead
	MinioSecretKey pulumi.StringPtrOutput `pulumi:"minioSecretKey"`
	// Minio Host and Port
	MinioServer pulumi.StringOutput `pulumi:"minioServer"`
	// Minio Session Token
	MinioSessionToken pulumi.StringPtrOutput `pulumi:"minioSessionToken"`
	// Minio User
	MinioUser pulumi.StringPtrOutput `pulumi:"minioUser"`
}

The provider type for the minio 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 {
	// Minio Access Key
	//
	// Deprecated: use minio_user instead
	MinioAccessKey pulumi.StringPtrInput
	// Minio API Version (type: string, options: v2 or v4, default: v4)
	MinioApiVersion pulumi.StringPtrInput
	MinioCacertFile pulumi.StringPtrInput
	MinioCertFile   pulumi.StringPtrInput
	// Disable SSL certificate verification (default: false)
	MinioInsecure pulumi.BoolPtrInput
	MinioKeyFile  pulumi.StringPtrInput
	// Minio Password
	MinioPassword pulumi.StringPtrInput
	// Minio Region (default: us-east-1)
	MinioRegion pulumi.StringPtrInput
	// Minio Secret Key
	//
	// Deprecated: use minio_password instead
	MinioSecretKey pulumi.StringPtrInput
	// Minio Host and Port
	MinioServer pulumi.StringInput
	// Minio Session Token
	MinioSessionToken pulumi.StringPtrInput
	// Minio SSL enabled (default: false)
	MinioSsl pulumi.BoolPtrInput
	// Minio User
	MinioUser 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) ElementType 

func (ProviderOutput) ElementType() reflect.Type

func (ProviderOutput) MinioAccessKey deprecated 

func (o ProviderOutput) MinioAccessKey() pulumi.StringPtrOutput

Minio Access Key

Deprecated: use minio_user instead

func (ProviderOutput) MinioApiVersion 

func (o ProviderOutput) MinioApiVersion() pulumi.StringPtrOutput

Minio API Version (type: string, options: v2 or v4, default: v4)

func (ProviderOutput) MinioCacertFile 

func (o ProviderOutput) MinioCacertFile() pulumi.StringPtrOutput

func (ProviderOutput) MinioCertFile 

func (o ProviderOutput) MinioCertFile() pulumi.StringPtrOutput

func (ProviderOutput) MinioKeyFile 

func (o ProviderOutput) MinioKeyFile() pulumi.StringPtrOutput

func (ProviderOutput) MinioPassword 

func (o ProviderOutput) MinioPassword() pulumi.StringPtrOutput

Minio Password

func (ProviderOutput) MinioRegion 

func (o ProviderOutput) MinioRegion() pulumi.StringPtrOutput

Minio Region (default: us-east-1)

func (ProviderOutput) MinioSecretKey deprecated 

func (o ProviderOutput) MinioSecretKey() pulumi.StringPtrOutput

Minio Secret Key

Deprecated: use minio_password instead

func (ProviderOutput) MinioServer 

func (o ProviderOutput) MinioServer() pulumi.StringOutput

Minio Host and Port

func (ProviderOutput) MinioSessionToken 

func (o ProviderOutput) MinioSessionToken() pulumi.StringPtrOutput

Minio Session Token

func (ProviderOutput) MinioUser 

func (o ProviderOutput) MinioUser() pulumi.StringPtrOutput

Minio User

func (ProviderOutput) ToProviderOutput 

func (o ProviderOutput) ToProviderOutput() ProviderOutput

func (ProviderOutput) ToProviderOutputWithContext 

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

type S3Bucket 

type S3Bucket struct {
	pulumi.CustomResourceState

	Acl              pulumi.StringPtrOutput `pulumi:"acl"`
	Arn              pulumi.StringOutput    `pulumi:"arn"`
	Bucket           pulumi.StringOutput    `pulumi:"bucket"`
	BucketDomainName pulumi.StringOutput    `pulumi:"bucketDomainName"`
	BucketPrefix     pulumi.StringPtrOutput `pulumi:"bucketPrefix"`
	ForceDestroy     pulumi.BoolPtrOutput   `pulumi:"forceDestroy"`
	ObjectLocking    pulumi.BoolPtrOutput   `pulumi:"objectLocking"`
	Quota            pulumi.IntPtrOutput    `pulumi:"quota"`
}

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-minio/sdk/v2/go/minio"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		stateTerraformS3, err := minio.NewS3Bucket(ctx, "stateTerraformS3", &minio.S3BucketArgs{
			Acl:    pulumi.String("public"),
			Bucket: pulumi.String("state-terraform-s3"),
		})
		if err != nil {
			return err
		}
		ctx.Export("minioId", stateTerraformS3.ID())
		ctx.Export("minioUrl", stateTerraformS3.BucketDomainName)
		return nil
	})
}

```

func GetS3Bucket 

func GetS3Bucket(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *S3BucketState, opts ...pulumi.ResourceOption) (*S3Bucket, error)

GetS3Bucket gets an existing S3Bucket 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 NewS3Bucket 

func NewS3Bucket(ctx *pulumi.Context,
	name string, args *S3BucketArgs, opts ...pulumi.ResourceOption) (*S3Bucket, error)

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

func (*S3Bucket) ElementType 

func (*S3Bucket) ElementType() reflect.Type

func (*S3Bucket) ToS3BucketOutput 

func (i *S3Bucket) ToS3BucketOutput() S3BucketOutput

func (*S3Bucket) ToS3BucketOutputWithContext 

func (i *S3Bucket) ToS3BucketOutputWithContext(ctx context.Context) S3BucketOutput

type S3BucketArgs 

type S3BucketArgs struct {
	Acl           pulumi.StringPtrInput
	Bucket        pulumi.StringPtrInput
	BucketPrefix  pulumi.StringPtrInput
	ForceDestroy  pulumi.BoolPtrInput
	ObjectLocking pulumi.BoolPtrInput
	Quota         pulumi.IntPtrInput
}

The set of arguments for constructing a S3Bucket resource.

func (S3BucketArgs) ElementType 

func (S3BucketArgs) ElementType() reflect.Type

type S3BucketArray 

type S3BucketArray []S3BucketInput

func (S3BucketArray) ElementType 

func (S3BucketArray) ElementType() reflect.Type

func (S3BucketArray) ToS3BucketArrayOutput 

func (i S3BucketArray) ToS3BucketArrayOutput() S3BucketArrayOutput

func (S3BucketArray) ToS3BucketArrayOutputWithContext 

func (i S3BucketArray) ToS3BucketArrayOutputWithContext(ctx context.Context) S3BucketArrayOutput

type S3BucketArrayInput 

type S3BucketArrayInput interface {
	pulumi.Input

	ToS3BucketArrayOutput() S3BucketArrayOutput
	ToS3BucketArrayOutputWithContext(context.Context) S3BucketArrayOutput
}

S3BucketArrayInput is an input type that accepts S3BucketArray and S3BucketArrayOutput values. You can construct a concrete instance of `S3BucketArrayInput` via: 

S3BucketArray{ S3BucketArgs{...} }

type S3BucketArrayOutput 

type S3BucketArrayOutput struct{ *pulumi.OutputState }

func (S3BucketArrayOutput) ElementType 

func (S3BucketArrayOutput) ElementType() reflect.Type

func (S3BucketArrayOutput) Index 

func (o S3BucketArrayOutput) Index(i pulumi.IntInput) S3BucketOutput

func (S3BucketArrayOutput) ToS3BucketArrayOutput 

func (o S3BucketArrayOutput) ToS3BucketArrayOutput() S3BucketArrayOutput

func (S3BucketArrayOutput) ToS3BucketArrayOutputWithContext 

func (o S3BucketArrayOutput) ToS3BucketArrayOutputWithContext(ctx context.Context) S3BucketArrayOutput

type S3BucketInput 

type S3BucketInput interface {
	pulumi.Input

	ToS3BucketOutput() S3BucketOutput
	ToS3BucketOutputWithContext(ctx context.Context) S3BucketOutput
}

type S3BucketMap 

type S3BucketMap map[string]S3BucketInput

func (S3BucketMap) ElementType 

func (S3BucketMap) ElementType() reflect.Type

func (S3BucketMap) ToS3BucketMapOutput 

func (i S3BucketMap) ToS3BucketMapOutput() S3BucketMapOutput

func (S3BucketMap) ToS3BucketMapOutputWithContext 

func (i S3BucketMap) ToS3BucketMapOutputWithContext(ctx context.Context) S3BucketMapOutput

type S3BucketMapInput 

type S3BucketMapInput interface {
	pulumi.Input

	ToS3BucketMapOutput() S3BucketMapOutput
	ToS3BucketMapOutputWithContext(context.Context) S3BucketMapOutput
}

S3BucketMapInput is an input type that accepts S3BucketMap and S3BucketMapOutput values. You can construct a concrete instance of `S3BucketMapInput` via: 

S3BucketMap{ "key": S3BucketArgs{...} }

type S3BucketMapOutput 

type S3BucketMapOutput struct{ *pulumi.OutputState }

func (S3BucketMapOutput) ElementType 

func (S3BucketMapOutput) ElementType() reflect.Type

func (S3BucketMapOutput) MapIndex 

func (o S3BucketMapOutput) MapIndex(k pulumi.StringInput) S3BucketOutput

func (S3BucketMapOutput) ToS3BucketMapOutput 

func (o S3BucketMapOutput) ToS3BucketMapOutput() S3BucketMapOutput

func (S3BucketMapOutput) ToS3BucketMapOutputWithContext 

func (o S3BucketMapOutput) ToS3BucketMapOutputWithContext(ctx context.Context) S3BucketMapOutput

type S3BucketNotification 

type S3BucketNotification struct {
	pulumi.CustomResourceState

	Bucket pulumi.StringOutput                  `pulumi:"bucket"`
	Queues S3BucketNotificationQueueArrayOutput `pulumi:"queues"`
}

func GetS3BucketNotification 

func GetS3BucketNotification(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *S3BucketNotificationState, opts ...pulumi.ResourceOption) (*S3BucketNotification, error)

GetS3BucketNotification gets an existing S3BucketNotification 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 NewS3BucketNotification 

func NewS3BucketNotification(ctx *pulumi.Context,
	name string, args *S3BucketNotificationArgs, opts ...pulumi.ResourceOption) (*S3BucketNotification, error)

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

func (*S3BucketNotification) ElementType 

func (*S3BucketNotification) ElementType() reflect.Type

func (*S3BucketNotification) ToS3BucketNotificationOutput 

func (i *S3BucketNotification) ToS3BucketNotificationOutput() S3BucketNotificationOutput

func (*S3BucketNotification) ToS3BucketNotificationOutputWithContext 

func (i *S3BucketNotification) ToS3BucketNotificationOutputWithContext(ctx context.Context) S3BucketNotificationOutput

type S3BucketNotificationArgs 

type S3BucketNotificationArgs struct {
	Bucket pulumi.StringInput
	Queues S3BucketNotificationQueueArrayInput
}

The set of arguments for constructing a S3BucketNotification resource.

func (S3BucketNotificationArgs) ElementType 

func (S3BucketNotificationArgs) ElementType() reflect.Type

type S3BucketNotificationArray 

type S3BucketNotificationArray []S3BucketNotificationInput

func (S3BucketNotificationArray) ElementType 

func (S3BucketNotificationArray) ElementType() reflect.Type

func (S3BucketNotificationArray) ToS3BucketNotificationArrayOutput 

func (i S3BucketNotificationArray) ToS3BucketNotificationArrayOutput() S3BucketNotificationArrayOutput

func (S3BucketNotificationArray) ToS3BucketNotificationArrayOutputWithContext 

func (i S3BucketNotificationArray) ToS3BucketNotificationArrayOutputWithContext(ctx context.Context) S3BucketNotificationArrayOutput

type S3BucketNotificationArrayInput 

type S3BucketNotificationArrayInput interface {
	pulumi.Input

	ToS3BucketNotificationArrayOutput() S3BucketNotificationArrayOutput
	ToS3BucketNotificationArrayOutputWithContext(context.Context) S3BucketNotificationArrayOutput
}

S3BucketNotificationArrayInput is an input type that accepts S3BucketNotificationArray and S3BucketNotificationArrayOutput values. You can construct a concrete instance of `S3BucketNotificationArrayInput` via: 

S3BucketNotificationArray{ S3BucketNotificationArgs{...} }

type S3BucketNotificationArrayOutput 

type S3BucketNotificationArrayOutput struct{ *pulumi.OutputState }

func (S3BucketNotificationArrayOutput) ElementType 

func (S3BucketNotificationArrayOutput) ElementType() reflect.Type

func (S3BucketNotificationArrayOutput) Index 

func (o S3BucketNotificationArrayOutput) Index(i pulumi.IntInput) S3BucketNotificationOutput

func (S3BucketNotificationArrayOutput) ToS3BucketNotificationArrayOutput 

func (o S3BucketNotificationArrayOutput) ToS3BucketNotificationArrayOutput() S3BucketNotificationArrayOutput

func (S3BucketNotificationArrayOutput) ToS3BucketNotificationArrayOutputWithContext 

func (o S3BucketNotificationArrayOutput) ToS3BucketNotificationArrayOutputWithContext(ctx context.Context) S3BucketNotificationArrayOutput

type S3BucketNotificationInput 

type S3BucketNotificationInput interface {
	pulumi.Input

	ToS3BucketNotificationOutput() S3BucketNotificationOutput
	ToS3BucketNotificationOutputWithContext(ctx context.Context) S3BucketNotificationOutput
}

type S3BucketNotificationMap 

type S3BucketNotificationMap map[string]S3BucketNotificationInput

func (S3BucketNotificationMap) ElementType 

func (S3BucketNotificationMap) ElementType() reflect.Type

func (S3BucketNotificationMap) ToS3BucketNotificationMapOutput 

func (i S3BucketNotificationMap) ToS3BucketNotificationMapOutput() S3BucketNotificationMapOutput

func (S3BucketNotificationMap) ToS3BucketNotificationMapOutputWithContext 

func (i S3BucketNotificationMap) ToS3BucketNotificationMapOutputWithContext(ctx context.Context) S3BucketNotificationMapOutput

type S3BucketNotificationMapInput 

type S3BucketNotificationMapInput interface {
	pulumi.Input

	ToS3BucketNotificationMapOutput() S3BucketNotificationMapOutput
	ToS3BucketNotificationMapOutputWithContext(context.Context) S3BucketNotificationMapOutput
}

S3BucketNotificationMapInput is an input type that accepts S3BucketNotificationMap and S3BucketNotificationMapOutput values. You can construct a concrete instance of `S3BucketNotificationMapInput` via: 

S3BucketNotificationMap{ "key": S3BucketNotificationArgs{...} }

type S3BucketNotificationMapOutput 

type S3BucketNotificationMapOutput struct{ *pulumi.OutputState }

func (S3BucketNotificationMapOutput) ElementType 

func (S3BucketNotificationMapOutput) ElementType() reflect.Type

func (S3BucketNotificationMapOutput) MapIndex 

func (o S3BucketNotificationMapOutput) MapIndex(k pulumi.StringInput) S3BucketNotificationOutput

func (S3BucketNotificationMapOutput) ToS3BucketNotificationMapOutput 

func (o S3BucketNotificationMapOutput) ToS3BucketNotificationMapOutput() S3BucketNotificationMapOutput

func (S3BucketNotificationMapOutput) ToS3BucketNotificationMapOutputWithContext 

func (o S3BucketNotificationMapOutput) ToS3BucketNotificationMapOutputWithContext(ctx context.Context) S3BucketNotificationMapOutput

type S3BucketNotificationOutput 

type S3BucketNotificationOutput struct{ *pulumi.OutputState }

func (S3BucketNotificationOutput) Bucket 

func (o S3BucketNotificationOutput) Bucket() pulumi.StringOutput

func (S3BucketNotificationOutput) ElementType 

func (S3BucketNotificationOutput) ElementType() reflect.Type

func (S3BucketNotificationOutput) Queues 

func (o S3BucketNotificationOutput) Queues() S3BucketNotificationQueueArrayOutput

func (S3BucketNotificationOutput) ToS3BucketNotificationOutput 

func (o S3BucketNotificationOutput) ToS3BucketNotificationOutput() S3BucketNotificationOutput

func (S3BucketNotificationOutput) ToS3BucketNotificationOutputWithContext 

func (o S3BucketNotificationOutput) ToS3BucketNotificationOutputWithContext(ctx context.Context) S3BucketNotificationOutput

type S3BucketNotificationQueue 

type S3BucketNotificationQueue struct {
	Events       []string `pulumi:"events"`
	FilterPrefix *string  `pulumi:"filterPrefix"`
	FilterSuffix *string  `pulumi:"filterSuffix"`
	// The ID of this resource.
	Id       *string `pulumi:"id"`
	QueueArn string  `pulumi:"queueArn"`
}

type S3BucketNotificationQueueArgs 

type S3BucketNotificationQueueArgs struct {
	Events       pulumi.StringArrayInput `pulumi:"events"`
	FilterPrefix pulumi.StringPtrInput   `pulumi:"filterPrefix"`
	FilterSuffix pulumi.StringPtrInput   `pulumi:"filterSuffix"`
	// The ID of this resource.
	Id       pulumi.StringPtrInput `pulumi:"id"`
	QueueArn pulumi.StringInput    `pulumi:"queueArn"`
}

func (S3BucketNotificationQueueArgs) ElementType 

func (S3BucketNotificationQueueArgs) ElementType() reflect.Type

func (S3BucketNotificationQueueArgs) ToS3BucketNotificationQueueOutput 

func (i S3BucketNotificationQueueArgs) ToS3BucketNotificationQueueOutput() S3BucketNotificationQueueOutput

func (S3BucketNotificationQueueArgs) ToS3BucketNotificationQueueOutputWithContext 

func (i S3BucketNotificationQueueArgs) ToS3BucketNotificationQueueOutputWithContext(ctx context.Context) S3BucketNotificationQueueOutput

type S3BucketNotificationQueueArray 

type S3BucketNotificationQueueArray []S3BucketNotificationQueueInput

func (S3BucketNotificationQueueArray) ElementType 

func (S3BucketNotificationQueueArray) ElementType() reflect.Type

func (S3BucketNotificationQueueArray) ToS3BucketNotificationQueueArrayOutput 

func (i S3BucketNotificationQueueArray) ToS3BucketNotificationQueueArrayOutput() S3BucketNotificationQueueArrayOutput

func (S3BucketNotificationQueueArray) ToS3BucketNotificationQueueArrayOutputWithContext 

func (i S3BucketNotificationQueueArray) ToS3BucketNotificationQueueArrayOutputWithContext(ctx context.Context) S3BucketNotificationQueueArrayOutput

type S3BucketNotificationQueueArrayInput 

type S3BucketNotificationQueueArrayInput interface {
	pulumi.Input

	ToS3BucketNotificationQueueArrayOutput() S3BucketNotificationQueueArrayOutput
	ToS3BucketNotificationQueueArrayOutputWithContext(context.Context) S3BucketNotificationQueueArrayOutput
}

S3BucketNotificationQueueArrayInput is an input type that accepts S3BucketNotificationQueueArray and S3BucketNotificationQueueArrayOutput values. You can construct a concrete instance of `S3BucketNotificationQueueArrayInput` via: 

S3BucketNotificationQueueArray{ S3BucketNotificationQueueArgs{...} }

type S3BucketNotificationQueueArrayOutput 

type S3BucketNotificationQueueArrayOutput struct{ *pulumi.OutputState }

func (S3BucketNotificationQueueArrayOutput) ElementType 

func (S3BucketNotificationQueueArrayOutput) ElementType() reflect.Type

func (S3BucketNotificationQueueArrayOutput) Index 

func (o S3BucketNotificationQueueArrayOutput) Index(i pulumi.IntInput) S3BucketNotificationQueueOutput

func (S3BucketNotificationQueueArrayOutput) ToS3BucketNotificationQueueArrayOutput 

func (o S3BucketNotificationQueueArrayOutput) ToS3BucketNotificationQueueArrayOutput() S3BucketNotificationQueueArrayOutput

func (S3BucketNotificationQueueArrayOutput) ToS3BucketNotificationQueueArrayOutputWithContext 

func (o S3BucketNotificationQueueArrayOutput) ToS3BucketNotificationQueueArrayOutputWithContext(ctx context.Context) S3BucketNotificationQueueArrayOutput

type S3BucketNotificationQueueInput 

type S3BucketNotificationQueueInput interface {
	pulumi.Input

	ToS3BucketNotificationQueueOutput() S3BucketNotificationQueueOutput
	ToS3BucketNotificationQueueOutputWithContext(context.Context) S3BucketNotificationQueueOutput
}

S3BucketNotificationQueueInput is an input type that accepts S3BucketNotificationQueueArgs and S3BucketNotificationQueueOutput values. You can construct a concrete instance of `S3BucketNotificationQueueInput` via: 

S3BucketNotificationQueueArgs{...}

type S3BucketNotificationQueueOutput 

type S3BucketNotificationQueueOutput struct{ *pulumi.OutputState }

func (S3BucketNotificationQueueOutput) ElementType 

func (S3BucketNotificationQueueOutput) ElementType() reflect.Type

func (S3BucketNotificationQueueOutput) Events 

func (o S3BucketNotificationQueueOutput) Events() pulumi.StringArrayOutput

func (S3BucketNotificationQueueOutput) FilterPrefix 

func (o S3BucketNotificationQueueOutput) FilterPrefix() pulumi.StringPtrOutput

func (S3BucketNotificationQueueOutput) FilterSuffix 

func (o S3BucketNotificationQueueOutput) FilterSuffix() pulumi.StringPtrOutput

func (S3BucketNotificationQueueOutput) Id 

func (o S3BucketNotificationQueueOutput) Id() pulumi.StringPtrOutput

The ID of this resource.

func (S3BucketNotificationQueueOutput) QueueArn 

func (o S3BucketNotificationQueueOutput) QueueArn() pulumi.StringOutput

func (S3BucketNotificationQueueOutput) ToS3BucketNotificationQueueOutput 

func (o S3BucketNotificationQueueOutput) ToS3BucketNotificationQueueOutput() S3BucketNotificationQueueOutput

func (S3BucketNotificationQueueOutput) ToS3BucketNotificationQueueOutputWithContext 

func (o S3BucketNotificationQueueOutput) ToS3BucketNotificationQueueOutputWithContext(ctx context.Context) S3BucketNotificationQueueOutput

type S3BucketNotificationState 

type S3BucketNotificationState struct {
	Bucket pulumi.StringPtrInput
	Queues S3BucketNotificationQueueArrayInput
}

func (S3BucketNotificationState) ElementType 

func (S3BucketNotificationState) ElementType() reflect.Type

type S3BucketOutput 

type S3BucketOutput struct{ *pulumi.OutputState }

func (S3BucketOutput) Acl 

func (o S3BucketOutput) Acl() pulumi.StringPtrOutput

func (S3BucketOutput) Arn 

func (o S3BucketOutput) Arn() pulumi.StringOutput

func (S3BucketOutput) Bucket 

func (o S3BucketOutput) Bucket() pulumi.StringOutput

func (S3BucketOutput) BucketDomainName 

func (o S3BucketOutput) BucketDomainName() pulumi.StringOutput

func (S3BucketOutput) BucketPrefix 

func (o S3BucketOutput) BucketPrefix() pulumi.StringPtrOutput

func (S3BucketOutput) ElementType 

func (S3BucketOutput) ElementType() reflect.Type

func (S3BucketOutput) ForceDestroy 

func (o S3BucketOutput) ForceDestroy() pulumi.BoolPtrOutput

func (S3BucketOutput) ObjectLocking 

func (o S3BucketOutput) ObjectLocking() pulumi.BoolPtrOutput

func (S3BucketOutput) Quota 

func (o S3BucketOutput) Quota() pulumi.IntPtrOutput

func (S3BucketOutput) ToS3BucketOutput 

func (o S3BucketOutput) ToS3BucketOutput() S3BucketOutput

func (S3BucketOutput) ToS3BucketOutputWithContext 

func (o S3BucketOutput) ToS3BucketOutputWithContext(ctx context.Context) S3BucketOutput

type S3BucketPolicy 

type S3BucketPolicy struct {
	pulumi.CustomResourceState

	Bucket pulumi.StringOutput `pulumi:"bucket"`
	Policy pulumi.StringOutput `pulumi:"policy"`
}

func GetS3BucketPolicy 

func GetS3BucketPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *S3BucketPolicyState, opts ...pulumi.ResourceOption) (*S3BucketPolicy, error)

GetS3BucketPolicy gets an existing S3BucketPolicy 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 NewS3BucketPolicy 

func NewS3BucketPolicy(ctx *pulumi.Context,
	name string, args *S3BucketPolicyArgs, opts ...pulumi.ResourceOption) (*S3BucketPolicy, error)

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

func (*S3BucketPolicy) ElementType 

func (*S3BucketPolicy) ElementType() reflect.Type

func (*S3BucketPolicy) ToS3BucketPolicyOutput 

func (i *S3BucketPolicy) ToS3BucketPolicyOutput() S3BucketPolicyOutput

func (*S3BucketPolicy) ToS3BucketPolicyOutputWithContext 

func (i *S3BucketPolicy) ToS3BucketPolicyOutputWithContext(ctx context.Context) S3BucketPolicyOutput

type S3BucketPolicyArgs 

type S3BucketPolicyArgs struct {
	Bucket pulumi.StringInput
	Policy pulumi.StringInput
}

The set of arguments for constructing a S3BucketPolicy resource.

func (S3BucketPolicyArgs) ElementType 

func (S3BucketPolicyArgs) ElementType() reflect.Type

type S3BucketPolicyArray 

type S3BucketPolicyArray []S3BucketPolicyInput

func (S3BucketPolicyArray) ElementType 

func (S3BucketPolicyArray) ElementType() reflect.Type

func (S3BucketPolicyArray) ToS3BucketPolicyArrayOutput 

func (i S3BucketPolicyArray) ToS3BucketPolicyArrayOutput() S3BucketPolicyArrayOutput

func (S3BucketPolicyArray) ToS3BucketPolicyArrayOutputWithContext 

func (i S3BucketPolicyArray) ToS3BucketPolicyArrayOutputWithContext(ctx context.Context) S3BucketPolicyArrayOutput

type S3BucketPolicyArrayInput 

type S3BucketPolicyArrayInput interface {
	pulumi.Input

	ToS3BucketPolicyArrayOutput() S3BucketPolicyArrayOutput
	ToS3BucketPolicyArrayOutputWithContext(context.Context) S3BucketPolicyArrayOutput
}

S3BucketPolicyArrayInput is an input type that accepts S3BucketPolicyArray and S3BucketPolicyArrayOutput values. You can construct a concrete instance of `S3BucketPolicyArrayInput` via: 

S3BucketPolicyArray{ S3BucketPolicyArgs{...} }

type S3BucketPolicyArrayOutput 

type S3BucketPolicyArrayOutput struct{ *pulumi.OutputState }

func (S3BucketPolicyArrayOutput) ElementType 

func (S3BucketPolicyArrayOutput) ElementType() reflect.Type

func (S3BucketPolicyArrayOutput) Index 

func (o S3BucketPolicyArrayOutput) Index(i pulumi.IntInput) S3BucketPolicyOutput

func (S3BucketPolicyArrayOutput) ToS3BucketPolicyArrayOutput 

func (o S3BucketPolicyArrayOutput) ToS3BucketPolicyArrayOutput() S3BucketPolicyArrayOutput

func (S3BucketPolicyArrayOutput) ToS3BucketPolicyArrayOutputWithContext 

func (o S3BucketPolicyArrayOutput) ToS3BucketPolicyArrayOutputWithContext(ctx context.Context) S3BucketPolicyArrayOutput

type S3BucketPolicyInput 

type S3BucketPolicyInput interface {
	pulumi.Input

	ToS3BucketPolicyOutput() S3BucketPolicyOutput
	ToS3BucketPolicyOutputWithContext(ctx context.Context) S3BucketPolicyOutput
}

type S3BucketPolicyMap 

type S3BucketPolicyMap map[string]S3BucketPolicyInput

func (S3BucketPolicyMap) ElementType 

func (S3BucketPolicyMap) ElementType() reflect.Type

func (S3BucketPolicyMap) ToS3BucketPolicyMapOutput 

func (i S3BucketPolicyMap) ToS3BucketPolicyMapOutput() S3BucketPolicyMapOutput

func (S3BucketPolicyMap) ToS3BucketPolicyMapOutputWithContext 

func (i S3BucketPolicyMap) ToS3BucketPolicyMapOutputWithContext(ctx context.Context) S3BucketPolicyMapOutput

type S3BucketPolicyMapInput 

type S3BucketPolicyMapInput interface {
	pulumi.Input

	ToS3BucketPolicyMapOutput() S3BucketPolicyMapOutput
	ToS3BucketPolicyMapOutputWithContext(context.Context) S3BucketPolicyMapOutput
}

S3BucketPolicyMapInput is an input type that accepts S3BucketPolicyMap and S3BucketPolicyMapOutput values. You can construct a concrete instance of `S3BucketPolicyMapInput` via: 

S3BucketPolicyMap{ "key": S3BucketPolicyArgs{...} }

type S3BucketPolicyMapOutput 

type S3BucketPolicyMapOutput struct{ *pulumi.OutputState }

func (S3BucketPolicyMapOutput) ElementType 

func (S3BucketPolicyMapOutput) ElementType() reflect.Type

func (S3BucketPolicyMapOutput) MapIndex 

func (o S3BucketPolicyMapOutput) MapIndex(k pulumi.StringInput) S3BucketPolicyOutput

func (S3BucketPolicyMapOutput) ToS3BucketPolicyMapOutput 

func (o S3BucketPolicyMapOutput) ToS3BucketPolicyMapOutput() S3BucketPolicyMapOutput

func (S3BucketPolicyMapOutput) ToS3BucketPolicyMapOutputWithContext 

func (o S3BucketPolicyMapOutput) ToS3BucketPolicyMapOutputWithContext(ctx context.Context) S3BucketPolicyMapOutput

type S3BucketPolicyOutput 

type S3BucketPolicyOutput struct{ *pulumi.OutputState }

func (S3BucketPolicyOutput) Bucket 

func (o S3BucketPolicyOutput) Bucket() pulumi.StringOutput

func (S3BucketPolicyOutput) ElementType 

func (S3BucketPolicyOutput) ElementType() reflect.Type

func (S3BucketPolicyOutput) Policy 

func (o S3BucketPolicyOutput) Policy() pulumi.StringOutput

func (S3BucketPolicyOutput) ToS3BucketPolicyOutput 

func (o S3BucketPolicyOutput) ToS3BucketPolicyOutput() S3BucketPolicyOutput

func (S3BucketPolicyOutput) ToS3BucketPolicyOutputWithContext 

func (o S3BucketPolicyOutput) ToS3BucketPolicyOutputWithContext(ctx context.Context) S3BucketPolicyOutput

type S3BucketPolicyState 

type S3BucketPolicyState struct {
	Bucket pulumi.StringPtrInput
	Policy pulumi.StringPtrInput
}

func (S3BucketPolicyState) ElementType 

func (S3BucketPolicyState) ElementType() reflect.Type

type S3BucketReplication 

type S3BucketReplication struct {
	pulumi.CustomResourceState

	// The name of the existing target bucket to replicate into
	Bucket pulumi.StringOutput `pulumi:"bucket"`
	// Rule definitions
	Rules S3BucketReplicationRuleArrayOutput `pulumi:"rules"`
}

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-minio/sdk/v2/go/minio"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myBucketInAS3Bucket, err := minio.NewS3Bucket(ctx, "myBucketInAS3Bucket", &minio.S3BucketArgs{
			Bucket: pulumi.String("my-bucket"),
		})
		if err != nil {
			return err
		}
		myBucketInBS3Bucket, err := minio.NewS3Bucket(ctx, "myBucketInBS3Bucket", &minio.S3BucketArgs{
			Bucket: pulumi.String("my-bucket"),
		}, pulumi.Provider(minio.Deployment_b))
		if err != nil {
			return err
		}
		myBucketInAS3BucketVersioning, err := minio.NewS3BucketVersioning(ctx, "myBucketInAS3BucketVersioning", &minio.S3BucketVersioningArgs{
			Bucket: myBucketInAS3Bucket.Bucket,
			VersioningConfiguration: &minio.S3BucketVersioningVersioningConfigurationArgs{
				Status: pulumi.String("Enabled"),
			},
		})
		if err != nil {
			return err
		}
		myBucketInBS3BucketVersioning, err := minio.NewS3BucketVersioning(ctx, "myBucketInBS3BucketVersioning", &minio.S3BucketVersioningArgs{
			Bucket: myBucketInBS3Bucket.Bucket,
			VersioningConfiguration: &minio.S3BucketVersioningVersioningConfigurationArgs{
				Status: pulumi.String("Enabled"),
			},
		}, pulumi.Provider(minio.Deployment_b))
		if err != nil {
			return err
		}
		replicationPolicy, err := minio.GetIamPolicyDocument(ctx, &minio.GetIamPolicyDocumentArgs{
			Statements: []minio.GetIamPolicyDocumentStatement{
				{
					Sid:    pulumi.StringRef("ReadBuckets"),
					Effect: pulumi.StringRef("Allow"),
					Resources: []string{
						"arn:aws:s3:::*",
					},
					Actions: []string{
						"s3:ListBucket",
					},
				},
				{
					Sid:    pulumi.StringRef("EnableReplicationOnBucket"),
					Effect: pulumi.StringRef("Allow"),
					Resources: []string{
						"arn:aws:s3:::my-bucket",
					},
					Actions: []string{
						"s3:GetReplicationConfiguration",
						"s3:ListBucket",
						"s3:ListBucketMultipartUploads",
						"s3:GetBucketLocation",
						"s3:GetBucketVersioning",
						"s3:GetBucketObjectLockConfiguration",
						"s3:GetEncryptionConfiguration",
					},
				},
				{
					Sid:    pulumi.StringRef("EnableReplicatingDataIntoBucket"),
					Effect: pulumi.StringRef("Allow"),
					Resources: []string{
						"arn:aws:s3:::my-bucket/*",
					},
					Actions: []string{
						"s3:GetReplicationConfiguration",
						"s3:ReplicateTags",
						"s3:AbortMultipartUpload",
						"s3:GetObject",
						"s3:GetObjectVersion",
						"s3:GetObjectVersionTagging",
						"s3:PutObject",
						"s3:PutObjectRetention",
						"s3:PutBucketObjectLockConfiguration",
						"s3:PutObjectLegalHold",
						"s3:DeleteObject",
						"s3:ReplicateObject",
						"s3:ReplicateDelete",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		replicationInBIamPolicy, err := minio.NewIamPolicy(ctx, "replicationInBIamPolicy", &minio.IamPolicyArgs{
			Policy: *pulumi.String(replicationPolicy.Json),
		}, pulumi.Provider(minio.Deployment_b))
		if err != nil {
			return err
		}
		replicationInBIamUser, err := minio.NewIamUser(ctx, "replicationInBIamUser", &minio.IamUserArgs{
			ForceDestroy: pulumi.Bool(true),
		}, pulumi.Provider(minio.Deployment_b))
		if err != nil {
			return err
		}
		replicationInBIamUserPolicyAttachment, err := minio.NewIamUserPolicyAttachment(ctx, "replicationInBIamUserPolicyAttachment", &minio.IamUserPolicyAttachmentArgs{
			UserName:   replicationInBIamUser.Name,
			PolicyName: replicationInBIamPolicy.ID(),
		}, pulumi.Provider(minio.Deployment_b))
		if err != nil {
			return err
		}
		replicationInBIamServiceAccount, err := minio.NewIamServiceAccount(ctx, "replicationInBIamServiceAccount", &minio.IamServiceAccountArgs{
			TargetUser: replicationInBIamUser.Name,
		}, pulumi.Provider(minio.Deployment_b), pulumi.DependsOn([]pulumi.Resource{
			replicationInBIamUserPolicyAttachment,
		}))
		if err != nil {
			return err
		}
		_, err = minio.NewS3BucketReplication(ctx, "replicationInBS3BucketReplication", &minio.S3BucketReplicationArgs{
			Bucket: myBucketInAS3Bucket.Bucket,
			Rules: minio.S3BucketReplicationRuleArray{
				&minio.S3BucketReplicationRuleArgs{
					DeleteReplication:         pulumi.Bool(true),
					DeleteMarkerReplication:   pulumi.Bool(true),
					ExistingObjectReplication: pulumi.Bool(true),
					MetadataSync:              pulumi.Bool(true),
					Target: &minio.S3BucketReplicationRuleTargetArgs{
						Bucket:        myBucketInBS3Bucket.Bucket,
						Secure:        pulumi.Bool(false),
						Host:          pulumi.Any(_var.Minio_server_b),
						BandwidthLimt: pulumi.String("100M"),
						AccessKey:     replicationInBIamServiceAccount.AccessKey,
						SecretKey:     replicationInBIamServiceAccount.SecretKey,
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			myBucketInAS3BucketVersioning,
			myBucketInBS3BucketVersioning,
		}))
		if err != nil {
			return err
		}
		replicationInAIamPolicy, err := minio.NewIamPolicy(ctx, "replicationInAIamPolicy", &minio.IamPolicyArgs{
			Policy: *pulumi.String(replicationPolicy.Json),
		})
		if err != nil {
			return err
		}
		replicationInAIamUser, err := minio.NewIamUser(ctx, "replicationInAIamUser", &minio.IamUserArgs{
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = minio.NewIamUserPolicyAttachment(ctx, "replicationInAIamUserPolicyAttachment", &minio.IamUserPolicyAttachmentArgs{
			UserName:   replicationInAIamUser.Name,
			PolicyName: replicationInAIamPolicy.ID(),
		})
		if err != nil {
			return err
		}
		replicationInAIamServiceAccount, err := minio.NewIamServiceAccount(ctx, "replicationInAIamServiceAccount", &minio.IamServiceAccountArgs{
			TargetUser: replicationInAIamUser.Name,
		}, pulumi.DependsOn([]pulumi.Resource{
			replicationInBIamUserPolicyAttachment,
		}))
		if err != nil {
			return err
		}
		_, err = minio.NewS3BucketReplication(ctx, "replicationInAS3BucketReplication", &minio.S3BucketReplicationArgs{
			Bucket: myBucketInBS3Bucket.Bucket,
			Rules: minio.S3BucketReplicationRuleArray{
				&minio.S3BucketReplicationRuleArgs{
					DeleteReplication:         pulumi.Bool(true),
					DeleteMarkerReplication:   pulumi.Bool(true),
					ExistingObjectReplication: pulumi.Bool(true),
					MetadataSync:              pulumi.Bool(true),
					Target: &minio.S3BucketReplicationRuleTargetArgs{
						Bucket:        myBucketInAS3Bucket.Bucket,
						Host:          pulumi.Any(_var.Minio_server_a),
						Secure:        pulumi.Bool(false),
						BandwidthLimt: pulumi.String("100M"),
						AccessKey:     replicationInAIamServiceAccount.AccessKey,
						SecretKey:     replicationInAIamServiceAccount.SecretKey,
					},
				},
			},
		}, pulumi.Provider(minio.Deployment_b), pulumi.DependsOn([]pulumi.Resource{
			myBucketInAS3BucketVersioning,
			myBucketInBS3BucketVersioning,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetS3BucketReplication 

func GetS3BucketReplication(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *S3BucketReplicationState, opts ...pulumi.ResourceOption) (*S3BucketReplication, error)

GetS3BucketReplication gets an existing S3BucketReplication 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 NewS3BucketReplication 

func NewS3BucketReplication(ctx *pulumi.Context,
	name string, args *S3BucketReplicationArgs, opts ...pulumi.ResourceOption) (*S3BucketReplication, error)

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

func (*S3BucketReplication) ElementType 

func (*S3BucketReplication) ElementType() reflect.Type

func (*S3BucketReplication) ToS3BucketReplicationOutput 

func (i *S3BucketReplication) ToS3BucketReplicationOutput() S3BucketReplicationOutput

func (*S3BucketReplication) ToS3BucketReplicationOutputWithContext 

func (i *S3BucketReplication) ToS3BucketReplicationOutputWithContext(ctx context.Context) S3BucketReplicationOutput

type S3BucketReplicationArgs 

type S3BucketReplicationArgs struct {
	// The name of the existing target bucket to replicate into
	Bucket pulumi.StringInput
	// Rule definitions
	Rules S3BucketReplicationRuleArrayInput
}

The set of arguments for constructing a S3BucketReplication resource.

func (S3BucketReplicationArgs) ElementType 

func (S3BucketReplicationArgs) ElementType() reflect.Type

type S3BucketReplicationArray 

type S3BucketReplicationArray []S3BucketReplicationInput

func (S3BucketReplicationArray) ElementType 

func (S3BucketReplicationArray) ElementType() reflect.Type

func (S3BucketReplicationArray) ToS3BucketReplicationArrayOutput 

func (i S3BucketReplicationArray) ToS3BucketReplicationArrayOutput() S3BucketReplicationArrayOutput

func (S3BucketReplicationArray) ToS3BucketReplicationArrayOutputWithContext 

func (i S3BucketReplicationArray) ToS3BucketReplicationArrayOutputWithContext(ctx context.Context) S3BucketReplicationArrayOutput

type S3BucketReplicationArrayInput 

type S3BucketReplicationArrayInput interface {
	pulumi.Input

	ToS3BucketReplicationArrayOutput() S3BucketReplicationArrayOutput
	ToS3BucketReplicationArrayOutputWithContext(context.Context) S3BucketReplicationArrayOutput
}

S3BucketReplicationArrayInput is an input type that accepts S3BucketReplicationArray and S3BucketReplicationArrayOutput values. You can construct a concrete instance of `S3BucketReplicationArrayInput` via: 

S3BucketReplicationArray{ S3BucketReplicationArgs{...} }

type S3BucketReplicationArrayOutput 

type S3BucketReplicationArrayOutput struct{ *pulumi.OutputState }

func (S3BucketReplicationArrayOutput) ElementType 

func (S3BucketReplicationArrayOutput) ElementType() reflect.Type

func (S3BucketReplicationArrayOutput) Index 

func (o S3BucketReplicationArrayOutput) Index(i pulumi.IntInput) S3BucketReplicationOutput

func (S3BucketReplicationArrayOutput) ToS3BucketReplicationArrayOutput 

func (o S3BucketReplicationArrayOutput) ToS3BucketReplicationArrayOutput() S3BucketReplicationArrayOutput

func (S3BucketReplicationArrayOutput) ToS3BucketReplicationArrayOutputWithContext 

func (o S3BucketReplicationArrayOutput) ToS3BucketReplicationArrayOutputWithContext(ctx context.Context) S3BucketReplicationArrayOutput

type S3BucketReplicationInput 

type S3BucketReplicationInput interface {
	pulumi.Input

	ToS3BucketReplicationOutput() S3BucketReplicationOutput
	ToS3BucketReplicationOutputWithContext(ctx context.Context) S3BucketReplicationOutput
}

type S3BucketReplicationMap 

type S3BucketReplicationMap map[string]S3BucketReplicationInput

func (S3BucketReplicationMap) ElementType 

func (S3BucketReplicationMap) ElementType() reflect.Type

func (S3BucketReplicationMap) ToS3BucketReplicationMapOutput 

func (i S3BucketReplicationMap) ToS3BucketReplicationMapOutput() S3BucketReplicationMapOutput

func (S3BucketReplicationMap) ToS3BucketReplicationMapOutputWithContext 

func (i S3BucketReplicationMap) ToS3BucketReplicationMapOutputWithContext(ctx context.Context) S3BucketReplicationMapOutput

type S3BucketReplicationMapInput 

type S3BucketReplicationMapInput interface {
	pulumi.Input

	ToS3BucketReplicationMapOutput() S3BucketReplicationMapOutput
	ToS3BucketReplicationMapOutputWithContext(context.Context) S3BucketReplicationMapOutput
}

S3BucketReplicationMapInput is an input type that accepts S3BucketReplicationMap and S3BucketReplicationMapOutput values. You can construct a concrete instance of `S3BucketReplicationMapInput` via: 

S3BucketReplicationMap{ "key": S3BucketReplicationArgs{...} }

type S3BucketReplicationMapOutput 

type S3BucketReplicationMapOutput struct{ *pulumi.OutputState }

func (S3BucketReplicationMapOutput) ElementType 

func (S3BucketReplicationMapOutput) ElementType() reflect.Type

func (S3BucketReplicationMapOutput) MapIndex 

func (o S3BucketReplicationMapOutput) MapIndex(k pulumi.StringInput) S3BucketReplicationOutput

func (S3BucketReplicationMapOutput) ToS3BucketReplicationMapOutput 

func (o S3BucketReplicationMapOutput) ToS3BucketReplicationMapOutput() S3BucketReplicationMapOutput

func (S3BucketReplicationMapOutput) ToS3BucketReplicationMapOutputWithContext 

func (o S3BucketReplicationMapOutput) ToS3BucketReplicationMapOutputWithContext(ctx context.Context) S3BucketReplicationMapOutput

type S3BucketReplicationOutput 

type S3BucketReplicationOutput struct{ *pulumi.OutputState }

func (S3BucketReplicationOutput) Bucket 

func (o S3BucketReplicationOutput) Bucket() pulumi.StringOutput

The name of the existing target bucket to replicate into

func (S3BucketReplicationOutput) ElementType 

func (S3BucketReplicationOutput) ElementType() reflect.Type

func (S3BucketReplicationOutput) Rules 

func (o S3BucketReplicationOutput) Rules() S3BucketReplicationRuleArrayOutput

Rule definitions

func (S3BucketReplicationOutput) ToS3BucketReplicationOutput 

func (o S3BucketReplicationOutput) ToS3BucketReplicationOutput() S3BucketReplicationOutput

func (S3BucketReplicationOutput) ToS3BucketReplicationOutputWithContext 

func (o S3BucketReplicationOutput) ToS3BucketReplicationOutputWithContext(ctx context.Context) S3BucketReplicationOutput

type S3BucketReplicationRule 

type S3BucketReplicationRule struct {
	// Rule ARN genrated by MinIO
	Arn *string `pulumi:"arn"`
	// Whether or not to synchronise marker deletion
	DeleteMarkerReplication *bool `pulumi:"deleteMarkerReplication"`
	// Whether or not to propagate deletion
	DeleteReplication *bool `pulumi:"deleteReplication"`
	// Whether or not this rule is enabled
	Enabled *bool `pulumi:"enabled"`
	// Whether or not to synchronise object created prior the replication configuration
	ExistingObjectReplication *bool `pulumi:"existingObjectReplication"`
	// Rule ID generated by MinIO
	Id *string `pulumi:"id"`
	// Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication
	MetadataSync *bool `pulumi:"metadataSync"`
	// Bucket prefix object must be in to be syncronised
	Prefix *string `pulumi:"prefix"`
	// Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority
	Priority *int `pulumi:"priority"`
	// Tags which objects must have to be syncronised
	Tags map[string]interface{} `pulumi:"tags"`
	// Bucket prefix
	Target S3BucketReplicationRuleTarget `pulumi:"target"`
}

type S3BucketReplicationRuleArgs 

type S3BucketReplicationRuleArgs struct {
	// Rule ARN genrated by MinIO
	Arn pulumi.StringPtrInput `pulumi:"arn"`
	// Whether or not to synchronise marker deletion
	DeleteMarkerReplication pulumi.BoolPtrInput `pulumi:"deleteMarkerReplication"`
	// Whether or not to propagate deletion
	DeleteReplication pulumi.BoolPtrInput `pulumi:"deleteReplication"`
	// Whether or not this rule is enabled
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
	// Whether or not to synchronise object created prior the replication configuration
	ExistingObjectReplication pulumi.BoolPtrInput `pulumi:"existingObjectReplication"`
	// Rule ID generated by MinIO
	Id pulumi.StringPtrInput `pulumi:"id"`
	// Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication
	MetadataSync pulumi.BoolPtrInput `pulumi:"metadataSync"`
	// Bucket prefix object must be in to be syncronised
	Prefix pulumi.StringPtrInput `pulumi:"prefix"`
	// Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority
	Priority pulumi.IntPtrInput `pulumi:"priority"`
	// Tags which objects must have to be syncronised
	Tags pulumi.MapInput `pulumi:"tags"`
	// Bucket prefix
	Target S3BucketReplicationRuleTargetInput `pulumi:"target"`
}

func (S3BucketReplicationRuleArgs) ElementType 

func (S3BucketReplicationRuleArgs) ElementType() reflect.Type

func (S3BucketReplicationRuleArgs) ToS3BucketReplicationRuleOutput 

func (i S3BucketReplicationRuleArgs) ToS3BucketReplicationRuleOutput() S3BucketReplicationRuleOutput

func (S3BucketReplicationRuleArgs) ToS3BucketReplicationRuleOutputWithContext 

func (i S3BucketReplicationRuleArgs) ToS3BucketReplicationRuleOutputWithContext(ctx context.Context) S3BucketReplicationRuleOutput

type S3BucketReplicationRuleArray 

type S3BucketReplicationRuleArray []S3BucketReplicationRuleInput

func (S3BucketReplicationRuleArray) ElementType 

func (S3BucketReplicationRuleArray) ElementType() reflect.Type

func (S3BucketReplicationRuleArray) ToS3BucketReplicationRuleArrayOutput 

func (i S3BucketReplicationRuleArray) ToS3BucketReplicationRuleArrayOutput() S3BucketReplicationRuleArrayOutput

func (S3BucketReplicationRuleArray) ToS3BucketReplicationRuleArrayOutputWithContext 

func (i S3BucketReplicationRuleArray) ToS3BucketReplicationRuleArrayOutputWithContext(ctx context.Context) S3BucketReplicationRuleArrayOutput

type S3BucketReplicationRuleArrayInput 

type S3BucketReplicationRuleArrayInput interface {
	pulumi.Input

	ToS3BucketReplicationRuleArrayOutput() S3BucketReplicationRuleArrayOutput
	ToS3BucketReplicationRuleArrayOutputWithContext(context.Context) S3BucketReplicationRuleArrayOutput
}

S3BucketReplicationRuleArrayInput is an input type that accepts S3BucketReplicationRuleArray and S3BucketReplicationRuleArrayOutput values. You can construct a concrete instance of `S3BucketReplicationRuleArrayInput` via: 

S3BucketReplicationRuleArray{ S3BucketReplicationRuleArgs{...} }

type S3BucketReplicationRuleArrayOutput 

type S3BucketReplicationRuleArrayOutput struct{ *pulumi.OutputState }

func (S3BucketReplicationRuleArrayOutput) ElementType 

func (S3BucketReplicationRuleArrayOutput) ElementType() reflect.Type

func (S3BucketReplicationRuleArrayOutput) Index 

func (o S3BucketReplicationRuleArrayOutput) Index(i pulumi.IntInput) S3BucketReplicationRuleOutput

func (S3BucketReplicationRuleArrayOutput) ToS3BucketReplicationRuleArrayOutput 

func (o S3BucketReplicationRuleArrayOutput) ToS3BucketReplicationRuleArrayOutput() S3BucketReplicationRuleArrayOutput

func (S3BucketReplicationRuleArrayOutput) ToS3BucketReplicationRuleArrayOutputWithContext 

func (o S3BucketReplicationRuleArrayOutput) ToS3BucketReplicationRuleArrayOutputWithContext(ctx context.Context) S3BucketReplicationRuleArrayOutput

type S3BucketReplicationRuleInput 

type S3BucketReplicationRuleInput interface {
	pulumi.Input

	ToS3BucketReplicationRuleOutput() S3BucketReplicationRuleOutput
	ToS3BucketReplicationRuleOutputWithContext(context.Context) S3BucketReplicationRuleOutput
}

S3BucketReplicationRuleInput is an input type that accepts S3BucketReplicationRuleArgs and S3BucketReplicationRuleOutput values. You can construct a concrete instance of `S3BucketReplicationRuleInput` via: 

S3BucketReplicationRuleArgs{...}

type S3BucketReplicationRuleOutput 

type S3BucketReplicationRuleOutput struct{ *pulumi.OutputState }

func (S3BucketReplicationRuleOutput) Arn 

func (o S3BucketReplicationRuleOutput) Arn() pulumi.StringPtrOutput

Rule ARN genrated by MinIO

func (S3BucketReplicationRuleOutput) DeleteMarkerReplication 

func (o S3BucketReplicationRuleOutput) DeleteMarkerReplication() pulumi.BoolPtrOutput

Whether or not to synchronise marker deletion

func (S3BucketReplicationRuleOutput) DeleteReplication 

func (o S3BucketReplicationRuleOutput) DeleteReplication() pulumi.BoolPtrOutput

Whether or not to propagate deletion

func (S3BucketReplicationRuleOutput) ElementType 

func (S3BucketReplicationRuleOutput) ElementType() reflect.Type

func (S3BucketReplicationRuleOutput) Enabled 

func (o S3BucketReplicationRuleOutput) Enabled() pulumi.BoolPtrOutput

Whether or not this rule is enabled

func (S3BucketReplicationRuleOutput) ExistingObjectReplication 

func (o S3BucketReplicationRuleOutput) ExistingObjectReplication() pulumi.BoolPtrOutput

Whether or not to synchronise object created prior the replication configuration

func (S3BucketReplicationRuleOutput) Id 

func (o S3BucketReplicationRuleOutput) Id() pulumi.StringPtrOutput

Rule ID generated by MinIO

func (S3BucketReplicationRuleOutput) MetadataSync 

func (o S3BucketReplicationRuleOutput) MetadataSync() pulumi.BoolPtrOutput

Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication

func (S3BucketReplicationRuleOutput) Prefix 

func (o S3BucketReplicationRuleOutput) Prefix() pulumi.StringPtrOutput

Bucket prefix object must be in to be syncronised

func (S3BucketReplicationRuleOutput) Priority 

func (o S3BucketReplicationRuleOutput) Priority() pulumi.IntPtrOutput

Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority

func (S3BucketReplicationRuleOutput) Tags 

func (o S3BucketReplicationRuleOutput) Tags() pulumi.MapOutput

Tags which objects must have to be syncronised

func (S3BucketReplicationRuleOutput) Target 

func (o S3BucketReplicationRuleOutput) Target() S3BucketReplicationRuleTargetOutput

Bucket prefix

func (S3BucketReplicationRuleOutput) ToS3BucketReplicationRuleOutput 

func (o S3BucketReplicationRuleOutput) ToS3BucketReplicationRuleOutput() S3BucketReplicationRuleOutput

func (S3BucketReplicationRuleOutput) ToS3BucketReplicationRuleOutputWithContext 

func (o S3BucketReplicationRuleOutput) ToS3BucketReplicationRuleOutputWithContext(ctx context.Context) S3BucketReplicationRuleOutput

type S3BucketReplicationRuleTarget 

type S3BucketReplicationRuleTarget struct {
	// Access key for the replication service account in the target MinIO
	AccessKey string `pulumi:"accessKey"`
	// Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB
	BandwidthLimt *string `pulumi:"bandwidthLimt"`
	// The name of the existing target bucket to replicate into
	Bucket string `pulumi:"bucket"`
	// Disable proxy for this target
	DisableProxy *bool `pulumi:"disableProxy"`
	// Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m`
	HealthCheckPeriod *string `pulumi:"healthCheckPeriod"`
	// The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself
	Host string `pulumi:"host"`
	// Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/`
	Path *string `pulumi:"path"`
	// Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)`
	PathStyle *string `pulumi:"pathStyle"`
	// Region of the target MinIO. This will be used to generate the target ARN
	Region *string `pulumi:"region"`
	// Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update
	SecretKey *string `pulumi:"secretKey"`
	Secure    *bool   `pulumi:"secure"`
	// The storage class to use for the object on this target
	StorageClass *string `pulumi:"storageClass"`
	// Use synchronous replication.
	Syncronous *bool `pulumi:"syncronous"`
}

type S3BucketReplicationRuleTargetArgs 

type S3BucketReplicationRuleTargetArgs struct {
	// Access key for the replication service account in the target MinIO
	AccessKey pulumi.StringInput `pulumi:"accessKey"`
	// Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB
	BandwidthLimt pulumi.StringPtrInput `pulumi:"bandwidthLimt"`
	// The name of the existing target bucket to replicate into
	Bucket pulumi.StringInput `pulumi:"bucket"`
	// Disable proxy for this target
	DisableProxy pulumi.BoolPtrInput `pulumi:"disableProxy"`
	// Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m`
	HealthCheckPeriod pulumi.StringPtrInput `pulumi:"healthCheckPeriod"`
	// The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself
	Host pulumi.StringInput `pulumi:"host"`
	// Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/`
	Path pulumi.StringPtrInput `pulumi:"path"`
	// Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)`
	PathStyle pulumi.StringPtrInput `pulumi:"pathStyle"`
	// Region of the target MinIO. This will be used to generate the target ARN
	Region pulumi.StringPtrInput `pulumi:"region"`
	// Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update
	SecretKey pulumi.StringPtrInput `pulumi:"secretKey"`
	Secure    pulumi.BoolPtrInput   `pulumi:"secure"`
	// The storage class to use for the object on this target
	StorageClass pulumi.StringPtrInput `pulumi:"storageClass"`
	// Use synchronous replication.
	Syncronous pulumi.BoolPtrInput `pulumi:"syncronous"`
}

func (S3BucketReplicationRuleTargetArgs) ElementType 

func (S3BucketReplicationRuleTargetArgs) ElementType() reflect.Type

func (S3BucketReplicationRuleTargetArgs) ToS3BucketReplicationRuleTargetOutput 

func (i S3BucketReplicationRuleTargetArgs) ToS3BucketReplicationRuleTargetOutput() S3BucketReplicationRuleTargetOutput

func (S3BucketReplicationRuleTargetArgs) ToS3BucketReplicationRuleTargetOutputWithContext 

func (i S3BucketReplicationRuleTargetArgs) ToS3BucketReplicationRuleTargetOutputWithContext(ctx context.Context) S3BucketReplicationRuleTargetOutput

type S3BucketReplicationRuleTargetInput 

type S3BucketReplicationRuleTargetInput interface {
	pulumi.Input

	ToS3BucketReplicationRuleTargetOutput() S3BucketReplicationRuleTargetOutput
	ToS3BucketReplicationRuleTargetOutputWithContext(context.Context) S3BucketReplicationRuleTargetOutput
}

S3BucketReplicationRuleTargetInput is an input type that accepts S3BucketReplicationRuleTargetArgs and S3BucketReplicationRuleTargetOutput values. You can construct a concrete instance of `S3BucketReplicationRuleTargetInput` via: 

S3BucketReplicationRuleTargetArgs{...}

type S3BucketReplicationRuleTargetOutput 

type S3BucketReplicationRuleTargetOutput struct{ *pulumi.OutputState }

func (S3BucketReplicationRuleTargetOutput) AccessKey 

func (o S3BucketReplicationRuleTargetOutput) AccessKey() pulumi.StringOutput

Access key for the replication service account in the target MinIO

func (S3BucketReplicationRuleTargetOutput) BandwidthLimt 

func (o S3BucketReplicationRuleTargetOutput) BandwidthLimt() pulumi.StringPtrOutput

Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB

func (S3BucketReplicationRuleTargetOutput) Bucket 

func (o S3BucketReplicationRuleTargetOutput) Bucket() pulumi.StringOutput

The name of the existing target bucket to replicate into

func (S3BucketReplicationRuleTargetOutput) DisableProxy 

func (o S3BucketReplicationRuleTargetOutput) DisableProxy() pulumi.BoolPtrOutput

Disable proxy for this target

func (S3BucketReplicationRuleTargetOutput) ElementType 

func (S3BucketReplicationRuleTargetOutput) ElementType() reflect.Type

func (S3BucketReplicationRuleTargetOutput) HealthCheckPeriod 

func (o S3BucketReplicationRuleTargetOutput) HealthCheckPeriod() pulumi.StringPtrOutput

Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m`

func (S3BucketReplicationRuleTargetOutput) Host 

func (o S3BucketReplicationRuleTargetOutput) Host() pulumi.StringOutput

The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself

func (S3BucketReplicationRuleTargetOutput) Path 

func (o S3BucketReplicationRuleTargetOutput) Path() pulumi.StringPtrOutput

Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/`

func (S3BucketReplicationRuleTargetOutput) PathStyle 

func (o S3BucketReplicationRuleTargetOutput) PathStyle() pulumi.StringPtrOutput

Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)`

func (S3BucketReplicationRuleTargetOutput) Region 

func (o S3BucketReplicationRuleTargetOutput) Region() pulumi.StringPtrOutput

Region of the target MinIO. This will be used to generate the target ARN

func (S3BucketReplicationRuleTargetOutput) SecretKey 

func (o S3BucketReplicationRuleTargetOutput) SecretKey() pulumi.StringPtrOutput

Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update

func (S3BucketReplicationRuleTargetOutput) Secure 

func (o S3BucketReplicationRuleTargetOutput) Secure() pulumi.BoolPtrOutput

func (S3BucketReplicationRuleTargetOutput) StorageClass 

func (o S3BucketReplicationRuleTargetOutput) StorageClass() pulumi.StringPtrOutput

The storage class to use for the object on this target

func (S3BucketReplicationRuleTargetOutput) Syncronous 

func (o S3BucketReplicationRuleTargetOutput) Syncronous() pulumi.BoolPtrOutput

Use synchronous replication.

func (S3BucketReplicationRuleTargetOutput) ToS3BucketReplicationRuleTargetOutput 

func (o S3BucketReplicationRuleTargetOutput) ToS3BucketReplicationRuleTargetOutput() S3BucketReplicationRuleTargetOutput

func (S3BucketReplicationRuleTargetOutput) ToS3BucketReplicationRuleTargetOutputWithContext 

func (o S3BucketReplicationRuleTargetOutput) ToS3BucketReplicationRuleTargetOutputWithContext(ctx context.Context) S3BucketReplicationRuleTargetOutput

type S3BucketReplicationState 

type S3BucketReplicationState struct {
	// The name of the existing target bucket to replicate into
	Bucket pulumi.StringPtrInput
	// Rule definitions
	Rules S3BucketReplicationRuleArrayInput
}

func (S3BucketReplicationState) ElementType 

func (S3BucketReplicationState) ElementType() reflect.Type

type S3BucketServerSideEncryption 

type S3BucketServerSideEncryption struct {
	pulumi.CustomResourceState

	Bucket         pulumi.StringOutput `pulumi:"bucket"`
	EncryptionType pulumi.StringOutput `pulumi:"encryptionType"`
	KmsKeyId       pulumi.StringOutput `pulumi:"kmsKeyId"`
}

func GetS3BucketServerSideEncryption 

func GetS3BucketServerSideEncryption(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *S3BucketServerSideEncryptionState, opts ...pulumi.ResourceOption) (*S3BucketServerSideEncryption, error)

GetS3BucketServerSideEncryption gets an existing S3BucketServerSideEncryption 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 NewS3BucketServerSideEncryption 

func NewS3BucketServerSideEncryption(ctx *pulumi.Context,
	name string, args *S3BucketServerSideEncryptionArgs, opts ...pulumi.ResourceOption) (*S3BucketServerSideEncryption, error)

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

func (*S3BucketServerSideEncryption) ElementType 

func (*S3BucketServerSideEncryption) ElementType() reflect.Type

func (*S3BucketServerSideEncryption) ToS3BucketServerSideEncryptionOutput 

func (i *S3BucketServerSideEncryption) ToS3BucketServerSideEncryptionOutput() S3BucketServerSideEncryptionOutput

func (*S3BucketServerSideEncryption) ToS3BucketServerSideEncryptionOutputWithContext 

func (i *S3BucketServerSideEncryption) ToS3BucketServerSideEncryptionOutputWithContext(ctx context.Context) S3BucketServerSideEncryptionOutput

type S3BucketServerSideEncryptionArgs 

type S3BucketServerSideEncryptionArgs struct {
	Bucket         pulumi.StringInput
	EncryptionType pulumi.StringInput
	KmsKeyId       pulumi.StringInput
}

The set of arguments for constructing a S3BucketServerSideEncryption resource.

func (S3BucketServerSideEncryptionArgs) ElementType 

func (S3BucketServerSideEncryptionArgs) ElementType() reflect.Type

type S3BucketServerSideEncryptionArray 

type S3BucketServerSideEncryptionArray []S3BucketServerSideEncryptionInput

func (S3BucketServerSideEncryptionArray) ElementType 

func (S3BucketServerSideEncryptionArray) ElementType() reflect.Type

func (S3BucketServerSideEncryptionArray) ToS3BucketServerSideEncryptionArrayOutput 

func (i S3BucketServerSideEncryptionArray) ToS3BucketServerSideEncryptionArrayOutput() S3BucketServerSideEncryptionArrayOutput

func (S3BucketServerSideEncryptionArray) ToS3BucketServerSideEncryptionArrayOutputWithContext 

func (i S3BucketServerSideEncryptionArray) ToS3BucketServerSideEncryptionArrayOutputWithContext(ctx context.Context) S3BucketServerSideEncryptionArrayOutput

type S3BucketServerSideEncryptionArrayInput 

type S3BucketServerSideEncryptionArrayInput interface {
	pulumi.Input

	ToS3BucketServerSideEncryptionArrayOutput() S3BucketServerSideEncryptionArrayOutput
	ToS3BucketServerSideEncryptionArrayOutputWithContext(context.Context) S3BucketServerSideEncryptionArrayOutput
}

S3BucketServerSideEncryptionArrayInput is an input type that accepts S3BucketServerSideEncryptionArray and S3BucketServerSideEncryptionArrayOutput values. You can construct a concrete instance of `S3BucketServerSideEncryptionArrayInput` via: 

S3BucketServerSideEncryptionArray{ S3BucketServerSideEncryptionArgs{...} }

type S3BucketServerSideEncryptionArrayOutput 

type S3BucketServerSideEncryptionArrayOutput struct{ *pulumi.OutputState }

func (S3BucketServerSideEncryptionArrayOutput) ElementType 

func (S3BucketServerSideEncryptionArrayOutput) ElementType() reflect.Type

func (S3BucketServerSideEncryptionArrayOutput) Index 

func (o S3BucketServerSideEncryptionArrayOutput) Index(i pulumi.IntInput) S3BucketServerSideEncryptionOutput

func (S3BucketServerSideEncryptionArrayOutput) ToS3BucketServerSideEncryptionArrayOutput 

func (o S3BucketServerSideEncryptionArrayOutput) ToS3BucketServerSideEncryptionArrayOutput() S3BucketServerSideEncryptionArrayOutput

func (S3BucketServerSideEncryptionArrayOutput) ToS3BucketServerSideEncryptionArrayOutputWithContext 

func (o S3BucketServerSideEncryptionArrayOutput) ToS3BucketServerSideEncryptionArrayOutputWithContext(ctx context.Context) S3BucketServerSideEncryptionArrayOutput

type S3BucketServerSideEncryptionInput 

type S3BucketServerSideEncryptionInput interface {
	pulumi.Input

	ToS3BucketServerSideEncryptionOutput() S3BucketServerSideEncryptionOutput
	ToS3BucketServerSideEncryptionOutputWithContext(ctx context.Context) S3BucketServerSideEncryptionOutput
}

type S3BucketServerSideEncryptionMap 

type S3BucketServerSideEncryptionMap map[string]S3BucketServerSideEncryptionInput

func (S3BucketServerSideEncryptionMap) ElementType 

func (S3BucketServerSideEncryptionMap) ElementType() reflect.Type

func (S3BucketServerSideEncryptionMap) ToS3BucketServerSideEncryptionMapOutput 

func (i S3BucketServerSideEncryptionMap) ToS3BucketServerSideEncryptionMapOutput() S3BucketServerSideEncryptionMapOutput

func (S3BucketServerSideEncryptionMap) ToS3BucketServerSideEncryptionMapOutputWithContext 

func (i S3BucketServerSideEncryptionMap) ToS3BucketServerSideEncryptionMapOutputWithContext(ctx context.Context) S3BucketServerSideEncryptionMapOutput

type S3BucketServerSideEncryptionMapInput 

type S3BucketServerSideEncryptionMapInput interface {
	pulumi.Input

	ToS3BucketServerSideEncryptionMapOutput() S3BucketServerSideEncryptionMapOutput
	ToS3BucketServerSideEncryptionMapOutputWithContext(context.Context) S3BucketServerSideEncryptionMapOutput
}

S3BucketServerSideEncryptionMapInput is an input type that accepts S3BucketServerSideEncryptionMap and S3BucketServerSideEncryptionMapOutput values. You can construct a concrete instance of `S3BucketServerSideEncryptionMapInput` via: 

S3BucketServerSideEncryptionMap{ "key": S3BucketServerSideEncryptionArgs{...} }

type S3BucketServerSideEncryptionMapOutput 

type S3BucketServerSideEncryptionMapOutput struct{ *pulumi.OutputState }

func (S3BucketServerSideEncryptionMapOutput) ElementType 

func (S3BucketServerSideEncryptionMapOutput) ElementType() reflect.Type

func (S3BucketServerSideEncryptionMapOutput) MapIndex 

func (o S3BucketServerSideEncryptionMapOutput) MapIndex(k pulumi.StringInput) S3BucketServerSideEncryptionOutput

func (S3BucketServerSideEncryptionMapOutput) ToS3BucketServerSideEncryptionMapOutput 

func (o S3BucketServerSideEncryptionMapOutput) ToS3BucketServerSideEncryptionMapOutput() S3BucketServerSideEncryptionMapOutput

func (S3BucketServerSideEncryptionMapOutput) ToS3BucketServerSideEncryptionMapOutputWithContext 

func (o S3BucketServerSideEncryptionMapOutput) ToS3BucketServerSideEncryptionMapOutputWithContext(ctx context.Context) S3BucketServerSideEncryptionMapOutput

type S3BucketServerSideEncryptionOutput 

type S3BucketServerSideEncryptionOutput struct{ *pulumi.OutputState }

func (S3BucketServerSideEncryptionOutput) Bucket 

func (o S3BucketServerSideEncryptionOutput) Bucket() pulumi.StringOutput

func (S3BucketServerSideEncryptionOutput) ElementType 

func (S3BucketServerSideEncryptionOutput) ElementType() reflect.Type

func (S3BucketServerSideEncryptionOutput) EncryptionType 

func (o S3BucketServerSideEncryptionOutput) EncryptionType() pulumi.StringOutput

func (S3BucketServerSideEncryptionOutput) KmsKeyId 

func (o S3BucketServerSideEncryptionOutput) KmsKeyId() pulumi.StringOutput

func (S3BucketServerSideEncryptionOutput) ToS3BucketServerSideEncryptionOutput 

func (o S3BucketServerSideEncryptionOutput) ToS3BucketServerSideEncryptionOutput() S3BucketServerSideEncryptionOutput

func (S3BucketServerSideEncryptionOutput) ToS3BucketServerSideEncryptionOutputWithContext 

func (o S3BucketServerSideEncryptionOutput) ToS3BucketServerSideEncryptionOutputWithContext(ctx context.Context) S3BucketServerSideEncryptionOutput

type S3BucketServerSideEncryptionState 

type S3BucketServerSideEncryptionState struct {
	Bucket         pulumi.StringPtrInput
	EncryptionType pulumi.StringPtrInput
	KmsKeyId       pulumi.StringPtrInput
}

func (S3BucketServerSideEncryptionState) ElementType 

func (S3BucketServerSideEncryptionState) ElementType() reflect.Type

type S3BucketState 

type S3BucketState struct {
	Acl              pulumi.StringPtrInput
	Arn              pulumi.StringPtrInput
	Bucket           pulumi.StringPtrInput
	BucketDomainName pulumi.StringPtrInput
	BucketPrefix     pulumi.StringPtrInput
	ForceDestroy     pulumi.BoolPtrInput
	ObjectLocking    pulumi.BoolPtrInput
	Quota            pulumi.IntPtrInput
}

func (S3BucketState) ElementType 

func (S3BucketState) ElementType() reflect.Type

type S3BucketVersioning 

type S3BucketVersioning struct {
	pulumi.CustomResourceState

	Bucket                  pulumi.StringOutput                             `pulumi:"bucket"`
	VersioningConfiguration S3BucketVersioningVersioningConfigurationOutput `pulumi:"versioningConfiguration"`
}

func GetS3BucketVersioning 

func GetS3BucketVersioning(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *S3BucketVersioningState, opts ...pulumi.ResourceOption) (*S3BucketVersioning, error)

GetS3BucketVersioning gets an existing S3BucketVersioning 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 NewS3BucketVersioning 

func NewS3BucketVersioning(ctx *pulumi.Context,
	name string, args *S3BucketVersioningArgs, opts ...pulumi.ResourceOption) (*S3BucketVersioning, error)

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

func (*S3BucketVersioning) ElementType 

func (*S3BucketVersioning) ElementType() reflect.Type

func (*S3BucketVersioning) ToS3BucketVersioningOutput 

func (i *S3BucketVersioning) ToS3BucketVersioningOutput() S3BucketVersioningOutput

func (*S3BucketVersioning) ToS3BucketVersioningOutputWithContext 

func (i *S3BucketVersioning) ToS3BucketVersioningOutputWithContext(ctx context.Context) S3BucketVersioningOutput

type S3BucketVersioningArgs 

type S3BucketVersioningArgs struct {
	Bucket                  pulumi.StringInput
	VersioningConfiguration S3BucketVersioningVersioningConfigurationInput
}

The set of arguments for constructing a S3BucketVersioning resource.

func (S3BucketVersioningArgs) ElementType 

func (S3BucketVersioningArgs) ElementType() reflect.Type

type S3BucketVersioningArray 

type S3BucketVersioningArray []S3BucketVersioningInput

func (S3BucketVersioningArray) ElementType 

func (S3BucketVersioningArray) ElementType() reflect.Type

func (S3BucketVersioningArray) ToS3BucketVersioningArrayOutput 

func (i S3BucketVersioningArray) ToS3BucketVersioningArrayOutput() S3BucketVersioningArrayOutput

func (S3BucketVersioningArray) ToS3BucketVersioningArrayOutputWithContext 

func (i S3BucketVersioningArray) ToS3BucketVersioningArrayOutputWithContext(ctx context.Context) S3BucketVersioningArrayOutput

type S3BucketVersioningArrayInput 

type S3BucketVersioningArrayInput interface {
	pulumi.Input

	ToS3BucketVersioningArrayOutput() S3BucketVersioningArrayOutput
	ToS3BucketVersioningArrayOutputWithContext(context.Context) S3BucketVersioningArrayOutput
}

S3BucketVersioningArrayInput is an input type that accepts S3BucketVersioningArray and S3BucketVersioningArrayOutput values. You can construct a concrete instance of `S3BucketVersioningArrayInput` via: 

S3BucketVersioningArray{ S3BucketVersioningArgs{...} }

type S3BucketVersioningArrayOutput 

type S3BucketVersioningArrayOutput struct{ *pulumi.OutputState }

func (S3BucketVersioningArrayOutput) ElementType 

func (S3BucketVersioningArrayOutput) ElementType() reflect.Type

func (S3BucketVersioningArrayOutput) Index 

func (o S3BucketVersioningArrayOutput) Index(i pulumi.IntInput) S3BucketVersioningOutput

func (S3BucketVersioningArrayOutput) ToS3BucketVersioningArrayOutput 

func (o S3BucketVersioningArrayOutput) ToS3BucketVersioningArrayOutput() S3BucketVersioningArrayOutput

func (S3BucketVersioningArrayOutput) ToS3BucketVersioningArrayOutputWithContext 

func (o S3BucketVersioningArrayOutput) ToS3BucketVersioningArrayOutputWithContext(ctx context.Context) S3BucketVersioningArrayOutput

type S3BucketVersioningInput 

type S3BucketVersioningInput interface {
	pulumi.Input

	ToS3BucketVersioningOutput() S3BucketVersioningOutput
	ToS3BucketVersioningOutputWithContext(ctx context.Context) S3BucketVersioningOutput
}

type S3BucketVersioningMap 

type S3BucketVersioningMap map[string]S3BucketVersioningInput

func (S3BucketVersioningMap) ElementType 

func (S3BucketVersioningMap) ElementType() reflect.Type

func (S3BucketVersioningMap) ToS3BucketVersioningMapOutput 

func (i S3BucketVersioningMap) ToS3BucketVersioningMapOutput() S3BucketVersioningMapOutput

func (S3BucketVersioningMap) ToS3BucketVersioningMapOutputWithContext 

func (i S3BucketVersioningMap) ToS3BucketVersioningMapOutputWithContext(ctx context.Context) S3BucketVersioningMapOutput

type S3BucketVersioningMapInput 

type S3BucketVersioningMapInput interface {
	pulumi.Input

	ToS3BucketVersioningMapOutput() S3BucketVersioningMapOutput
	ToS3BucketVersioningMapOutputWithContext(context.Context) S3BucketVersioningMapOutput
}

S3BucketVersioningMapInput is an input type that accepts S3BucketVersioningMap and S3BucketVersioningMapOutput values. You can construct a concrete instance of `S3BucketVersioningMapInput` via: 

S3BucketVersioningMap{ "key": S3BucketVersioningArgs{...} }

type S3BucketVersioningMapOutput 

type S3BucketVersioningMapOutput struct{ *pulumi.OutputState }

func (S3BucketVersioningMapOutput) ElementType 

func (S3BucketVersioningMapOutput) ElementType() reflect.Type

func (S3BucketVersioningMapOutput) MapIndex 

func (o S3BucketVersioningMapOutput) MapIndex(k pulumi.StringInput) S3BucketVersioningOutput

func (S3BucketVersioningMapOutput) ToS3BucketVersioningMapOutput 

func (o S3BucketVersioningMapOutput) ToS3BucketVersioningMapOutput() S3BucketVersioningMapOutput

func (S3BucketVersioningMapOutput) ToS3BucketVersioningMapOutputWithContext 

func (o S3BucketVersioningMapOutput) ToS3BucketVersioningMapOutputWithContext(ctx context.Context) S3BucketVersioningMapOutput

type S3BucketVersioningOutput 

type S3BucketVersioningOutput struct{ *pulumi.OutputState }

func (S3BucketVersioningOutput) Bucket 

func (o S3BucketVersioningOutput) Bucket() pulumi.StringOutput

func (S3BucketVersioningOutput) ElementType 

func (S3BucketVersioningOutput) ElementType() reflect.Type

func (S3BucketVersioningOutput) ToS3BucketVersioningOutput 

func (o S3BucketVersioningOutput) ToS3BucketVersioningOutput() S3BucketVersioningOutput

func (S3BucketVersioningOutput) ToS3BucketVersioningOutputWithContext 

func (o S3BucketVersioningOutput) ToS3BucketVersioningOutputWithContext(ctx context.Context) S3BucketVersioningOutput

func (S3BucketVersioningOutput) VersioningConfiguration 

func (o S3BucketVersioningOutput) VersioningConfiguration() S3BucketVersioningVersioningConfigurationOutput

type S3BucketVersioningState 

type S3BucketVersioningState struct {
	Bucket                  pulumi.StringPtrInput
	VersioningConfiguration S3BucketVersioningVersioningConfigurationPtrInput
}

func (S3BucketVersioningState) ElementType 

func (S3BucketVersioningState) ElementType() reflect.Type

type S3BucketVersioningVersioningConfiguration 

type S3BucketVersioningVersioningConfiguration struct {
	ExcludeFolders   *bool    `pulumi:"excludeFolders"`
	ExcludedPrefixes []string `pulumi:"excludedPrefixes"`
	Status           string   `pulumi:"status"`
}

type S3BucketVersioningVersioningConfigurationArgs 

type S3BucketVersioningVersioningConfigurationArgs struct {
	ExcludeFolders   pulumi.BoolPtrInput     `pulumi:"excludeFolders"`
	ExcludedPrefixes pulumi.StringArrayInput `pulumi:"excludedPrefixes"`
	Status           pulumi.StringInput      `pulumi:"status"`
}

func (S3BucketVersioningVersioningConfigurationArgs) ElementType 

func (S3BucketVersioningVersioningConfigurationArgs) ElementType() reflect.Type

func (S3BucketVersioningVersioningConfigurationArgs) ToS3BucketVersioningVersioningConfigurationOutput 

func (i S3BucketVersioningVersioningConfigurationArgs) ToS3BucketVersioningVersioningConfigurationOutput() S3BucketVersioningVersioningConfigurationOutput

func (S3BucketVersioningVersioningConfigurationArgs) ToS3BucketVersioningVersioningConfigurationOutputWithContext 

func (i S3BucketVersioningVersioningConfigurationArgs) ToS3BucketVersioningVersioningConfigurationOutputWithContext(ctx context.Context) S3BucketVersioningVersioningConfigurationOutput

func (S3BucketVersioningVersioningConfigurationArgs) ToS3BucketVersioningVersioningConfigurationPtrOutput 

func (i S3BucketVersioningVersioningConfigurationArgs) ToS3BucketVersioningVersioningConfigurationPtrOutput() S3BucketVersioningVersioningConfigurationPtrOutput

func (S3BucketVersioningVersioningConfigurationArgs) ToS3BucketVersioningVersioningConfigurationPtrOutputWithContext 

func (i S3BucketVersioningVersioningConfigurationArgs) ToS3BucketVersioningVersioningConfigurationPtrOutputWithContext(ctx context.Context) S3BucketVersioningVersioningConfigurationPtrOutput

type S3BucketVersioningVersioningConfigurationInput 

type S3BucketVersioningVersioningConfigurationInput interface {
	pulumi.Input

	ToS3BucketVersioningVersioningConfigurationOutput() S3BucketVersioningVersioningConfigurationOutput
	ToS3BucketVersioningVersioningConfigurationOutputWithContext(context.Context) S3BucketVersioningVersioningConfigurationOutput
}

S3BucketVersioningVersioningConfigurationInput is an input type that accepts S3BucketVersioningVersioningConfigurationArgs and S3BucketVersioningVersioningConfigurationOutput values. You can construct a concrete instance of `S3BucketVersioningVersioningConfigurationInput` via: 

S3BucketVersioningVersioningConfigurationArgs{...}

type S3BucketVersioningVersioningConfigurationOutput 

type S3BucketVersioningVersioningConfigurationOutput struct{ *pulumi.OutputState }

func (S3BucketVersioningVersioningConfigurationOutput) ElementType 

func (S3BucketVersioningVersioningConfigurationOutput) ElementType() reflect.Type

func (S3BucketVersioningVersioningConfigurationOutput) ExcludeFolders 

func (o S3BucketVersioningVersioningConfigurationOutput) ExcludeFolders() pulumi.BoolPtrOutput

func (S3BucketVersioningVersioningConfigurationOutput) ExcludedPrefixes 

func (o S3BucketVersioningVersioningConfigurationOutput) ExcludedPrefixes() pulumi.StringArrayOutput

func (S3BucketVersioningVersioningConfigurationOutput) Status 

func (o S3BucketVersioningVersioningConfigurationOutput) Status() pulumi.StringOutput

func (S3BucketVersioningVersioningConfigurationOutput) ToS3BucketVersioningVersioningConfigurationOutput 

func (o S3BucketVersioningVersioningConfigurationOutput) ToS3BucketVersioningVersioningConfigurationOutput() S3BucketVersioningVersioningConfigurationOutput

func (S3BucketVersioningVersioningConfigurationOutput) ToS3BucketVersioningVersioningConfigurationOutputWithContext 

func (o S3BucketVersioningVersioningConfigurationOutput) ToS3BucketVersioningVersioningConfigurationOutputWithContext(ctx context.Context) S3BucketVersioningVersioningConfigurationOutput

func (S3BucketVersioningVersioningConfigurationOutput) ToS3BucketVersioningVersioningConfigurationPtrOutput 

func (o S3BucketVersioningVersioningConfigurationOutput) ToS3BucketVersioningVersioningConfigurationPtrOutput() S3BucketVersioningVersioningConfigurationPtrOutput

func (S3BucketVersioningVersioningConfigurationOutput) ToS3BucketVersioningVersioningConfigurationPtrOutputWithContext 

func (o S3BucketVersioningVersioningConfigurationOutput) ToS3BucketVersioningVersioningConfigurationPtrOutputWithContext(ctx context.Context) S3BucketVersioningVersioningConfigurationPtrOutput

type S3BucketVersioningVersioningConfigurationPtrInput 

type S3BucketVersioningVersioningConfigurationPtrInput interface {
	pulumi.Input

	ToS3BucketVersioningVersioningConfigurationPtrOutput() S3BucketVersioningVersioningConfigurationPtrOutput
	ToS3BucketVersioningVersioningConfigurationPtrOutputWithContext(context.Context) S3BucketVersioningVersioningConfigurationPtrOutput
}

S3BucketVersioningVersioningConfigurationPtrInput is an input type that accepts S3BucketVersioningVersioningConfigurationArgs, S3BucketVersioningVersioningConfigurationPtr and S3BucketVersioningVersioningConfigurationPtrOutput values. You can construct a concrete instance of `S3BucketVersioningVersioningConfigurationPtrInput` via: 

        S3BucketVersioningVersioningConfigurationArgs{...}

or:

        nil

func S3BucketVersioningVersioningConfigurationPtr 

func S3BucketVersioningVersioningConfigurationPtr(v *S3BucketVersioningVersioningConfigurationArgs) S3BucketVersioningVersioningConfigurationPtrInput

type S3BucketVersioningVersioningConfigurationPtrOutput 

type S3BucketVersioningVersioningConfigurationPtrOutput struct{ *pulumi.OutputState }

func (S3BucketVersioningVersioningConfigurationPtrOutput) Elem 

func (o S3BucketVersioningVersioningConfigurationPtrOutput) Elem() S3BucketVersioningVersioningConfigurationOutput

func (S3BucketVersioningVersioningConfigurationPtrOutput) ElementType 

func (S3BucketVersioningVersioningConfigurationPtrOutput) ElementType() reflect.Type

func (S3BucketVersioningVersioningConfigurationPtrOutput) ExcludeFolders 

func (o S3BucketVersioningVersioningConfigurationPtrOutput) ExcludeFolders() pulumi.BoolPtrOutput

func (S3BucketVersioningVersioningConfigurationPtrOutput) ExcludedPrefixes 

func (o S3BucketVersioningVersioningConfigurationPtrOutput) ExcludedPrefixes() pulumi.StringArrayOutput

func (S3BucketVersioningVersioningConfigurationPtrOutput) Status 

func (o S3BucketVersioningVersioningConfigurationPtrOutput) Status() pulumi.StringPtrOutput

func (S3BucketVersioningVersioningConfigurationPtrOutput) ToS3BucketVersioningVersioningConfigurationPtrOutput 

func (o S3BucketVersioningVersioningConfigurationPtrOutput) ToS3BucketVersioningVersioningConfigurationPtrOutput() S3BucketVersioningVersioningConfigurationPtrOutput

func (S3BucketVersioningVersioningConfigurationPtrOutput) ToS3BucketVersioningVersioningConfigurationPtrOutputWithContext 

func (o S3BucketVersioningVersioningConfigurationPtrOutput) ToS3BucketVersioningVersioningConfigurationPtrOutputWithContext(ctx context.Context) S3BucketVersioningVersioningConfigurationPtrOutput

type S3Object 

type S3Object struct {
	pulumi.CustomResourceState

	BucketName    pulumi.StringOutput    `pulumi:"bucketName"`
	Content       pulumi.StringPtrOutput `pulumi:"content"`
	ContentBase64 pulumi.StringPtrOutput `pulumi:"contentBase64"`
	ContentType   pulumi.StringOutput    `pulumi:"contentType"`
	Etag          pulumi.StringOutput    `pulumi:"etag"`
	ObjectName    pulumi.StringOutput    `pulumi:"objectName"`
	Source        pulumi.StringPtrOutput `pulumi:"source"`
	VersionId     pulumi.StringOutput    `pulumi:"versionId"`
}

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-minio/sdk/v2/go/minio"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		stateTerraformS3, err := minio.NewS3Bucket(ctx, "stateTerraformS3", &minio.S3BucketArgs{
			Bucket: pulumi.String("state-terraform-s3"),
			Acl:    pulumi.String("public"),
		})
		if err != nil {
			return err
		}
		txtFile, err := minio.NewS3Object(ctx, "txtFile", &minio.S3ObjectArgs{
			BucketName:  stateTerraformS3.Bucket,
			ObjectName:  pulumi.String("text.txt"),
			Content:     pulumi.String("Lorem ipsum dolor sit amet."),
			ContentType: pulumi.String("text/plain"),
		}, pulumi.DependsOn([]pulumi.Resource{
			stateTerraformS3,
		}))
		if err != nil {
			return err
		}
		ctx.Export("minioId", txtFile.ID())
		return nil
	})
}

```

func GetS3Object 

func GetS3Object(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *S3ObjectState, opts ...pulumi.ResourceOption) (*S3Object, error)

GetS3Object gets an existing S3Object 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 NewS3Object 

func NewS3Object(ctx *pulumi.Context,
	name string, args *S3ObjectArgs, opts ...pulumi.ResourceOption) (*S3Object, error)

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

func (*S3Object) ElementType 

func (*S3Object) ElementType() reflect.Type

func (*S3Object) ToS3ObjectOutput 

func (i *S3Object) ToS3ObjectOutput() S3ObjectOutput

func (*S3Object) ToS3ObjectOutputWithContext 

func (i *S3Object) ToS3ObjectOutputWithContext(ctx context.Context) S3ObjectOutput

type S3ObjectArgs 

type S3ObjectArgs struct {
	BucketName    pulumi.StringInput
	Content       pulumi.StringPtrInput
	ContentBase64 pulumi.StringPtrInput
	ContentType   pulumi.StringPtrInput
	Etag          pulumi.StringPtrInput
	ObjectName    pulumi.StringInput
	Source        pulumi.StringPtrInput
	VersionId     pulumi.StringPtrInput
}

The set of arguments for constructing a S3Object resource.

func (S3ObjectArgs) ElementType 

func (S3ObjectArgs) ElementType() reflect.Type

type S3ObjectArray 

type S3ObjectArray []S3ObjectInput

func (S3ObjectArray) ElementType 

func (S3ObjectArray) ElementType() reflect.Type

func (S3ObjectArray) ToS3ObjectArrayOutput 

func (i S3ObjectArray) ToS3ObjectArrayOutput() S3ObjectArrayOutput

func (S3ObjectArray) ToS3ObjectArrayOutputWithContext 

func (i S3ObjectArray) ToS3ObjectArrayOutputWithContext(ctx context.Context) S3ObjectArrayOutput

type S3ObjectArrayInput 

type S3ObjectArrayInput interface {
	pulumi.Input

	ToS3ObjectArrayOutput() S3ObjectArrayOutput
	ToS3ObjectArrayOutputWithContext(context.Context) S3ObjectArrayOutput
}

S3ObjectArrayInput is an input type that accepts S3ObjectArray and S3ObjectArrayOutput values. You can construct a concrete instance of `S3ObjectArrayInput` via: 

S3ObjectArray{ S3ObjectArgs{...} }

type S3ObjectArrayOutput 

type S3ObjectArrayOutput struct{ *pulumi.OutputState }

func (S3ObjectArrayOutput) ElementType 

func (S3ObjectArrayOutput) ElementType() reflect.Type

func (S3ObjectArrayOutput) Index 

func (o S3ObjectArrayOutput) Index(i pulumi.IntInput) S3ObjectOutput

func (S3ObjectArrayOutput) ToS3ObjectArrayOutput 

func (o S3ObjectArrayOutput) ToS3ObjectArrayOutput() S3ObjectArrayOutput

func (S3ObjectArrayOutput) ToS3ObjectArrayOutputWithContext 

func (o S3ObjectArrayOutput) ToS3ObjectArrayOutputWithContext(ctx context.Context) S3ObjectArrayOutput

type S3ObjectInput 

type S3ObjectInput interface {
	pulumi.Input

	ToS3ObjectOutput() S3ObjectOutput
	ToS3ObjectOutputWithContext(ctx context.Context) S3ObjectOutput
}

type S3ObjectMap 

type S3ObjectMap map[string]S3ObjectInput

func (S3ObjectMap) ElementType 

func (S3ObjectMap) ElementType() reflect.Type

func (S3ObjectMap) ToS3ObjectMapOutput 

func (i S3ObjectMap) ToS3ObjectMapOutput() S3ObjectMapOutput

func (S3ObjectMap) ToS3ObjectMapOutputWithContext 

func (i S3ObjectMap) ToS3ObjectMapOutputWithContext(ctx context.Context) S3ObjectMapOutput

type S3ObjectMapInput 

type S3ObjectMapInput interface {
	pulumi.Input

	ToS3ObjectMapOutput() S3ObjectMapOutput
	ToS3ObjectMapOutputWithContext(context.Context) S3ObjectMapOutput
}

S3ObjectMapInput is an input type that accepts S3ObjectMap and S3ObjectMapOutput values. You can construct a concrete instance of `S3ObjectMapInput` via: 

S3ObjectMap{ "key": S3ObjectArgs{...} }

type S3ObjectMapOutput 

type S3ObjectMapOutput struct{ *pulumi.OutputState }

func (S3ObjectMapOutput) ElementType 

func (S3ObjectMapOutput) ElementType() reflect.Type

func (S3ObjectMapOutput) MapIndex 

func (o S3ObjectMapOutput) MapIndex(k pulumi.StringInput) S3ObjectOutput

func (S3ObjectMapOutput) ToS3ObjectMapOutput 

func (o S3ObjectMapOutput) ToS3ObjectMapOutput() S3ObjectMapOutput

func (S3ObjectMapOutput) ToS3ObjectMapOutputWithContext 

func (o S3ObjectMapOutput) ToS3ObjectMapOutputWithContext(ctx context.Context) S3ObjectMapOutput

type S3ObjectOutput 

type S3ObjectOutput struct{ *pulumi.OutputState }

func (S3ObjectOutput) BucketName 

func (o S3ObjectOutput) BucketName() pulumi.StringOutput

func (S3ObjectOutput) Content 

func (o S3ObjectOutput) Content() pulumi.StringPtrOutput

func (S3ObjectOutput) ContentBase64 

func (o S3ObjectOutput) ContentBase64() pulumi.StringPtrOutput

func (S3ObjectOutput) ContentType 

func (o S3ObjectOutput) ContentType() pulumi.StringOutput

func (S3ObjectOutput) ElementType 

func (S3ObjectOutput) ElementType() reflect.Type

func (S3ObjectOutput) Etag 

func (o S3ObjectOutput) Etag() pulumi.StringOutput

func (S3ObjectOutput) ObjectName 

func (o S3ObjectOutput) ObjectName() pulumi.StringOutput

func (S3ObjectOutput) Source 

func (o S3ObjectOutput) Source() pulumi.StringPtrOutput

func (S3ObjectOutput) ToS3ObjectOutput 

func (o S3ObjectOutput) ToS3ObjectOutput() S3ObjectOutput

func (S3ObjectOutput) ToS3ObjectOutputWithContext 

func (o S3ObjectOutput) ToS3ObjectOutputWithContext(ctx context.Context) S3ObjectOutput

func (S3ObjectOutput) VersionId 

func (o S3ObjectOutput) VersionId() pulumi.StringOutput

type S3ObjectState 

type S3ObjectState struct {
	BucketName    pulumi.StringPtrInput
	Content       pulumi.StringPtrInput
	ContentBase64 pulumi.StringPtrInput
	ContentType   pulumi.StringPtrInput
	Etag          pulumi.StringPtrInput
	ObjectName    pulumi.StringPtrInput
	Source        pulumi.StringPtrInput
	VersionId     pulumi.StringPtrInput
}

func (S3ObjectState) ElementType 

func (S3ObjectState) ElementType() reflect.Type

Source Files

View all Source files

Directories

Path Synopsis

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.