scm.RemoteNetwork

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

// --- DEPENDENCY 1: IKE Crypto Profile ---
// This profile defines the encryption and authentication algorithms for the IKE Gateway.
// The values are taken from the 'createTestIKECryptoProfile' helper function.
const example = new scm.IkeCryptoProfile("example", {
    name: "example-ike-crypto-prf-for-rn",
    folder: "Remote Networks",
    hashes: ["sha256"],
    dhGroups: ["group14"],
    encryptions: ["aes-256-cbc"],
});
// --- DEPENDENCY 2: IKE Gateway ---
// This defines the VPN peer. It depends on the IKE Crypto Profile created above.
// The values are taken from the 'createTestIKEGateway' helper function.
const exampleIkeGateway = new scm.IkeGateway("example", {
    name: "example-ike-gateway-for-rn",
    folder: "Remote Networks",
    authentication: {
        preSharedKey: {
            key: "secret",
        },
    },
    peerAddress: {
        ip: "1.1.1.1",
    },
    protocol: {
        ikev1: {
            ikeCryptoProfile: example.name,
        },
    },
}, {
    dependsOn: [example],
});
// --- DEPENDENCY 3: IPsec Tunnel ---
// This defines the tunnel interface itself and uses the IKE Gateway.
// The values are taken from the 'createTestIPsecTunnel' helper function.
const exampleIpsecTunnel = new scm.IpsecTunnel("example", {
    name: "example-ipsec-tunnel-for-rn",
    folder: "Remote Networks",
    antiReplay: true,
    copyTos: false,
    enableGreEncapsulation: false,
    autoKey: {
        ikeGateways: [{
            name: exampleIkeGateway.name,
        }],
        ipsecCryptoProfile: "PaloAlto-Networks-IPSec-Crypto",
    },
}, {
    dependsOn: [exampleIkeGateway],
});
// --- MAIN RESOURCE: Remote Network ---
// This is the final resource, which uses the IPsec Tunnel created above.
// The values are taken directly from the 'Test_deployment_services_RemoteNetworksAPIService_Create' test.
const exampleRemoteNetwork = new scm.RemoteNetwork("example", {
    name: "example-remote-network",
    folder: "Remote Networks",
    licenseType: "FWAAS-AGGREGATE",
    region: "us-west-2",
    spnName: "us-west-dakota",
    subnets: ["192.168.1.0/24"],
    ipsecTunnel: exampleIpsecTunnel.name,
    protocol: {
        bgp: {
            enable: true,
            peerAs: "65000",
            localIpAddress: "169.254.1.1",
            peerIpAddress: "169.254.1.2",
            doNotExportRoutes: false,
            originateDefaultRoute: false,
            summarizeMobileUserRoutes: false,
        },
    },
}, {
    dependsOn: [exampleIpsecTunnel],
});

import pulumi
import pulumi_scm as scm

# --- DEPENDENCY 1: IKE Crypto Profile ---
# This profile defines the encryption and authentication algorithms for the IKE Gateway.
# The values are taken from the 'createTestIKECryptoProfile' helper function.
example = scm.IkeCryptoProfile("example",
    name="example-ike-crypto-prf-for-rn",
    folder="Remote Networks",
    hashes=["sha256"],
    dh_groups=["group14"],
    encryptions=["aes-256-cbc"])
# --- DEPENDENCY 2: IKE Gateway ---
# This defines the VPN peer. It depends on the IKE Crypto Profile created above.
# The values are taken from the 'createTestIKEGateway' helper function.
example_ike_gateway = scm.IkeGateway("example",
    name="example-ike-gateway-for-rn",
    folder="Remote Networks",
    authentication={
        "pre_shared_key": {
            "key": "secret",
        },
    },
    peer_address={
        "ip": "1.1.1.1",
    },
    protocol={
        "ikev1": {
            "ike_crypto_profile": example.name,
        },
    },
    opts = pulumi.ResourceOptions(depends_on=[example]))
# --- DEPENDENCY 3: IPsec Tunnel ---
# This defines the tunnel interface itself and uses the IKE Gateway.
# The values are taken from the 'createTestIPsecTunnel' helper function.
example_ipsec_tunnel = scm.IpsecTunnel("example",
    name="example-ipsec-tunnel-for-rn",
    folder="Remote Networks",
    anti_replay=True,
    copy_tos=False,
    enable_gre_encapsulation=False,
    auto_key={
        "ike_gateways": [{
            "name": example_ike_gateway.name,
        }],
        "ipsec_crypto_profile": "PaloAlto-Networks-IPSec-Crypto",
    },
    opts = pulumi.ResourceOptions(depends_on=[example_ike_gateway]))
# --- MAIN RESOURCE: Remote Network ---
# This is the final resource, which uses the IPsec Tunnel created above.
# The values are taken directly from the 'Test_deployment_services_RemoteNetworksAPIService_Create' test.
example_remote_network = scm.RemoteNetwork("example",
    name="example-remote-network",
    folder="Remote Networks",
    license_type="FWAAS-AGGREGATE",
    region="us-west-2",
    spn_name="us-west-dakota",
    subnets=["192.168.1.0/24"],
    ipsec_tunnel=example_ipsec_tunnel.name,
    protocol={
        "bgp": {
            "enable": True,
            "peer_as": "65000",
            "local_ip_address": "169.254.1.1",
            "peer_ip_address": "169.254.1.2",
            "do_not_export_routes": False,
            "originate_default_route": False,
            "summarize_mobile_user_routes": False,
        },
    },
    opts = pulumi.ResourceOptions(depends_on=[example_ipsec_tunnel]))

package main

import (
	"github.com/pulumi/pulumi-scm/sdk/go/scm"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// --- DEPENDENCY 1: IKE Crypto Profile ---
		// This profile defines the encryption and authentication algorithms for the IKE Gateway.
		// The values are taken from the 'createTestIKECryptoProfile' helper function.
		example, err := scm.NewIkeCryptoProfile(ctx, "example", &scm.IkeCryptoProfileArgs{
			Name:   pulumi.String("example-ike-crypto-prf-for-rn"),
			Folder: pulumi.String("Remote Networks"),
			Hashes: pulumi.StringArray{
				pulumi.String("sha256"),
			},
			DhGroups: pulumi.StringArray{
				pulumi.String("group14"),
			},
			Encryptions: pulumi.StringArray{
				pulumi.String("aes-256-cbc"),
			},
		})
		if err != nil {
			return err
		}
		// --- DEPENDENCY 2: IKE Gateway ---
		// This defines the VPN peer. It depends on the IKE Crypto Profile created above.
		// The values are taken from the 'createTestIKEGateway' helper function.
		exampleIkeGateway, err := scm.NewIkeGateway(ctx, "example", &scm.IkeGatewayArgs{
			Name:   pulumi.String("example-ike-gateway-for-rn"),
			Folder: pulumi.String("Remote Networks"),
			Authentication: &scm.IkeGatewayAuthenticationArgs{
				PreSharedKey: &scm.IkeGatewayAuthenticationPreSharedKeyArgs{
					Key: pulumi.String("secret"),
				},
			},
			PeerAddress: &scm.IkeGatewayPeerAddressArgs{
				Ip: pulumi.String("1.1.1.1"),
			},
			Protocol: &scm.IkeGatewayProtocolArgs{
				Ikev1: &scm.IkeGatewayProtocolIkev1Args{
					IkeCryptoProfile: example.Name,
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			example,
		}))
		if err != nil {
			return err
		}
		// --- DEPENDENCY 3: IPsec Tunnel ---
		// This defines the tunnel interface itself and uses the IKE Gateway.
		// The values are taken from the 'createTestIPsecTunnel' helper function.
		exampleIpsecTunnel, err := scm.NewIpsecTunnel(ctx, "example", &scm.IpsecTunnelArgs{
			Name:                   pulumi.String("example-ipsec-tunnel-for-rn"),
			Folder:                 pulumi.String("Remote Networks"),
			AntiReplay:             pulumi.Bool(true),
			CopyTos:                pulumi.Bool(false),
			EnableGreEncapsulation: pulumi.Bool(false),
			AutoKey: &scm.IpsecTunnelAutoKeyArgs{
				IkeGateways: scm.IpsecTunnelAutoKeyIkeGatewayArray{
					&scm.IpsecTunnelAutoKeyIkeGatewayArgs{
						Name: exampleIkeGateway.Name,
					},
				},
				IpsecCryptoProfile: pulumi.String("PaloAlto-Networks-IPSec-Crypto"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleIkeGateway,
		}))
		if err != nil {
			return err
		}
		// --- MAIN RESOURCE: Remote Network ---
		// This is the final resource, which uses the IPsec Tunnel created above.
		// The values are taken directly from the 'Test_deployment_services_RemoteNetworksAPIService_Create' test.
		_, err = scm.NewRemoteNetwork(ctx, "example", &scm.RemoteNetworkArgs{
			Name:        pulumi.String("example-remote-network"),
			Folder:      pulumi.String("Remote Networks"),
			LicenseType: pulumi.String("FWAAS-AGGREGATE"),
			Region:      pulumi.String("us-west-2"),
			SpnName:     pulumi.String("us-west-dakota"),
			Subnets: pulumi.StringArray{
				pulumi.String("192.168.1.0/24"),
			},
			IpsecTunnel: exampleIpsecTunnel.Name,
			Protocol: &scm.RemoteNetworkProtocolArgs{
				Bgp: &scm.RemoteNetworkProtocolBgpArgs{
					Enable:                    pulumi.Bool(true),
					PeerAs:                    pulumi.String("65000"),
					LocalIpAddress:            pulumi.String("169.254.1.1"),
					PeerIpAddress:             pulumi.String("169.254.1.2"),
					DoNotExportRoutes:         pulumi.Bool(false),
					OriginateDefaultRoute:     pulumi.Bool(false),
					SummarizeMobileUserRoutes: pulumi.Bool(false),
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleIpsecTunnel,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scm = Pulumi.Scm;

return await Deployment.RunAsync(() => 
{
    // --- DEPENDENCY 1: IKE Crypto Profile ---
    // This profile defines the encryption and authentication algorithms for the IKE Gateway.
    // The values are taken from the 'createTestIKECryptoProfile' helper function.
    var example = new Scm.IkeCryptoProfile("example", new()
    {
        Name = "example-ike-crypto-prf-for-rn",
        Folder = "Remote Networks",
        Hashes = new[]
        {
            "sha256",
        },
        DhGroups = new[]
        {
            "group14",
        },
        Encryptions = new[]
        {
            "aes-256-cbc",
        },
    });

    // --- DEPENDENCY 2: IKE Gateway ---
    // This defines the VPN peer. It depends on the IKE Crypto Profile created above.
    // The values are taken from the 'createTestIKEGateway' helper function.
    var exampleIkeGateway = new Scm.IkeGateway("example", new()
    {
        Name = "example-ike-gateway-for-rn",
        Folder = "Remote Networks",
        Authentication = new Scm.Inputs.IkeGatewayAuthenticationArgs
        {
            PreSharedKey = new Scm.Inputs.IkeGatewayAuthenticationPreSharedKeyArgs
            {
                Key = "secret",
            },
        },
        PeerAddress = new Scm.Inputs.IkeGatewayPeerAddressArgs
        {
            Ip = "1.1.1.1",
        },
        Protocol = new Scm.Inputs.IkeGatewayProtocolArgs
        {
            Ikev1 = new Scm.Inputs.IkeGatewayProtocolIkev1Args
            {
                IkeCryptoProfile = example.Name,
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            example,
        },
    });

    // --- DEPENDENCY 3: IPsec Tunnel ---
    // This defines the tunnel interface itself and uses the IKE Gateway.
    // The values are taken from the 'createTestIPsecTunnel' helper function.
    var exampleIpsecTunnel = new Scm.IpsecTunnel("example", new()
    {
        Name = "example-ipsec-tunnel-for-rn",
        Folder = "Remote Networks",
        AntiReplay = true,
        CopyTos = false,
        EnableGreEncapsulation = false,
        AutoKey = new Scm.Inputs.IpsecTunnelAutoKeyArgs
        {
            IkeGateways = new[]
            {
                new Scm.Inputs.IpsecTunnelAutoKeyIkeGatewayArgs
                {
                    Name = exampleIkeGateway.Name,
                },
            },
            IpsecCryptoProfile = "PaloAlto-Networks-IPSec-Crypto",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleIkeGateway,
        },
    });

    // --- MAIN RESOURCE: Remote Network ---
    // This is the final resource, which uses the IPsec Tunnel created above.
    // The values are taken directly from the 'Test_deployment_services_RemoteNetworksAPIService_Create' test.
    var exampleRemoteNetwork = new Scm.RemoteNetwork("example", new()
    {
        Name = "example-remote-network",
        Folder = "Remote Networks",
        LicenseType = "FWAAS-AGGREGATE",
        Region = "us-west-2",
        SpnName = "us-west-dakota",
        Subnets = new[]
        {
            "192.168.1.0/24",
        },
        IpsecTunnel = exampleIpsecTunnel.Name,
        Protocol = new Scm.Inputs.RemoteNetworkProtocolArgs
        {
            Bgp = new Scm.Inputs.RemoteNetworkProtocolBgpArgs
            {
                Enable = true,
                PeerAs = "65000",
                LocalIpAddress = "169.254.1.1",
                PeerIpAddress = "169.254.1.2",
                DoNotExportRoutes = false,
                OriginateDefaultRoute = false,
                SummarizeMobileUserRoutes = false,
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleIpsecTunnel,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scm.IkeCryptoProfile;
import com.pulumi.scm.IkeCryptoProfileArgs;
import com.pulumi.scm.IkeGateway;
import com.pulumi.scm.IkeGatewayArgs;
import com.pulumi.scm.inputs.IkeGatewayAuthenticationArgs;
import com.pulumi.scm.inputs.IkeGatewayAuthenticationPreSharedKeyArgs;
import com.pulumi.scm.inputs.IkeGatewayPeerAddressArgs;
import com.pulumi.scm.inputs.IkeGatewayProtocolArgs;
import com.pulumi.scm.inputs.IkeGatewayProtocolIkev1Args;
import com.pulumi.scm.IpsecTunnel;
import com.pulumi.scm.IpsecTunnelArgs;
import com.pulumi.scm.inputs.IpsecTunnelAutoKeyArgs;
import com.pulumi.scm.RemoteNetwork;
import com.pulumi.scm.RemoteNetworkArgs;
import com.pulumi.scm.inputs.RemoteNetworkProtocolArgs;
import com.pulumi.scm.inputs.RemoteNetworkProtocolBgpArgs;
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) {
        // --- DEPENDENCY 1: IKE Crypto Profile ---
        // This profile defines the encryption and authentication algorithms for the IKE Gateway.
        // The values are taken from the 'createTestIKECryptoProfile' helper function.
        var example = new IkeCryptoProfile("example", IkeCryptoProfileArgs.builder()
            .name("example-ike-crypto-prf-for-rn")
            .folder("Remote Networks")
            .hashes("sha256")
            .dhGroups("group14")
            .encryptions("aes-256-cbc")
            .build());

        // --- DEPENDENCY 2: IKE Gateway ---
        // This defines the VPN peer. It depends on the IKE Crypto Profile created above.
        // The values are taken from the 'createTestIKEGateway' helper function.
        var exampleIkeGateway = new IkeGateway("exampleIkeGateway", IkeGatewayArgs.builder()
            .name("example-ike-gateway-for-rn")
            .folder("Remote Networks")
            .authentication(IkeGatewayAuthenticationArgs.builder()
                .preSharedKey(IkeGatewayAuthenticationPreSharedKeyArgs.builder()
                    .key("secret")
                    .build())
                .build())
            .peerAddress(IkeGatewayPeerAddressArgs.builder()
                .ip("1.1.1.1")
                .build())
            .protocol(IkeGatewayProtocolArgs.builder()
                .ikev1(IkeGatewayProtocolIkev1Args.builder()
                    .ikeCryptoProfile(example.name())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(example)
                .build());

        // --- DEPENDENCY 3: IPsec Tunnel ---
        // This defines the tunnel interface itself and uses the IKE Gateway.
        // The values are taken from the 'createTestIPsecTunnel' helper function.
        var exampleIpsecTunnel = new IpsecTunnel("exampleIpsecTunnel", IpsecTunnelArgs.builder()
            .name("example-ipsec-tunnel-for-rn")
            .folder("Remote Networks")
            .antiReplay(true)
            .copyTos(false)
            .enableGreEncapsulation(false)
            .autoKey(IpsecTunnelAutoKeyArgs.builder()
                .ikeGateways(IpsecTunnelAutoKeyIkeGatewayArgs.builder()
                    .name(exampleIkeGateway.name())
                    .build())
                .ipsecCryptoProfile("PaloAlto-Networks-IPSec-Crypto")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleIkeGateway)
                .build());

        // --- MAIN RESOURCE: Remote Network ---
        // This is the final resource, which uses the IPsec Tunnel created above.
        // The values are taken directly from the 'Test_deployment_services_RemoteNetworksAPIService_Create' test.
        var exampleRemoteNetwork = new RemoteNetwork("exampleRemoteNetwork", RemoteNetworkArgs.builder()
            .name("example-remote-network")
            .folder("Remote Networks")
            .licenseType("FWAAS-AGGREGATE")
            .region("us-west-2")
            .spnName("us-west-dakota")
            .subnets("192.168.1.0/24")
            .ipsecTunnel(exampleIpsecTunnel.name())
            .protocol(RemoteNetworkProtocolArgs.builder()
                .bgp(RemoteNetworkProtocolBgpArgs.builder()
                    .enable(true)
                    .peerAs("65000")
                    .localIpAddress("169.254.1.1")
                    .peerIpAddress("169.254.1.2")
                    .doNotExportRoutes(false)
                    .originateDefaultRoute(false)
                    .summarizeMobileUserRoutes(false)
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleIpsecTunnel)
                .build());

    }
}

resources:
  # --- DEPENDENCY 1: IKE Crypto Profile ---
  # This profile defines the encryption and authentication algorithms for the IKE Gateway.
  # The values are taken from the 'createTestIKECryptoProfile' helper function.
  example:
    type: scm:IkeCryptoProfile
    properties:
      name: example-ike-crypto-prf-for-rn
      folder: Remote Networks
      hashes:
        - sha256
      dhGroups:
        - group14
      encryptions:
        - aes-256-cbc
  # --- DEPENDENCY 2: IKE Gateway ---
  # This defines the VPN peer. It depends on the IKE Crypto Profile created above.
  # The values are taken from the 'createTestIKEGateway' helper function.
  exampleIkeGateway:
    type: scm:IkeGateway
    name: example
    properties:
      name: example-ike-gateway-for-rn
      folder: Remote Networks
      authentication:
        preSharedKey:
          key: secret
      peerAddress:
        ip: 1.1.1.1
      protocol:
        ikev1:
          ikeCryptoProfile: ${example.name}
    options:
      dependsOn:
        - ${example}
  # --- DEPENDENCY 3: IPsec Tunnel ---
  # This defines the tunnel interface itself and uses the IKE Gateway.
  # The values are taken from the 'createTestIPsecTunnel' helper function.
  exampleIpsecTunnel:
    type: scm:IpsecTunnel
    name: example
    properties:
      name: example-ipsec-tunnel-for-rn
      folder: Remote Networks
      antiReplay: true
      copyTos: false
      enableGreEncapsulation: false
      autoKey:
        ikeGateways:
          - name: ${exampleIkeGateway.name}
        ipsecCryptoProfile: PaloAlto-Networks-IPSec-Crypto
    options:
      dependsOn:
        - ${exampleIkeGateway}
  # --- MAIN RESOURCE: Remote Network ---
  # This is the final resource, which uses the IPsec Tunnel created above.
  # The values are taken directly from the 'Test_deployment_services_RemoteNetworksAPIService_Create' test.
  exampleRemoteNetwork:
    type: scm:RemoteNetwork
    name: example
    properties:
      name: example-remote-network
      folder: Remote Networks
      licenseType: FWAAS-AGGREGATE
      region: us-west-2
      spnName: us-west-dakota
      subnets:
        - 192.168.1.0/24
      ipsecTunnel: ${exampleIpsecTunnel.name}
      protocol:
        bgp:
          enable: true
          peerAs: '65000'
          localIpAddress: 169.254.1.1
          peerIpAddress: 169.254.1.2
          doNotExportRoutes: false
          originateDefaultRoute: false
          summarizeMobileUserRoutes: false
    options:
      dependsOn:
        - ${exampleIpsecTunnel}

var remoteNetworkResource = new Scm.RemoteNetwork("remoteNetworkResource", new()
{
    Folder = "string",
    LicenseType = "string",
    Region = "string",
    EcmpLoadBalancing = "string",
    EcmpTunnels = new[]
    {
        new Scm.Inputs.RemoteNetworkEcmpTunnelArgs
        {
            IpsecTunnel = "string",
            Name = "string",
            Protocol = new Scm.Inputs.RemoteNetworkEcmpTunnelProtocolArgs
            {
                Bgp = new Scm.Inputs.RemoteNetworkEcmpTunnelProtocolBgpArgs
                {
                    DoNotExportRoutes = false,
                    Enable = false,
                    LocalIpAddress = "string",
                    OriginateDefaultRoute = false,
                    PeerAs = "string",
                    PeerIpAddress = "string",
                    PeeringType = "string",
                    Secret = "string",
                    SummarizeMobileUserRoutes = false,
                },
            },
        },
    },
    IpsecTunnel = "string",
    Name = "string",
    Protocol = new Scm.Inputs.RemoteNetworkProtocolArgs
    {
        Bgp = new Scm.Inputs.RemoteNetworkProtocolBgpArgs
        {
            DoNotExportRoutes = false,
            Enable = false,
            LocalIpAddress = "string",
            OriginateDefaultRoute = false,
            PeerAs = "string",
            PeerIpAddress = "string",
            PeeringType = "string",
            Secret = "string",
            SummarizeMobileUserRoutes = false,
        },
        BgpPeer = new Scm.Inputs.RemoteNetworkProtocolBgpPeerArgs
        {
            LocalIpAddress = "string",
            PeerIpAddress = "string",
            Secret = "string",
        },
    },
    SecondaryIpsecTunnel = "string",
    SpnName = "string",
    Subnets = new[]
    {
        "string",
    },
});

example, err := scm.NewRemoteNetwork(ctx, "remoteNetworkResource", &scm.RemoteNetworkArgs{
	Folder:            pulumi.String("string"),
	LicenseType:       pulumi.String("string"),
	Region:            pulumi.String("string"),
	EcmpLoadBalancing: pulumi.String("string"),
	EcmpTunnels: scm.RemoteNetworkEcmpTunnelArray{
		&scm.RemoteNetworkEcmpTunnelArgs{
			IpsecTunnel: pulumi.String("string"),
			Name:        pulumi.String("string"),
			Protocol: &scm.RemoteNetworkEcmpTunnelProtocolArgs{
				Bgp: &scm.RemoteNetworkEcmpTunnelProtocolBgpArgs{
					DoNotExportRoutes:         pulumi.Bool(false),
					Enable:                    pulumi.Bool(false),
					LocalIpAddress:            pulumi.String("string"),
					OriginateDefaultRoute:     pulumi.Bool(false),
					PeerAs:                    pulumi.String("string"),
					PeerIpAddress:             pulumi.String("string"),
					PeeringType:               pulumi.String("string"),
					Secret:                    pulumi.String("string"),
					SummarizeMobileUserRoutes: pulumi.Bool(false),
				},
			},
		},
	},
	IpsecTunnel: pulumi.String("string"),
	Name:        pulumi.String("string"),
	Protocol: &scm.RemoteNetworkProtocolArgs{
		Bgp: &scm.RemoteNetworkProtocolBgpArgs{
			DoNotExportRoutes:         pulumi.Bool(false),
			Enable:                    pulumi.Bool(false),
			LocalIpAddress:            pulumi.String("string"),
			OriginateDefaultRoute:     pulumi.Bool(false),
			PeerAs:                    pulumi.String("string"),
			PeerIpAddress:             pulumi.String("string"),
			PeeringType:               pulumi.String("string"),
			Secret:                    pulumi.String("string"),
			SummarizeMobileUserRoutes: pulumi.Bool(false),
		},
		BgpPeer: &scm.RemoteNetworkProtocolBgpPeerArgs{
			LocalIpAddress: pulumi.String("string"),
			PeerIpAddress:  pulumi.String("string"),
			Secret:         pulumi.String("string"),
		},
	},
	SecondaryIpsecTunnel: pulumi.String("string"),
	SpnName:              pulumi.String("string"),
	Subnets: pulumi.StringArray{
		pulumi.String("string"),
	},
})

var remoteNetworkResource = new RemoteNetwork("remoteNetworkResource", RemoteNetworkArgs.builder()
    .folder("string")
    .licenseType("string")
    .region("string")
    .ecmpLoadBalancing("string")
    .ecmpTunnels(RemoteNetworkEcmpTunnelArgs.builder()
        .ipsecTunnel("string")
        .name("string")
        .protocol(RemoteNetworkEcmpTunnelProtocolArgs.builder()
            .bgp(RemoteNetworkEcmpTunnelProtocolBgpArgs.builder()
                .doNotExportRoutes(false)
                .enable(false)
                .localIpAddress("string")
                .originateDefaultRoute(false)
                .peerAs("string")
                .peerIpAddress("string")
                .peeringType("string")
                .secret("string")
                .summarizeMobileUserRoutes(false)
                .build())
            .build())
        .build())
    .ipsecTunnel("string")
    .name("string")
    .protocol(RemoteNetworkProtocolArgs.builder()
        .bgp(RemoteNetworkProtocolBgpArgs.builder()
            .doNotExportRoutes(false)
            .enable(false)
            .localIpAddress("string")
            .originateDefaultRoute(false)
            .peerAs("string")
            .peerIpAddress("string")
            .peeringType("string")
            .secret("string")
            .summarizeMobileUserRoutes(false)
            .build())
        .bgpPeer(RemoteNetworkProtocolBgpPeerArgs.builder()
            .localIpAddress("string")
            .peerIpAddress("string")
            .secret("string")
            .build())
        .build())
    .secondaryIpsecTunnel("string")
    .spnName("string")
    .subnets("string")
    .build());

remote_network_resource = scm.RemoteNetwork("remoteNetworkResource",
    folder="string",
    license_type="string",
    region="string",
    ecmp_load_balancing="string",
    ecmp_tunnels=[{
        "ipsec_tunnel": "string",
        "name": "string",
        "protocol": {
            "bgp": {
                "do_not_export_routes": False,
                "enable": False,
                "local_ip_address": "string",
                "originate_default_route": False,
                "peer_as": "string",
                "peer_ip_address": "string",
                "peering_type": "string",
                "secret": "string",
                "summarize_mobile_user_routes": False,
            },
        },
    }],
    ipsec_tunnel="string",
    name="string",
    protocol={
        "bgp": {
            "do_not_export_routes": False,
            "enable": False,
            "local_ip_address": "string",
            "originate_default_route": False,
            "peer_as": "string",
            "peer_ip_address": "string",
            "peering_type": "string",
            "secret": "string",
            "summarize_mobile_user_routes": False,
        },
        "bgp_peer": {
            "local_ip_address": "string",
            "peer_ip_address": "string",
            "secret": "string",
        },
    },
    secondary_ipsec_tunnel="string",
    spn_name="string",
    subnets=["string"])

const remoteNetworkResource = new scm.RemoteNetwork("remoteNetworkResource", {
    folder: "string",
    licenseType: "string",
    region: "string",
    ecmpLoadBalancing: "string",
    ecmpTunnels: [{
        ipsecTunnel: "string",
        name: "string",
        protocol: {
            bgp: {
                doNotExportRoutes: false,
                enable: false,
                localIpAddress: "string",
                originateDefaultRoute: false,
                peerAs: "string",
                peerIpAddress: "string",
                peeringType: "string",
                secret: "string",
                summarizeMobileUserRoutes: false,
            },
        },
    }],
    ipsecTunnel: "string",
    name: "string",
    protocol: {
        bgp: {
            doNotExportRoutes: false,
            enable: false,
            localIpAddress: "string",
            originateDefaultRoute: false,
            peerAs: "string",
            peerIpAddress: "string",
            peeringType: "string",
            secret: "string",
            summarizeMobileUserRoutes: false,
        },
        bgpPeer: {
            localIpAddress: "string",
            peerIpAddress: "string",
            secret: "string",
        },
    },
    secondaryIpsecTunnel: "string",
    spnName: "string",
    subnets: ["string"],
});

type: scm:RemoteNetwork
properties:
    ecmpLoadBalancing: string
    ecmpTunnels:
        - ipsecTunnel: string
          name: string
          protocol:
            bgp:
                doNotExportRoutes: false
                enable: false
                localIpAddress: string
                originateDefaultRoute: false
                peerAs: string
                peerIpAddress: string
                peeringType: string
                secret: string
                summarizeMobileUserRoutes: false
    folder: string
    ipsecTunnel: string
    licenseType: string
    name: string
    protocol:
        bgp:
            doNotExportRoutes: false
            enable: false
            localIpAddress: string
            originateDefaultRoute: false
            peerAs: string
            peerIpAddress: string
            peeringType: string
            secret: string
            summarizeMobileUserRoutes: false
        bgpPeer:
            localIpAddress: string
            peerIpAddress: string
            secret: string
    region: string
    secondaryIpsecTunnel: string
    spnName: string
    subnets:
        - string