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

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 a VPC peering connection.
//
// > **NOTE on VPC Peering Connections and VPC Peering Connection Options:** This provider provides
// both a standalone VPC Peering Connection Options and a VPC Peering Connection
// resource with `accepter` and `requester` attributes. Do not manage options for the same VPC peering
// connection in both a VPC Peering Connection resource and a VPC Peering Connection Options resource.
// Doing so will cause a conflict of options and will overwrite the options.
// Using a VPC Peering Connection Options resource decouples management of the connection options from
// management of the VPC Peering Connection and allows options to be set correctly in cross-account scenarios.
//
// > **Note:** For cross-account (requester's AWS account differs from the accepter's AWS account) or inter-region
// VPC Peering Connections use the `ec2.VpcPeeringConnection` resource to manage the requester's side of the
// connection and use the `ec2.VpcPeeringConnectionAccepter` resource to manage the accepter's side of the connection.
//
// > **Note:** Creating multiple `ec2.VpcPeeringConnection` resources with the same `peerVpcId` and `vpcId` will not produce an error. Instead, AWS will return the connection `id` that already exists, resulting in multiple `ec2.VpcPeeringConnection` resources with the same `id`.
//
// ## Example Usage
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := ec2.NewVpcPeeringConnection(ctx, "foo", &ec2.VpcPeeringConnectionArgs{
//				PeerOwnerId: pulumi.Any(peerOwnerId),
//				PeerVpcId:   pulumi.Any(bar.Id),
//				VpcId:       pulumi.Any(fooAwsVpc.Id),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// Basic usage with connection options:
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := ec2.NewVpcPeeringConnection(ctx, "foo", &ec2.VpcPeeringConnectionArgs{
//				PeerOwnerId: pulumi.Any(peerOwnerId),
//				PeerVpcId:   pulumi.Any(bar.Id),
//				VpcId:       pulumi.Any(fooAwsVpc.Id),
//				Accepter: &ec2.VpcPeeringConnectionAccepterTypeArgs{
//					AllowRemoteVpcDnsResolution: pulumi.Bool(true),
//				},
//				Requester: &ec2.VpcPeeringConnectionRequesterArgs{
//					AllowRemoteVpcDnsResolution: pulumi.Bool(true),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// Basic usage with tags:
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			fooVpc, err := ec2.NewVpc(ctx, "foo", &ec2.VpcArgs{
//				CidrBlock: pulumi.String("10.1.0.0/16"),
//			})
//			if err != nil {
//				return err
//			}
//			bar, err := ec2.NewVpc(ctx, "bar", &ec2.VpcArgs{
//				CidrBlock: pulumi.String("10.2.0.0/16"),
//			})
//			if err != nil {
//				return err
//			}
//			_, err = ec2.NewVpcPeeringConnection(ctx, "foo", &ec2.VpcPeeringConnectionArgs{
//				PeerOwnerId: pulumi.Any(peerOwnerId),
//				PeerVpcId:   bar.ID(),
//				VpcId:       fooVpc.ID(),
//				AutoAccept:  pulumi.Bool(true),
//				Tags: pulumi.StringMap{
//					"Name": pulumi.String("VPC Peering between foo and bar"),
//				},
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// Basic usage with region:
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			fooVpc, err := ec2.NewVpc(ctx, "foo", &ec2.VpcArgs{
//				CidrBlock: pulumi.String("10.1.0.0/16"),
//			})
//			if err != nil {
//				return err
//			}
//			bar, err := ec2.NewVpc(ctx, "bar", &ec2.VpcArgs{
//				CidrBlock: pulumi.String("10.2.0.0/16"),
//			})
//			if err != nil {
//				return err
//			}
//			_, err = ec2.NewVpcPeeringConnection(ctx, "foo", &ec2.VpcPeeringConnectionArgs{
//				PeerOwnerId: pulumi.Any(peerOwnerId),
//				PeerVpcId:   bar.ID(),
//				VpcId:       fooVpc.ID(),
//				PeerRegion:  pulumi.String("us-east-1"),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Notes
//
// If both VPCs are not in the same AWS account and region do not enable the `autoAccept` attribute.
// The accepter can manage its side of the connection using the `ec2.VpcPeeringConnectionAccepter` resource
// or accept the connection manually using the AWS Management Console, AWS CLI, through SDKs, etc.
//
// ## Import
//
// Using `pulumi import`, import VPC Peering resources using the VPC peering `id`. For example:
//
// ```sh
// $ pulumi import aws:ec2/vpcPeeringConnection:VpcPeeringConnection test_connection pcx-111aaa111
// ```
type VpcPeeringConnection struct {
	pulumi.CustomResourceState

	// The status of the VPC Peering Connection request.
	AcceptStatus pulumi.StringOutput `pulumi:"acceptStatus"`
	// An optional configuration block that allows for [VPC Peering Connection](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) options to be set for the VPC that accepts
	// the peering connection (a maximum of one).
	Accepter VpcPeeringConnectionAccepterTypeOutput `pulumi:"accepter"`
	// Accept the peering (both VPCs need to be in the same AWS account and region).
	AutoAccept pulumi.BoolPtrOutput `pulumi:"autoAccept"`
	// The AWS account ID of the target peer VPC.
	// Defaults to the account ID the [AWS provider][1] is currently connected to, so must be managed if connecting cross-account.
	PeerOwnerId pulumi.StringOutput `pulumi:"peerOwnerId"`
	// The region of the accepter VPC of the VPC Peering Connection. `autoAccept` must be `false`,
	// and use the `ec2.VpcPeeringConnectionAccepter` to manage the accepter side.
	PeerRegion pulumi.StringOutput `pulumi:"peerRegion"`
	// The ID of the target VPC with which you are creating the VPC Peering Connection.
	PeerVpcId pulumi.StringOutput `pulumi:"peerVpcId"`
	// A optional configuration block that allows for [VPC Peering Connection](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) options to be set for the VPC that requests
	// the peering connection (a maximum of one).
	Requester VpcPeeringConnectionRequesterOutput `pulumi:"requester"`
	// A map of tags to assign to the resource. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	//
	// Deprecated: Please use `tags` instead.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// The ID of the requester VPC.
	VpcId pulumi.StringOutput `pulumi:"vpcId"`
}

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

	if args.PeerVpcId == nil {
		return nil, errors.New("invalid value for required argument 'PeerVpcId'")
	}
	if args.VpcId == nil {
		return nil, errors.New("invalid value for required argument 'VpcId'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource VpcPeeringConnection
	err := ctx.RegisterResource("aws:ec2/vpcPeeringConnection:VpcPeeringConnection", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

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

// Input properties used for looking up and filtering VpcPeeringConnection resources.
type vpcPeeringConnectionState struct {
	// The status of the VPC Peering Connection request.
	AcceptStatus *string `pulumi:"acceptStatus"`
	// An optional configuration block that allows for [VPC Peering Connection](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) options to be set for the VPC that accepts
	// the peering connection (a maximum of one).
	Accepter *VpcPeeringConnectionAccepterType `pulumi:"accepter"`
	// Accept the peering (both VPCs need to be in the same AWS account and region).
	AutoAccept *bool `pulumi:"autoAccept"`
	// The AWS account ID of the target peer VPC.
	// Defaults to the account ID the [AWS provider][1] is currently connected to, so must be managed if connecting cross-account.
	PeerOwnerId *string `pulumi:"peerOwnerId"`
	// The region of the accepter VPC of the VPC Peering Connection. `autoAccept` must be `false`,
	// and use the `ec2.VpcPeeringConnectionAccepter` to manage the accepter side.
	PeerRegion *string `pulumi:"peerRegion"`
	// The ID of the target VPC with which you are creating the VPC Peering Connection.
	PeerVpcId *string `pulumi:"peerVpcId"`
	// A optional configuration block that allows for [VPC Peering Connection](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) options to be set for the VPC that requests
	// the peering connection (a maximum of one).
	Requester *VpcPeeringConnectionRequester `pulumi:"requester"`
	// A map of tags to assign to the resource. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags map[string]string `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	//
	// Deprecated: Please use `tags` instead.
	TagsAll map[string]string `pulumi:"tagsAll"`
	// The ID of the requester VPC.
	VpcId *string `pulumi:"vpcId"`
}

type VpcPeeringConnectionState struct {
	// The status of the VPC Peering Connection request.
	AcceptStatus pulumi.StringPtrInput
	// An optional configuration block that allows for [VPC Peering Connection](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) options to be set for the VPC that accepts
	// the peering connection (a maximum of one).
	Accepter VpcPeeringConnectionAccepterTypePtrInput
	// Accept the peering (both VPCs need to be in the same AWS account and region).
	AutoAccept pulumi.BoolPtrInput
	// The AWS account ID of the target peer VPC.
	// Defaults to the account ID the [AWS provider][1] is currently connected to, so must be managed if connecting cross-account.
	PeerOwnerId pulumi.StringPtrInput
	// The region of the accepter VPC of the VPC Peering Connection. `autoAccept` must be `false`,
	// and use the `ec2.VpcPeeringConnectionAccepter` to manage the accepter side.
	PeerRegion pulumi.StringPtrInput
	// The ID of the target VPC with which you are creating the VPC Peering Connection.
	PeerVpcId pulumi.StringPtrInput
	// A optional configuration block that allows for [VPC Peering Connection](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) options to be set for the VPC that requests
	// the peering connection (a maximum of one).
	Requester VpcPeeringConnectionRequesterPtrInput
	// A map of tags to assign to the resource. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
	//
	// Deprecated: Please use `tags` instead.
	TagsAll pulumi.StringMapInput
	// The ID of the requester VPC.
	VpcId pulumi.StringPtrInput
}

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

type vpcPeeringConnectionArgs struct {
	// An optional configuration block that allows for [VPC Peering Connection](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) options to be set for the VPC that accepts
	// the peering connection (a maximum of one).
	Accepter *VpcPeeringConnectionAccepterType `pulumi:"accepter"`
	// Accept the peering (both VPCs need to be in the same AWS account and region).
	AutoAccept *bool `pulumi:"autoAccept"`
	// The AWS account ID of the target peer VPC.
	// Defaults to the account ID the [AWS provider][1] is currently connected to, so must be managed if connecting cross-account.
	PeerOwnerId *string `pulumi:"peerOwnerId"`
	// The region of the accepter VPC of the VPC Peering Connection. `autoAccept` must be `false`,
	// and use the `ec2.VpcPeeringConnectionAccepter` to manage the accepter side.
	PeerRegion *string `pulumi:"peerRegion"`
	// The ID of the target VPC with which you are creating the VPC Peering Connection.
	PeerVpcId string `pulumi:"peerVpcId"`
	// A optional configuration block that allows for [VPC Peering Connection](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) options to be set for the VPC that requests
	// the peering connection (a maximum of one).
	Requester *VpcPeeringConnectionRequester `pulumi:"requester"`
	// A map of tags to assign to the resource. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags map[string]string `pulumi:"tags"`
	// The ID of the requester VPC.
	VpcId string `pulumi:"vpcId"`
}

// The set of arguments for constructing a VpcPeeringConnection resource.
type VpcPeeringConnectionArgs struct {
	// An optional configuration block that allows for [VPC Peering Connection](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) options to be set for the VPC that accepts
	// the peering connection (a maximum of one).
	Accepter VpcPeeringConnectionAccepterTypePtrInput
	// Accept the peering (both VPCs need to be in the same AWS account and region).
	AutoAccept pulumi.BoolPtrInput
	// The AWS account ID of the target peer VPC.
	// Defaults to the account ID the [AWS provider][1] is currently connected to, so must be managed if connecting cross-account.
	PeerOwnerId pulumi.StringPtrInput
	// The region of the accepter VPC of the VPC Peering Connection. `autoAccept` must be `false`,
	// and use the `ec2.VpcPeeringConnectionAccepter` to manage the accepter side.
	PeerRegion pulumi.StringPtrInput
	// The ID of the target VPC with which you are creating the VPC Peering Connection.
	PeerVpcId pulumi.StringInput
	// A optional configuration block that allows for [VPC Peering Connection](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) options to be set for the VPC that requests
	// the peering connection (a maximum of one).
	Requester VpcPeeringConnectionRequesterPtrInput
	// A map of tags to assign to the resource. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// The ID of the requester VPC.
	VpcId pulumi.StringInput
}

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

type VpcPeeringConnectionInput interface {
	pulumi.Input

	ToVpcPeeringConnectionOutput() VpcPeeringConnectionOutput
	ToVpcPeeringConnectionOutputWithContext(ctx context.Context) VpcPeeringConnectionOutput
}

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

func (i *VpcPeeringConnection) ToVpcPeeringConnectionOutput() VpcPeeringConnectionOutput {
	return i.ToVpcPeeringConnectionOutputWithContext(context.Background())
}

func (i *VpcPeeringConnection) ToVpcPeeringConnectionOutputWithContext(ctx context.Context) VpcPeeringConnectionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(VpcPeeringConnectionOutput)
}

// VpcPeeringConnectionArrayInput is an input type that accepts VpcPeeringConnectionArray and VpcPeeringConnectionArrayOutput values.
// You can construct a concrete instance of `VpcPeeringConnectionArrayInput` via:
//
//	VpcPeeringConnectionArray{ VpcPeeringConnectionArgs{...} }
type VpcPeeringConnectionArrayInput interface {
	pulumi.Input

	ToVpcPeeringConnectionArrayOutput() VpcPeeringConnectionArrayOutput
	ToVpcPeeringConnectionArrayOutputWithContext(context.Context) VpcPeeringConnectionArrayOutput
}

type VpcPeeringConnectionArray []VpcPeeringConnectionInput

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

func (i VpcPeeringConnectionArray) ToVpcPeeringConnectionArrayOutput() VpcPeeringConnectionArrayOutput {
	return i.ToVpcPeeringConnectionArrayOutputWithContext(context.Background())
}

func (i VpcPeeringConnectionArray) ToVpcPeeringConnectionArrayOutputWithContext(ctx context.Context) VpcPeeringConnectionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(VpcPeeringConnectionArrayOutput)
}

// VpcPeeringConnectionMapInput is an input type that accepts VpcPeeringConnectionMap and VpcPeeringConnectionMapOutput values.
// You can construct a concrete instance of `VpcPeeringConnectionMapInput` via:
//
//	VpcPeeringConnectionMap{ "key": VpcPeeringConnectionArgs{...} }
type VpcPeeringConnectionMapInput interface {
	pulumi.Input

	ToVpcPeeringConnectionMapOutput() VpcPeeringConnectionMapOutput
	ToVpcPeeringConnectionMapOutputWithContext(context.Context) VpcPeeringConnectionMapOutput
}

type VpcPeeringConnectionMap map[string]VpcPeeringConnectionInput

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

func (i VpcPeeringConnectionMap) ToVpcPeeringConnectionMapOutput() VpcPeeringConnectionMapOutput {
	return i.ToVpcPeeringConnectionMapOutputWithContext(context.Background())
}

func (i VpcPeeringConnectionMap) ToVpcPeeringConnectionMapOutputWithContext(ctx context.Context) VpcPeeringConnectionMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(VpcPeeringConnectionMapOutput)
}

type VpcPeeringConnectionOutput struct{ *pulumi.OutputState }

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

func (o VpcPeeringConnectionOutput) ToVpcPeeringConnectionOutput() VpcPeeringConnectionOutput {
	return o
}

func (o VpcPeeringConnectionOutput) ToVpcPeeringConnectionOutputWithContext(ctx context.Context) VpcPeeringConnectionOutput {
	return o
}

// The status of the VPC Peering Connection request.
func (o VpcPeeringConnectionOutput) AcceptStatus() pulumi.StringOutput {
	return o.ApplyT(func(v *VpcPeeringConnection) pulumi.StringOutput { return v.AcceptStatus }).(pulumi.StringOutput)
}

// An optional configuration block that allows for [VPC Peering Connection](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) options to be set for the VPC that accepts
// the peering connection (a maximum of one).
func (o VpcPeeringConnectionOutput) Accepter() VpcPeeringConnectionAccepterTypeOutput {
	return o.ApplyT(func(v *VpcPeeringConnection) VpcPeeringConnectionAccepterTypeOutput { return v.Accepter }).(VpcPeeringConnectionAccepterTypeOutput)
}

// Accept the peering (both VPCs need to be in the same AWS account and region).
func (o VpcPeeringConnectionOutput) AutoAccept() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *VpcPeeringConnection) pulumi.BoolPtrOutput { return v.AutoAccept }).(pulumi.BoolPtrOutput)
}

// The AWS account ID of the target peer VPC.
// Defaults to the account ID the [AWS provider][1] is currently connected to, so must be managed if connecting cross-account.
func (o VpcPeeringConnectionOutput) PeerOwnerId() pulumi.StringOutput {
	return o.ApplyT(func(v *VpcPeeringConnection) pulumi.StringOutput { return v.PeerOwnerId }).(pulumi.StringOutput)
}

// The region of the accepter VPC of the VPC Peering Connection. `autoAccept` must be `false`,
// and use the `ec2.VpcPeeringConnectionAccepter` to manage the accepter side.
func (o VpcPeeringConnectionOutput) PeerRegion() pulumi.StringOutput {
	return o.ApplyT(func(v *VpcPeeringConnection) pulumi.StringOutput { return v.PeerRegion }).(pulumi.StringOutput)
}

// The ID of the target VPC with which you are creating the VPC Peering Connection.
func (o VpcPeeringConnectionOutput) PeerVpcId() pulumi.StringOutput {
	return o.ApplyT(func(v *VpcPeeringConnection) pulumi.StringOutput { return v.PeerVpcId }).(pulumi.StringOutput)
}

// A optional configuration block that allows for [VPC Peering Connection](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) options to be set for the VPC that requests
// the peering connection (a maximum of one).
func (o VpcPeeringConnectionOutput) Requester() VpcPeeringConnectionRequesterOutput {
	return o.ApplyT(func(v *VpcPeeringConnection) VpcPeeringConnectionRequesterOutput { return v.Requester }).(VpcPeeringConnectionRequesterOutput)
}

// A map of tags to assign to the resource. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
func (o VpcPeeringConnectionOutput) Tags() pulumi.StringMapOutput {
	return o.ApplyT(func(v *VpcPeeringConnection) pulumi.StringMapOutput { return v.Tags }).(pulumi.StringMapOutput)
}

// A map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.
//
// Deprecated: Please use `tags` instead.
func (o VpcPeeringConnectionOutput) TagsAll() pulumi.StringMapOutput {
	return o.ApplyT(func(v *VpcPeeringConnection) pulumi.StringMapOutput { return v.TagsAll }).(pulumi.StringMapOutput)
}

// The ID of the requester VPC.
func (o VpcPeeringConnectionOutput) VpcId() pulumi.StringOutput {
	return o.ApplyT(func(v *VpcPeeringConnection) pulumi.StringOutput { return v.VpcId }).(pulumi.StringOutput)
}

type VpcPeeringConnectionArrayOutput struct{ *pulumi.OutputState }

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

func (o VpcPeeringConnectionArrayOutput) ToVpcPeeringConnectionArrayOutput() VpcPeeringConnectionArrayOutput {
	return o
}

func (o VpcPeeringConnectionArrayOutput) ToVpcPeeringConnectionArrayOutputWithContext(ctx context.Context) VpcPeeringConnectionArrayOutput {
	return o
}

func (o VpcPeeringConnectionArrayOutput) Index(i pulumi.IntInput) VpcPeeringConnectionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *VpcPeeringConnection {
		return vs[0].([]*VpcPeeringConnection)[vs[1].(int)]
	}).(VpcPeeringConnectionOutput)
}

type VpcPeeringConnectionMapOutput struct{ *pulumi.OutputState }

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

func (o VpcPeeringConnectionMapOutput) ToVpcPeeringConnectionMapOutput() VpcPeeringConnectionMapOutput {
	return o
}

func (o VpcPeeringConnectionMapOutput) ToVpcPeeringConnectionMapOutputWithContext(ctx context.Context) VpcPeeringConnectionMapOutput {
	return o
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*VpcPeeringConnectionInput)(nil)).Elem(), &VpcPeeringConnection{})
	pulumi.RegisterInputType(reflect.TypeOf((*VpcPeeringConnectionArrayInput)(nil)).Elem(), VpcPeeringConnectionArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*VpcPeeringConnectionMapInput)(nil)).Elem(), VpcPeeringConnectionMap{})
	pulumi.RegisterOutputType(VpcPeeringConnectionOutput{})
	pulumi.RegisterOutputType(VpcPeeringConnectionArrayOutput{})
	pulumi.RegisterOutputType(VpcPeeringConnectionMapOutput{})
}