scm.BgpFilteringProfile

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

//
// Creates an empty bgp filtering profile
//
const scmBgpFilteringProfile = new scm.BgpFilteringProfile("scm_bgp_filtering_profile", {
    folder: "ngfw-shared",
    name: "scm_bgp_filtering_profile",
    ipv4: {},
});
//
// Creates various resources used for scm_bgp_filtering_profile_complex
//
const scmPlInbound = new scm.RoutePrefixList("scm_pl_inbound", {
    folder: "ngfw-shared",
    name: "scm_pl_inbound",
    description: "Managed by Pulumi",
    type: {
        ipv4: {
            ipv4Entries: [{
                name: 10,
                action: "permit",
                prefix: {
                    greaterThanOrEqual: 24,
                    network: "any",
                },
            }],
        },
    },
});
const scmRmInbound = new scm.BgpRouteMap("scm_rm_inbound", {
    folder: "ngfw-shared",
    name: "scm_rm_inbound",
    description: "Managed by Pulumi",
    routeMaps: [{
        name: 10,
        description: "No Export",
        match: {
            ipv4: {
                address: {
                    prefixList: "scm_pl_inbound",
                },
            },
        },
        set: {
            regularCommunity: ["no-export"],
        },
    }],
}, {
    dependsOn: [scmPlInbound],
});
const scmPlOutbound = new scm.RoutePrefixList("scm_pl_outbound", {
    folder: "ngfw-shared",
    name: "scm_pl_outbound",
    description: "Managed by Pulumi",
    type: {
        ipv4: {
            ipv4Entries: [{
                name: 10,
                action: "permit",
                prefix: {
                    greaterThanOrEqual: 24,
                    network: "any",
                },
            }],
        },
    },
});
const scmRmOutbound = new scm.BgpRouteMap("scm_rm_outbound", {
    folder: "ngfw-shared",
    name: "scm_rm_outbound",
    description: "Managed by Pulumi",
    routeMaps: [{
        name: 10,
        description: "No Export",
        match: {
            ipv4: {
                address: {
                    prefixList: "scm_pl_outbound",
                },
            },
        },
        set: {
            regularCommunity: ["no-export"],
        },
    }],
}, {
    dependsOn: [scmPlOutbound],
});
//
// Creates a complex filtering profile that utilises previously created FL, PL and RM
//
const scmBgpFilteringProfileComplex = new scm.BgpFilteringProfile("scm_bgp_filtering_profile_complex", {
    folder: "ngfw-shared",
    name: "scm_bgp_filtering_profile_complex",
    ipv4: {
        unicast: {
            inboundNetworkFilters: {
                prefixList: "scm_pl_inbound",
            },
            routeMaps: {
                inbound: "scm_rm_inbound",
                outbound: "scm_rm_outbound",
            },
        },
    },
}, {
    dependsOn: [
        scmPlInbound,
        scmRmInbound,
        scmRmOutbound,
    ],
});

import pulumi
import pulumi_scm as scm

#
# Creates an empty bgp filtering profile
#
scm_bgp_filtering_profile = scm.BgpFilteringProfile("scm_bgp_filtering_profile",
    folder="ngfw-shared",
    name="scm_bgp_filtering_profile",
    ipv4={})
#
# Creates various resources used for scm_bgp_filtering_profile_complex
#
scm_pl_inbound = scm.RoutePrefixList("scm_pl_inbound",
    folder="ngfw-shared",
    name="scm_pl_inbound",
    description="Managed by Pulumi",
    type={
        "ipv4": {
            "ipv4_entries": [{
                "name": 10,
                "action": "permit",
                "prefix": {
                    "greater_than_or_equal": 24,
                    "network": "any",
                },
            }],
        },
    })
scm_rm_inbound = scm.BgpRouteMap("scm_rm_inbound",
    folder="ngfw-shared",
    name="scm_rm_inbound",
    description="Managed by Pulumi",
    route_maps=[{
        "name": 10,
        "description": "No Export",
        "match": {
            "ipv4": {
                "address": {
                    "prefix_list": "scm_pl_inbound",
                },
            },
        },
        "set": {
            "regular_community": ["no-export"],
        },
    }],
    opts = pulumi.ResourceOptions(depends_on=[scm_pl_inbound]))
scm_pl_outbound = scm.RoutePrefixList("scm_pl_outbound",
    folder="ngfw-shared",
    name="scm_pl_outbound",
    description="Managed by Pulumi",
    type={
        "ipv4": {
            "ipv4_entries": [{
                "name": 10,
                "action": "permit",
                "prefix": {
                    "greater_than_or_equal": 24,
                    "network": "any",
                },
            }],
        },
    })
scm_rm_outbound = scm.BgpRouteMap("scm_rm_outbound",
    folder="ngfw-shared",
    name="scm_rm_outbound",
    description="Managed by Pulumi",
    route_maps=[{
        "name": 10,
        "description": "No Export",
        "match": {
            "ipv4": {
                "address": {
                    "prefix_list": "scm_pl_outbound",
                },
            },
        },
        "set": {
            "regular_community": ["no-export"],
        },
    }],
    opts = pulumi.ResourceOptions(depends_on=[scm_pl_outbound]))
#
# Creates a complex filtering profile that utilises previously created FL, PL and RM
#
scm_bgp_filtering_profile_complex = scm.BgpFilteringProfile("scm_bgp_filtering_profile_complex",
    folder="ngfw-shared",
    name="scm_bgp_filtering_profile_complex",
    ipv4={
        "unicast": {
            "inbound_network_filters": {
                "prefix_list": "scm_pl_inbound",
            },
            "route_maps": {
                "inbound": "scm_rm_inbound",
                "outbound": "scm_rm_outbound",
            },
        },
    },
    opts = pulumi.ResourceOptions(depends_on=[
            scm_pl_inbound,
            scm_rm_inbound,
            scm_rm_outbound,
        ]))

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 {
		// Creates an empty bgp filtering profile
		_, err := scm.NewBgpFilteringProfile(ctx, "scm_bgp_filtering_profile", &scm.BgpFilteringProfileArgs{
			Folder: pulumi.String("ngfw-shared"),
			Name:   pulumi.String("scm_bgp_filtering_profile"),
			Ipv4:   &scm.BgpFilteringProfileIpv4Args{},
		})
		if err != nil {
			return err
		}
		// Creates various resources used for scm_bgp_filtering_profile_complex
		scmPlInbound, err := scm.NewRoutePrefixList(ctx, "scm_pl_inbound", &scm.RoutePrefixListArgs{
			Folder:      pulumi.String("ngfw-shared"),
			Name:        pulumi.String("scm_pl_inbound"),
			Description: pulumi.String("Managed by Pulumi"),
			Type: &scm.RoutePrefixListTypeArgs{
				Ipv4: &scm.RoutePrefixListTypeIpv4Args{
					Ipv4Entries: scm.RoutePrefixListTypeIpv4Ipv4EntryArray{
						&scm.RoutePrefixListTypeIpv4Ipv4EntryArgs{
							Name:   pulumi.Int(10),
							Action: pulumi.String("permit"),
							Prefix: &scm.RoutePrefixListTypeIpv4Ipv4EntryPrefixArgs{
								GreaterThanOrEqual: 24,
								Network:            pulumi.String("any"),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		scmRmInbound, err := scm.NewBgpRouteMap(ctx, "scm_rm_inbound", &scm.BgpRouteMapArgs{
			Folder:      pulumi.String("ngfw-shared"),
			Name:        pulumi.String("scm_rm_inbound"),
			Description: pulumi.String("Managed by Pulumi"),
			RouteMaps: scm.BgpRouteMapRouteMapArray{
				&scm.BgpRouteMapRouteMapArgs{
					Name:        pulumi.Int(10),
					Description: pulumi.String("No Export"),
					Match: &scm.BgpRouteMapRouteMapMatchArgs{
						Ipv4: &scm.BgpRouteMapRouteMapMatchIpv4Args{
							Address: &scm.BgpRouteMapRouteMapMatchIpv4AddressArgs{
								PrefixList: pulumi.String("scm_pl_inbound"),
							},
						},
					},
					Set: &scm.BgpRouteMapRouteMapSetArgs{
						RegularCommunity: []string{
							"no-export",
						},
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			scmPlInbound,
		}))
		if err != nil {
			return err
		}
		scmPlOutbound, err := scm.NewRoutePrefixList(ctx, "scm_pl_outbound", &scm.RoutePrefixListArgs{
			Folder:      pulumi.String("ngfw-shared"),
			Name:        pulumi.String("scm_pl_outbound"),
			Description: pulumi.String("Managed by Pulumi"),
			Type: &scm.RoutePrefixListTypeArgs{
				Ipv4: &scm.RoutePrefixListTypeIpv4Args{
					Ipv4Entries: scm.RoutePrefixListTypeIpv4Ipv4EntryArray{
						&scm.RoutePrefixListTypeIpv4Ipv4EntryArgs{
							Name:   pulumi.Int(10),
							Action: pulumi.String("permit"),
							Prefix: &scm.RoutePrefixListTypeIpv4Ipv4EntryPrefixArgs{
								GreaterThanOrEqual: 24,
								Network:            pulumi.String("any"),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		scmRmOutbound, err := scm.NewBgpRouteMap(ctx, "scm_rm_outbound", &scm.BgpRouteMapArgs{
			Folder:      pulumi.String("ngfw-shared"),
			Name:        pulumi.String("scm_rm_outbound"),
			Description: pulumi.String("Managed by Pulumi"),
			RouteMaps: scm.BgpRouteMapRouteMapArray{
				&scm.BgpRouteMapRouteMapArgs{
					Name:        pulumi.Int(10),
					Description: pulumi.String("No Export"),
					Match: &scm.BgpRouteMapRouteMapMatchArgs{
						Ipv4: &scm.BgpRouteMapRouteMapMatchIpv4Args{
							Address: &scm.BgpRouteMapRouteMapMatchIpv4AddressArgs{
								PrefixList: pulumi.String("scm_pl_outbound"),
							},
						},
					},
					Set: &scm.BgpRouteMapRouteMapSetArgs{
						RegularCommunity: []string{
							"no-export",
						},
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			scmPlOutbound,
		}))
		if err != nil {
			return err
		}
		// Creates a complex filtering profile that utilises previously created FL, PL and RM
		_, err = scm.NewBgpFilteringProfile(ctx, "scm_bgp_filtering_profile_complex", &scm.BgpFilteringProfileArgs{
			Folder: pulumi.String("ngfw-shared"),
			Name:   pulumi.String("scm_bgp_filtering_profile_complex"),
			Ipv4: &scm.BgpFilteringProfileIpv4Args{
				Unicast: &scm.BgpFilteringProfileIpv4UnicastArgs{
					InboundNetworkFilters: &scm.BgpFilteringProfileIpv4UnicastInboundNetworkFiltersArgs{
						PrefixList: pulumi.String("scm_pl_inbound"),
					},
					RouteMaps: &scm.BgpFilteringProfileIpv4UnicastRouteMapsArgs{
						Inbound:  pulumi.String("scm_rm_inbound"),
						Outbound: pulumi.String("scm_rm_outbound"),
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			scmPlInbound,
			scmRmInbound,
			scmRmOutbound,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    //
    // Creates an empty bgp filtering profile
    //
    var scmBgpFilteringProfile = new Scm.BgpFilteringProfile("scm_bgp_filtering_profile", new()
    {
        Folder = "ngfw-shared",
        Name = "scm_bgp_filtering_profile",
        Ipv4 = null,
    });

    //
    // Creates various resources used for scm_bgp_filtering_profile_complex
    //
    var scmPlInbound = new Scm.RoutePrefixList("scm_pl_inbound", new()
    {
        Folder = "ngfw-shared",
        Name = "scm_pl_inbound",
        Description = "Managed by Pulumi",
        Type = new Scm.Inputs.RoutePrefixListTypeArgs
        {
            Ipv4 = new Scm.Inputs.RoutePrefixListTypeIpv4Args
            {
                Ipv4Entries = new[]
                {
                    new Scm.Inputs.RoutePrefixListTypeIpv4Ipv4EntryArgs
                    {
                        Name = 10,
                        Action = "permit",
                        Prefix = new Scm.Inputs.RoutePrefixListTypeIpv4Ipv4EntryPrefixArgs
                        {
                            GreaterThanOrEqual = 24,
                            Network = "any",
                        },
                    },
                },
            },
        },
    });

    var scmRmInbound = new Scm.BgpRouteMap("scm_rm_inbound", new()
    {
        Folder = "ngfw-shared",
        Name = "scm_rm_inbound",
        Description = "Managed by Pulumi",
        RouteMaps = new[]
        {
            new Scm.Inputs.BgpRouteMapRouteMapArgs
            {
                Name = 10,
                Description = "No Export",
                Match = new Scm.Inputs.BgpRouteMapRouteMapMatchArgs
                {
                    Ipv4 = new Scm.Inputs.BgpRouteMapRouteMapMatchIpv4Args
                    {
                        Address = new Scm.Inputs.BgpRouteMapRouteMapMatchIpv4AddressArgs
                        {
                            PrefixList = "scm_pl_inbound",
                        },
                    },
                },
                Set = new Scm.Inputs.BgpRouteMapRouteMapSetArgs
                {
                    RegularCommunity = new[]
                    {
                        "no-export",
                    },
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            scmPlInbound,
        },
    });

    var scmPlOutbound = new Scm.RoutePrefixList("scm_pl_outbound", new()
    {
        Folder = "ngfw-shared",
        Name = "scm_pl_outbound",
        Description = "Managed by Pulumi",
        Type = new Scm.Inputs.RoutePrefixListTypeArgs
        {
            Ipv4 = new Scm.Inputs.RoutePrefixListTypeIpv4Args
            {
                Ipv4Entries = new[]
                {
                    new Scm.Inputs.RoutePrefixListTypeIpv4Ipv4EntryArgs
                    {
                        Name = 10,
                        Action = "permit",
                        Prefix = new Scm.Inputs.RoutePrefixListTypeIpv4Ipv4EntryPrefixArgs
                        {
                            GreaterThanOrEqual = 24,
                            Network = "any",
                        },
                    },
                },
            },
        },
    });

    var scmRmOutbound = new Scm.BgpRouteMap("scm_rm_outbound", new()
    {
        Folder = "ngfw-shared",
        Name = "scm_rm_outbound",
        Description = "Managed by Pulumi",
        RouteMaps = new[]
        {
            new Scm.Inputs.BgpRouteMapRouteMapArgs
            {
                Name = 10,
                Description = "No Export",
                Match = new Scm.Inputs.BgpRouteMapRouteMapMatchArgs
                {
                    Ipv4 = new Scm.Inputs.BgpRouteMapRouteMapMatchIpv4Args
                    {
                        Address = new Scm.Inputs.BgpRouteMapRouteMapMatchIpv4AddressArgs
                        {
                            PrefixList = "scm_pl_outbound",
                        },
                    },
                },
                Set = new Scm.Inputs.BgpRouteMapRouteMapSetArgs
                {
                    RegularCommunity = new[]
                    {
                        "no-export",
                    },
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            scmPlOutbound,
        },
    });

    //
    // Creates a complex filtering profile that utilises previously created FL, PL and RM
    //
    var scmBgpFilteringProfileComplex = new Scm.BgpFilteringProfile("scm_bgp_filtering_profile_complex", new()
    {
        Folder = "ngfw-shared",
        Name = "scm_bgp_filtering_profile_complex",
        Ipv4 = new Scm.Inputs.BgpFilteringProfileIpv4Args
        {
            Unicast = new Scm.Inputs.BgpFilteringProfileIpv4UnicastArgs
            {
                InboundNetworkFilters = new Scm.Inputs.BgpFilteringProfileIpv4UnicastInboundNetworkFiltersArgs
                {
                    PrefixList = "scm_pl_inbound",
                },
                RouteMaps = new Scm.Inputs.BgpFilteringProfileIpv4UnicastRouteMapsArgs
                {
                    Inbound = "scm_rm_inbound",
                    Outbound = "scm_rm_outbound",
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            scmPlInbound,
            scmRmInbound,
            scmRmOutbound,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scm.BgpFilteringProfile;
import com.pulumi.scm.BgpFilteringProfileArgs;
import com.pulumi.scm.inputs.BgpFilteringProfileIpv4Args;
import com.pulumi.scm.RoutePrefixList;
import com.pulumi.scm.RoutePrefixListArgs;
import com.pulumi.scm.inputs.RoutePrefixListTypeArgs;
import com.pulumi.scm.inputs.RoutePrefixListTypeIpv4Args;
import com.pulumi.scm.BgpRouteMap;
import com.pulumi.scm.BgpRouteMapArgs;
import com.pulumi.scm.inputs.BgpRouteMapRouteMapArgs;
import com.pulumi.scm.inputs.BgpRouteMapRouteMapMatchArgs;
import com.pulumi.scm.inputs.BgpRouteMapRouteMapMatchIpv4Args;
import com.pulumi.scm.inputs.BgpRouteMapRouteMapMatchIpv4AddressArgs;
import com.pulumi.scm.inputs.BgpRouteMapRouteMapSetArgs;
import com.pulumi.scm.inputs.BgpFilteringProfileIpv4UnicastArgs;
import com.pulumi.scm.inputs.BgpFilteringProfileIpv4UnicastInboundNetworkFiltersArgs;
import com.pulumi.scm.inputs.BgpFilteringProfileIpv4UnicastRouteMapsArgs;
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) {
        //
        // Creates an empty bgp filtering profile
        //
        var scmBgpFilteringProfile = new BgpFilteringProfile("scmBgpFilteringProfile", BgpFilteringProfileArgs.builder()
            .folder("ngfw-shared")
            .name("scm_bgp_filtering_profile")
            .ipv4(BgpFilteringProfileIpv4Args.builder()
                .build())
            .build());

        //
        // Creates various resources used for scm_bgp_filtering_profile_complex
        //
        var scmPlInbound = new RoutePrefixList("scmPlInbound", RoutePrefixListArgs.builder()
            .folder("ngfw-shared")
            .name("scm_pl_inbound")
            .description("Managed by Pulumi")
            .type(RoutePrefixListTypeArgs.builder()
                .ipv4(RoutePrefixListTypeIpv4Args.builder()
                    .ipv4Entries(RoutePrefixListTypeIpv4Ipv4EntryArgs.builder()
                        .name(10)
                        .action("permit")
                        .prefix(RoutePrefixListTypeIpv4Ipv4EntryPrefixArgs.builder()
                            .greaterThanOrEqual(24)
                            .network("any")
                            .build())
                        .build())
                    .build())
                .build())
            .build());

        var scmRmInbound = new BgpRouteMap("scmRmInbound", BgpRouteMapArgs.builder()
            .folder("ngfw-shared")
            .name("scm_rm_inbound")
            .description("Managed by Pulumi")
            .routeMaps(BgpRouteMapRouteMapArgs.builder()
                .name(10)
                .description("No Export")
                .match(BgpRouteMapRouteMapMatchArgs.builder()
                    .ipv4(BgpRouteMapRouteMapMatchIpv4Args.builder()
                        .address(BgpRouteMapRouteMapMatchIpv4AddressArgs.builder()
                            .prefixList("scm_pl_inbound")
                            .build())
                        .build())
                    .build())
                .set(BgpRouteMapRouteMapSetArgs.builder()
                    .regularCommunity(List.of("no-export"))
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(scmPlInbound)
                .build());

        var scmPlOutbound = new RoutePrefixList("scmPlOutbound", RoutePrefixListArgs.builder()
            .folder("ngfw-shared")
            .name("scm_pl_outbound")
            .description("Managed by Pulumi")
            .type(RoutePrefixListTypeArgs.builder()
                .ipv4(RoutePrefixListTypeIpv4Args.builder()
                    .ipv4Entries(RoutePrefixListTypeIpv4Ipv4EntryArgs.builder()
                        .name(10)
                        .action("permit")
                        .prefix(RoutePrefixListTypeIpv4Ipv4EntryPrefixArgs.builder()
                            .greaterThanOrEqual(24)
                            .network("any")
                            .build())
                        .build())
                    .build())
                .build())
            .build());

        var scmRmOutbound = new BgpRouteMap("scmRmOutbound", BgpRouteMapArgs.builder()
            .folder("ngfw-shared")
            .name("scm_rm_outbound")
            .description("Managed by Pulumi")
            .routeMaps(BgpRouteMapRouteMapArgs.builder()
                .name(10)
                .description("No Export")
                .match(BgpRouteMapRouteMapMatchArgs.builder()
                    .ipv4(BgpRouteMapRouteMapMatchIpv4Args.builder()
                        .address(BgpRouteMapRouteMapMatchIpv4AddressArgs.builder()
                            .prefixList("scm_pl_outbound")
                            .build())
                        .build())
                    .build())
                .set(BgpRouteMapRouteMapSetArgs.builder()
                    .regularCommunity(List.of("no-export"))
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(scmPlOutbound)
                .build());

        //
        // Creates a complex filtering profile that utilises previously created FL, PL and RM
        //
        var scmBgpFilteringProfileComplex = new BgpFilteringProfile("scmBgpFilteringProfileComplex", BgpFilteringProfileArgs.builder()
            .folder("ngfw-shared")
            .name("scm_bgp_filtering_profile_complex")
            .ipv4(BgpFilteringProfileIpv4Args.builder()
                .unicast(BgpFilteringProfileIpv4UnicastArgs.builder()
                    .inboundNetworkFilters(BgpFilteringProfileIpv4UnicastInboundNetworkFiltersArgs.builder()
                        .prefixList("scm_pl_inbound")
                        .build())
                    .routeMaps(BgpFilteringProfileIpv4UnicastRouteMapsArgs.builder()
                        .inbound("scm_rm_inbound")
                        .outbound("scm_rm_outbound")
                        .build())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    scmPlInbound,
                    scmRmInbound,
                    scmRmOutbound)
                .build());

    }
}

resources:
  #
  # Creates an empty bgp filtering profile
  #
  scmBgpFilteringProfile:
    type: scm:BgpFilteringProfile
    name: scm_bgp_filtering_profile
    properties:
      folder: ngfw-shared
      name: scm_bgp_filtering_profile
      ipv4: {}
  #
  # Creates a complex filtering profile that utilises previously created FL, PL and RM
  #
  scmBgpFilteringProfileComplex:
    type: scm:BgpFilteringProfile
    name: scm_bgp_filtering_profile_complex
    properties:
      folder: ngfw-shared
      name: scm_bgp_filtering_profile_complex
      ipv4:
        unicast:
          inboundNetworkFilters:
            prefixList: scm_pl_inbound
          routeMaps:
            inbound: scm_rm_inbound
            outbound: scm_rm_outbound
    options:
      dependsOn:
        - ${scmPlInbound}
        - ${scmRmInbound}
        - ${scmRmOutbound}
  #
  # Creates various resources used for scm_bgp_filtering_profile_complex
  #
  scmPlInbound:
    type: scm:RoutePrefixList
    name: scm_pl_inbound
    properties:
      folder: ngfw-shared
      name: scm_pl_inbound
      description: Managed by Pulumi
      type:
        ipv4:
          ipv4Entries:
            - name: 10
              action: permit
              prefix:
                greaterThanOrEqual: 24
                network: any
  scmPlOutbound:
    type: scm:RoutePrefixList
    name: scm_pl_outbound
    properties:
      folder: ngfw-shared
      name: scm_pl_outbound
      description: Managed by Pulumi
      type:
        ipv4:
          ipv4Entries:
            - name: 10
              action: permit
              prefix:
                greaterThanOrEqual: 24
                network: any
  scmRmInbound:
    type: scm:BgpRouteMap
    name: scm_rm_inbound
    properties:
      folder: ngfw-shared
      name: scm_rm_inbound
      description: Managed by Pulumi
      routeMaps:
        - name: 10
          description: No Export
          match:
            ipv4:
              address:
                prefixList: scm_pl_inbound
          set:
            regularCommunity:
              - no-export
    options:
      dependsOn:
        - ${scmPlInbound}
  scmRmOutbound:
    type: scm:BgpRouteMap
    name: scm_rm_outbound
    properties:
      folder: ngfw-shared
      name: scm_rm_outbound
      description: Managed by Pulumi
      routeMaps:
        - name: 10
          description: No Export
          match:
            ipv4:
              address:
                prefixList: scm_pl_outbound
          set:
            regularCommunity:
              - no-export
    options:
      dependsOn:
        - ${scmPlOutbound}

var bgpFilteringProfileResource = new Scm.BgpFilteringProfile("bgpFilteringProfileResource", new()
{
    Description = "string",
    Device = "string",
    Folder = "string",
    Ipv4 = new Scm.Inputs.BgpFilteringProfileIpv4Args
    {
        Multicast = new Scm.Inputs.BgpFilteringProfileIpv4MulticastArgs
        {
            ConditionalAdvertisement = new Scm.Inputs.BgpFilteringProfileIpv4MulticastConditionalAdvertisementArgs
            {
                Exist = new Scm.Inputs.BgpFilteringProfileIpv4MulticastConditionalAdvertisementExistArgs
                {
                    AdvertiseMap = "string",
                    ExistMap = "string",
                },
                NonExist = new Scm.Inputs.BgpFilteringProfileIpv4MulticastConditionalAdvertisementNonExistArgs
                {
                    AdvertiseMap = "string",
                    NonExistMap = "string",
                },
            },
            FilterList = new Scm.Inputs.BgpFilteringProfileIpv4MulticastFilterListArgs
            {
                Inbound = "string",
                Outbound = "string",
            },
            InboundNetworkFilters = new Scm.Inputs.BgpFilteringProfileIpv4MulticastInboundNetworkFiltersArgs
            {
                DistributeList = "string",
                PrefixList = "string",
            },
            Inherit = false,
            OutboundNetworkFilters = new Scm.Inputs.BgpFilteringProfileIpv4MulticastOutboundNetworkFiltersArgs
            {
                DistributeList = "string",
                PrefixList = "string",
            },
            RouteMaps = new Scm.Inputs.BgpFilteringProfileIpv4MulticastRouteMapsArgs
            {
                Inbound = "string",
                Outbound = "string",
            },
            UnsuppressMap = "string",
        },
        Unicast = new Scm.Inputs.BgpFilteringProfileIpv4UnicastArgs
        {
            ConditionalAdvertisement = new Scm.Inputs.BgpFilteringProfileIpv4UnicastConditionalAdvertisementArgs
            {
                Exist = new Scm.Inputs.BgpFilteringProfileIpv4UnicastConditionalAdvertisementExistArgs
                {
                    AdvertiseMap = "string",
                    ExistMap = "string",
                },
                NonExist = new Scm.Inputs.BgpFilteringProfileIpv4UnicastConditionalAdvertisementNonExistArgs
                {
                    AdvertiseMap = "string",
                    NonExistMap = "string",
                },
            },
            FilterList = new Scm.Inputs.BgpFilteringProfileIpv4UnicastFilterListArgs
            {
                Inbound = "string",
                Outbound = "string",
            },
            InboundNetworkFilters = new Scm.Inputs.BgpFilteringProfileIpv4UnicastInboundNetworkFiltersArgs
            {
                DistributeList = "string",
                PrefixList = "string",
            },
            OutboundNetworkFilters = new Scm.Inputs.BgpFilteringProfileIpv4UnicastOutboundNetworkFiltersArgs
            {
                DistributeList = "string",
                PrefixList = "string",
            },
            RouteMaps = new Scm.Inputs.BgpFilteringProfileIpv4UnicastRouteMapsArgs
            {
                Inbound = "string",
                Outbound = "string",
            },
            UnsuppressMap = "string",
        },
    },
    Name = "string",
    Snippet = "string",
});

example, err := scm.NewBgpFilteringProfile(ctx, "bgpFilteringProfileResource", &scm.BgpFilteringProfileArgs{
	Description: pulumi.String("string"),
	Device:      pulumi.String("string"),
	Folder:      pulumi.String("string"),
	Ipv4: &scm.BgpFilteringProfileIpv4Args{
		Multicast: &scm.BgpFilteringProfileIpv4MulticastArgs{
			ConditionalAdvertisement: &scm.BgpFilteringProfileIpv4MulticastConditionalAdvertisementArgs{
				Exist: &scm.BgpFilteringProfileIpv4MulticastConditionalAdvertisementExistArgs{
					AdvertiseMap: pulumi.String("string"),
					ExistMap:     pulumi.String("string"),
				},
				NonExist: &scm.BgpFilteringProfileIpv4MulticastConditionalAdvertisementNonExistArgs{
					AdvertiseMap: pulumi.String("string"),
					NonExistMap:  pulumi.String("string"),
				},
			},
			FilterList: &scm.BgpFilteringProfileIpv4MulticastFilterListArgs{
				Inbound:  pulumi.String("string"),
				Outbound: pulumi.String("string"),
			},
			InboundNetworkFilters: &scm.BgpFilteringProfileIpv4MulticastInboundNetworkFiltersArgs{
				DistributeList: pulumi.String("string"),
				PrefixList:     pulumi.String("string"),
			},
			Inherit: pulumi.Bool(false),
			OutboundNetworkFilters: &scm.BgpFilteringProfileIpv4MulticastOutboundNetworkFiltersArgs{
				DistributeList: pulumi.String("string"),
				PrefixList:     pulumi.String("string"),
			},
			RouteMaps: &scm.BgpFilteringProfileIpv4MulticastRouteMapsArgs{
				Inbound:  pulumi.String("string"),
				Outbound: pulumi.String("string"),
			},
			UnsuppressMap: pulumi.String("string"),
		},
		Unicast: &scm.BgpFilteringProfileIpv4UnicastArgs{
			ConditionalAdvertisement: &scm.BgpFilteringProfileIpv4UnicastConditionalAdvertisementArgs{
				Exist: &scm.BgpFilteringProfileIpv4UnicastConditionalAdvertisementExistArgs{
					AdvertiseMap: pulumi.String("string"),
					ExistMap:     pulumi.String("string"),
				},
				NonExist: &scm.BgpFilteringProfileIpv4UnicastConditionalAdvertisementNonExistArgs{
					AdvertiseMap: pulumi.String("string"),
					NonExistMap:  pulumi.String("string"),
				},
			},
			FilterList: &scm.BgpFilteringProfileIpv4UnicastFilterListArgs{
				Inbound:  pulumi.String("string"),
				Outbound: pulumi.String("string"),
			},
			InboundNetworkFilters: &scm.BgpFilteringProfileIpv4UnicastInboundNetworkFiltersArgs{
				DistributeList: pulumi.String("string"),
				PrefixList:     pulumi.String("string"),
			},
			OutboundNetworkFilters: &scm.BgpFilteringProfileIpv4UnicastOutboundNetworkFiltersArgs{
				DistributeList: pulumi.String("string"),
				PrefixList:     pulumi.String("string"),
			},
			RouteMaps: &scm.BgpFilteringProfileIpv4UnicastRouteMapsArgs{
				Inbound:  pulumi.String("string"),
				Outbound: pulumi.String("string"),
			},
			UnsuppressMap: pulumi.String("string"),
		},
	},
	Name:    pulumi.String("string"),
	Snippet: pulumi.String("string"),
})

var bgpFilteringProfileResource = new BgpFilteringProfile("bgpFilteringProfileResource", BgpFilteringProfileArgs.builder()
    .description("string")
    .device("string")
    .folder("string")
    .ipv4(BgpFilteringProfileIpv4Args.builder()
        .multicast(BgpFilteringProfileIpv4MulticastArgs.builder()
            .conditionalAdvertisement(BgpFilteringProfileIpv4MulticastConditionalAdvertisementArgs.builder()
                .exist(BgpFilteringProfileIpv4MulticastConditionalAdvertisementExistArgs.builder()
                    .advertiseMap("string")
                    .existMap("string")
                    .build())
                .nonExist(BgpFilteringProfileIpv4MulticastConditionalAdvertisementNonExistArgs.builder()
                    .advertiseMap("string")
                    .nonExistMap("string")
                    .build())
                .build())
            .filterList(BgpFilteringProfileIpv4MulticastFilterListArgs.builder()
                .inbound("string")
                .outbound("string")
                .build())
            .inboundNetworkFilters(BgpFilteringProfileIpv4MulticastInboundNetworkFiltersArgs.builder()
                .distributeList("string")
                .prefixList("string")
                .build())
            .inherit(false)
            .outboundNetworkFilters(BgpFilteringProfileIpv4MulticastOutboundNetworkFiltersArgs.builder()
                .distributeList("string")
                .prefixList("string")
                .build())
            .routeMaps(BgpFilteringProfileIpv4MulticastRouteMapsArgs.builder()
                .inbound("string")
                .outbound("string")
                .build())
            .unsuppressMap("string")
            .build())
        .unicast(BgpFilteringProfileIpv4UnicastArgs.builder()
            .conditionalAdvertisement(BgpFilteringProfileIpv4UnicastConditionalAdvertisementArgs.builder()
                .exist(BgpFilteringProfileIpv4UnicastConditionalAdvertisementExistArgs.builder()
                    .advertiseMap("string")
                    .existMap("string")
                    .build())
                .nonExist(BgpFilteringProfileIpv4UnicastConditionalAdvertisementNonExistArgs.builder()
                    .advertiseMap("string")
                    .nonExistMap("string")
                    .build())
                .build())
            .filterList(BgpFilteringProfileIpv4UnicastFilterListArgs.builder()
                .inbound("string")
                .outbound("string")
                .build())
            .inboundNetworkFilters(BgpFilteringProfileIpv4UnicastInboundNetworkFiltersArgs.builder()
                .distributeList("string")
                .prefixList("string")
                .build())
            .outboundNetworkFilters(BgpFilteringProfileIpv4UnicastOutboundNetworkFiltersArgs.builder()
                .distributeList("string")
                .prefixList("string")
                .build())
            .routeMaps(BgpFilteringProfileIpv4UnicastRouteMapsArgs.builder()
                .inbound("string")
                .outbound("string")
                .build())
            .unsuppressMap("string")
            .build())
        .build())
    .name("string")
    .snippet("string")
    .build());

bgp_filtering_profile_resource = scm.BgpFilteringProfile("bgpFilteringProfileResource",
    description="string",
    device="string",
    folder="string",
    ipv4={
        "multicast": {
            "conditional_advertisement": {
                "exist": {
                    "advertise_map": "string",
                    "exist_map": "string",
                },
                "non_exist": {
                    "advertise_map": "string",
                    "non_exist_map": "string",
                },
            },
            "filter_list": {
                "inbound": "string",
                "outbound": "string",
            },
            "inbound_network_filters": {
                "distribute_list": "string",
                "prefix_list": "string",
            },
            "inherit": False,
            "outbound_network_filters": {
                "distribute_list": "string",
                "prefix_list": "string",
            },
            "route_maps": {
                "inbound": "string",
                "outbound": "string",
            },
            "unsuppress_map": "string",
        },
        "unicast": {
            "conditional_advertisement": {
                "exist": {
                    "advertise_map": "string",
                    "exist_map": "string",
                },
                "non_exist": {
                    "advertise_map": "string",
                    "non_exist_map": "string",
                },
            },
            "filter_list": {
                "inbound": "string",
                "outbound": "string",
            },
            "inbound_network_filters": {
                "distribute_list": "string",
                "prefix_list": "string",
            },
            "outbound_network_filters": {
                "distribute_list": "string",
                "prefix_list": "string",
            },
            "route_maps": {
                "inbound": "string",
                "outbound": "string",
            },
            "unsuppress_map": "string",
        },
    },
    name="string",
    snippet="string")