github.com/pulumi/pulumi-aws/sdk/v6@v6.32.0/go/aws/oam/sinkPolicy.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 oam

import (
	"context"
	"reflect"

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

// Resource for managing an AWS CloudWatch Observability Access Manager Sink Policy.
//
// ## Example Usage
//
// ### Basic Usage
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"encoding/json"
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/oam"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			example, err := oam.NewSink(ctx, "example", &oam.SinkArgs{
//				Name: pulumi.String("ExampleSink"),
//			})
//			if err != nil {
//				return err
//			}
//			tmpJSON0, err := json.Marshal(map[string]interface{}{
//				"Version": "2012-10-17",
//				"Statement": []map[string]interface{}{
//					map[string]interface{}{
//						"Action": []string{
//							"oam:CreateLink",
//							"oam:UpdateLink",
//						},
//						"Effect":   "Allow",
//						"Resource": "*",
//						"Principal": map[string]interface{}{
//							"AWS": []string{
//								"1111111111111",
//								"222222222222",
//							},
//						},
//						"Condition": map[string]interface{}{
//							"ForAllValues:StringEquals": map[string]interface{}{
//								"oam:ResourceTypes": []string{
//									"AWS::CloudWatch::Metric",
//									"AWS::Logs::LogGroup",
//								},
//							},
//						},
//					},
//				},
//			})
//			if err != nil {
//				return err
//			}
//			json0 := string(tmpJSON0)
//			_, err = oam.NewSinkPolicy(ctx, "example", &oam.SinkPolicyArgs{
//				SinkIdentifier: example.ID(),
//				Policy:         pulumi.String(json0),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Import
//
// Using `pulumi import`, import CloudWatch Observability Access Manager Sink Policy using the `sink_identifier`. For example:
//
// ```sh
// $ pulumi import aws:oam/sinkPolicy:SinkPolicy example arn:aws:oam:us-west-2:123456789012:sink/sink-id
// ```
type SinkPolicy struct {
	pulumi.CustomResourceState

	// ARN of the Sink.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// JSON policy to use. If you are updating an existing policy, the entire existing policy is replaced by what you specify here.
	Policy pulumi.StringOutput `pulumi:"policy"`
	// ID string that AWS generated as part of the sink ARN.
	SinkId pulumi.StringOutput `pulumi:"sinkId"`
	// ARN of the sink to attach this policy to.
	SinkIdentifier pulumi.StringOutput `pulumi:"sinkIdentifier"`
}

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

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

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

// Input properties used for looking up and filtering SinkPolicy resources.
type sinkPolicyState struct {
	// ARN of the Sink.
	Arn *string `pulumi:"arn"`
	// JSON policy to use. If you are updating an existing policy, the entire existing policy is replaced by what you specify here.
	Policy *string `pulumi:"policy"`
	// ID string that AWS generated as part of the sink ARN.
	SinkId *string `pulumi:"sinkId"`
	// ARN of the sink to attach this policy to.
	SinkIdentifier *string `pulumi:"sinkIdentifier"`
}

type SinkPolicyState struct {
	// ARN of the Sink.
	Arn pulumi.StringPtrInput
	// JSON policy to use. If you are updating an existing policy, the entire existing policy is replaced by what you specify here.
	Policy pulumi.StringPtrInput
	// ID string that AWS generated as part of the sink ARN.
	SinkId pulumi.StringPtrInput
	// ARN of the sink to attach this policy to.
	SinkIdentifier pulumi.StringPtrInput
}

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

type sinkPolicyArgs struct {
	// JSON policy to use. If you are updating an existing policy, the entire existing policy is replaced by what you specify here.
	Policy string `pulumi:"policy"`
	// ARN of the sink to attach this policy to.
	SinkIdentifier string `pulumi:"sinkIdentifier"`
}

// The set of arguments for constructing a SinkPolicy resource.
type SinkPolicyArgs struct {
	// JSON policy to use. If you are updating an existing policy, the entire existing policy is replaced by what you specify here.
	Policy pulumi.StringInput
	// ARN of the sink to attach this policy to.
	SinkIdentifier pulumi.StringInput
}

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

type SinkPolicyInput interface {
	pulumi.Input

	ToSinkPolicyOutput() SinkPolicyOutput
	ToSinkPolicyOutputWithContext(ctx context.Context) SinkPolicyOutput
}

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

func (i *SinkPolicy) ToSinkPolicyOutput() SinkPolicyOutput {
	return i.ToSinkPolicyOutputWithContext(context.Background())
}

func (i *SinkPolicy) ToSinkPolicyOutputWithContext(ctx context.Context) SinkPolicyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SinkPolicyOutput)
}

// SinkPolicyArrayInput is an input type that accepts SinkPolicyArray and SinkPolicyArrayOutput values.
// You can construct a concrete instance of `SinkPolicyArrayInput` via:
//
//	SinkPolicyArray{ SinkPolicyArgs{...} }
type SinkPolicyArrayInput interface {
	pulumi.Input

	ToSinkPolicyArrayOutput() SinkPolicyArrayOutput
	ToSinkPolicyArrayOutputWithContext(context.Context) SinkPolicyArrayOutput
}

type SinkPolicyArray []SinkPolicyInput

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

func (i SinkPolicyArray) ToSinkPolicyArrayOutput() SinkPolicyArrayOutput {
	return i.ToSinkPolicyArrayOutputWithContext(context.Background())
}

func (i SinkPolicyArray) ToSinkPolicyArrayOutputWithContext(ctx context.Context) SinkPolicyArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SinkPolicyArrayOutput)
}

// SinkPolicyMapInput is an input type that accepts SinkPolicyMap and SinkPolicyMapOutput values.
// You can construct a concrete instance of `SinkPolicyMapInput` via:
//
//	SinkPolicyMap{ "key": SinkPolicyArgs{...} }
type SinkPolicyMapInput interface {
	pulumi.Input

	ToSinkPolicyMapOutput() SinkPolicyMapOutput
	ToSinkPolicyMapOutputWithContext(context.Context) SinkPolicyMapOutput
}

type SinkPolicyMap map[string]SinkPolicyInput

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

func (i SinkPolicyMap) ToSinkPolicyMapOutput() SinkPolicyMapOutput {
	return i.ToSinkPolicyMapOutputWithContext(context.Background())
}

func (i SinkPolicyMap) ToSinkPolicyMapOutputWithContext(ctx context.Context) SinkPolicyMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SinkPolicyMapOutput)
}

type SinkPolicyOutput struct{ *pulumi.OutputState }

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

func (o SinkPolicyOutput) ToSinkPolicyOutput() SinkPolicyOutput {
	return o
}

func (o SinkPolicyOutput) ToSinkPolicyOutputWithContext(ctx context.Context) SinkPolicyOutput {
	return o
}

// ARN of the Sink.
func (o SinkPolicyOutput) Arn() pulumi.StringOutput {
	return o.ApplyT(func(v *SinkPolicy) pulumi.StringOutput { return v.Arn }).(pulumi.StringOutput)
}

// JSON policy to use. If you are updating an existing policy, the entire existing policy is replaced by what you specify here.
func (o SinkPolicyOutput) Policy() pulumi.StringOutput {
	return o.ApplyT(func(v *SinkPolicy) pulumi.StringOutput { return v.Policy }).(pulumi.StringOutput)
}

// ID string that AWS generated as part of the sink ARN.
func (o SinkPolicyOutput) SinkId() pulumi.StringOutput {
	return o.ApplyT(func(v *SinkPolicy) pulumi.StringOutput { return v.SinkId }).(pulumi.StringOutput)
}

// ARN of the sink to attach this policy to.
func (o SinkPolicyOutput) SinkIdentifier() pulumi.StringOutput {
	return o.ApplyT(func(v *SinkPolicy) pulumi.StringOutput { return v.SinkIdentifier }).(pulumi.StringOutput)
}

type SinkPolicyArrayOutput struct{ *pulumi.OutputState }

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

func (o SinkPolicyArrayOutput) ToSinkPolicyArrayOutput() SinkPolicyArrayOutput {
	return o
}

func (o SinkPolicyArrayOutput) ToSinkPolicyArrayOutputWithContext(ctx context.Context) SinkPolicyArrayOutput {
	return o
}

func (o SinkPolicyArrayOutput) Index(i pulumi.IntInput) SinkPolicyOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *SinkPolicy {
		return vs[0].([]*SinkPolicy)[vs[1].(int)]
	}).(SinkPolicyOutput)
}

type SinkPolicyMapOutput struct{ *pulumi.OutputState }

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

func (o SinkPolicyMapOutput) ToSinkPolicyMapOutput() SinkPolicyMapOutput {
	return o
}

func (o SinkPolicyMapOutput) ToSinkPolicyMapOutputWithContext(ctx context.Context) SinkPolicyMapOutput {
	return o
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*SinkPolicyInput)(nil)).Elem(), &SinkPolicy{})
	pulumi.RegisterInputType(reflect.TypeOf((*SinkPolicyArrayInput)(nil)).Elem(), SinkPolicyArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*SinkPolicyMapInput)(nil)).Elem(), SinkPolicyMap{})
	pulumi.RegisterOutputType(SinkPolicyOutput{})
	pulumi.RegisterOutputType(SinkPolicyArrayOutput{})
	pulumi.RegisterOutputType(SinkPolicyMapOutput{})
}