github.com/pulumi/pulumi-aws/sdk/v6@v6.32.0/go/aws/s3control/accessPointPolicy.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package s3control

import (
	"context"
	"reflect"

	"errors"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// Provides a resource to manage an S3 Access Point resource policy.
//
// > **NOTE on Access Points and Access Point Policies:** The provider provides both a standalone Access Point Policy resource and an Access Point resource with a resource policy defined in-line. You cannot use an Access Point with in-line resource policy in conjunction with an Access Point Policy resource. Doing so will cause a conflict of policies and will overwrite the access point's resource policy.
//
// ## Example Usage
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"encoding/json"
//	"fmt"
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3control"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			example, err := s3.NewBucketV2(ctx, "example", &s3.BucketV2Args{
//				Bucket: pulumi.String("example"),
//			})
//			if err != nil {
//				return err
//			}
//			exampleAccessPoint, err := s3.NewAccessPoint(ctx, "example", &s3.AccessPointArgs{
//				Bucket: example.ID(),
//				Name:   pulumi.String("example"),
//				PublicAccessBlockConfiguration: &s3.AccessPointPublicAccessBlockConfigurationArgs{
//					BlockPublicAcls:       pulumi.Bool(true),
//					BlockPublicPolicy:     pulumi.Bool(false),
//					IgnorePublicAcls:      pulumi.Bool(true),
//					RestrictPublicBuckets: pulumi.Bool(false),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			_, err = s3control.NewAccessPointPolicy(ctx, "example", &s3control.AccessPointPolicyArgs{
//				AccessPointArn: exampleAccessPoint.Arn,
//				Policy: exampleAccessPoint.Arn.ApplyT(func(arn string) (pulumi.String, error) {
//					var _zero pulumi.String
//					tmpJSON0, err := json.Marshal(map[string]interface{}{
//						"Version": "2008-10-17",
//						"Statement": []map[string]interface{}{
//							map[string]interface{}{
//								"Effect": "Allow",
//								"Action": "s3:GetObjectTagging",
//								"Principal": map[string]interface{}{
//									"AWS": "*",
//								},
//								"Resource": fmt.Sprintf("%v/object/*", arn),
//							},
//						},
//					})
//					if err != nil {
//						return _zero, err
//					}
//					json0 := string(tmpJSON0)
//					return pulumi.String(json0), nil
//				}).(pulumi.StringOutput),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Import
//
// Using `pulumi import`, import Access Point policies using the `access_point_arn`. For example:
//
// ```sh
// $ pulumi import aws:s3control/accessPointPolicy:AccessPointPolicy example arn:aws:s3:us-west-2:123456789012:accesspoint/example
// ```
type AccessPointPolicy struct {
	pulumi.CustomResourceState

	// The ARN of the access point that you want to associate with the specified policy.
	AccessPointArn pulumi.StringOutput `pulumi:"accessPointArn"`
	// Indicates whether this access point currently has a policy that allows public access.
	HasPublicAccessPolicy pulumi.BoolOutput `pulumi:"hasPublicAccessPolicy"`
	// The policy that you want to apply to the specified access point.
	Policy pulumi.StringOutput `pulumi:"policy"`
}

// NewAccessPointPolicy registers a new resource with the given unique name, arguments, and options.
func NewAccessPointPolicy(ctx *pulumi.Context,
	name string, args *AccessPointPolicyArgs, opts ...pulumi.ResourceOption) (*AccessPointPolicy, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.AccessPointArn == nil {
		return nil, errors.New("invalid value for required argument 'AccessPointArn'")
	}
	if args.Policy == nil {
		return nil, errors.New("invalid value for required argument 'Policy'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource AccessPointPolicy
	err := ctx.RegisterResource("aws:s3control/accessPointPolicy:AccessPointPolicy", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetAccessPointPolicy gets an existing AccessPointPolicy 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 GetAccessPointPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AccessPointPolicyState, opts ...pulumi.ResourceOption) (*AccessPointPolicy, error) {
	var resource AccessPointPolicy
	err := ctx.ReadResource("aws:s3control/accessPointPolicy:AccessPointPolicy", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering AccessPointPolicy resources.
type accessPointPolicyState struct {
	// The ARN of the access point that you want to associate with the specified policy.
	AccessPointArn *string `pulumi:"accessPointArn"`
	// Indicates whether this access point currently has a policy that allows public access.
	HasPublicAccessPolicy *bool `pulumi:"hasPublicAccessPolicy"`
	// The policy that you want to apply to the specified access point.
	Policy *string `pulumi:"policy"`
}

type AccessPointPolicyState struct {
	// The ARN of the access point that you want to associate with the specified policy.
	AccessPointArn pulumi.StringPtrInput
	// Indicates whether this access point currently has a policy that allows public access.
	HasPublicAccessPolicy pulumi.BoolPtrInput
	// The policy that you want to apply to the specified access point.
	Policy pulumi.StringPtrInput
}

func (AccessPointPolicyState) ElementType() reflect.Type {
	return reflect.TypeOf((*accessPointPolicyState)(nil)).Elem()
}

type accessPointPolicyArgs struct {
	// The ARN of the access point that you want to associate with the specified policy.
	AccessPointArn string `pulumi:"accessPointArn"`
	// The policy that you want to apply to the specified access point.
	Policy string `pulumi:"policy"`
}

// The set of arguments for constructing a AccessPointPolicy resource.
type AccessPointPolicyArgs struct {
	// The ARN of the access point that you want to associate with the specified policy.
	AccessPointArn pulumi.StringInput
	// The policy that you want to apply to the specified access point.
	Policy pulumi.StringInput
}

func (AccessPointPolicyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*accessPointPolicyArgs)(nil)).Elem()
}

type AccessPointPolicyInput interface {
	pulumi.Input

	ToAccessPointPolicyOutput() AccessPointPolicyOutput
	ToAccessPointPolicyOutputWithContext(ctx context.Context) AccessPointPolicyOutput
}

func (*AccessPointPolicy) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessPointPolicy)(nil)).Elem()
}

func (i *AccessPointPolicy) ToAccessPointPolicyOutput() AccessPointPolicyOutput {
	return i.ToAccessPointPolicyOutputWithContext(context.Background())
}

func (i *AccessPointPolicy) ToAccessPointPolicyOutputWithContext(ctx context.Context) AccessPointPolicyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessPointPolicyOutput)
}

// AccessPointPolicyArrayInput is an input type that accepts AccessPointPolicyArray and AccessPointPolicyArrayOutput values.
// You can construct a concrete instance of `AccessPointPolicyArrayInput` via:
//
//	AccessPointPolicyArray{ AccessPointPolicyArgs{...} }
type AccessPointPolicyArrayInput interface {
	pulumi.Input

	ToAccessPointPolicyArrayOutput() AccessPointPolicyArrayOutput
	ToAccessPointPolicyArrayOutputWithContext(context.Context) AccessPointPolicyArrayOutput
}

type AccessPointPolicyArray []AccessPointPolicyInput

func (AccessPointPolicyArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*AccessPointPolicy)(nil)).Elem()
}

func (i AccessPointPolicyArray) ToAccessPointPolicyArrayOutput() AccessPointPolicyArrayOutput {
	return i.ToAccessPointPolicyArrayOutputWithContext(context.Background())
}

func (i AccessPointPolicyArray) ToAccessPointPolicyArrayOutputWithContext(ctx context.Context) AccessPointPolicyArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessPointPolicyArrayOutput)
}

// AccessPointPolicyMapInput is an input type that accepts AccessPointPolicyMap and AccessPointPolicyMapOutput values.
// You can construct a concrete instance of `AccessPointPolicyMapInput` via:
//
//	AccessPointPolicyMap{ "key": AccessPointPolicyArgs{...} }
type AccessPointPolicyMapInput interface {
	pulumi.Input

	ToAccessPointPolicyMapOutput() AccessPointPolicyMapOutput
	ToAccessPointPolicyMapOutputWithContext(context.Context) AccessPointPolicyMapOutput
}

type AccessPointPolicyMap map[string]AccessPointPolicyInput

func (AccessPointPolicyMap) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*AccessPointPolicy)(nil)).Elem()
}

func (i AccessPointPolicyMap) ToAccessPointPolicyMapOutput() AccessPointPolicyMapOutput {
	return i.ToAccessPointPolicyMapOutputWithContext(context.Background())
}

func (i AccessPointPolicyMap) ToAccessPointPolicyMapOutputWithContext(ctx context.Context) AccessPointPolicyMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessPointPolicyMapOutput)
}

type AccessPointPolicyOutput struct{ *pulumi.OutputState }

func (AccessPointPolicyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessPointPolicy)(nil)).Elem()
}

func (o AccessPointPolicyOutput) ToAccessPointPolicyOutput() AccessPointPolicyOutput {
	return o
}

func (o AccessPointPolicyOutput) ToAccessPointPolicyOutputWithContext(ctx context.Context) AccessPointPolicyOutput {
	return o
}

// The ARN of the access point that you want to associate with the specified policy.
func (o AccessPointPolicyOutput) AccessPointArn() pulumi.StringOutput {
	return o.ApplyT(func(v *AccessPointPolicy) pulumi.StringOutput { return v.AccessPointArn }).(pulumi.StringOutput)
}

// Indicates whether this access point currently has a policy that allows public access.
func (o AccessPointPolicyOutput) HasPublicAccessPolicy() pulumi.BoolOutput {
	return o.ApplyT(func(v *AccessPointPolicy) pulumi.BoolOutput { return v.HasPublicAccessPolicy }).(pulumi.BoolOutput)
}

// The policy that you want to apply to the specified access point.
func (o AccessPointPolicyOutput) Policy() pulumi.StringOutput {
	return o.ApplyT(func(v *AccessPointPolicy) pulumi.StringOutput { return v.Policy }).(pulumi.StringOutput)
}

type AccessPointPolicyArrayOutput struct{ *pulumi.OutputState }

func (AccessPointPolicyArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*AccessPointPolicy)(nil)).Elem()
}

func (o AccessPointPolicyArrayOutput) ToAccessPointPolicyArrayOutput() AccessPointPolicyArrayOutput {
	return o
}

func (o AccessPointPolicyArrayOutput) ToAccessPointPolicyArrayOutputWithContext(ctx context.Context) AccessPointPolicyArrayOutput {
	return o
}

func (o AccessPointPolicyArrayOutput) Index(i pulumi.IntInput) AccessPointPolicyOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AccessPointPolicy {
		return vs[0].([]*AccessPointPolicy)[vs[1].(int)]
	}).(AccessPointPolicyOutput)
}

type AccessPointPolicyMapOutput struct{ *pulumi.OutputState }

func (AccessPointPolicyMapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*AccessPointPolicy)(nil)).Elem()
}

func (o AccessPointPolicyMapOutput) ToAccessPointPolicyMapOutput() AccessPointPolicyMapOutput {
	return o
}

func (o AccessPointPolicyMapOutput) ToAccessPointPolicyMapOutputWithContext(ctx context.Context) AccessPointPolicyMapOutput {
	return o
}

func (o AccessPointPolicyMapOutput) MapIndex(k pulumi.StringInput) AccessPointPolicyOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AccessPointPolicy {
		return vs[0].(map[string]*AccessPointPolicy)[vs[1].(string)]
	}).(AccessPointPolicyOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*AccessPointPolicyInput)(nil)).Elem(), &AccessPointPolicy{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessPointPolicyArrayInput)(nil)).Elem(), AccessPointPolicyArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessPointPolicyMapInput)(nil)).Elem(), AccessPointPolicyMap{})
	pulumi.RegisterOutputType(AccessPointPolicyOutput{})
	pulumi.RegisterOutputType(AccessPointPolicyArrayOutput{})
	pulumi.RegisterOutputType(AccessPointPolicyMapOutput{})
}