using Pulumi;
using Aws = Pulumi.Aws;

class MyStack : Stack
{
    public MyStack()
    {
        var accepter = new Aws.Provider("accepter", new Aws.ProviderArgs
        {
        });
        // Accepter's credentials.
        var accepterCallerIdentity = Output.Create(Aws.GetCallerIdentity.InvokeAsync());
        // Accepter's side of the VIF.
        var example = new Aws.DirectConnect.Gateway("example", new Aws.DirectConnect.GatewayArgs
        {
            AmazonSideAsn = "64512",
        }, new CustomResourceOptions
        {
            Provider = aws.Accepter,
        });
        // Creator's side of the VIF
        var creator = new Aws.DirectConnect.HostedTransitVirtualInterface("creator", new Aws.DirectConnect.HostedTransitVirtualInterfaceArgs
        {
            ConnectionId = "dxcon-zzzzzzzz",
            OwnerAccountId = accepterCallerIdentity.Apply(accepterCallerIdentity => accepterCallerIdentity.AccountId),
            Vlan = 4094,
            AddressFamily = "ipv4",
            BgpAsn = 65352,
        }, new CustomResourceOptions
        {
            DependsOn = 
            {
                example,
            },
        });
        var accepterHostedTransitVirtualInterfaceAcceptor = new Aws.DirectConnect.HostedTransitVirtualInterfaceAcceptor("accepterHostedTransitVirtualInterfaceAcceptor", new Aws.DirectConnect.HostedTransitVirtualInterfaceAcceptorArgs
        {
            VirtualInterfaceId = creator.Id,
            DxGatewayId = example.Id,
            Tags = 
            {
                { "Side", "Accepter" },
            },
        }, new CustomResourceOptions
        {
            Provider = aws.Accepter,
        });
    }

}

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v5/go/aws"
	"github.com/pulumi/pulumi-aws/sdk/v5/go/aws/directconnect"
	"github.com/pulumi/pulumi-aws/sdk/v5/go/aws/providers"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := providers.Newaws(ctx, "accepter", nil)
		if err != nil {
			return err
		}
		accepterCallerIdentity, err := aws.GetCallerIdentity(ctx, nil, nil)
		if err != nil {
			return err
		}
		example, err := directconnect.NewGateway(ctx, "example", &directconnect.GatewayArgs{
			AmazonSideAsn: pulumi.String("64512"),
		}, pulumi.Provider(aws.Accepter))
		if err != nil {
			return err
		}
		creator, err := directconnect.NewHostedTransitVirtualInterface(ctx, "creator", &directconnect.HostedTransitVirtualInterfaceArgs{
			ConnectionId:   pulumi.String("dxcon-zzzzzzzz"),
			OwnerAccountId: pulumi.String(accepterCallerIdentity.AccountId),
			Vlan:           pulumi.Int(4094),
			AddressFamily:  pulumi.String("ipv4"),
			BgpAsn:         pulumi.Int(65352),
		}, pulumi.DependsOn([]pulumi.Resource{
			example,
		}))
		if err != nil {
			return err
		}
		_, err = directconnect.NewHostedTransitVirtualInterfaceAcceptor(ctx, "accepterHostedTransitVirtualInterfaceAcceptor", &directconnect.HostedTransitVirtualInterfaceAcceptorArgs{
			VirtualInterfaceId: creator.ID(),
			DxGatewayId:        example.ID(),
			Tags: pulumi.StringMap{
				"Side": pulumi.String("Accepter"),
			},
		}, pulumi.Provider(aws.Accepter))
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import java.util.*;
import java.io.*;
import java.nio.*;
import com.pulumi.*;
import com.pulumi.resources.CustomResourceOptions;

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

    public static void stack(Context ctx) {
        var accepter = new Provider("accepter");

        final var accepterCallerIdentity = Output.of(AwsFunctions.getCallerIdentity());

        var example = new Gateway("example", GatewayArgs.builder()        
            .amazonSideAsn(64512)
            .build(), CustomResourceOptions.builder()
                .provider(aws.accepter())
                .build());

        var creator = new HostedTransitVirtualInterface("creator", HostedTransitVirtualInterfaceArgs.builder()        
            .connectionId("dxcon-zzzzzzzz")
            .ownerAccountId(accepterCallerIdentity.apply(getCallerIdentityResult -> getCallerIdentityResult.accountId()))
            .vlan(4094)
            .addressFamily("ipv4")
            .bgpAsn(65352)
            .build(), CustomResourceOptions.builder()
                .dependsOn(example)
                .build());

        var accepterHostedTransitVirtualInterfaceAcceptor = new HostedTransitVirtualInterfaceAcceptor("accepterHostedTransitVirtualInterfaceAcceptor", HostedTransitVirtualInterfaceAcceptorArgs.builder()        
            .virtualInterfaceId(creator.id())
            .dxGatewayId(example.id())
            .tags(Map.of("Side", "Accepter"))
            .build(), CustomResourceOptions.builder()
                .provider(aws.accepter())
                .build());

    }
}

import pulumi
import pulumi_aws as aws
import pulumi_pulumi as pulumi

accepter = pulumi.providers.Aws("accepter")
# Accepter's credentials.
accepter_caller_identity = aws.get_caller_identity()
# Accepter's side of the VIF.
example = aws.directconnect.Gateway("example", amazon_side_asn="64512",
opts=pulumi.ResourceOptions(provider=aws["accepter"]))
# Creator's side of the VIF
creator = aws.directconnect.HostedTransitVirtualInterface("creator",
    connection_id="dxcon-zzzzzzzz",
    owner_account_id=accepter_caller_identity.account_id,
    vlan=4094,
    address_family="ipv4",
    bgp_asn=65352,
    opts=pulumi.ResourceOptions(depends_on=[example]))
accepter_hosted_transit_virtual_interface_acceptor = aws.directconnect.HostedTransitVirtualInterfaceAcceptor("accepterHostedTransitVirtualInterfaceAcceptor",
    virtual_interface_id=creator.id,
    dx_gateway_id=example.id,
    tags={
        "Side": "Accepter",
    },
    opts=pulumi.ResourceOptions(provider=aws["accepter"]))

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const accepter = new aws.Provider("accepter", {});
// Accepter's credentials.
const accepterCallerIdentity = aws.getCallerIdentity({});
// Accepter's side of the VIF.
const example = new aws.directconnect.Gateway("example", {amazonSideAsn: "64512"}, {
    provider: aws.accepter,
});
// Creator's side of the VIF
const creator = new aws.directconnect.HostedTransitVirtualInterface("creator", {
    connectionId: "dxcon-zzzzzzzz",
    ownerAccountId: accepterCallerIdentity.then(accepterCallerIdentity => accepterCallerIdentity.accountId),
    vlan: 4094,
    addressFamily: "ipv4",
    bgpAsn: 65352,
}, {
    dependsOn: [example],
});
const accepterHostedTransitVirtualInterfaceAcceptor = new aws.directconnect.HostedTransitVirtualInterfaceAcceptor("accepterHostedTransitVirtualInterfaceAcceptor", {
    virtualInterfaceId: creator.id,
    dxGatewayId: example.id,
    tags: {
        Side: "Accepter",
    },
}, {
    provider: aws.accepter,
});

resources:
  accepter:
    type: pulumi:providers:aws
  creator:
    type: aws:directconnect:HostedTransitVirtualInterface
    properties:
      connectionId: dxcon-zzzzzzzz
      ownerAccountId: ${accepterCallerIdentity.accountId}
      vlan: 4094
      addressFamily: ipv4
      bgpAsn: 65352
    options:
      dependson:
        - ${example}
  example:
    type: aws:directconnect:Gateway
    properties:
      amazonSideAsn: 64512
    options:
      provider: ${aws.accepter}
  accepterHostedTransitVirtualInterfaceAcceptor:
    type: aws:directconnect:HostedTransitVirtualInterfaceAcceptor
    properties:
      virtualInterfaceId: ${creator.id}
      dxGatewayId: ${example.id}
      tags:
        Side: Accepter
    options:
      provider: ${aws.accepter}
variables:
  accepterCallerIdentity:
    Fn::Invoke:
      Function: aws:getCallerIdentity
      Arguments: {}