using System.Collections.Generic;
using Pulumi;
using Aws = Pulumi.Aws;
using Hcp = Pulumi.Hcp;

return await Deployment.RunAsync(() => 
{
    var main = new Hcp.Hvn("main", new()
    {
        HvnId = "main-hvn",
        CloudProvider = "aws",
        Region = "us-west-2",
        CidrBlock = "172.25.16.0/20",
    });

    var exampleVpc = new Aws.Ec2.Vpc("exampleVpc", new()
    {
        CidrBlock = "172.31.0.0/16",
    });

    var exampleTransitGateway = new Aws.Ec2TransitGateway.TransitGateway("exampleTransitGateway", new()
    {
        Tags = 
        {
            { "Name", "example-tgw" },
        },
    });

    var exampleResourceShare = new Aws.Ram.ResourceShare("exampleResourceShare", new()
    {
        AllowExternalPrincipals = true,
    });

    var examplePrincipalAssociation = new Aws.Ram.PrincipalAssociation("examplePrincipalAssociation", new()
    {
        ResourceShareArn = exampleResourceShare.Arn,
        Principal = main.ProviderAccountId,
    });

    var exampleResourceAssociation = new Aws.Ram.ResourceAssociation("exampleResourceAssociation", new()
    {
        ResourceShareArn = exampleResourceShare.Arn,
        ResourceArn = exampleTransitGateway.Arn,
    });

    var exampleAwsTransitGatewayAttachment = new Hcp.AwsTransitGatewayAttachment("exampleAwsTransitGatewayAttachment", new()
    {
        HvnId = main.HvnId,
        TransitGatewayAttachmentId = "example-tgw-attachment",
        TransitGatewayId = exampleTransitGateway.Id,
        ResourceShareArn = exampleResourceShare.Arn,
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            examplePrincipalAssociation,
            exampleResourceAssociation,
        },
    });

    var route = new Hcp.HvnRoute("route", new()
    {
        HvnLink = main.SelfLink,
        HvnRouteId = "hvn-to-tgw-attachment",
        DestinationCidr = exampleVpc.CidrBlock,
        TargetLink = exampleAwsTransitGatewayAttachment.SelfLink,
    });

    var exampleVpcAttachmentAccepter = new Aws.Ec2TransitGateway.VpcAttachmentAccepter("exampleVpcAttachmentAccepter", new()
    {
        TransitGatewayAttachmentId = exampleAwsTransitGatewayAttachment.ProviderTransitGatewayAttachmentId,
    });

});

package main

import (
	"github.com/grapl-security/pulumi-hcp/sdk/go/hcp"
	"github.com/pulumi/pulumi-aws/sdk/v5/go/aws/ec2"
	"github.com/pulumi/pulumi-aws/sdk/v5/go/aws/ec2transitgateway"
	"github.com/pulumi/pulumi-aws/sdk/v5/go/aws/ram"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		main, err := hcp.NewHvn(ctx, "main", &hcp.HvnArgs{
			HvnId:         pulumi.String("main-hvn"),
			CloudProvider: pulumi.String("aws"),
			Region:        pulumi.String("us-west-2"),
			CidrBlock:     pulumi.String("172.25.16.0/20"),
		})
		if err != nil {
			return err
		}
		exampleVpc, err := ec2.NewVpc(ctx, "exampleVpc", &ec2.VpcArgs{
			CidrBlock: pulumi.String("172.31.0.0/16"),
		})
		if err != nil {
			return err
		}
		exampleTransitGateway, err := ec2transitgateway.NewTransitGateway(ctx, "exampleTransitGateway", &ec2transitgateway.TransitGatewayArgs{
			Tags: pulumi.StringMap{
				"Name": pulumi.String("example-tgw"),
			},
		})
		if err != nil {
			return err
		}
		exampleResourceShare, err := ram.NewResourceShare(ctx, "exampleResourceShare", &ram.ResourceShareArgs{
			AllowExternalPrincipals: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		examplePrincipalAssociation, err := ram.NewPrincipalAssociation(ctx, "examplePrincipalAssociation", &ram.PrincipalAssociationArgs{
			ResourceShareArn: exampleResourceShare.Arn,
			Principal:        main.ProviderAccountId,
		})
		if err != nil {
			return err
		}
		exampleResourceAssociation, err := ram.NewResourceAssociation(ctx, "exampleResourceAssociation", &ram.ResourceAssociationArgs{
			ResourceShareArn: exampleResourceShare.Arn,
			ResourceArn:      exampleTransitGateway.Arn,
		})
		if err != nil {
			return err
		}
		exampleAwsTransitGatewayAttachment, err := hcp.NewAwsTransitGatewayAttachment(ctx, "exampleAwsTransitGatewayAttachment", &hcp.AwsTransitGatewayAttachmentArgs{
			HvnId:                      main.HvnId,
			TransitGatewayAttachmentId: pulumi.String("example-tgw-attachment"),
			TransitGatewayId:           exampleTransitGateway.ID(),
			ResourceShareArn:           exampleResourceShare.Arn,
		}, pulumi.DependsOn([]pulumi.Resource{
			examplePrincipalAssociation,
			exampleResourceAssociation,
		}))
		if err != nil {
			return err
		}
		_, err = hcp.NewHvnRoute(ctx, "route", &hcp.HvnRouteArgs{
			HvnLink:         main.SelfLink,
			HvnRouteId:      pulumi.String("hvn-to-tgw-attachment"),
			DestinationCidr: exampleVpc.CidrBlock,
			TargetLink:      exampleAwsTransitGatewayAttachment.SelfLink,
		})
		if err != nil {
			return err
		}
		_, err = ec2transitgateway.NewVpcAttachmentAccepter(ctx, "exampleVpcAttachmentAccepter", &ec2transitgateway.VpcAttachmentAccepterArgs{
			TransitGatewayAttachmentId: exampleAwsTransitGatewayAttachment.ProviderTransitGatewayAttachmentId,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.hcp.Hvn;
import com.pulumi.hcp.HvnArgs;
import com.pulumi.aws.ec2.Vpc;
import com.pulumi.aws.ec2.VpcArgs;
import com.pulumi.aws.ec2transitgateway.TransitGateway;
import com.pulumi.aws.ec2transitgateway.TransitGatewayArgs;
import com.pulumi.aws.ram.ResourceShare;
import com.pulumi.aws.ram.ResourceShareArgs;
import com.pulumi.aws.ram.PrincipalAssociation;
import com.pulumi.aws.ram.PrincipalAssociationArgs;
import com.pulumi.aws.ram.ResourceAssociation;
import com.pulumi.aws.ram.ResourceAssociationArgs;
import com.pulumi.hcp.AwsTransitGatewayAttachment;
import com.pulumi.hcp.AwsTransitGatewayAttachmentArgs;
import com.pulumi.hcp.HvnRoute;
import com.pulumi.hcp.HvnRouteArgs;
import com.pulumi.aws.ec2transitgateway.VpcAttachmentAccepter;
import com.pulumi.aws.ec2transitgateway.VpcAttachmentAccepterArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var main = new Hvn("main", HvnArgs.builder()        
            .hvnId("main-hvn")
            .cloudProvider("aws")
            .region("us-west-2")
            .cidrBlock("172.25.16.0/20")
            .build());

        var exampleVpc = new Vpc("exampleVpc", VpcArgs.builder()        
            .cidrBlock("172.31.0.0/16")
            .build());

        var exampleTransitGateway = new TransitGateway("exampleTransitGateway", TransitGatewayArgs.builder()        
            .tags(Map.of("Name", "example-tgw"))
            .build());

        var exampleResourceShare = new ResourceShare("exampleResourceShare", ResourceShareArgs.builder()        
            .allowExternalPrincipals(true)
            .build());

        var examplePrincipalAssociation = new PrincipalAssociation("examplePrincipalAssociation", PrincipalAssociationArgs.builder()        
            .resourceShareArn(exampleResourceShare.arn())
            .principal(main.providerAccountId())
            .build());

        var exampleResourceAssociation = new ResourceAssociation("exampleResourceAssociation", ResourceAssociationArgs.builder()        
            .resourceShareArn(exampleResourceShare.arn())
            .resourceArn(exampleTransitGateway.arn())
            .build());

        var exampleAwsTransitGatewayAttachment = new AwsTransitGatewayAttachment("exampleAwsTransitGatewayAttachment", AwsTransitGatewayAttachmentArgs.builder()        
            .hvnId(main.hvnId())
            .transitGatewayAttachmentId("example-tgw-attachment")
            .transitGatewayId(exampleTransitGateway.id())
            .resourceShareArn(exampleResourceShare.arn())
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    examplePrincipalAssociation,
                    exampleResourceAssociation)
                .build());

        var route = new HvnRoute("route", HvnRouteArgs.builder()        
            .hvnLink(main.selfLink())
            .hvnRouteId("hvn-to-tgw-attachment")
            .destinationCidr(exampleVpc.cidrBlock())
            .targetLink(exampleAwsTransitGatewayAttachment.selfLink())
            .build());

        var exampleVpcAttachmentAccepter = new VpcAttachmentAccepter("exampleVpcAttachmentAccepter", VpcAttachmentAccepterArgs.builder()        
            .transitGatewayAttachmentId(exampleAwsTransitGatewayAttachment.providerTransitGatewayAttachmentId())
            .build());

    }
}

import pulumi
import pulumi_aws as aws
import pulumi_hcp as hcp

main = hcp.Hvn("main",
    hvn_id="main-hvn",
    cloud_provider="aws",
    region="us-west-2",
    cidr_block="172.25.16.0/20")
example_vpc = aws.ec2.Vpc("exampleVpc", cidr_block="172.31.0.0/16")
example_transit_gateway = aws.ec2transitgateway.TransitGateway("exampleTransitGateway", tags={
    "Name": "example-tgw",
})
example_resource_share = aws.ram.ResourceShare("exampleResourceShare", allow_external_principals=True)
example_principal_association = aws.ram.PrincipalAssociation("examplePrincipalAssociation",
    resource_share_arn=example_resource_share.arn,
    principal=main.provider_account_id)
example_resource_association = aws.ram.ResourceAssociation("exampleResourceAssociation",
    resource_share_arn=example_resource_share.arn,
    resource_arn=example_transit_gateway.arn)
example_aws_transit_gateway_attachment = hcp.AwsTransitGatewayAttachment("exampleAwsTransitGatewayAttachment",
    hvn_id=main.hvn_id,
    transit_gateway_attachment_id="example-tgw-attachment",
    transit_gateway_id=example_transit_gateway.id,
    resource_share_arn=example_resource_share.arn,
    opts=pulumi.ResourceOptions(depends_on=[
            example_principal_association,
            example_resource_association,
        ]))
route = hcp.HvnRoute("route",
    hvn_link=main.self_link,
    hvn_route_id="hvn-to-tgw-attachment",
    destination_cidr=example_vpc.cidr_block,
    target_link=example_aws_transit_gateway_attachment.self_link)
example_vpc_attachment_accepter = aws.ec2transitgateway.VpcAttachmentAccepter("exampleVpcAttachmentAccepter", transit_gateway_attachment_id=example_aws_transit_gateway_attachment.provider_transit_gateway_attachment_id)

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as hcp from "@grapl/pulumi-hcp";

const main = new hcp.Hvn("main", {
    hvnId: "main-hvn",
    cloudProvider: "aws",
    region: "us-west-2",
    cidrBlock: "172.25.16.0/20",
});
const exampleVpc = new aws.ec2.Vpc("exampleVpc", {cidrBlock: "172.31.0.0/16"});
const exampleTransitGateway = new aws.ec2transitgateway.TransitGateway("exampleTransitGateway", {tags: {
    Name: "example-tgw",
}});
const exampleResourceShare = new aws.ram.ResourceShare("exampleResourceShare", {allowExternalPrincipals: true});
const examplePrincipalAssociation = new aws.ram.PrincipalAssociation("examplePrincipalAssociation", {
    resourceShareArn: exampleResourceShare.arn,
    principal: main.providerAccountId,
});
const exampleResourceAssociation = new aws.ram.ResourceAssociation("exampleResourceAssociation", {
    resourceShareArn: exampleResourceShare.arn,
    resourceArn: exampleTransitGateway.arn,
});
const exampleAwsTransitGatewayAttachment = new hcp.AwsTransitGatewayAttachment("exampleAwsTransitGatewayAttachment", {
    hvnId: main.hvnId,
    transitGatewayAttachmentId: "example-tgw-attachment",
    transitGatewayId: exampleTransitGateway.id,
    resourceShareArn: exampleResourceShare.arn,
}, {
    dependsOn: [
        examplePrincipalAssociation,
        exampleResourceAssociation,
    ],
});
const route = new hcp.HvnRoute("route", {
    hvnLink: main.selfLink,
    hvnRouteId: "hvn-to-tgw-attachment",
    destinationCidr: exampleVpc.cidrBlock,
    targetLink: exampleAwsTransitGatewayAttachment.selfLink,
});
const exampleVpcAttachmentAccepter = new aws.ec2transitgateway.VpcAttachmentAccepter("exampleVpcAttachmentAccepter", {transitGatewayAttachmentId: exampleAwsTransitGatewayAttachment.providerTransitGatewayAttachmentId});

resources:
  main:
    type: hcp:Hvn
    properties:
      hvnId: main-hvn
      cloudProvider: aws
      region: us-west-2
      cidrBlock: 172.25.16.0/20
  exampleVpc:
    type: aws:ec2:Vpc
    properties:
      cidrBlock: 172.31.0.0/16
  exampleTransitGateway:
    type: aws:ec2transitgateway:TransitGateway
    properties:
      tags:
        Name: example-tgw
  exampleResourceShare:
    type: aws:ram:ResourceShare
    properties:
      allowExternalPrincipals: true
  examplePrincipalAssociation:
    type: aws:ram:PrincipalAssociation
    properties:
      resourceShareArn: ${exampleResourceShare.arn}
      principal: ${main.providerAccountId}
  exampleResourceAssociation:
    type: aws:ram:ResourceAssociation
    properties:
      resourceShareArn: ${exampleResourceShare.arn}
      resourceArn: ${exampleTransitGateway.arn}
  exampleAwsTransitGatewayAttachment:
    type: hcp:AwsTransitGatewayAttachment
    properties:
      hvnId: ${main.hvnId}
      transitGatewayAttachmentId: example-tgw-attachment
      transitGatewayId: ${exampleTransitGateway.id}
      resourceShareArn: ${exampleResourceShare.arn}
    options:
      dependson:
        - ${examplePrincipalAssociation}
        - ${exampleResourceAssociation}
  route:
    type: hcp:HvnRoute
    properties:
      hvnLink: ${main.selfLink}
      hvnRouteId: hvn-to-tgw-attachment
      destinationCidr: ${exampleVpc.cidrBlock}
      targetLink: ${exampleAwsTransitGatewayAttachment.selfLink}
  exampleVpcAttachmentAccepter:
    type: aws:ec2transitgateway:VpcAttachmentAccepter
    properties:
      transitGatewayAttachmentId: ${exampleAwsTransitGatewayAttachment.providerTransitGatewayAttachmentId}