scm.AggregateInterface

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

//
// Creates a layer 2 aggregate interface without vlan configuration
//
const scmAggregateIntfL2 = new scm.AggregateInterface("scm_aggregate_intf_l2", {
    name: "$scm_aggregate_intf_l2",
    comment: "Managed by Pulumi",
    folder: "ngfw-shared",
    layer2: {},
});
//
// Creates a layer 2 aggregate interface with vlan and lacp configuration
//
const scmAggregateIntfL2Lacp = new scm.AggregateInterface("scm_aggregate_intf_l2_lacp", {
    name: "$scm_aggregate_intf_l2_lacp",
    comment: "Managed by Pulumi",
    folder: "ngfw-shared",
    layer2: {
        vlanTag: "1234",
        lacp: {
            enable: true,
            fastFailover: true,
            systenPriority: 32768,
            transmissionRate: "fast",
            highAvailability: {
                passivePreNegotiation: true,
            },
        },
        lldp: {
            enable: false,
        },
    },
});
//
// Creates a layer3 aggregate interface without ip configuration
//
const scmAggregateIntfL3 = new scm.AggregateInterface("scm_aggregate_intf_l3", {
    name: "$scm_aggregate_intf_l3",
    comment: "Managed by Pulumi",
    folder: "ngfw-shared",
    layer3: {},
});
//
// Creates a layer3 aggregate interface with static ip address and lacp
//
const scmAggregateIntfL3Static = new scm.AggregateInterface("scm_aggregate_intf_l3_static", {
    name: "$scm_aggregate_intf_l3_static",
    comment: "Managed by Pulumi",
    folder: "ngfw-shared",
    layer3: {
        ips: [{
            name: "198.18.1.1/24",
        }],
        lacp: {
            enable: true,
            fastFailover: true,
            systenPriority: 32768,
            transmissionRate: "fast",
            highAvailability: {
                passivePreNegotiation: true,
            },
        },
    },
});
//
// Creates a layer3 aggregate interface with dhcp-assigned ip address
//
const scmAggregateIntfL3Dhcp = new scm.AggregateInterface("scm_aggregate_intf_l3_dhcp", {
    name: "$scm_aggregate_intf_l3_dhcp",
    comment: "Managed by Pulumi",
    folder: "ngfw-shared",
    layer3: {
        dhcpClient: {
            enable: true,
            createDefaultRoute: true,
            defaultRouteMetric: 10,
        },
    },
});
//
// Creates a layer3 aggregate interface with multiple static ip addresses
//
const scmAggregateIntfL3Complex = new scm.AggregateInterface("scm_aggregate_intf_l3_complex", {
    name: "$scm_aggregate_intf_l3_complex",
    comment: "Managed by Pulumi",
    folder: "ngfw-shared",
    layer3: {
        ips: [
            {
                name: "198.18.1.1/24",
            },
            {
                name: "198.18.1.2/32",
            },
        ],
        mtu: 1500,
        adjustTcpMss: {
            enable: true,
            ipv4MssAdjustment: 40,
            ipv6MssAdjustment: 60,
        },
    },
});

import pulumi
import pulumi_scm as scm

#
# Creates a layer 2 aggregate interface without vlan configuration
#
scm_aggregate_intf_l2 = scm.AggregateInterface("scm_aggregate_intf_l2",
    name="$scm_aggregate_intf_l2",
    comment="Managed by Pulumi",
    folder="ngfw-shared",
    layer2={})
#
# Creates a layer 2 aggregate interface with vlan and lacp configuration
#
scm_aggregate_intf_l2_lacp = scm.AggregateInterface("scm_aggregate_intf_l2_lacp",
    name="$scm_aggregate_intf_l2_lacp",
    comment="Managed by Pulumi",
    folder="ngfw-shared",
    layer2={
        "vlan_tag": "1234",
        "lacp": {
            "enable": True,
            "fast_failover": True,
            "systen_priority": 32768,
            "transmission_rate": "fast",
            "high_availability": {
                "passive_pre_negotiation": True,
            },
        },
        "lldp": {
            "enable": False,
        },
    })
#
# Creates a layer3 aggregate interface without ip configuration
#
scm_aggregate_intf_l3 = scm.AggregateInterface("scm_aggregate_intf_l3",
    name="$scm_aggregate_intf_l3",
    comment="Managed by Pulumi",
    folder="ngfw-shared",
    layer3={})
#
# Creates a layer3 aggregate interface with static ip address and lacp
#
scm_aggregate_intf_l3_static = scm.AggregateInterface("scm_aggregate_intf_l3_static",
    name="$scm_aggregate_intf_l3_static",
    comment="Managed by Pulumi",
    folder="ngfw-shared",
    layer3={
        "ips": [{
            "name": "198.18.1.1/24",
        }],
        "lacp": {
            "enable": True,
            "fast_failover": True,
            "systen_priority": 32768,
            "transmission_rate": "fast",
            "high_availability": {
                "passive_pre_negotiation": True,
            },
        },
    })
#
# Creates a layer3 aggregate interface with dhcp-assigned ip address
#
scm_aggregate_intf_l3_dhcp = scm.AggregateInterface("scm_aggregate_intf_l3_dhcp",
    name="$scm_aggregate_intf_l3_dhcp",
    comment="Managed by Pulumi",
    folder="ngfw-shared",
    layer3={
        "dhcp_client": {
            "enable": True,
            "create_default_route": True,
            "default_route_metric": 10,
        },
    })
#
# Creates a layer3 aggregate interface with multiple static ip addresses
#
scm_aggregate_intf_l3_complex = scm.AggregateInterface("scm_aggregate_intf_l3_complex",
    name="$scm_aggregate_intf_l3_complex",
    comment="Managed by Pulumi",
    folder="ngfw-shared",
    layer3={
        "ips": [
            {
                "name": "198.18.1.1/24",
            },
            {
                "name": "198.18.1.2/32",
            },
        ],
        "mtu": 1500,
        "adjust_tcp_mss": {
            "enable": True,
            "ipv4_mss_adjustment": 40,
            "ipv6_mss_adjustment": 60,
        },
    })

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 a layer 2 aggregate interface without vlan configuration
		_, err := scm.NewAggregateInterface(ctx, "scm_aggregate_intf_l2", &scm.AggregateInterfaceArgs{
			Name:    pulumi.String("$scm_aggregate_intf_l2"),
			Comment: pulumi.String("Managed by Pulumi"),
			Folder:  pulumi.String("ngfw-shared"),
			Layer2:  &scm.AggregateInterfaceLayer2Args{},
		})
		if err != nil {
			return err
		}
		// Creates a layer 2 aggregate interface with vlan and lacp configuration
		_, err = scm.NewAggregateInterface(ctx, "scm_aggregate_intf_l2_lacp", &scm.AggregateInterfaceArgs{
			Name:    pulumi.String("$scm_aggregate_intf_l2_lacp"),
			Comment: pulumi.String("Managed by Pulumi"),
			Folder:  pulumi.String("ngfw-shared"),
			Layer2: &scm.AggregateInterfaceLayer2Args{
				VlanTag: pulumi.String("1234"),
				Lacp: &scm.AggregateInterfaceLayer2LacpArgs{
					Enable:           pulumi.Bool(true),
					FastFailover:     pulumi.Bool(true),
					SystenPriority:   32768,
					TransmissionRate: pulumi.String("fast"),
					HighAvailability: &scm.AggregateInterfaceLayer2LacpHighAvailabilityArgs{
						PassivePreNegotiation: pulumi.Bool(true),
					},
				},
				Lldp: &scm.AggregateInterfaceLayer2LldpArgs{
					Enable: pulumi.Bool(false),
				},
			},
		})
		if err != nil {
			return err
		}
		// Creates a layer3 aggregate interface without ip configuration
		_, err = scm.NewAggregateInterface(ctx, "scm_aggregate_intf_l3", &scm.AggregateInterfaceArgs{
			Name:    pulumi.String("$scm_aggregate_intf_l3"),
			Comment: pulumi.String("Managed by Pulumi"),
			Folder:  pulumi.String("ngfw-shared"),
			Layer3:  &scm.AggregateInterfaceLayer3Args{},
		})
		if err != nil {
			return err
		}
		// Creates a layer3 aggregate interface with static ip address and lacp
		_, err = scm.NewAggregateInterface(ctx, "scm_aggregate_intf_l3_static", &scm.AggregateInterfaceArgs{
			Name:    pulumi.String("$scm_aggregate_intf_l3_static"),
			Comment: pulumi.String("Managed by Pulumi"),
			Folder:  pulumi.String("ngfw-shared"),
			Layer3: &scm.AggregateInterfaceLayer3Args{
				Ips: scm.AggregateInterfaceLayer3IpArray{
					&scm.AggregateInterfaceLayer3IpArgs{
						Name: pulumi.String("198.18.1.1/24"),
					},
				},
				Lacp: &scm.AggregateInterfaceLayer3LacpArgs{
					Enable:           pulumi.Bool(true),
					FastFailover:     pulumi.Bool(true),
					SystenPriority:   32768,
					TransmissionRate: pulumi.String("fast"),
					HighAvailability: &scm.AggregateInterfaceLayer3LacpHighAvailabilityArgs{
						PassivePreNegotiation: pulumi.Bool(true),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Creates a layer3 aggregate interface with dhcp-assigned ip address
		_, err = scm.NewAggregateInterface(ctx, "scm_aggregate_intf_l3_dhcp", &scm.AggregateInterfaceArgs{
			Name:    pulumi.String("$scm_aggregate_intf_l3_dhcp"),
			Comment: pulumi.String("Managed by Pulumi"),
			Folder:  pulumi.String("ngfw-shared"),
			Layer3: &scm.AggregateInterfaceLayer3Args{
				DhcpClient: &scm.AggregateInterfaceLayer3DhcpClientArgs{
					Enable:             pulumi.Bool(true),
					CreateDefaultRoute: pulumi.Bool(true),
					DefaultRouteMetric: pulumi.Int(10),
				},
			},
		})
		if err != nil {
			return err
		}
		// Creates a layer3 aggregate interface with multiple static ip addresses
		_, err = scm.NewAggregateInterface(ctx, "scm_aggregate_intf_l3_complex", &scm.AggregateInterfaceArgs{
			Name:    pulumi.String("$scm_aggregate_intf_l3_complex"),
			Comment: pulumi.String("Managed by Pulumi"),
			Folder:  pulumi.String("ngfw-shared"),
			Layer3: &scm.AggregateInterfaceLayer3Args{
				Ips: scm.AggregateInterfaceLayer3IpArray{
					&scm.AggregateInterfaceLayer3IpArgs{
						Name: pulumi.String("198.18.1.1/24"),
					},
					&scm.AggregateInterfaceLayer3IpArgs{
						Name: pulumi.String("198.18.1.2/32"),
					},
				},
				Mtu: pulumi.Int(1500),
				AdjustTcpMss: &scm.AggregateInterfaceLayer3AdjustTcpMssArgs{
					Enable:            pulumi.Bool(true),
					Ipv4MssAdjustment: pulumi.Int(40),
					Ipv6MssAdjustment: pulumi.Int(60),
				},
			},
		})
		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 a layer 2 aggregate interface without vlan configuration
    //
    var scmAggregateIntfL2 = new Scm.AggregateInterface("scm_aggregate_intf_l2", new()
    {
        Name = "$scm_aggregate_intf_l2",
        Comment = "Managed by Pulumi",
        Folder = "ngfw-shared",
        Layer2 = new() { },
    });

    //
    // Creates a layer 2 aggregate interface with vlan and lacp configuration
    //
    var scmAggregateIntfL2Lacp = new Scm.AggregateInterface("scm_aggregate_intf_l2_lacp", new()
    {
        Name = "$scm_aggregate_intf_l2_lacp",
        Comment = "Managed by Pulumi",
        Folder = "ngfw-shared",
        Layer2 = new Scm.Inputs.AggregateInterfaceLayer2Args
        {
            VlanTag = "1234",
            Lacp = new Scm.Inputs.AggregateInterfaceLayer2LacpArgs
            {
                Enable = true,
                FastFailover = true,
                SystenPriority = 32768,
                TransmissionRate = "fast",
                HighAvailability = new Scm.Inputs.AggregateInterfaceLayer2LacpHighAvailabilityArgs
                {
                    PassivePreNegotiation = true,
                },
            },
            Lldp = new Scm.Inputs.AggregateInterfaceLayer2LldpArgs
            {
                Enable = false,
            },
        },
    });

    //
    // Creates a layer3 aggregate interface without ip configuration
    //
    var scmAggregateIntfL3 = new Scm.AggregateInterface("scm_aggregate_intf_l3", new()
    {
        Name = "$scm_aggregate_intf_l3",
        Comment = "Managed by Pulumi",
        Folder = "ngfw-shared",
        Layer3 = new() { },
    });

    //
    // Creates a layer3 aggregate interface with static ip address and lacp
    //
    var scmAggregateIntfL3Static = new Scm.AggregateInterface("scm_aggregate_intf_l3_static", new()
    {
        Name = "$scm_aggregate_intf_l3_static",
        Comment = "Managed by Pulumi",
        Folder = "ngfw-shared",
        Layer3 = new Scm.Inputs.AggregateInterfaceLayer3Args
        {
            Ips = new[]
            {
                new Scm.Inputs.AggregateInterfaceLayer3IpArgs
                {
                    Name = "198.18.1.1/24",
                },
            },
            Lacp = new Scm.Inputs.AggregateInterfaceLayer3LacpArgs
            {
                Enable = true,
                FastFailover = true,
                SystenPriority = 32768,
                TransmissionRate = "fast",
                HighAvailability = new Scm.Inputs.AggregateInterfaceLayer3LacpHighAvailabilityArgs
                {
                    PassivePreNegotiation = true,
                },
            },
        },
    });

    //
    // Creates a layer3 aggregate interface with dhcp-assigned ip address
    //
    var scmAggregateIntfL3Dhcp = new Scm.AggregateInterface("scm_aggregate_intf_l3_dhcp", new()
    {
        Name = "$scm_aggregate_intf_l3_dhcp",
        Comment = "Managed by Pulumi",
        Folder = "ngfw-shared",
        Layer3 = new Scm.Inputs.AggregateInterfaceLayer3Args
        {
            DhcpClient = new Scm.Inputs.AggregateInterfaceLayer3DhcpClientArgs
            {
                Enable = true,
                CreateDefaultRoute = true,
                DefaultRouteMetric = 10,
            },
        },
    });

    //
    // Creates a layer3 aggregate interface with multiple static ip addresses
    //
    var scmAggregateIntfL3Complex = new Scm.AggregateInterface("scm_aggregate_intf_l3_complex", new()
    {
        Name = "$scm_aggregate_intf_l3_complex",
        Comment = "Managed by Pulumi",
        Folder = "ngfw-shared",
        Layer3 = new Scm.Inputs.AggregateInterfaceLayer3Args
        {
            Ips = new[]
            {
                new Scm.Inputs.AggregateInterfaceLayer3IpArgs
                {
                    Name = "198.18.1.1/24",
                },
                new Scm.Inputs.AggregateInterfaceLayer3IpArgs
                {
                    Name = "198.18.1.2/32",
                },
            },
            Mtu = 1500,
            AdjustTcpMss = new Scm.Inputs.AggregateInterfaceLayer3AdjustTcpMssArgs
            {
                Enable = true,
                Ipv4MssAdjustment = 40,
                Ipv6MssAdjustment = 60,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scm.AggregateInterface;
import com.pulumi.scm.AggregateInterfaceArgs;
import com.pulumi.scm.inputs.AggregateInterfaceLayer2Args;
import com.pulumi.scm.inputs.AggregateInterfaceLayer2LacpArgs;
import com.pulumi.scm.inputs.AggregateInterfaceLayer2LacpHighAvailabilityArgs;
import com.pulumi.scm.inputs.AggregateInterfaceLayer2LldpArgs;
import com.pulumi.scm.inputs.AggregateInterfaceLayer3Args;
import com.pulumi.scm.inputs.AggregateInterfaceLayer3IpArgs;
import com.pulumi.scm.inputs.AggregateInterfaceLayer3LacpArgs;
import com.pulumi.scm.inputs.AggregateInterfaceLayer3LacpHighAvailabilityArgs;
import com.pulumi.scm.inputs.AggregateInterfaceLayer3DhcpClientArgs;
import com.pulumi.scm.inputs.AggregateInterfaceLayer3AdjustTcpMssArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 a layer 2 aggregate interface without vlan configuration
        //
        var scmAggregateIntfL2 = new AggregateInterface("scmAggregateIntfL2", AggregateInterfaceArgs.builder()
            .name("$scm_aggregate_intf_l2")
            .comment("Managed by Pulumi")
            .folder("ngfw-shared")
            .layer2(AggregateInterfaceLayer2Args.builder()
                .build())
            .build());

        //
        // Creates a layer 2 aggregate interface with vlan and lacp configuration
        //
        var scmAggregateIntfL2Lacp = new AggregateInterface("scmAggregateIntfL2Lacp", AggregateInterfaceArgs.builder()
            .name("$scm_aggregate_intf_l2_lacp")
            .comment("Managed by Pulumi")
            .folder("ngfw-shared")
            .layer2(AggregateInterfaceLayer2Args.builder()
                .vlanTag("1234")
                .lacp(AggregateInterfaceLayer2LacpArgs.builder()
                    .enable(true)
                    .fastFailover(true)
                    .systenPriority(32768)
                    .transmissionRate("fast")
                    .highAvailability(AggregateInterfaceLayer2LacpHighAvailabilityArgs.builder()
                        .passivePreNegotiation(true)
                        .build())
                    .build())
                .lldp(AggregateInterfaceLayer2LldpArgs.builder()
                    .enable(false)
                    .build())
                .build())
            .build());

        //
        // Creates a layer3 aggregate interface without ip configuration
        //
        var scmAggregateIntfL3 = new AggregateInterface("scmAggregateIntfL3", AggregateInterfaceArgs.builder()
            .name("$scm_aggregate_intf_l3")
            .comment("Managed by Pulumi")
            .folder("ngfw-shared")
            .layer3(AggregateInterfaceLayer3Args.builder()
                .build())
            .build());

        //
        // Creates a layer3 aggregate interface with static ip address and lacp
        //
        var scmAggregateIntfL3Static = new AggregateInterface("scmAggregateIntfL3Static", AggregateInterfaceArgs.builder()
            .name("$scm_aggregate_intf_l3_static")
            .comment("Managed by Pulumi")
            .folder("ngfw-shared")
            .layer3(AggregateInterfaceLayer3Args.builder()
                .ips(AggregateInterfaceLayer3IpArgs.builder()
                    .name("198.18.1.1/24")
                    .build())
                .lacp(AggregateInterfaceLayer3LacpArgs.builder()
                    .enable(true)
                    .fastFailover(true)
                    .systenPriority(32768)
                    .transmissionRate("fast")
                    .highAvailability(AggregateInterfaceLayer3LacpHighAvailabilityArgs.builder()
                        .passivePreNegotiation(true)
                        .build())
                    .build())
                .build())
            .build());

        //
        // Creates a layer3 aggregate interface with dhcp-assigned ip address
        //
        var scmAggregateIntfL3Dhcp = new AggregateInterface("scmAggregateIntfL3Dhcp", AggregateInterfaceArgs.builder()
            .name("$scm_aggregate_intf_l3_dhcp")
            .comment("Managed by Pulumi")
            .folder("ngfw-shared")
            .layer3(AggregateInterfaceLayer3Args.builder()
                .dhcpClient(AggregateInterfaceLayer3DhcpClientArgs.builder()
                    .enable(true)
                    .createDefaultRoute(true)
                    .defaultRouteMetric(10)
                    .build())
                .build())
            .build());

        //
        // Creates a layer3 aggregate interface with multiple static ip addresses
        //
        var scmAggregateIntfL3Complex = new AggregateInterface("scmAggregateIntfL3Complex", AggregateInterfaceArgs.builder()
            .name("$scm_aggregate_intf_l3_complex")
            .comment("Managed by Pulumi")
            .folder("ngfw-shared")
            .layer3(AggregateInterfaceLayer3Args.builder()
                .ips(                
                    AggregateInterfaceLayer3IpArgs.builder()
                        .name("198.18.1.1/24")
                        .build(),
                    AggregateInterfaceLayer3IpArgs.builder()
                        .name("198.18.1.2/32")
                        .build())
                .mtu(1500)
                .adjustTcpMss(AggregateInterfaceLayer3AdjustTcpMssArgs.builder()
                    .enable(true)
                    .ipv4MssAdjustment(40)
                    .ipv6MssAdjustment(60)
                    .build())
                .build())
            .build());

    }
}

resources:
  #
  # Creates a layer 2 aggregate interface without vlan configuration
  #
  scmAggregateIntfL2:
    type: scm:AggregateInterface
    name: scm_aggregate_intf_l2
    properties:
      name: $scm_aggregate_intf_l2
      comment: Managed by Pulumi
      folder: ngfw-shared
      layer2: {}
  #
  # Creates a layer 2 aggregate interface with vlan and lacp configuration
  #
  scmAggregateIntfL2Lacp:
    type: scm:AggregateInterface
    name: scm_aggregate_intf_l2_lacp
    properties:
      name: $scm_aggregate_intf_l2_lacp
      comment: Managed by Pulumi
      folder: ngfw-shared
      layer2:
        vlanTag: 1234
        lacp:
          enable: true
          fastFailover: true
          systenPriority: 32768
          transmissionRate: fast
          highAvailability:
            passivePreNegotiation: true
        lldp:
          enable: false
  #
  # Creates a layer3 aggregate interface without ip configuration
  #
  scmAggregateIntfL3:
    type: scm:AggregateInterface
    name: scm_aggregate_intf_l3
    properties:
      name: $scm_aggregate_intf_l3
      comment: Managed by Pulumi
      folder: ngfw-shared
      layer3: {}
  #
  # Creates a layer3 aggregate interface with static ip address and lacp
  #
  scmAggregateIntfL3Static:
    type: scm:AggregateInterface
    name: scm_aggregate_intf_l3_static
    properties:
      name: $scm_aggregate_intf_l3_static
      comment: Managed by Pulumi
      folder: ngfw-shared
      layer3:
        ips:
          - name: 198.18.1.1/24
        lacp:
          enable: true
          fastFailover: true
          systenPriority: 32768
          transmissionRate: fast
          highAvailability:
            passivePreNegotiation: true
  #
  # Creates a layer3 aggregate interface with dhcp-assigned ip address
  #
  scmAggregateIntfL3Dhcp:
    type: scm:AggregateInterface
    name: scm_aggregate_intf_l3_dhcp
    properties:
      name: $scm_aggregate_intf_l3_dhcp
      comment: Managed by Pulumi
      folder: ngfw-shared
      layer3:
        dhcpClient:
          enable: true
          createDefaultRoute: true
          defaultRouteMetric: 10
  #
  # Creates a layer3 aggregate interface with multiple static ip addresses
  #
  scmAggregateIntfL3Complex:
    type: scm:AggregateInterface
    name: scm_aggregate_intf_l3_complex
    properties:
      name: $scm_aggregate_intf_l3_complex
      comment: Managed by Pulumi
      folder: ngfw-shared
      layer3:
        ips:
          - name: 198.18.1.1/24
          - name: 198.18.1.2/32
        mtu: 1500
        adjustTcpMss:
          enable: true
          ipv4MssAdjustment: 40
          ipv6MssAdjustment: 60

terraform {
  required_providers {
    scm = {
      source = "pulumi/scm"
    }
  }
}

#
# Creates a layer 2 aggregate interface without vlan configuration
#
resource "scm_aggregate_interface" "scm_aggregate_intf_l2" {
  lifecycle {
    create_before_destroy = true
  }
  name    = "$scm_aggregate_intf_l2"
  comment = "Managed by Pulumi"
  folder  = "ngfw-shared"
  layer2  = {}
}
#
# Creates a layer 2 aggregate interface with vlan and lacp configuration
#
resource "scm_aggregate_interface" "scm_aggregate_intf_l2_lacp" {
  lifecycle {
    create_before_destroy = true
  }
  name    = "$scm_aggregate_intf_l2_lacp"
  comment = "Managed by Pulumi"
  folder  = "ngfw-shared"
  layer2 = {
    vlan_tag = 1234
    lacp = {
      enable            = true
      fast_failover     = true
      systen_priority   = 32768
      transmission_rate = "fast"
      high_availability = {
        passive_pre_negotiation = true
      }
    }
    lldp = {
      enable = false
    }
  }
}
#
# Creates a layer3 aggregate interface without ip configuration
#
resource "scm_aggregate_interface" "scm_aggregate_intf_l3" {
  lifecycle {
    create_before_destroy = true
  }
  name    = "$scm_aggregate_intf_l3"
  comment = "Managed by Pulumi"
  folder  = "ngfw-shared"
  layer3  = {}
}
#
# Creates a layer3 aggregate interface with static ip address and lacp
#
resource "scm_aggregate_interface" "scm_aggregate_intf_l3_static" {
  lifecycle {
    create_before_destroy = true
  }
  name    = "$scm_aggregate_intf_l3_static"
  comment = "Managed by Pulumi"
  folder  = "ngfw-shared"
  layer3 = {
    ips = [{
      name = "198.18.1.1/24"
    }]
    lacp = {
      enable            = true
      fast_failover     = true
      systen_priority   = 32768
      transmission_rate = "fast"
      high_availability = {
        passive_pre_negotiation = true
      }
    }
  }
}
#
# Creates a layer3 aggregate interface with dhcp-assigned ip address
#
resource "scm_aggregate_interface" "scm_aggregate_intf_l3_dhcp" {
  lifecycle {
    create_before_destroy = true
  }
  name    = "$scm_aggregate_intf_l3_dhcp"
  comment = "Managed by Pulumi"
  folder  = "ngfw-shared"
  layer3 = {
    dhcp_client = {
      enable               = true
      create_default_route = true
      default_route_metric = 10
    }
  }
}
#
# Creates a layer3 aggregate interface with multiple static ip addresses
#
resource "scm_aggregate_interface" "scm_aggregate_intf_l3_complex" {
  lifecycle {
    create_before_destroy = true
  }
  name    = "$scm_aggregate_intf_l3_complex"
  comment = "Managed by Pulumi"
  folder  = "ngfw-shared"
  layer3 = {
    ips = [{
      name = "198.18.1.1/24"
      }, {
      name = "198.18.1.2/32"
    }]
    mtu = 1500
    adjust_tcp_mss = {
      enable              = true
      ipv4_mss_adjustment = 40
      ipv6_mss_adjustment = 60
    }
  }
}

var aggregateInterfaceResource = new Scm.AggregateInterface("aggregateInterfaceResource", new()
{
    Comment = "string",
    DefaultValue = "string",
    Device = "string",
    Folder = "string",
    Layer2 = new Scm.Inputs.AggregateInterfaceLayer2Args
    {
        Lacp = new Scm.Inputs.AggregateInterfaceLayer2LacpArgs
        {
            Enable = false,
            FastFailover = false,
            HighAvailability = new Scm.Inputs.AggregateInterfaceLayer2LacpHighAvailabilityArgs
            {
                PassivePreNegotiation = false,
            },
            MaxPorts = 0,
            Mode = "string",
            SystemPriority = 0,
            TransmissionRate = "string",
        },
        Lldp = new Scm.Inputs.AggregateInterfaceLayer2LldpArgs
        {
            Enable = false,
            HighAvailability = new Scm.Inputs.AggregateInterfaceLayer2LldpHighAvailabilityArgs
            {
                PassivePreNegotiation = false,
            },
            Profile = "string",
        },
        NetflowProfile = "string",
        VlanTag = "string",
    },
    Layer3 = new Scm.Inputs.AggregateInterfaceLayer3Args
    {
        AdjustTcpMss = new Scm.Inputs.AggregateInterfaceLayer3AdjustTcpMssArgs
        {
            Enable = false,
            Ipv4MssAdjustment = 0,
            Ipv6MssAdjustment = 0,
        },
        Arps = new[]
        {
            new Scm.Inputs.AggregateInterfaceLayer3ArpArgs
            {
                HwAddress = "string",
                Name = "string",
            },
        },
        DdnsConfig = new Scm.Inputs.AggregateInterfaceLayer3DdnsConfigArgs
        {
            DdnsCertProfile = "string",
            DdnsHostname = "string",
            DdnsVendor = "string",
            DdnsVendorConfig = "string",
            DdnsEnabled = false,
            DdnsIp = "string",
            DdnsUpdateInterval = 0,
        },
        DhcpClient = new Scm.Inputs.AggregateInterfaceLayer3DhcpClientArgs
        {
            CreateDefaultRoute = false,
            DefaultRouteMetric = 0,
            Enable = false,
            SendHostname = new Scm.Inputs.AggregateInterfaceLayer3DhcpClientSendHostnameArgs
            {
                Enable = false,
                Hostname = "string",
            },
        },
        InterfaceManagementProfile = "string",
        Ips = new[]
        {
            new Scm.Inputs.AggregateInterfaceLayer3IpArgs
            {
                Name = "string",
            },
        },
        Lacp = new Scm.Inputs.AggregateInterfaceLayer3LacpArgs
        {
            Enable = false,
            FastFailover = false,
            HighAvailability = new Scm.Inputs.AggregateInterfaceLayer3LacpHighAvailabilityArgs
            {
                PassivePreNegotiation = false,
            },
            MaxPorts = 0,
            Mode = "string",
            SystemPriority = 0,
            TransmissionRate = "string",
        },
        Lldp = new Scm.Inputs.AggregateInterfaceLayer3LldpArgs
        {
            Enable = false,
            HighAvailability = new Scm.Inputs.AggregateInterfaceLayer3LldpHighAvailabilityArgs
            {
                PassivePreNegotiation = false,
            },
            Profile = "string",
        },
        Mtu = 0,
        NetflowProfile = "string",
    },
    Name = "string",
    Snippet = "string",
});

example, err := scm.NewAggregateInterface(ctx, "aggregateInterfaceResource", &scm.AggregateInterfaceArgs{
	Comment:      pulumi.String("string"),
	DefaultValue: pulumi.String("string"),
	Device:       pulumi.String("string"),
	Folder:       pulumi.String("string"),
	Layer2: &scm.AggregateInterfaceLayer2Args{
		Lacp: &scm.AggregateInterfaceLayer2LacpArgs{
			Enable:       pulumi.Bool(false),
			FastFailover: pulumi.Bool(false),
			HighAvailability: &scm.AggregateInterfaceLayer2LacpHighAvailabilityArgs{
				PassivePreNegotiation: pulumi.Bool(false),
			},
			MaxPorts:         pulumi.Int(0),
			Mode:             pulumi.String("string"),
			SystemPriority:   pulumi.Int(0),
			TransmissionRate: pulumi.String("string"),
		},
		Lldp: &scm.AggregateInterfaceLayer2LldpArgs{
			Enable: pulumi.Bool(false),
			HighAvailability: &scm.AggregateInterfaceLayer2LldpHighAvailabilityArgs{
				PassivePreNegotiation: pulumi.Bool(false),
			},
			Profile: pulumi.String("string"),
		},
		NetflowProfile: pulumi.String("string"),
		VlanTag:        pulumi.String("string"),
	},
	Layer3: &scm.AggregateInterfaceLayer3Args{
		AdjustTcpMss: &scm.AggregateInterfaceLayer3AdjustTcpMssArgs{
			Enable:            pulumi.Bool(false),
			Ipv4MssAdjustment: pulumi.Int(0),
			Ipv6MssAdjustment: pulumi.Int(0),
		},
		Arps: scm.AggregateInterfaceLayer3ArpArray{
			&scm.AggregateInterfaceLayer3ArpArgs{
				HwAddress: pulumi.String("string"),
				Name:      pulumi.String("string"),
			},
		},
		DdnsConfig: &scm.AggregateInterfaceLayer3DdnsConfigArgs{
			DdnsCertProfile:    pulumi.String("string"),
			DdnsHostname:       pulumi.String("string"),
			DdnsVendor:         pulumi.String("string"),
			DdnsVendorConfig:   pulumi.String("string"),
			DdnsEnabled:        pulumi.Bool(false),
			DdnsIp:             pulumi.String("string"),
			DdnsUpdateInterval: pulumi.Int(0),
		},
		DhcpClient: &scm.AggregateInterfaceLayer3DhcpClientArgs{
			CreateDefaultRoute: pulumi.Bool(false),
			DefaultRouteMetric: pulumi.Int(0),
			Enable:             pulumi.Bool(false),
			SendHostname: &scm.AggregateInterfaceLayer3DhcpClientSendHostnameArgs{
				Enable:   pulumi.Bool(false),
				Hostname: pulumi.String("string"),
			},
		},
		InterfaceManagementProfile: pulumi.String("string"),
		Ips: scm.AggregateInterfaceLayer3IpArray{
			&scm.AggregateInterfaceLayer3IpArgs{
				Name: pulumi.String("string"),
			},
		},
		Lacp: &scm.AggregateInterfaceLayer3LacpArgs{
			Enable:       pulumi.Bool(false),
			FastFailover: pulumi.Bool(false),
			HighAvailability: &scm.AggregateInterfaceLayer3LacpHighAvailabilityArgs{
				PassivePreNegotiation: pulumi.Bool(false),
			},
			MaxPorts:         pulumi.Int(0),
			Mode:             pulumi.String("string"),
			SystemPriority:   pulumi.Int(0),
			TransmissionRate: pulumi.String("string"),
		},
		Lldp: &scm.AggregateInterfaceLayer3LldpArgs{
			Enable: pulumi.Bool(false),
			HighAvailability: &scm.AggregateInterfaceLayer3LldpHighAvailabilityArgs{
				PassivePreNegotiation: pulumi.Bool(false),
			},
			Profile: pulumi.String("string"),
		},
		Mtu:            pulumi.Int(0),
		NetflowProfile: pulumi.String("string"),
	},
	Name:    pulumi.String("string"),
	Snippet: pulumi.String("string"),
})

resource "scm_aggregate_interface" "aggregateInterfaceResource" {
  lifecycle {
    create_before_destroy = true
  }
  comment       = "string"
  default_value = "string"
  device        = "string"
  folder        = "string"
  layer2 = {
    lacp = {
      enable        = false
      fast_failover = false
      high_availability = {
        passive_pre_negotiation = false
      }
      max_ports         = 0
      mode              = "string"
      system_priority   = 0
      transmission_rate = "string"
    }
    lldp = {
      enable = false
      high_availability = {
        passive_pre_negotiation = false
      }
      profile = "string"
    }
    netflow_profile = "string"
    vlan_tag        = "string"
  }
  layer3 = {
    adjust_tcp_mss = {
      enable              = false
      ipv4_mss_adjustment = 0
      ipv6_mss_adjustment = 0
    }
    arps = [{
      hw_address = "string"
      name       = "string"
    }]
    ddns_config = {
      ddns_cert_profile    = "string"
      ddns_hostname        = "string"
      ddns_vendor          = "string"
      ddns_vendor_config   = "string"
      ddns_enabled         = false
      ddns_ip              = "string"
      ddns_update_interval = 0
    }
    dhcp_client = {
      create_default_route = false
      default_route_metric = 0
      enable               = false
      send_hostname = {
        enable   = false
        hostname = "string"
      }
    }
    interface_management_profile = "string"
    ips = [{
      name = "string"
    }]
    lacp = {
      enable        = false
      fast_failover = false
      high_availability = {
        passive_pre_negotiation = false
      }
      max_ports         = 0
      mode              = "string"
      system_priority   = 0
      transmission_rate = "string"
    }
    lldp = {
      enable = false
      high_availability = {
        passive_pre_negotiation = false
      }
      profile = "string"
    }
    mtu             = 0
    netflow_profile = "string"
  }
  name    = "string"
  snippet = "string"
}

var aggregateInterfaceResource = new AggregateInterface("aggregateInterfaceResource", AggregateInterfaceArgs.builder()
    .comment("string")
    .defaultValue("string")
    .device("string")
    .folder("string")
    .layer2(AggregateInterfaceLayer2Args.builder()
        .lacp(AggregateInterfaceLayer2LacpArgs.builder()
            .enable(false)
            .fastFailover(false)
            .highAvailability(AggregateInterfaceLayer2LacpHighAvailabilityArgs.builder()
                .passivePreNegotiation(false)
                .build())
            .maxPorts(0)
            .mode("string")
            .systemPriority(0)
            .transmissionRate("string")
            .build())
        .lldp(AggregateInterfaceLayer2LldpArgs.builder()
            .enable(false)
            .highAvailability(AggregateInterfaceLayer2LldpHighAvailabilityArgs.builder()
                .passivePreNegotiation(false)
                .build())
            .profile("string")
            .build())
        .netflowProfile("string")
        .vlanTag("string")
        .build())
    .layer3(AggregateInterfaceLayer3Args.builder()
        .adjustTcpMss(AggregateInterfaceLayer3AdjustTcpMssArgs.builder()
            .enable(false)
            .ipv4MssAdjustment(0)
            .ipv6MssAdjustment(0)
            .build())
        .arps(AggregateInterfaceLayer3ArpArgs.builder()
            .hwAddress("string")
            .name("string")
            .build())
        .ddnsConfig(AggregateInterfaceLayer3DdnsConfigArgs.builder()
            .ddnsCertProfile("string")
            .ddnsHostname("string")
            .ddnsVendor("string")
            .ddnsVendorConfig("string")
            .ddnsEnabled(false)
            .ddnsIp("string")
            .ddnsUpdateInterval(0)
            .build())
        .dhcpClient(AggregateInterfaceLayer3DhcpClientArgs.builder()
            .createDefaultRoute(false)
            .defaultRouteMetric(0)
            .enable(false)
            .sendHostname(AggregateInterfaceLayer3DhcpClientSendHostnameArgs.builder()
                .enable(false)
                .hostname("string")
                .build())
            .build())
        .interfaceManagementProfile("string")
        .ips(AggregateInterfaceLayer3IpArgs.builder()
            .name("string")
            .build())
        .lacp(AggregateInterfaceLayer3LacpArgs.builder()
            .enable(false)
            .fastFailover(false)
            .highAvailability(AggregateInterfaceLayer3LacpHighAvailabilityArgs.builder()
                .passivePreNegotiation(false)
                .build())
            .maxPorts(0)
            .mode("string")
            .systemPriority(0)
            .transmissionRate("string")
            .build())
        .lldp(AggregateInterfaceLayer3LldpArgs.builder()
            .enable(false)
            .highAvailability(AggregateInterfaceLayer3LldpHighAvailabilityArgs.builder()
                .passivePreNegotiation(false)
                .build())
            .profile("string")
            .build())
        .mtu(0)
        .netflowProfile("string")
        .build())
    .name("string")
    .snippet("string")
    .build());