scm.ForwardingProfile

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

// User location representing the US East office IP ranges
const exampleUsEast = new scm.ForwardingProfileUserLocation("example_us_east", {
    folder: "Mobile Users",
    name: "us-east-tf",
    description: "Managed by Terraform - US East office user location",
    ipAddresses: [
        "10.1.0.0/16",
        "10.2.0.0/16",
    ],
});
// Corporate destination profile with FQDN and IP ranges
const corpDestinations = new scm.ForwardingProfileDestination("corp_destinations", {
    folder: "Mobile Users",
    name: "corp-destinations-combined",
    description: "Managed by Terraform - Corporate FQDN and IP destinations (combined example)",
    fqdns: [
        {
            name: "*.corporate.com",
            port: 443,
        },
        {
            name: "api.internal.com",
            port: 8443,
        },
    ],
    ipAddresses: [
        {
            name: "10.0.0.0/8",
            port: 443,
        },
        {
            name: "172.16.0.0/12",
            port: 443,
        },
    ],
});
// Basic Global Protect proxy-based forwarding profile with a single forwarding rule
const exampleGpProxyBasic = new scm.ForwardingProfile("example_gp_proxy_basic", {
    folder: "Mobile Users",
    name: "example-gp-proxy-basic",
    type: {
        globalProtectProxy: {
            forwardingRules: [{
                name: "direct-rule",
                connectivity: "direct",
                destinations: "Any",
                enabled: true,
            }],
        },
    },
}, {
    dependsOn: [
        exampleUsEast,
        corpDestinations,
    ],
});
// Global Protect proxy-based forwarding profile with block rule and multiple forwarding rules
const exampleGpProxyFull = new scm.ForwardingProfile("example_gp_proxy_full", {
    folder: "Mobile Users",
    name: "example-gp-proxy-full",
    description: "Managed by Terraform - GP proxy with block rule and multiple forwarding rules",
    type: {
        globalProtectProxy: {
            pacUpload: false,
            blockRule: {
                enable: true,
                allowTcp: {
                    enableLocations: true,
                    locations: [exampleUsEast.name],
                },
                allowUdp: {
                    enableLocations: true,
                    locations: [exampleUsEast.name],
                    enableDestinations: true,
                    destinations: "any",
                },
            },
            forwardingRules: [{
                name: "direct-rule",
                connectivity: "direct",
                destinations: corpDestinations.name,
                userLocations: "Any",
                enabled: true,
            }],
        },
    },
}, {
    dependsOn: [
        exampleUsEast,
        corpDestinations,
    ],
});
// PAC file based forwarding profile
const examplePacFile = new scm.ForwardingProfile("example_pac_file", {
    folder: "Mobile Users",
    name: "example-pac-file",
    description: "Managed by Terraform - PAC file based forwarding profile",
    type: {
        pacFile: {
            pacUpload: true,
            forwardingRules: [{
                name: "pac-direct-rule",
                connectivity: "direct",
                destinations: "Any",
                enabled: true,
            }],
        },
    },
}, {
    dependsOn: [
        exampleUsEast,
        corpDestinations,
    ],
});
// ZTNA agent-based forwarding profile with block rule and forwarding rules
const exampleZtnaAgent = new scm.ForwardingProfile("example_ztna_agent", {
    folder: "Mobile Users",
    name: "example-ztna-agent",
    description: "Managed by Terraform - ZTNA agent forwarding profile with block rule",
    type: {
        ztnaAgent: {
            blockRule: {
                blockAllOtherUnmatchedOutboundConnections: false,
                blockInboundAccessWhenConnectedToTunnel: false,
                blockNonTcpNonUdpTrafficWhenConnectedToTunnel: false,
                allowIcmpForTroubleshooting: false,
                blockOutboundLanAccessWhenConnectedToTunnel: false,
                enforcerFqdnDnsResolutionViaDnsServers: true,
                resolveAllFqdnsUsingDnsServersAssignedByTheTunnel: true,
            },
            forwardingRules: [
                {
                    name: "ztna-dns-rule",
                    connectivity: "tunnel",
                    destinations: corpDestinations.name,
                    sourceApplications: "Any",
                    trafficType: "dns-and-network-traffic",
                    userLocations: "Any",
                    enabled: true,
                },
                {
                    name: "ztna-direct-rule",
                    connectivity: "direct",
                    destinations: "Any",
                    sourceApplications: "Any",
                    trafficType: "network-traffic",
                    userLocations: "Any",
                    enabled: true,
                },
            ],
        },
    },
}, {
    dependsOn: [corpDestinations],
});

import pulumi
import pulumi_scm as scm

# User location representing the US East office IP ranges
example_us_east = scm.ForwardingProfileUserLocation("example_us_east",
    folder="Mobile Users",
    name="us-east-tf",
    description="Managed by Terraform - US East office user location",
    ip_addresses=[
        "10.1.0.0/16",
        "10.2.0.0/16",
    ])
# Corporate destination profile with FQDN and IP ranges
corp_destinations = scm.ForwardingProfileDestination("corp_destinations",
    folder="Mobile Users",
    name="corp-destinations-combined",
    description="Managed by Terraform - Corporate FQDN and IP destinations (combined example)",
    fqdns=[
        {
            "name": "*.corporate.com",
            "port": 443,
        },
        {
            "name": "api.internal.com",
            "port": 8443,
        },
    ],
    ip_addresses=[
        {
            "name": "10.0.0.0/8",
            "port": 443,
        },
        {
            "name": "172.16.0.0/12",
            "port": 443,
        },
    ])
# Basic Global Protect proxy-based forwarding profile with a single forwarding rule
example_gp_proxy_basic = scm.ForwardingProfile("example_gp_proxy_basic",
    folder="Mobile Users",
    name="example-gp-proxy-basic",
    type={
        "global_protect_proxy": {
            "forwarding_rules": [{
                "name": "direct-rule",
                "connectivity": "direct",
                "destinations": "Any",
                "enabled": True,
            }],
        },
    },
    opts = pulumi.ResourceOptions(depends_on=[
            example_us_east,
            corp_destinations,
        ]))
# Global Protect proxy-based forwarding profile with block rule and multiple forwarding rules
example_gp_proxy_full = scm.ForwardingProfile("example_gp_proxy_full",
    folder="Mobile Users",
    name="example-gp-proxy-full",
    description="Managed by Terraform - GP proxy with block rule and multiple forwarding rules",
    type={
        "global_protect_proxy": {
            "pac_upload": False,
            "block_rule": {
                "enable": True,
                "allow_tcp": {
                    "enable_locations": True,
                    "locations": [example_us_east.name],
                },
                "allow_udp": {
                    "enable_locations": True,
                    "locations": [example_us_east.name],
                    "enable_destinations": True,
                    "destinations": "any",
                },
            },
            "forwarding_rules": [{
                "name": "direct-rule",
                "connectivity": "direct",
                "destinations": corp_destinations.name,
                "user_locations": "Any",
                "enabled": True,
            }],
        },
    },
    opts = pulumi.ResourceOptions(depends_on=[
            example_us_east,
            corp_destinations,
        ]))
# PAC file based forwarding profile
example_pac_file = scm.ForwardingProfile("example_pac_file",
    folder="Mobile Users",
    name="example-pac-file",
    description="Managed by Terraform - PAC file based forwarding profile",
    type={
        "pac_file": {
            "pac_upload": True,
            "forwarding_rules": [{
                "name": "pac-direct-rule",
                "connectivity": "direct",
                "destinations": "Any",
                "enabled": True,
            }],
        },
    },
    opts = pulumi.ResourceOptions(depends_on=[
            example_us_east,
            corp_destinations,
        ]))
# ZTNA agent-based forwarding profile with block rule and forwarding rules
example_ztna_agent = scm.ForwardingProfile("example_ztna_agent",
    folder="Mobile Users",
    name="example-ztna-agent",
    description="Managed by Terraform - ZTNA agent forwarding profile with block rule",
    type={
        "ztna_agent": {
            "block_rule": {
                "block_all_other_unmatched_outbound_connections": False,
                "block_inbound_access_when_connected_to_tunnel": False,
                "block_non_tcp_non_udp_traffic_when_connected_to_tunnel": False,
                "allow_icmp_for_troubleshooting": False,
                "block_outbound_lan_access_when_connected_to_tunnel": False,
                "enforcer_fqdn_dns_resolution_via_dns_servers": True,
                "resolve_all_fqdns_using_dns_servers_assigned_by_the_tunnel": True,
            },
            "forwarding_rules": [
                {
                    "name": "ztna-dns-rule",
                    "connectivity": "tunnel",
                    "destinations": corp_destinations.name,
                    "source_applications": "Any",
                    "traffic_type": "dns-and-network-traffic",
                    "user_locations": "Any",
                    "enabled": True,
                },
                {
                    "name": "ztna-direct-rule",
                    "connectivity": "direct",
                    "destinations": "Any",
                    "source_applications": "Any",
                    "traffic_type": "network-traffic",
                    "user_locations": "Any",
                    "enabled": True,
                },
            ],
        },
    },
    opts = pulumi.ResourceOptions(depends_on=[corp_destinations]))

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 {
		// User location representing the US East office IP ranges
		exampleUsEast, err := scm.NewForwardingProfileUserLocation(ctx, "example_us_east", &scm.ForwardingProfileUserLocationArgs{
			Folder:      pulumi.String("Mobile Users"),
			Name:        pulumi.String("us-east-tf"),
			Description: pulumi.String("Managed by Terraform - US East office user location"),
			IpAddresses: pulumi.StringArray{
				pulumi.String("10.1.0.0/16"),
				pulumi.String("10.2.0.0/16"),
			},
		})
		if err != nil {
			return err
		}
		// Corporate destination profile with FQDN and IP ranges
		corpDestinations, err := scm.NewForwardingProfileDestination(ctx, "corp_destinations", &scm.ForwardingProfileDestinationArgs{
			Folder:      pulumi.String("Mobile Users"),
			Name:        pulumi.String("corp-destinations-combined"),
			Description: pulumi.String("Managed by Terraform - Corporate FQDN and IP destinations (combined example)"),
			Fqdns: scm.ForwardingProfileDestinationFqdnArray{
				&scm.ForwardingProfileDestinationFqdnArgs{
					Name: pulumi.String("*.corporate.com"),
					Port: pulumi.Int(443),
				},
				&scm.ForwardingProfileDestinationFqdnArgs{
					Name: pulumi.String("api.internal.com"),
					Port: pulumi.Int(8443),
				},
			},
			IpAddresses: scm.ForwardingProfileDestinationIpAddressArray{
				&scm.ForwardingProfileDestinationIpAddressArgs{
					Name: pulumi.String("10.0.0.0/8"),
					Port: pulumi.Int(443),
				},
				&scm.ForwardingProfileDestinationIpAddressArgs{
					Name: pulumi.String("172.16.0.0/12"),
					Port: pulumi.Int(443),
				},
			},
		})
		if err != nil {
			return err
		}
		// Basic Global Protect proxy-based forwarding profile with a single forwarding rule
		_, err = scm.NewForwardingProfile(ctx, "example_gp_proxy_basic", &scm.ForwardingProfileArgs{
			Folder: pulumi.String("Mobile Users"),
			Name:   pulumi.String("example-gp-proxy-basic"),
			Type: &scm.ForwardingProfileTypeArgs{
				GlobalProtectProxy: &scm.ForwardingProfileTypeGlobalProtectProxyArgs{
					ForwardingRules: scm.ForwardingProfileTypeGlobalProtectProxyForwardingRuleArray{
						&scm.ForwardingProfileTypeGlobalProtectProxyForwardingRuleArgs{
							Name:         pulumi.String("direct-rule"),
							Connectivity: pulumi.String("direct"),
							Destinations: pulumi.String("Any"),
							Enabled:      pulumi.Bool(true),
						},
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleUsEast,
			corpDestinations,
		}))
		if err != nil {
			return err
		}
		// Global Protect proxy-based forwarding profile with block rule and multiple forwarding rules
		_, err = scm.NewForwardingProfile(ctx, "example_gp_proxy_full", &scm.ForwardingProfileArgs{
			Folder:      pulumi.String("Mobile Users"),
			Name:        pulumi.String("example-gp-proxy-full"),
			Description: pulumi.String("Managed by Terraform - GP proxy with block rule and multiple forwarding rules"),
			Type: &scm.ForwardingProfileTypeArgs{
				GlobalProtectProxy: &scm.ForwardingProfileTypeGlobalProtectProxyArgs{
					PacUpload: pulumi.Bool(false),
					BlockRule: &scm.ForwardingProfileTypeGlobalProtectProxyBlockRuleArgs{
						Enable: pulumi.Bool(true),
						AllowTcp: &scm.ForwardingProfileTypeGlobalProtectProxyBlockRuleAllowTcpArgs{
							EnableLocations: pulumi.Bool(true),
							Locations: pulumi.StringArray{
								exampleUsEast.Name,
							},
						},
						AllowUdp: &scm.ForwardingProfileTypeGlobalProtectProxyBlockRuleAllowUdpArgs{
							EnableLocations: pulumi.Bool(true),
							Locations: pulumi.StringArray{
								exampleUsEast.Name,
							},
							EnableDestinations: pulumi.Bool(true),
							Destinations:       pulumi.String("any"),
						},
					},
					ForwardingRules: scm.ForwardingProfileTypeGlobalProtectProxyForwardingRuleArray{
						&scm.ForwardingProfileTypeGlobalProtectProxyForwardingRuleArgs{
							Name:          pulumi.String("direct-rule"),
							Connectivity:  pulumi.String("direct"),
							Destinations:  corpDestinations.Name,
							UserLocations: pulumi.String("Any"),
							Enabled:       pulumi.Bool(true),
						},
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleUsEast,
			corpDestinations,
		}))
		if err != nil {
			return err
		}
		// PAC file based forwarding profile
		_, err = scm.NewForwardingProfile(ctx, "example_pac_file", &scm.ForwardingProfileArgs{
			Folder:      pulumi.String("Mobile Users"),
			Name:        pulumi.String("example-pac-file"),
			Description: pulumi.String("Managed by Terraform - PAC file based forwarding profile"),
			Type: &scm.ForwardingProfileTypeArgs{
				PacFile: &scm.ForwardingProfileTypePacFileArgs{
					PacUpload: pulumi.Bool(true),
					ForwardingRules: scm.ForwardingProfileTypePacFileForwardingRuleArray{
						&scm.ForwardingProfileTypePacFileForwardingRuleArgs{
							Name:         pulumi.String("pac-direct-rule"),
							Connectivity: pulumi.String("direct"),
							Destinations: pulumi.String("Any"),
							Enabled:      pulumi.Bool(true),
						},
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleUsEast,
			corpDestinations,
		}))
		if err != nil {
			return err
		}
		// ZTNA agent-based forwarding profile with block rule and forwarding rules
		_, err = scm.NewForwardingProfile(ctx, "example_ztna_agent", &scm.ForwardingProfileArgs{
			Folder:      pulumi.String("Mobile Users"),
			Name:        pulumi.String("example-ztna-agent"),
			Description: pulumi.String("Managed by Terraform - ZTNA agent forwarding profile with block rule"),
			Type: &scm.ForwardingProfileTypeArgs{
				ZtnaAgent: &scm.ForwardingProfileTypeZtnaAgentArgs{
					BlockRule: &scm.ForwardingProfileTypeZtnaAgentBlockRuleArgs{
						BlockAllOtherUnmatchedOutboundConnections:         pulumi.Bool(false),
						BlockInboundAccessWhenConnectedToTunnel:           pulumi.Bool(false),
						BlockNonTcpNonUdpTrafficWhenConnectedToTunnel:     pulumi.Bool(false),
						AllowIcmpForTroubleshooting:                       pulumi.Bool(false),
						BlockOutboundLanAccessWhenConnectedToTunnel:       pulumi.Bool(false),
						EnforcerFqdnDnsResolutionViaDnsServers:            pulumi.Bool(true),
						ResolveAllFqdnsUsingDnsServersAssignedByTheTunnel: pulumi.Bool(true),
					},
					ForwardingRules: scm.ForwardingProfileTypeZtnaAgentForwardingRuleArray{
						&scm.ForwardingProfileTypeZtnaAgentForwardingRuleArgs{
							Name:               pulumi.String("ztna-dns-rule"),
							Connectivity:       pulumi.String("tunnel"),
							Destinations:       corpDestinations.Name,
							SourceApplications: pulumi.String("Any"),
							TrafficType:        pulumi.String("dns-and-network-traffic"),
							UserLocations:      pulumi.String("Any"),
							Enabled:            pulumi.Bool(true),
						},
						&scm.ForwardingProfileTypeZtnaAgentForwardingRuleArgs{
							Name:               pulumi.String("ztna-direct-rule"),
							Connectivity:       pulumi.String("direct"),
							Destinations:       pulumi.String("Any"),
							SourceApplications: pulumi.String("Any"),
							TrafficType:        pulumi.String("network-traffic"),
							UserLocations:      pulumi.String("Any"),
							Enabled:            pulumi.Bool(true),
						},
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			corpDestinations,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // User location representing the US East office IP ranges
    var exampleUsEast = new Scm.Index.ForwardingProfileUserLocation("example_us_east", new()
    {
        Folder = "Mobile Users",
        Name = "us-east-tf",
        Description = "Managed by Terraform - US East office user location",
        IpAddresses = new[]
        {
            "10.1.0.0/16",
            "10.2.0.0/16",
        },
    });

    // Corporate destination profile with FQDN and IP ranges
    var corpDestinations = new Scm.Index.ForwardingProfileDestination("corp_destinations", new()
    {
        Folder = "Mobile Users",
        Name = "corp-destinations-combined",
        Description = "Managed by Terraform - Corporate FQDN and IP destinations (combined example)",
        Fqdns = new[]
        {
            new Scm.Inputs.ForwardingProfileDestinationFqdnArgs
            {
                Name = "*.corporate.com",
                Port = 443,
            },
            new Scm.Inputs.ForwardingProfileDestinationFqdnArgs
            {
                Name = "api.internal.com",
                Port = 8443,
            },
        },
        IpAddresses = new[]
        {
            new Scm.Inputs.ForwardingProfileDestinationIpAddressArgs
            {
                Name = "10.0.0.0/8",
                Port = 443,
            },
            new Scm.Inputs.ForwardingProfileDestinationIpAddressArgs
            {
                Name = "172.16.0.0/12",
                Port = 443,
            },
        },
    });

    // Basic Global Protect proxy-based forwarding profile with a single forwarding rule
    var exampleGpProxyBasic = new Scm.Index.ForwardingProfile("example_gp_proxy_basic", new()
    {
        Folder = "Mobile Users",
        Name = "example-gp-proxy-basic",
        Type = new Scm.Inputs.ForwardingProfileTypeArgs
        {
            GlobalProtectProxy = new Scm.Inputs.ForwardingProfileTypeGlobalProtectProxyArgs
            {
                ForwardingRules = new[]
                {
                    new Scm.Inputs.ForwardingProfileTypeGlobalProtectProxyForwardingRuleArgs
                    {
                        Name = "direct-rule",
                        Connectivity = "direct",
                        Destinations = "Any",
                        Enabled = true,
                    },
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleUsEast,
            corpDestinations,
        },
    });

    // Global Protect proxy-based forwarding profile with block rule and multiple forwarding rules
    var exampleGpProxyFull = new Scm.Index.ForwardingProfile("example_gp_proxy_full", new()
    {
        Folder = "Mobile Users",
        Name = "example-gp-proxy-full",
        Description = "Managed by Terraform - GP proxy with block rule and multiple forwarding rules",
        Type = new Scm.Inputs.ForwardingProfileTypeArgs
        {
            GlobalProtectProxy = new Scm.Inputs.ForwardingProfileTypeGlobalProtectProxyArgs
            {
                PacUpload = false,
                BlockRule = new Scm.Inputs.ForwardingProfileTypeGlobalProtectProxyBlockRuleArgs
                {
                    Enable = true,
                    AllowTcp = new Scm.Inputs.ForwardingProfileTypeGlobalProtectProxyBlockRuleAllowTcpArgs
                    {
                        EnableLocations = true,
                        Locations = new[]
                        {
                            exampleUsEast.Name,
                        },
                    },
                    AllowUdp = new Scm.Inputs.ForwardingProfileTypeGlobalProtectProxyBlockRuleAllowUdpArgs
                    {
                        EnableLocations = true,
                        Locations = new[]
                        {
                            exampleUsEast.Name,
                        },
                        EnableDestinations = true,
                        Destinations = "any",
                    },
                },
                ForwardingRules = new[]
                {
                    new Scm.Inputs.ForwardingProfileTypeGlobalProtectProxyForwardingRuleArgs
                    {
                        Name = "direct-rule",
                        Connectivity = "direct",
                        Destinations = corpDestinations.Name,
                        UserLocations = "Any",
                        Enabled = true,
                    },
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleUsEast,
            corpDestinations,
        },
    });

    // PAC file based forwarding profile
    var examplePacFile = new Scm.Index.ForwardingProfile("example_pac_file", new()
    {
        Folder = "Mobile Users",
        Name = "example-pac-file",
        Description = "Managed by Terraform - PAC file based forwarding profile",
        Type = new Scm.Inputs.ForwardingProfileTypeArgs
        {
            PacFile = new Scm.Inputs.ForwardingProfileTypePacFileArgs
            {
                PacUpload = true,
                ForwardingRules = new[]
                {
                    new Scm.Inputs.ForwardingProfileTypePacFileForwardingRuleArgs
                    {
                        Name = "pac-direct-rule",
                        Connectivity = "direct",
                        Destinations = "Any",
                        Enabled = true,
                    },
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleUsEast,
            corpDestinations,
        },
    });

    // ZTNA agent-based forwarding profile with block rule and forwarding rules
    var exampleZtnaAgent = new Scm.Index.ForwardingProfile("example_ztna_agent", new()
    {
        Folder = "Mobile Users",
        Name = "example-ztna-agent",
        Description = "Managed by Terraform - ZTNA agent forwarding profile with block rule",
        Type = new Scm.Inputs.ForwardingProfileTypeArgs
        {
            ZtnaAgent = new Scm.Inputs.ForwardingProfileTypeZtnaAgentArgs
            {
                BlockRule = new Scm.Inputs.ForwardingProfileTypeZtnaAgentBlockRuleArgs
                {
                    BlockAllOtherUnmatchedOutboundConnections = false,
                    BlockInboundAccessWhenConnectedToTunnel = false,
                    BlockNonTcpNonUdpTrafficWhenConnectedToTunnel = false,
                    AllowIcmpForTroubleshooting = false,
                    BlockOutboundLanAccessWhenConnectedToTunnel = false,
                    EnforcerFqdnDnsResolutionViaDnsServers = true,
                    ResolveAllFqdnsUsingDnsServersAssignedByTheTunnel = true,
                },
                ForwardingRules = new[]
                {
                    new Scm.Inputs.ForwardingProfileTypeZtnaAgentForwardingRuleArgs
                    {
                        Name = "ztna-dns-rule",
                        Connectivity = "tunnel",
                        Destinations = corpDestinations.Name,
                        SourceApplications = "Any",
                        TrafficType = "dns-and-network-traffic",
                        UserLocations = "Any",
                        Enabled = true,
                    },
                    new Scm.Inputs.ForwardingProfileTypeZtnaAgentForwardingRuleArgs
                    {
                        Name = "ztna-direct-rule",
                        Connectivity = "direct",
                        Destinations = "Any",
                        SourceApplications = "Any",
                        TrafficType = "network-traffic",
                        UserLocations = "Any",
                        Enabled = true,
                    },
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            corpDestinations,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scm.ForwardingProfileUserLocation;
import com.pulumi.scm.ForwardingProfileUserLocationArgs;
import com.pulumi.scm.ForwardingProfileDestination;
import com.pulumi.scm.ForwardingProfileDestinationArgs;
import com.pulumi.scm.inputs.ForwardingProfileDestinationFqdnArgs;
import com.pulumi.scm.inputs.ForwardingProfileDestinationIpAddressArgs;
import com.pulumi.scm.ForwardingProfile;
import com.pulumi.scm.ForwardingProfileArgs;
import com.pulumi.scm.inputs.ForwardingProfileTypeArgs;
import com.pulumi.scm.inputs.ForwardingProfileTypeGlobalProtectProxyArgs;
import com.pulumi.scm.inputs.ForwardingProfileTypeGlobalProtectProxyBlockRuleArgs;
import com.pulumi.scm.inputs.ForwardingProfileTypeGlobalProtectProxyBlockRuleAllowTcpArgs;
import com.pulumi.scm.inputs.ForwardingProfileTypeGlobalProtectProxyBlockRuleAllowUdpArgs;
import com.pulumi.scm.inputs.ForwardingProfileTypePacFileArgs;
import com.pulumi.scm.inputs.ForwardingProfileTypeZtnaAgentArgs;
import com.pulumi.scm.inputs.ForwardingProfileTypeZtnaAgentBlockRuleArgs;
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) {
        // User location representing the US East office IP ranges
        var exampleUsEast = new ForwardingProfileUserLocation("exampleUsEast", ForwardingProfileUserLocationArgs.builder()
            .folder("Mobile Users")
            .name("us-east-tf")
            .description("Managed by Terraform - US East office user location")
            .ipAddresses(            
                "10.1.0.0/16",
                "10.2.0.0/16")
            .build());

        // Corporate destination profile with FQDN and IP ranges
        var corpDestinations = new ForwardingProfileDestination("corpDestinations", ForwardingProfileDestinationArgs.builder()
            .folder("Mobile Users")
            .name("corp-destinations-combined")
            .description("Managed by Terraform - Corporate FQDN and IP destinations (combined example)")
            .fqdns(            
                ForwardingProfileDestinationFqdnArgs.builder()
                    .name("*.corporate.com")
                    .port(443)
                    .build(),
                ForwardingProfileDestinationFqdnArgs.builder()
                    .name("api.internal.com")
                    .port(8443)
                    .build())
            .ipAddresses(            
                ForwardingProfileDestinationIpAddressArgs.builder()
                    .name("10.0.0.0/8")
                    .port(443)
                    .build(),
                ForwardingProfileDestinationIpAddressArgs.builder()
                    .name("172.16.0.0/12")
                    .port(443)
                    .build())
            .build());

        // Basic Global Protect proxy-based forwarding profile with a single forwarding rule
        var exampleGpProxyBasic = new ForwardingProfile("exampleGpProxyBasic", ForwardingProfileArgs.builder()
            .folder("Mobile Users")
            .name("example-gp-proxy-basic")
            .type(ForwardingProfileTypeArgs.builder()
                .globalProtectProxy(ForwardingProfileTypeGlobalProtectProxyArgs.builder()
                    .forwardingRules(ForwardingProfileTypeGlobalProtectProxyForwardingRuleArgs.builder()
                        .name("direct-rule")
                        .connectivity("direct")
                        .destinations("Any")
                        .enabled(true)
                        .build())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    exampleUsEast,
                    corpDestinations)
                .build());

        // Global Protect proxy-based forwarding profile with block rule and multiple forwarding rules
        var exampleGpProxyFull = new ForwardingProfile("exampleGpProxyFull", ForwardingProfileArgs.builder()
            .folder("Mobile Users")
            .name("example-gp-proxy-full")
            .description("Managed by Terraform - GP proxy with block rule and multiple forwarding rules")
            .type(ForwardingProfileTypeArgs.builder()
                .globalProtectProxy(ForwardingProfileTypeGlobalProtectProxyArgs.builder()
                    .pacUpload(false)
                    .blockRule(ForwardingProfileTypeGlobalProtectProxyBlockRuleArgs.builder()
                        .enable(true)
                        .allowTcp(ForwardingProfileTypeGlobalProtectProxyBlockRuleAllowTcpArgs.builder()
                            .enableLocations(true)
                            .locations(exampleUsEast.name())
                            .build())
                        .allowUdp(ForwardingProfileTypeGlobalProtectProxyBlockRuleAllowUdpArgs.builder()
                            .enableLocations(true)
                            .locations(exampleUsEast.name())
                            .enableDestinations(true)
                            .destinations("any")
                            .build())
                        .build())
                    .forwardingRules(ForwardingProfileTypeGlobalProtectProxyForwardingRuleArgs.builder()
                        .name("direct-rule")
                        .connectivity("direct")
                        .destinations(corpDestinations.name())
                        .userLocations("Any")
                        .enabled(true)
                        .build())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    exampleUsEast,
                    corpDestinations)
                .build());

        // PAC file based forwarding profile
        var examplePacFile = new ForwardingProfile("examplePacFile", ForwardingProfileArgs.builder()
            .folder("Mobile Users")
            .name("example-pac-file")
            .description("Managed by Terraform - PAC file based forwarding profile")
            .type(ForwardingProfileTypeArgs.builder()
                .pacFile(ForwardingProfileTypePacFileArgs.builder()
                    .pacUpload(true)
                    .forwardingRules(ForwardingProfileTypePacFileForwardingRuleArgs.builder()
                        .name("pac-direct-rule")
                        .connectivity("direct")
                        .destinations("Any")
                        .enabled(true)
                        .build())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    exampleUsEast,
                    corpDestinations)
                .build());

        // ZTNA agent-based forwarding profile with block rule and forwarding rules
        var exampleZtnaAgent = new ForwardingProfile("exampleZtnaAgent", ForwardingProfileArgs.builder()
            .folder("Mobile Users")
            .name("example-ztna-agent")
            .description("Managed by Terraform - ZTNA agent forwarding profile with block rule")
            .type(ForwardingProfileTypeArgs.builder()
                .ztnaAgent(ForwardingProfileTypeZtnaAgentArgs.builder()
                    .blockRule(ForwardingProfileTypeZtnaAgentBlockRuleArgs.builder()
                        .blockAllOtherUnmatchedOutboundConnections(false)
                        .blockInboundAccessWhenConnectedToTunnel(false)
                        .blockNonTcpNonUdpTrafficWhenConnectedToTunnel(false)
                        .allowIcmpForTroubleshooting(false)
                        .blockOutboundLanAccessWhenConnectedToTunnel(false)
                        .enforcerFqdnDnsResolutionViaDnsServers(true)
                        .resolveAllFqdnsUsingDnsServersAssignedByTheTunnel(true)
                        .build())
                    .forwardingRules(                    
                        ForwardingProfileTypeZtnaAgentForwardingRuleArgs.builder()
                            .name("ztna-dns-rule")
                            .connectivity("tunnel")
                            .destinations(corpDestinations.name())
                            .sourceApplications("Any")
                            .trafficType("dns-and-network-traffic")
                            .userLocations("Any")
                            .enabled(true)
                            .build(),
                        ForwardingProfileTypeZtnaAgentForwardingRuleArgs.builder()
                            .name("ztna-direct-rule")
                            .connectivity("direct")
                            .destinations("Any")
                            .sourceApplications("Any")
                            .trafficType("network-traffic")
                            .userLocations("Any")
                            .enabled(true)
                            .build())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(corpDestinations)
                .build());

    }
}

resources:
  # User location representing the US East office IP ranges
  exampleUsEast:
    type: scm:ForwardingProfileUserLocation
    name: example_us_east
    properties:
      folder: Mobile Users
      name: us-east-tf
      description: Managed by Terraform - US East office user location
      ipAddresses:
        - 10.1.0.0/16
        - 10.2.0.0/16
  # Corporate destination profile with FQDN and IP ranges
  corpDestinations:
    type: scm:ForwardingProfileDestination
    name: corp_destinations
    properties:
      folder: Mobile Users
      name: corp-destinations-combined
      description: Managed by Terraform - Corporate FQDN and IP destinations (combined example)
      fqdns:
        - name: '*.corporate.com'
          port: 443
        - name: api.internal.com
          port: 8443
      ipAddresses:
        - name: 10.0.0.0/8
          port: 443
        - name: 172.16.0.0/12
          port: 443
  # Basic Global Protect proxy-based forwarding profile with a single forwarding rule
  exampleGpProxyBasic:
    type: scm:ForwardingProfile
    name: example_gp_proxy_basic
    properties:
      folder: Mobile Users
      name: example-gp-proxy-basic
      type:
        globalProtectProxy:
          forwardingRules:
            - name: direct-rule
              connectivity: direct
              destinations: Any
              enabled: true
    options:
      dependsOn:
        - ${exampleUsEast}
        - ${corpDestinations}
  # Global Protect proxy-based forwarding profile with block rule and multiple forwarding rules
  exampleGpProxyFull:
    type: scm:ForwardingProfile
    name: example_gp_proxy_full
    properties:
      folder: Mobile Users
      name: example-gp-proxy-full
      description: Managed by Terraform - GP proxy with block rule and multiple forwarding rules
      type:
        globalProtectProxy:
          pacUpload: false
          blockRule:
            enable: true
            allowTcp:
              enableLocations: true
              locations:
                - ${exampleUsEast.name}
            allowUdp:
              enableLocations: true
              locations:
                - ${exampleUsEast.name}
              enableDestinations: true
              destinations: any
          forwardingRules:
            - name: direct-rule
              connectivity: direct
              destinations: ${corpDestinations.name}
              userLocations: Any
              enabled: true
    options:
      dependsOn:
        - ${exampleUsEast}
        - ${corpDestinations}
  # PAC file based forwarding profile
  examplePacFile:
    type: scm:ForwardingProfile
    name: example_pac_file
    properties:
      folder: Mobile Users
      name: example-pac-file
      description: Managed by Terraform - PAC file based forwarding profile
      type:
        pacFile:
          pacUpload: true
          forwardingRules:
            - name: pac-direct-rule
              connectivity: direct
              destinations: Any
              enabled: true
    options:
      dependsOn:
        - ${exampleUsEast}
        - ${corpDestinations}
  # ZTNA agent-based forwarding profile with block rule and forwarding rules
  exampleZtnaAgent:
    type: scm:ForwardingProfile
    name: example_ztna_agent
    properties:
      folder: Mobile Users
      name: example-ztna-agent
      description: Managed by Terraform - ZTNA agent forwarding profile with block rule
      type:
        ztnaAgent:
          blockRule:
            blockAllOtherUnmatchedOutboundConnections: false
            blockInboundAccessWhenConnectedToTunnel: false
            blockNonTcpNonUdpTrafficWhenConnectedToTunnel: false
            allowIcmpForTroubleshooting: false
            blockOutboundLanAccessWhenConnectedToTunnel: false
            enforcerFqdnDnsResolutionViaDnsServers: true
            resolveAllFqdnsUsingDnsServersAssignedByTheTunnel: true
          forwardingRules:
            - name: ztna-dns-rule
              connectivity: tunnel
              destinations: ${corpDestinations.name}
              sourceApplications: Any
              trafficType: dns-and-network-traffic
              userLocations: Any
              enabled: true
            - name: ztna-direct-rule
              connectivity: direct
              destinations: Any
              sourceApplications: Any
              trafficType: network-traffic
              userLocations: Any
              enabled: true
    options:
      dependsOn:
        - ${corpDestinations}

var forwardingProfileResource = new Scm.ForwardingProfile("forwardingProfileResource", new()
{
    DefinitionMethod = "string",
    Description = "string",
    Folder = "string",
    Name = "string",
    Type = new Scm.Inputs.ForwardingProfileTypeArgs
    {
        GlobalProtectProxy = new Scm.Inputs.ForwardingProfileTypeGlobalProtectProxyArgs
        {
            BlockRule = new Scm.Inputs.ForwardingProfileTypeGlobalProtectProxyBlockRuleArgs
            {
                AllowTcp = new Scm.Inputs.ForwardingProfileTypeGlobalProtectProxyBlockRuleAllowTcpArgs
                {
                    EnableLocations = false,
                    Locations = new[]
                    {
                        "string",
                    },
                },
                AllowUdp = new Scm.Inputs.ForwardingProfileTypeGlobalProtectProxyBlockRuleAllowUdpArgs
                {
                    Destinations = "string",
                    EnableDestinations = false,
                    EnableLocations = false,
                    Locations = new[]
                    {
                        "string",
                    },
                },
                Enable = false,
            },
            ForwardingRules = new[]
            {
                new Scm.Inputs.ForwardingProfileTypeGlobalProtectProxyForwardingRuleArgs
                {
                    Name = "string",
                    Connectivity = "string",
                    Destinations = "string",
                    Enabled = false,
                    UserLocations = "string",
                },
            },
            PacUpload = false,
        },
        PacFile = new Scm.Inputs.ForwardingProfileTypePacFileArgs
        {
            BlockRule = new Scm.Inputs.ForwardingProfileTypePacFileBlockRuleArgs
            {
                AllowTcp = new Scm.Inputs.ForwardingProfileTypePacFileBlockRuleAllowTcpArgs
                {
                    EnableLocations = false,
                    Locations = new[]
                    {
                        "string",
                    },
                },
                AllowUdp = new Scm.Inputs.ForwardingProfileTypePacFileBlockRuleAllowUdpArgs
                {
                    Destinations = "string",
                    EnableDestinations = false,
                    EnableLocations = false,
                    Locations = new[]
                    {
                        "string",
                    },
                },
                Enable = false,
            },
            ForwardingRules = new[]
            {
                new Scm.Inputs.ForwardingProfileTypePacFileForwardingRuleArgs
                {
                    Name = "string",
                    Connectivity = "string",
                    Destinations = "string",
                    Enabled = false,
                    UserLocations = "string",
                },
            },
            PacUpload = false,
        },
        ZtnaAgent = new Scm.Inputs.ForwardingProfileTypeZtnaAgentArgs
        {
            BlockRule = new Scm.Inputs.ForwardingProfileTypeZtnaAgentBlockRuleArgs
            {
                AllowIcmpForTroubleshooting = false,
                BlockAllOtherUnmatchedOutboundConnections = false,
                BlockInboundAccessWhenConnectedToTunnel = false,
                BlockNonTcpNonUdpTrafficWhenConnectedToTunnel = false,
                BlockOutboundLanAccessWhenConnectedToTunnel = false,
                EnforcerFqdnDnsResolutionViaDnsServers = false,
                ResolveAllFqdnsUsingDnsServersAssignedByTheTunnel = false,
            },
            ForwardingRules = new[]
            {
                new Scm.Inputs.ForwardingProfileTypeZtnaAgentForwardingRuleArgs
                {
                    Name = "string",
                    Connectivity = "string",
                    Destinations = "string",
                    Enabled = false,
                    SourceApplications = "string",
                    TrafficType = "string",
                    UserLocations = "string",
                },
            },
            PacUpload = false,
        },
    },
});