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

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 create an EventBridge Global Endpoint.
//
// > **Note:** EventBridge was formerly known as CloudWatch Events. The functionality is identical.
//
// ## Example Usage
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/cloudwatch"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := cloudwatch.NewEventEndpoint(ctx, "this", &cloudwatch.EventEndpointArgs{
//				Name:    pulumi.String("global-endpoint"),
//				RoleArn: pulumi.Any(replication.Arn),
//				EventBuses: cloudwatch.EventEndpointEventBusArray{
//					&cloudwatch.EventEndpointEventBusArgs{
//						EventBusArn: pulumi.Any(primary.Arn),
//					},
//					&cloudwatch.EventEndpointEventBusArgs{
//						EventBusArn: pulumi.Any(secondary.Arn),
//					},
//				},
//				ReplicationConfig: &cloudwatch.EventEndpointReplicationConfigArgs{
//					State: pulumi.String("DISABLED"),
//				},
//				RoutingConfig: &cloudwatch.EventEndpointRoutingConfigArgs{
//					FailoverConfig: &cloudwatch.EventEndpointRoutingConfigFailoverConfigArgs{
//						Primary: &cloudwatch.EventEndpointRoutingConfigFailoverConfigPrimaryArgs{
//							HealthCheck: pulumi.Any(primaryAwsRoute53HealthCheck.Arn),
//						},
//						Secondary: &cloudwatch.EventEndpointRoutingConfigFailoverConfigSecondaryArgs{
//							Route: pulumi.String("us-east-2"),
//						},
//					},
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Import
//
// Using `pulumi import`, import EventBridge Global Endpoints using the `name`. For example:
//
// ```sh
// $ pulumi import aws:cloudwatch/eventEndpoint:EventEndpoint imported_endpoint example-endpoint
// ```
type EventEndpoint struct {
	pulumi.CustomResourceState

	// The ARN of the endpoint that was created.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// A description of the global endpoint.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// The URL of the endpoint that was created.
	EndpointUrl pulumi.StringOutput `pulumi:"endpointUrl"`
	// The event buses to use. The names of the event buses must be identical in each Region. Exactly two event buses are required. Documented below.
	EventBuses EventEndpointEventBusArrayOutput `pulumi:"eventBuses"`
	// The name of the global endpoint.
	Name pulumi.StringOutput `pulumi:"name"`
	// Parameters used for replication. Documented below.
	ReplicationConfig EventEndpointReplicationConfigPtrOutput `pulumi:"replicationConfig"`
	// The ARN of the IAM role used for replication between event buses.
	RoleArn pulumi.StringPtrOutput `pulumi:"roleArn"`
	// Parameters used for routing, including the health check and secondary Region. Documented below.
	RoutingConfig EventEndpointRoutingConfigOutput `pulumi:"routingConfig"`
}

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

	if args.EventBuses == nil {
		return nil, errors.New("invalid value for required argument 'EventBuses'")
	}
	if args.RoutingConfig == nil {
		return nil, errors.New("invalid value for required argument 'RoutingConfig'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource EventEndpoint
	err := ctx.RegisterResource("aws:cloudwatch/eventEndpoint:EventEndpoint", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

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

// Input properties used for looking up and filtering EventEndpoint resources.
type eventEndpointState struct {
	// The ARN of the endpoint that was created.
	Arn *string `pulumi:"arn"`
	// A description of the global endpoint.
	Description *string `pulumi:"description"`
	// The URL of the endpoint that was created.
	EndpointUrl *string `pulumi:"endpointUrl"`
	// The event buses to use. The names of the event buses must be identical in each Region. Exactly two event buses are required. Documented below.
	EventBuses []EventEndpointEventBus `pulumi:"eventBuses"`
	// The name of the global endpoint.
	Name *string `pulumi:"name"`
	// Parameters used for replication. Documented below.
	ReplicationConfig *EventEndpointReplicationConfig `pulumi:"replicationConfig"`
	// The ARN of the IAM role used for replication between event buses.
	RoleArn *string `pulumi:"roleArn"`
	// Parameters used for routing, including the health check and secondary Region. Documented below.
	RoutingConfig *EventEndpointRoutingConfig `pulumi:"routingConfig"`
}

type EventEndpointState struct {
	// The ARN of the endpoint that was created.
	Arn pulumi.StringPtrInput
	// A description of the global endpoint.
	Description pulumi.StringPtrInput
	// The URL of the endpoint that was created.
	EndpointUrl pulumi.StringPtrInput
	// The event buses to use. The names of the event buses must be identical in each Region. Exactly two event buses are required. Documented below.
	EventBuses EventEndpointEventBusArrayInput
	// The name of the global endpoint.
	Name pulumi.StringPtrInput
	// Parameters used for replication. Documented below.
	ReplicationConfig EventEndpointReplicationConfigPtrInput
	// The ARN of the IAM role used for replication between event buses.
	RoleArn pulumi.StringPtrInput
	// Parameters used for routing, including the health check and secondary Region. Documented below.
	RoutingConfig EventEndpointRoutingConfigPtrInput
}

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

type eventEndpointArgs struct {
	// A description of the global endpoint.
	Description *string `pulumi:"description"`
	// The event buses to use. The names of the event buses must be identical in each Region. Exactly two event buses are required. Documented below.
	EventBuses []EventEndpointEventBus `pulumi:"eventBuses"`
	// The name of the global endpoint.
	Name *string `pulumi:"name"`
	// Parameters used for replication. Documented below.
	ReplicationConfig *EventEndpointReplicationConfig `pulumi:"replicationConfig"`
	// The ARN of the IAM role used for replication between event buses.
	RoleArn *string `pulumi:"roleArn"`
	// Parameters used for routing, including the health check and secondary Region. Documented below.
	RoutingConfig EventEndpointRoutingConfig `pulumi:"routingConfig"`
}

// The set of arguments for constructing a EventEndpoint resource.
type EventEndpointArgs struct {
	// A description of the global endpoint.
	Description pulumi.StringPtrInput
	// The event buses to use. The names of the event buses must be identical in each Region. Exactly two event buses are required. Documented below.
	EventBuses EventEndpointEventBusArrayInput
	// The name of the global endpoint.
	Name pulumi.StringPtrInput
	// Parameters used for replication. Documented below.
	ReplicationConfig EventEndpointReplicationConfigPtrInput
	// The ARN of the IAM role used for replication between event buses.
	RoleArn pulumi.StringPtrInput
	// Parameters used for routing, including the health check and secondary Region. Documented below.
	RoutingConfig EventEndpointRoutingConfigInput
}

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

type EventEndpointInput interface {
	pulumi.Input

	ToEventEndpointOutput() EventEndpointOutput
	ToEventEndpointOutputWithContext(ctx context.Context) EventEndpointOutput
}

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

func (i *EventEndpoint) ToEventEndpointOutput() EventEndpointOutput {
	return i.ToEventEndpointOutputWithContext(context.Background())
}

func (i *EventEndpoint) ToEventEndpointOutputWithContext(ctx context.Context) EventEndpointOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EventEndpointOutput)
}

// EventEndpointArrayInput is an input type that accepts EventEndpointArray and EventEndpointArrayOutput values.
// You can construct a concrete instance of `EventEndpointArrayInput` via:
//
//	EventEndpointArray{ EventEndpointArgs{...} }
type EventEndpointArrayInput interface {
	pulumi.Input

	ToEventEndpointArrayOutput() EventEndpointArrayOutput
	ToEventEndpointArrayOutputWithContext(context.Context) EventEndpointArrayOutput
}

type EventEndpointArray []EventEndpointInput

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

func (i EventEndpointArray) ToEventEndpointArrayOutput() EventEndpointArrayOutput {
	return i.ToEventEndpointArrayOutputWithContext(context.Background())
}

func (i EventEndpointArray) ToEventEndpointArrayOutputWithContext(ctx context.Context) EventEndpointArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EventEndpointArrayOutput)
}

// EventEndpointMapInput is an input type that accepts EventEndpointMap and EventEndpointMapOutput values.
// You can construct a concrete instance of `EventEndpointMapInput` via:
//
//	EventEndpointMap{ "key": EventEndpointArgs{...} }
type EventEndpointMapInput interface {
	pulumi.Input

	ToEventEndpointMapOutput() EventEndpointMapOutput
	ToEventEndpointMapOutputWithContext(context.Context) EventEndpointMapOutput
}

type EventEndpointMap map[string]EventEndpointInput

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

func (i EventEndpointMap) ToEventEndpointMapOutput() EventEndpointMapOutput {
	return i.ToEventEndpointMapOutputWithContext(context.Background())
}

func (i EventEndpointMap) ToEventEndpointMapOutputWithContext(ctx context.Context) EventEndpointMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EventEndpointMapOutput)
}

type EventEndpointOutput struct{ *pulumi.OutputState }

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

func (o EventEndpointOutput) ToEventEndpointOutput() EventEndpointOutput {
	return o
}

func (o EventEndpointOutput) ToEventEndpointOutputWithContext(ctx context.Context) EventEndpointOutput {
	return o
}

// The ARN of the endpoint that was created.
func (o EventEndpointOutput) Arn() pulumi.StringOutput {
	return o.ApplyT(func(v *EventEndpoint) pulumi.StringOutput { return v.Arn }).(pulumi.StringOutput)
}

// A description of the global endpoint.
func (o EventEndpointOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EventEndpoint) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput)
}

// The URL of the endpoint that was created.
func (o EventEndpointOutput) EndpointUrl() pulumi.StringOutput {
	return o.ApplyT(func(v *EventEndpoint) pulumi.StringOutput { return v.EndpointUrl }).(pulumi.StringOutput)
}

// The event buses to use. The names of the event buses must be identical in each Region. Exactly two event buses are required. Documented below.
func (o EventEndpointOutput) EventBuses() EventEndpointEventBusArrayOutput {
	return o.ApplyT(func(v *EventEndpoint) EventEndpointEventBusArrayOutput { return v.EventBuses }).(EventEndpointEventBusArrayOutput)
}

// The name of the global endpoint.
func (o EventEndpointOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v *EventEndpoint) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput)
}

// Parameters used for replication. Documented below.
func (o EventEndpointOutput) ReplicationConfig() EventEndpointReplicationConfigPtrOutput {
	return o.ApplyT(func(v *EventEndpoint) EventEndpointReplicationConfigPtrOutput { return v.ReplicationConfig }).(EventEndpointReplicationConfigPtrOutput)
}

// The ARN of the IAM role used for replication between event buses.
func (o EventEndpointOutput) RoleArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EventEndpoint) pulumi.StringPtrOutput { return v.RoleArn }).(pulumi.StringPtrOutput)
}

// Parameters used for routing, including the health check and secondary Region. Documented below.
func (o EventEndpointOutput) RoutingConfig() EventEndpointRoutingConfigOutput {
	return o.ApplyT(func(v *EventEndpoint) EventEndpointRoutingConfigOutput { return v.RoutingConfig }).(EventEndpointRoutingConfigOutput)
}

type EventEndpointArrayOutput struct{ *pulumi.OutputState }

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

func (o EventEndpointArrayOutput) ToEventEndpointArrayOutput() EventEndpointArrayOutput {
	return o
}

func (o EventEndpointArrayOutput) ToEventEndpointArrayOutputWithContext(ctx context.Context) EventEndpointArrayOutput {
	return o
}

func (o EventEndpointArrayOutput) Index(i pulumi.IntInput) EventEndpointOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EventEndpoint {
		return vs[0].([]*EventEndpoint)[vs[1].(int)]
	}).(EventEndpointOutput)
}

type EventEndpointMapOutput struct{ *pulumi.OutputState }

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

func (o EventEndpointMapOutput) ToEventEndpointMapOutput() EventEndpointMapOutput {
	return o
}

func (o EventEndpointMapOutput) ToEventEndpointMapOutputWithContext(ctx context.Context) EventEndpointMapOutput {
	return o
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*EventEndpointInput)(nil)).Elem(), &EventEndpoint{})
	pulumi.RegisterInputType(reflect.TypeOf((*EventEndpointArrayInput)(nil)).Elem(), EventEndpointArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*EventEndpointMapInput)(nil)).Elem(), EventEndpointMap{})
	pulumi.RegisterOutputType(EventEndpointOutput{})
	pulumi.RegisterOutputType(EventEndpointArrayOutput{})
	pulumi.RegisterOutputType(EventEndpointMapOutput{})
}