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

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 EventBridge Schemas Registry Policy.
//
// ## Example Usage
//
// ### Basic Usage
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/schemas"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			example, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
//				Statements: []iam.GetPolicyDocumentStatement{
//					{
//						Sid:    pulumi.StringRef("example"),
//						Effect: pulumi.StringRef("Allow"),
//						Principals: []iam.GetPolicyDocumentStatementPrincipal{
//							{
//								Type: "AWS",
//								Identifiers: []string{
//									"109876543210",
//								},
//							},
//						},
//						Actions: []string{
//							"schemas:*",
//						},
//						Resources: []string{
//							"arn:aws:schemas:us-east-1:012345678901:registry/example",
//							"arn:aws:schemas:us-east-1:012345678901:schema/example*",
//						},
//					},
//				},
//			}, nil)
//			if err != nil {
//				return err
//			}
//			_, err = schemas.NewRegistryPolicy(ctx, "example", &schemas.RegistryPolicyArgs{
//				RegistryName: pulumi.String("example"),
//				Policy:       pulumi.String(example.Json),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Import
//
// Using `pulumi import`, import EventBridge Schema Registry Policy using the `registry_name`. For example:
//
// ```sh
// $ pulumi import aws:schemas/registryPolicy:RegistryPolicy example example
// ```
type RegistryPolicy struct {
	pulumi.CustomResourceState

	// Resource Policy for EventBridge Schema Registry
	Policy pulumi.StringOutput `pulumi:"policy"`
	// Name of EventBridge Schema Registry
	RegistryName pulumi.StringOutput `pulumi:"registryName"`
}

// NewRegistryPolicy registers a new resource with the given unique name, arguments, and options.
func NewRegistryPolicy(ctx *pulumi.Context,
	name string, args *RegistryPolicyArgs, opts ...pulumi.ResourceOption) (*RegistryPolicy, 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.RegistryName == nil {
		return nil, errors.New("invalid value for required argument 'RegistryName'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource RegistryPolicy
	err := ctx.RegisterResource("aws:schemas/registryPolicy:RegistryPolicy", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

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

// Input properties used for looking up and filtering RegistryPolicy resources.
type registryPolicyState struct {
	// Resource Policy for EventBridge Schema Registry
	Policy *string `pulumi:"policy"`
	// Name of EventBridge Schema Registry
	RegistryName *string `pulumi:"registryName"`
}

type RegistryPolicyState struct {
	// Resource Policy for EventBridge Schema Registry
	Policy pulumi.StringPtrInput
	// Name of EventBridge Schema Registry
	RegistryName pulumi.StringPtrInput
}

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

type registryPolicyArgs struct {
	// Resource Policy for EventBridge Schema Registry
	Policy string `pulumi:"policy"`
	// Name of EventBridge Schema Registry
	RegistryName string `pulumi:"registryName"`
}

// The set of arguments for constructing a RegistryPolicy resource.
type RegistryPolicyArgs struct {
	// Resource Policy for EventBridge Schema Registry
	Policy pulumi.StringInput
	// Name of EventBridge Schema Registry
	RegistryName pulumi.StringInput
}

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

type RegistryPolicyInput interface {
	pulumi.Input

	ToRegistryPolicyOutput() RegistryPolicyOutput
	ToRegistryPolicyOutputWithContext(ctx context.Context) RegistryPolicyOutput
}

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

func (i *RegistryPolicy) ToRegistryPolicyOutput() RegistryPolicyOutput {
	return i.ToRegistryPolicyOutputWithContext(context.Background())
}

func (i *RegistryPolicy) ToRegistryPolicyOutputWithContext(ctx context.Context) RegistryPolicyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RegistryPolicyOutput)
}

// RegistryPolicyArrayInput is an input type that accepts RegistryPolicyArray and RegistryPolicyArrayOutput values.
// You can construct a concrete instance of `RegistryPolicyArrayInput` via:
//
//	RegistryPolicyArray{ RegistryPolicyArgs{...} }
type RegistryPolicyArrayInput interface {
	pulumi.Input

	ToRegistryPolicyArrayOutput() RegistryPolicyArrayOutput
	ToRegistryPolicyArrayOutputWithContext(context.Context) RegistryPolicyArrayOutput
}

type RegistryPolicyArray []RegistryPolicyInput

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

func (i RegistryPolicyArray) ToRegistryPolicyArrayOutput() RegistryPolicyArrayOutput {
	return i.ToRegistryPolicyArrayOutputWithContext(context.Background())
}

func (i RegistryPolicyArray) ToRegistryPolicyArrayOutputWithContext(ctx context.Context) RegistryPolicyArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RegistryPolicyArrayOutput)
}

// RegistryPolicyMapInput is an input type that accepts RegistryPolicyMap and RegistryPolicyMapOutput values.
// You can construct a concrete instance of `RegistryPolicyMapInput` via:
//
//	RegistryPolicyMap{ "key": RegistryPolicyArgs{...} }
type RegistryPolicyMapInput interface {
	pulumi.Input

	ToRegistryPolicyMapOutput() RegistryPolicyMapOutput
	ToRegistryPolicyMapOutputWithContext(context.Context) RegistryPolicyMapOutput
}

type RegistryPolicyMap map[string]RegistryPolicyInput

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

func (i RegistryPolicyMap) ToRegistryPolicyMapOutput() RegistryPolicyMapOutput {
	return i.ToRegistryPolicyMapOutputWithContext(context.Background())
}

func (i RegistryPolicyMap) ToRegistryPolicyMapOutputWithContext(ctx context.Context) RegistryPolicyMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RegistryPolicyMapOutput)
}

type RegistryPolicyOutput struct{ *pulumi.OutputState }

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

func (o RegistryPolicyOutput) ToRegistryPolicyOutput() RegistryPolicyOutput {
	return o
}

func (o RegistryPolicyOutput) ToRegistryPolicyOutputWithContext(ctx context.Context) RegistryPolicyOutput {
	return o
}

// Resource Policy for EventBridge Schema Registry
func (o RegistryPolicyOutput) Policy() pulumi.StringOutput {
	return o.ApplyT(func(v *RegistryPolicy) pulumi.StringOutput { return v.Policy }).(pulumi.StringOutput)
}

// Name of EventBridge Schema Registry
func (o RegistryPolicyOutput) RegistryName() pulumi.StringOutput {
	return o.ApplyT(func(v *RegistryPolicy) pulumi.StringOutput { return v.RegistryName }).(pulumi.StringOutput)
}

type RegistryPolicyArrayOutput struct{ *pulumi.OutputState }

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

func (o RegistryPolicyArrayOutput) ToRegistryPolicyArrayOutput() RegistryPolicyArrayOutput {
	return o
}

func (o RegistryPolicyArrayOutput) ToRegistryPolicyArrayOutputWithContext(ctx context.Context) RegistryPolicyArrayOutput {
	return o
}

func (o RegistryPolicyArrayOutput) Index(i pulumi.IntInput) RegistryPolicyOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RegistryPolicy {
		return vs[0].([]*RegistryPolicy)[vs[1].(int)]
	}).(RegistryPolicyOutput)
}

type RegistryPolicyMapOutput struct{ *pulumi.OutputState }

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

func (o RegistryPolicyMapOutput) ToRegistryPolicyMapOutput() RegistryPolicyMapOutput {
	return o
}

func (o RegistryPolicyMapOutput) ToRegistryPolicyMapOutputWithContext(ctx context.Context) RegistryPolicyMapOutput {
	return o
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*RegistryPolicyInput)(nil)).Elem(), &RegistryPolicy{})
	pulumi.RegisterInputType(reflect.TypeOf((*RegistryPolicyArrayInput)(nil)).Elem(), RegistryPolicyArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RegistryPolicyMapInput)(nil)).Elem(), RegistryPolicyMap{})
	pulumi.RegisterOutputType(RegistryPolicyOutput{})
	pulumi.RegisterOutputType(RegistryPolicyArrayOutput{})
	pulumi.RegisterOutputType(RegistryPolicyMapOutput{})
}