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

import (
	"context"
	"reflect"

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

// Manages an AWS Opensearch Outbound Connection.
//
// ## Example Usage
//
// ### Basic Usage
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws"
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/opensearch"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			current, err := aws.GetCallerIdentity(ctx, nil, nil)
//			if err != nil {
//				return err
//			}
//			currentGetRegion, err := aws.GetRegion(ctx, nil, nil)
//			if err != nil {
//				return err
//			}
//			_, err = opensearch.NewOutboundConnection(ctx, "foo", &opensearch.OutboundConnectionArgs{
//				ConnectionAlias: pulumi.String("outbound_connection"),
//				ConnectionMode:  pulumi.String("DIRECT"),
//				LocalDomainInfo: &opensearch.OutboundConnectionLocalDomainInfoArgs{
//					OwnerId:    pulumi.String(current.AccountId),
//					Region:     pulumi.String(currentGetRegion.Name),
//					DomainName: pulumi.Any(localDomain.DomainName),
//				},
//				RemoteDomainInfo: &opensearch.OutboundConnectionRemoteDomainInfoArgs{
//					OwnerId:    pulumi.String(current.AccountId),
//					Region:     pulumi.String(currentGetRegion.Name),
//					DomainName: pulumi.Any(remoteDomain.DomainName),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Import
//
// Using `pulumi import`, import AWS Opensearch Outbound Connections using the Outbound Connection ID. For example:
//
// ```sh
// $ pulumi import aws:opensearch/outboundConnection:OutboundConnection foo connection-id
// ```
type OutboundConnection struct {
	pulumi.CustomResourceState

	// Accepts the connection.
	AcceptConnection pulumi.BoolPtrOutput `pulumi:"acceptConnection"`
	// Specifies the connection alias that will be used by the customer for this connection.
	ConnectionAlias pulumi.StringOutput `pulumi:"connectionAlias"`
	// Specifies the connection mode. Accepted values are `DIRECT` or `VPC_ENDPOINT`.
	ConnectionMode pulumi.StringPtrOutput `pulumi:"connectionMode"`
	// Configuration block for the outbound connection.
	ConnectionProperties OutboundConnectionConnectionPropertiesOutput `pulumi:"connectionProperties"`
	// Status of the connection request.
	ConnectionStatus pulumi.StringOutput `pulumi:"connectionStatus"`
	// Configuration block for the local Opensearch domain.
	LocalDomainInfo OutboundConnectionLocalDomainInfoOutput `pulumi:"localDomainInfo"`
	// Configuration block for the remote Opensearch domain.
	RemoteDomainInfo OutboundConnectionRemoteDomainInfoOutput `pulumi:"remoteDomainInfo"`
}

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

	if args.ConnectionAlias == nil {
		return nil, errors.New("invalid value for required argument 'ConnectionAlias'")
	}
	if args.LocalDomainInfo == nil {
		return nil, errors.New("invalid value for required argument 'LocalDomainInfo'")
	}
	if args.RemoteDomainInfo == nil {
		return nil, errors.New("invalid value for required argument 'RemoteDomainInfo'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource OutboundConnection
	err := ctx.RegisterResource("aws:opensearch/outboundConnection:OutboundConnection", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

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

// Input properties used for looking up and filtering OutboundConnection resources.
type outboundConnectionState struct {
	// Accepts the connection.
	AcceptConnection *bool `pulumi:"acceptConnection"`
	// Specifies the connection alias that will be used by the customer for this connection.
	ConnectionAlias *string `pulumi:"connectionAlias"`
	// Specifies the connection mode. Accepted values are `DIRECT` or `VPC_ENDPOINT`.
	ConnectionMode *string `pulumi:"connectionMode"`
	// Configuration block for the outbound connection.
	ConnectionProperties *OutboundConnectionConnectionProperties `pulumi:"connectionProperties"`
	// Status of the connection request.
	ConnectionStatus *string `pulumi:"connectionStatus"`
	// Configuration block for the local Opensearch domain.
	LocalDomainInfo *OutboundConnectionLocalDomainInfo `pulumi:"localDomainInfo"`
	// Configuration block for the remote Opensearch domain.
	RemoteDomainInfo *OutboundConnectionRemoteDomainInfo `pulumi:"remoteDomainInfo"`
}

type OutboundConnectionState struct {
	// Accepts the connection.
	AcceptConnection pulumi.BoolPtrInput
	// Specifies the connection alias that will be used by the customer for this connection.
	ConnectionAlias pulumi.StringPtrInput
	// Specifies the connection mode. Accepted values are `DIRECT` or `VPC_ENDPOINT`.
	ConnectionMode pulumi.StringPtrInput
	// Configuration block for the outbound connection.
	ConnectionProperties OutboundConnectionConnectionPropertiesPtrInput
	// Status of the connection request.
	ConnectionStatus pulumi.StringPtrInput
	// Configuration block for the local Opensearch domain.
	LocalDomainInfo OutboundConnectionLocalDomainInfoPtrInput
	// Configuration block for the remote Opensearch domain.
	RemoteDomainInfo OutboundConnectionRemoteDomainInfoPtrInput
}

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

type outboundConnectionArgs struct {
	// Accepts the connection.
	AcceptConnection *bool `pulumi:"acceptConnection"`
	// Specifies the connection alias that will be used by the customer for this connection.
	ConnectionAlias string `pulumi:"connectionAlias"`
	// Specifies the connection mode. Accepted values are `DIRECT` or `VPC_ENDPOINT`.
	ConnectionMode *string `pulumi:"connectionMode"`
	// Configuration block for the outbound connection.
	ConnectionProperties *OutboundConnectionConnectionProperties `pulumi:"connectionProperties"`
	// Configuration block for the local Opensearch domain.
	LocalDomainInfo OutboundConnectionLocalDomainInfo `pulumi:"localDomainInfo"`
	// Configuration block for the remote Opensearch domain.
	RemoteDomainInfo OutboundConnectionRemoteDomainInfo `pulumi:"remoteDomainInfo"`
}

// The set of arguments for constructing a OutboundConnection resource.
type OutboundConnectionArgs struct {
	// Accepts the connection.
	AcceptConnection pulumi.BoolPtrInput
	// Specifies the connection alias that will be used by the customer for this connection.
	ConnectionAlias pulumi.StringInput
	// Specifies the connection mode. Accepted values are `DIRECT` or `VPC_ENDPOINT`.
	ConnectionMode pulumi.StringPtrInput
	// Configuration block for the outbound connection.
	ConnectionProperties OutboundConnectionConnectionPropertiesPtrInput
	// Configuration block for the local Opensearch domain.
	LocalDomainInfo OutboundConnectionLocalDomainInfoInput
	// Configuration block for the remote Opensearch domain.
	RemoteDomainInfo OutboundConnectionRemoteDomainInfoInput
}

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

type OutboundConnectionInput interface {
	pulumi.Input

	ToOutboundConnectionOutput() OutboundConnectionOutput
	ToOutboundConnectionOutputWithContext(ctx context.Context) OutboundConnectionOutput
}

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

func (i *OutboundConnection) ToOutboundConnectionOutput() OutboundConnectionOutput {
	return i.ToOutboundConnectionOutputWithContext(context.Background())
}

func (i *OutboundConnection) ToOutboundConnectionOutputWithContext(ctx context.Context) OutboundConnectionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OutboundConnectionOutput)
}

// OutboundConnectionArrayInput is an input type that accepts OutboundConnectionArray and OutboundConnectionArrayOutput values.
// You can construct a concrete instance of `OutboundConnectionArrayInput` via:
//
//	OutboundConnectionArray{ OutboundConnectionArgs{...} }
type OutboundConnectionArrayInput interface {
	pulumi.Input

	ToOutboundConnectionArrayOutput() OutboundConnectionArrayOutput
	ToOutboundConnectionArrayOutputWithContext(context.Context) OutboundConnectionArrayOutput
}

type OutboundConnectionArray []OutboundConnectionInput

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

func (i OutboundConnectionArray) ToOutboundConnectionArrayOutput() OutboundConnectionArrayOutput {
	return i.ToOutboundConnectionArrayOutputWithContext(context.Background())
}

func (i OutboundConnectionArray) ToOutboundConnectionArrayOutputWithContext(ctx context.Context) OutboundConnectionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OutboundConnectionArrayOutput)
}

// OutboundConnectionMapInput is an input type that accepts OutboundConnectionMap and OutboundConnectionMapOutput values.
// You can construct a concrete instance of `OutboundConnectionMapInput` via:
//
//	OutboundConnectionMap{ "key": OutboundConnectionArgs{...} }
type OutboundConnectionMapInput interface {
	pulumi.Input

	ToOutboundConnectionMapOutput() OutboundConnectionMapOutput
	ToOutboundConnectionMapOutputWithContext(context.Context) OutboundConnectionMapOutput
}

type OutboundConnectionMap map[string]OutboundConnectionInput

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

func (i OutboundConnectionMap) ToOutboundConnectionMapOutput() OutboundConnectionMapOutput {
	return i.ToOutboundConnectionMapOutputWithContext(context.Background())
}

func (i OutboundConnectionMap) ToOutboundConnectionMapOutputWithContext(ctx context.Context) OutboundConnectionMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OutboundConnectionMapOutput)
}

type OutboundConnectionOutput struct{ *pulumi.OutputState }

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

func (o OutboundConnectionOutput) ToOutboundConnectionOutput() OutboundConnectionOutput {
	return o
}

func (o OutboundConnectionOutput) ToOutboundConnectionOutputWithContext(ctx context.Context) OutboundConnectionOutput {
	return o
}

// Accepts the connection.
func (o OutboundConnectionOutput) AcceptConnection() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *OutboundConnection) pulumi.BoolPtrOutput { return v.AcceptConnection }).(pulumi.BoolPtrOutput)
}

// Specifies the connection alias that will be used by the customer for this connection.
func (o OutboundConnectionOutput) ConnectionAlias() pulumi.StringOutput {
	return o.ApplyT(func(v *OutboundConnection) pulumi.StringOutput { return v.ConnectionAlias }).(pulumi.StringOutput)
}

// Specifies the connection mode. Accepted values are `DIRECT` or `VPC_ENDPOINT`.
func (o OutboundConnectionOutput) ConnectionMode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *OutboundConnection) pulumi.StringPtrOutput { return v.ConnectionMode }).(pulumi.StringPtrOutput)
}

// Configuration block for the outbound connection.
func (o OutboundConnectionOutput) ConnectionProperties() OutboundConnectionConnectionPropertiesOutput {
	return o.ApplyT(func(v *OutboundConnection) OutboundConnectionConnectionPropertiesOutput {
		return v.ConnectionProperties
	}).(OutboundConnectionConnectionPropertiesOutput)
}

// Status of the connection request.
func (o OutboundConnectionOutput) ConnectionStatus() pulumi.StringOutput {
	return o.ApplyT(func(v *OutboundConnection) pulumi.StringOutput { return v.ConnectionStatus }).(pulumi.StringOutput)
}

// Configuration block for the local Opensearch domain.
func (o OutboundConnectionOutput) LocalDomainInfo() OutboundConnectionLocalDomainInfoOutput {
	return o.ApplyT(func(v *OutboundConnection) OutboundConnectionLocalDomainInfoOutput { return v.LocalDomainInfo }).(OutboundConnectionLocalDomainInfoOutput)
}

// Configuration block for the remote Opensearch domain.
func (o OutboundConnectionOutput) RemoteDomainInfo() OutboundConnectionRemoteDomainInfoOutput {
	return o.ApplyT(func(v *OutboundConnection) OutboundConnectionRemoteDomainInfoOutput { return v.RemoteDomainInfo }).(OutboundConnectionRemoteDomainInfoOutput)
}

type OutboundConnectionArrayOutput struct{ *pulumi.OutputState }

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

func (o OutboundConnectionArrayOutput) ToOutboundConnectionArrayOutput() OutboundConnectionArrayOutput {
	return o
}

func (o OutboundConnectionArrayOutput) ToOutboundConnectionArrayOutputWithContext(ctx context.Context) OutboundConnectionArrayOutput {
	return o
}

func (o OutboundConnectionArrayOutput) Index(i pulumi.IntInput) OutboundConnectionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OutboundConnection {
		return vs[0].([]*OutboundConnection)[vs[1].(int)]
	}).(OutboundConnectionOutput)
}

type OutboundConnectionMapOutput struct{ *pulumi.OutputState }

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

func (o OutboundConnectionMapOutput) ToOutboundConnectionMapOutput() OutboundConnectionMapOutput {
	return o
}

func (o OutboundConnectionMapOutput) ToOutboundConnectionMapOutputWithContext(ctx context.Context) OutboundConnectionMapOutput {
	return o
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*OutboundConnectionInput)(nil)).Elem(), &OutboundConnection{})
	pulumi.RegisterInputType(reflect.TypeOf((*OutboundConnectionArrayInput)(nil)).Elem(), OutboundConnectionArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*OutboundConnectionMapInput)(nil)).Elem(), OutboundConnectionMap{})
	pulumi.RegisterOutputType(OutboundConnectionOutput{})
	pulumi.RegisterOutputType(OutboundConnectionArrayOutput{})
	pulumi.RegisterOutputType(OutboundConnectionMapOutput{})
}