checkpoint.ManagementAccessRule

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

const rule1 = new checkpoint.ManagementAccessRule("rule1", {
    layer: "Network",
    position: {
        top: "top",
    },
    sources: ["Any"],
    destinations: ["Any"],
    services: ["Any"],
    contents: ["Any"],
    times: ["Any"],
    installOns: ["Policy Targets"],
    track: {
        type: "Log",
        accounting: "false",
        alert: "none",
        enable_firewall_session: "false",
        per_connection: "true",
        per_session: "false",
    },
    actionSettings: {},
    customFields: {},
    vpn: "Any",
});
const rule2 = new checkpoint.ManagementAccessRule("rule2", {
    layer: "Network",
    position: {
        below: rule1.name,
    },
    enabled: true,
    sources: [
        "DMZNet",
        "DMZZone",
        "WirelessZone",
    ],
    destinations: [
        "InternalNet",
        "CPDShield",
    ],
    destinationNegate: true,
    services: ["Any"],
    contents: ["Any"],
    times: ["Any"],
    installOns: ["Policy Targets"],
    track: {
        type: "Log",
        accounting: "false",
        alert: "none",
        enable_firewall_session: "false",
        per_connection: "true",
        per_session: "false",
    },
    actionSettings: {},
    customFields: {},
    vpn: "All_GwToGw",
});
const rule3 = new checkpoint.ManagementAccessRule("rule3", {
    layer: "Network",
    position: {
        below: rule2.name,
    },
    action: "Accept",
    actionSettings: {
        enable_identity_captive_portal: "true",
    },
    sources: ["DMZNet"],
    enabled: true,
    destinations: ["InternalNet"],
    destinationNegate: true,
    services: ["EDGE"],
    contents: ["Any"],
    times: ["Weekend"],
    installOns: ["Policy Targets"],
    track: {
        type: "Log",
        accounting: "false",
        alert: "none",
        enable_firewall_session: "false",
        per_connection: "true",
        per_session: "false",
    },
    customFields: {},
    vpnCommunities: [
        "StarCommunity",
        "MeshedCommunity",
    ],
});
const rule4 = new checkpoint.ManagementAccessRule("rule4", {
    layer: "Network",
    position: {
        below: rule3.name,
    },
    enabled: false,
    sources: ["Any"],
    destinations: ["Any"],
    services: ["Any"],
    contents: ["Any"],
    times: ["Any"],
    installOns: ["Policy Targets"],
    track: {
        type: "Log",
        accounting: "false",
        alert: "none",
        enable_firewall_session: "false",
        per_connection: "true",
        per_session: "false",
    },
    actionSettings: {},
    customFields: {},
    vpnDirectionals: [{
        from: "StarVpn",
        to: "MeshedCommunity",
    }],
});
const rule5 = new checkpoint.ManagementAccessRule("rule5", {
    layer: "Network",
    position: {
        below: rule4.name,
    },
    action: "Accept",
    actionSettings: {
        enable_identity_captive_portal: "false",
    },
    sources: ["Any"],
    destinations: ["Any"],
    services: ["Any"],
    contents: ["Any"],
    times: ["Any"],
    installOns: ["Policy Targets"],
    track: {
        type: "Log",
        accounting: "false",
        alert: "none",
        enable_firewall_session: "false",
        per_connection: "true",
        per_session: "false",
    },
    customFields: {},
    vpn: "Any",
});

import pulumi
import pulumi_checkpoint as checkpoint

rule1 = checkpoint.ManagementAccessRule("rule1",
    layer="Network",
    position={
        "top": "top",
    },
    sources=["Any"],
    destinations=["Any"],
    services=["Any"],
    contents=["Any"],
    times=["Any"],
    install_ons=["Policy Targets"],
    track={
        "type": "Log",
        "accounting": "false",
        "alert": "none",
        "enable_firewall_session": "false",
        "per_connection": "true",
        "per_session": "false",
    },
    action_settings={},
    custom_fields={},
    vpn="Any")
rule2 = checkpoint.ManagementAccessRule("rule2",
    layer="Network",
    position={
        "below": rule1.name,
    },
    enabled=True,
    sources=[
        "DMZNet",
        "DMZZone",
        "WirelessZone",
    ],
    destinations=[
        "InternalNet",
        "CPDShield",
    ],
    destination_negate=True,
    services=["Any"],
    contents=["Any"],
    times=["Any"],
    install_ons=["Policy Targets"],
    track={
        "type": "Log",
        "accounting": "false",
        "alert": "none",
        "enable_firewall_session": "false",
        "per_connection": "true",
        "per_session": "false",
    },
    action_settings={},
    custom_fields={},
    vpn="All_GwToGw")
rule3 = checkpoint.ManagementAccessRule("rule3",
    layer="Network",
    position={
        "below": rule2.name,
    },
    action="Accept",
    action_settings={
        "enable_identity_captive_portal": "true",
    },
    sources=["DMZNet"],
    enabled=True,
    destinations=["InternalNet"],
    destination_negate=True,
    services=["EDGE"],
    contents=["Any"],
    times=["Weekend"],
    install_ons=["Policy Targets"],
    track={
        "type": "Log",
        "accounting": "false",
        "alert": "none",
        "enable_firewall_session": "false",
        "per_connection": "true",
        "per_session": "false",
    },
    custom_fields={},
    vpn_communities=[
        "StarCommunity",
        "MeshedCommunity",
    ])
rule4 = checkpoint.ManagementAccessRule("rule4",
    layer="Network",
    position={
        "below": rule3.name,
    },
    enabled=False,
    sources=["Any"],
    destinations=["Any"],
    services=["Any"],
    contents=["Any"],
    times=["Any"],
    install_ons=["Policy Targets"],
    track={
        "type": "Log",
        "accounting": "false",
        "alert": "none",
        "enable_firewall_session": "false",
        "per_connection": "true",
        "per_session": "false",
    },
    action_settings={},
    custom_fields={},
    vpn_directionals=[{
        "from_": "StarVpn",
        "to": "MeshedCommunity",
    }])
rule5 = checkpoint.ManagementAccessRule("rule5",
    layer="Network",
    position={
        "below": rule4.name,
    },
    action="Accept",
    action_settings={
        "enable_identity_captive_portal": "false",
    },
    sources=["Any"],
    destinations=["Any"],
    services=["Any"],
    contents=["Any"],
    times=["Any"],
    install_ons=["Policy Targets"],
    track={
        "type": "Log",
        "accounting": "false",
        "alert": "none",
        "enable_firewall_session": "false",
        "per_connection": "true",
        "per_session": "false",
    },
    custom_fields={},
    vpn="Any")

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/checkpoint/v2/checkpoint"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		rule1, err := checkpoint.NewManagementAccessRule(ctx, "rule1", &checkpoint.ManagementAccessRuleArgs{
			Layer: pulumi.String("Network"),
			Position: pulumi.StringMap{
				"top": pulumi.String("top"),
			},
			Sources: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Destinations: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Services: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Contents: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Times: pulumi.StringArray{
				pulumi.String("Any"),
			},
			InstallOns: pulumi.StringArray{
				pulumi.String("Policy Targets"),
			},
			Track: pulumi.StringMap{
				"type":                    pulumi.String("Log"),
				"accounting":              pulumi.String("false"),
				"alert":                   pulumi.String("none"),
				"enable_firewall_session": pulumi.String("false"),
				"per_connection":          pulumi.String("true"),
				"per_session":             pulumi.String("false"),
			},
			ActionSettings: pulumi.StringMap{},
			CustomFields:   pulumi.StringMap{},
			Vpn:            pulumi.String("Any"),
		})
		if err != nil {
			return err
		}
		rule2, err := checkpoint.NewManagementAccessRule(ctx, "rule2", &checkpoint.ManagementAccessRuleArgs{
			Layer: pulumi.String("Network"),
			Position: pulumi.StringMap{
				"below": rule1.Name,
			},
			Enabled: pulumi.Bool(true),
			Sources: pulumi.StringArray{
				pulumi.String("DMZNet"),
				pulumi.String("DMZZone"),
				pulumi.String("WirelessZone"),
			},
			Destinations: pulumi.StringArray{
				pulumi.String("InternalNet"),
				pulumi.String("CPDShield"),
			},
			DestinationNegate: pulumi.Bool(true),
			Services: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Contents: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Times: pulumi.StringArray{
				pulumi.String("Any"),
			},
			InstallOns: pulumi.StringArray{
				pulumi.String("Policy Targets"),
			},
			Track: pulumi.StringMap{
				"type":                    pulumi.String("Log"),
				"accounting":              pulumi.String("false"),
				"alert":                   pulumi.String("none"),
				"enable_firewall_session": pulumi.String("false"),
				"per_connection":          pulumi.String("true"),
				"per_session":             pulumi.String("false"),
			},
			ActionSettings: pulumi.StringMap{},
			CustomFields:   pulumi.StringMap{},
			Vpn:            pulumi.String("All_GwToGw"),
		})
		if err != nil {
			return err
		}
		rule3, err := checkpoint.NewManagementAccessRule(ctx, "rule3", &checkpoint.ManagementAccessRuleArgs{
			Layer: pulumi.String("Network"),
			Position: pulumi.StringMap{
				"below": rule2.Name,
			},
			Action: pulumi.String("Accept"),
			ActionSettings: pulumi.StringMap{
				"enable_identity_captive_portal": pulumi.String("true"),
			},
			Sources: pulumi.StringArray{
				pulumi.String("DMZNet"),
			},
			Enabled: pulumi.Bool(true),
			Destinations: pulumi.StringArray{
				pulumi.String("InternalNet"),
			},
			DestinationNegate: pulumi.Bool(true),
			Services: pulumi.StringArray{
				pulumi.String("EDGE"),
			},
			Contents: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Times: pulumi.StringArray{
				pulumi.String("Weekend"),
			},
			InstallOns: pulumi.StringArray{
				pulumi.String("Policy Targets"),
			},
			Track: pulumi.StringMap{
				"type":                    pulumi.String("Log"),
				"accounting":              pulumi.String("false"),
				"alert":                   pulumi.String("none"),
				"enable_firewall_session": pulumi.String("false"),
				"per_connection":          pulumi.String("true"),
				"per_session":             pulumi.String("false"),
			},
			CustomFields: pulumi.StringMap{},
			VpnCommunities: pulumi.StringArray{
				pulumi.String("StarCommunity"),
				pulumi.String("MeshedCommunity"),
			},
		})
		if err != nil {
			return err
		}
		rule4, err := checkpoint.NewManagementAccessRule(ctx, "rule4", &checkpoint.ManagementAccessRuleArgs{
			Layer: pulumi.String("Network"),
			Position: pulumi.StringMap{
				"below": rule3.Name,
			},
			Enabled: pulumi.Bool(false),
			Sources: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Destinations: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Services: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Contents: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Times: pulumi.StringArray{
				pulumi.String("Any"),
			},
			InstallOns: pulumi.StringArray{
				pulumi.String("Policy Targets"),
			},
			Track: pulumi.StringMap{
				"type":                    pulumi.String("Log"),
				"accounting":              pulumi.String("false"),
				"alert":                   pulumi.String("none"),
				"enable_firewall_session": pulumi.String("false"),
				"per_connection":          pulumi.String("true"),
				"per_session":             pulumi.String("false"),
			},
			ActionSettings: pulumi.StringMap{},
			CustomFields:   pulumi.StringMap{},
			VpnDirectionals: checkpoint.ManagementAccessRuleVpnDirectionalArray{
				&checkpoint.ManagementAccessRuleVpnDirectionalArgs{
					From: pulumi.String("StarVpn"),
					To:   pulumi.String("MeshedCommunity"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = checkpoint.NewManagementAccessRule(ctx, "rule5", &checkpoint.ManagementAccessRuleArgs{
			Layer: pulumi.String("Network"),
			Position: pulumi.StringMap{
				"below": rule4.Name,
			},
			Action: pulumi.String("Accept"),
			ActionSettings: pulumi.StringMap{
				"enable_identity_captive_portal": pulumi.String("false"),
			},
			Sources: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Destinations: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Services: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Contents: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Times: pulumi.StringArray{
				pulumi.String("Any"),
			},
			InstallOns: pulumi.StringArray{
				pulumi.String("Policy Targets"),
			},
			Track: pulumi.StringMap{
				"type":                    pulumi.String("Log"),
				"accounting":              pulumi.String("false"),
				"alert":                   pulumi.String("none"),
				"enable_firewall_session": pulumi.String("false"),
				"per_connection":          pulumi.String("true"),
				"per_session":             pulumi.String("false"),
			},
			CustomFields: pulumi.StringMap{},
			Vpn:          pulumi.String("Any"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var rule1 = new Checkpoint.ManagementAccessRule("rule1", new()
    {
        Layer = "Network",
        Position = 
        {
            { "top", "top" },
        },
        Sources = new[]
        {
            "Any",
        },
        Destinations = new[]
        {
            "Any",
        },
        Services = new[]
        {
            "Any",
        },
        Contents = new[]
        {
            "Any",
        },
        Times = new[]
        {
            "Any",
        },
        InstallOns = new[]
        {
            "Policy Targets",
        },
        Track = 
        {
            { "type", "Log" },
            { "accounting", "false" },
            { "alert", "none" },
            { "enable_firewall_session", "false" },
            { "per_connection", "true" },
            { "per_session", "false" },
        },
        ActionSettings = null,
        CustomFields = null,
        Vpn = "Any",
    });

    var rule2 = new Checkpoint.ManagementAccessRule("rule2", new()
    {
        Layer = "Network",
        Position = 
        {
            { "below", rule1.Name },
        },
        Enabled = true,
        Sources = new[]
        {
            "DMZNet",
            "DMZZone",
            "WirelessZone",
        },
        Destinations = new[]
        {
            "InternalNet",
            "CPDShield",
        },
        DestinationNegate = true,
        Services = new[]
        {
            "Any",
        },
        Contents = new[]
        {
            "Any",
        },
        Times = new[]
        {
            "Any",
        },
        InstallOns = new[]
        {
            "Policy Targets",
        },
        Track = 
        {
            { "type", "Log" },
            { "accounting", "false" },
            { "alert", "none" },
            { "enable_firewall_session", "false" },
            { "per_connection", "true" },
            { "per_session", "false" },
        },
        ActionSettings = null,
        CustomFields = null,
        Vpn = "All_GwToGw",
    });

    var rule3 = new Checkpoint.ManagementAccessRule("rule3", new()
    {
        Layer = "Network",
        Position = 
        {
            { "below", rule2.Name },
        },
        Action = "Accept",
        ActionSettings = 
        {
            { "enable_identity_captive_portal", "true" },
        },
        Sources = new[]
        {
            "DMZNet",
        },
        Enabled = true,
        Destinations = new[]
        {
            "InternalNet",
        },
        DestinationNegate = true,
        Services = new[]
        {
            "EDGE",
        },
        Contents = new[]
        {
            "Any",
        },
        Times = new[]
        {
            "Weekend",
        },
        InstallOns = new[]
        {
            "Policy Targets",
        },
        Track = 
        {
            { "type", "Log" },
            { "accounting", "false" },
            { "alert", "none" },
            { "enable_firewall_session", "false" },
            { "per_connection", "true" },
            { "per_session", "false" },
        },
        CustomFields = null,
        VpnCommunities = new[]
        {
            "StarCommunity",
            "MeshedCommunity",
        },
    });

    var rule4 = new Checkpoint.ManagementAccessRule("rule4", new()
    {
        Layer = "Network",
        Position = 
        {
            { "below", rule3.Name },
        },
        Enabled = false,
        Sources = new[]
        {
            "Any",
        },
        Destinations = new[]
        {
            "Any",
        },
        Services = new[]
        {
            "Any",
        },
        Contents = new[]
        {
            "Any",
        },
        Times = new[]
        {
            "Any",
        },
        InstallOns = new[]
        {
            "Policy Targets",
        },
        Track = 
        {
            { "type", "Log" },
            { "accounting", "false" },
            { "alert", "none" },
            { "enable_firewall_session", "false" },
            { "per_connection", "true" },
            { "per_session", "false" },
        },
        ActionSettings = null,
        CustomFields = null,
        VpnDirectionals = new[]
        {
            new Checkpoint.Inputs.ManagementAccessRuleVpnDirectionalArgs
            {
                From = "StarVpn",
                To = "MeshedCommunity",
            },
        },
    });

    var rule5 = new Checkpoint.ManagementAccessRule("rule5", new()
    {
        Layer = "Network",
        Position = 
        {
            { "below", rule4.Name },
        },
        Action = "Accept",
        ActionSettings = 
        {
            { "enable_identity_captive_portal", "false" },
        },
        Sources = new[]
        {
            "Any",
        },
        Destinations = new[]
        {
            "Any",
        },
        Services = new[]
        {
            "Any",
        },
        Contents = new[]
        {
            "Any",
        },
        Times = new[]
        {
            "Any",
        },
        InstallOns = new[]
        {
            "Policy Targets",
        },
        Track = 
        {
            { "type", "Log" },
            { "accounting", "false" },
            { "alert", "none" },
            { "enable_firewall_session", "false" },
            { "per_connection", "true" },
            { "per_session", "false" },
        },
        CustomFields = null,
        Vpn = "Any",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.checkpoint.ManagementAccessRule;
import com.pulumi.checkpoint.ManagementAccessRuleArgs;
import com.pulumi.checkpoint.inputs.ManagementAccessRuleVpnDirectionalArgs;
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) {
        var rule1 = new ManagementAccessRule("rule1", ManagementAccessRuleArgs.builder()
            .layer("Network")
            .position(Map.of("top", "top"))
            .sources("Any")
            .destinations("Any")
            .services("Any")
            .contents("Any")
            .times("Any")
            .installOns("Policy Targets")
            .track(Map.ofEntries(
                Map.entry("type", "Log"),
                Map.entry("accounting", false),
                Map.entry("alert", "none"),
                Map.entry("enable_firewall_session", false),
                Map.entry("per_connection", true),
                Map.entry("per_session", false)
            ))
            .actionSettings()
            .customFields()
            .vpn("Any")
            .build());

        var rule2 = new ManagementAccessRule("rule2", ManagementAccessRuleArgs.builder()
            .layer("Network")
            .position(Map.of("below", rule1.name()))
            .enabled(true)
            .sources(            
                "DMZNet",
                "DMZZone",
                "WirelessZone")
            .destinations(            
                "InternalNet",
                "CPDShield")
            .destinationNegate(true)
            .services("Any")
            .contents("Any")
            .times("Any")
            .installOns("Policy Targets")
            .track(Map.ofEntries(
                Map.entry("type", "Log"),
                Map.entry("accounting", false),
                Map.entry("alert", "none"),
                Map.entry("enable_firewall_session", false),
                Map.entry("per_connection", true),
                Map.entry("per_session", false)
            ))
            .actionSettings()
            .customFields()
            .vpn("All_GwToGw")
            .build());

        var rule3 = new ManagementAccessRule("rule3", ManagementAccessRuleArgs.builder()
            .layer("Network")
            .position(Map.of("below", rule2.name()))
            .action("Accept")
            .actionSettings(Map.of("enable_identity_captive_portal", true))
            .sources("DMZNet")
            .enabled(true)
            .destinations("InternalNet")
            .destinationNegate(true)
            .services("EDGE")
            .contents("Any")
            .times("Weekend")
            .installOns("Policy Targets")
            .track(Map.ofEntries(
                Map.entry("type", "Log"),
                Map.entry("accounting", false),
                Map.entry("alert", "none"),
                Map.entry("enable_firewall_session", false),
                Map.entry("per_connection", true),
                Map.entry("per_session", false)
            ))
            .customFields()
            .vpnCommunities(            
                "StarCommunity",
                "MeshedCommunity")
            .build());

        var rule4 = new ManagementAccessRule("rule4", ManagementAccessRuleArgs.builder()
            .layer("Network")
            .position(Map.of("below", rule3.name()))
            .enabled(false)
            .sources("Any")
            .destinations("Any")
            .services("Any")
            .contents("Any")
            .times("Any")
            .installOns("Policy Targets")
            .track(Map.ofEntries(
                Map.entry("type", "Log"),
                Map.entry("accounting", false),
                Map.entry("alert", "none"),
                Map.entry("enable_firewall_session", false),
                Map.entry("per_connection", true),
                Map.entry("per_session", false)
            ))
            .actionSettings()
            .customFields()
            .vpnDirectionals(ManagementAccessRuleVpnDirectionalArgs.builder()
                .from("StarVpn")
                .to("MeshedCommunity")
                .build())
            .build());

        var rule5 = new ManagementAccessRule("rule5", ManagementAccessRuleArgs.builder()
            .layer("Network")
            .position(Map.of("below", rule4.name()))
            .action("Accept")
            .actionSettings(Map.of("enable_identity_captive_portal", false))
            .sources("Any")
            .destinations("Any")
            .services("Any")
            .contents("Any")
            .times("Any")
            .installOns("Policy Targets")
            .track(Map.ofEntries(
                Map.entry("type", "Log"),
                Map.entry("accounting", false),
                Map.entry("alert", "none"),
                Map.entry("enable_firewall_session", false),
                Map.entry("per_connection", true),
                Map.entry("per_session", false)
            ))
            .customFields()
            .vpn("Any")
            .build());

    }
}

resources:
  rule1:
    type: checkpoint:ManagementAccessRule
    properties:
      layer: Network
      position:
        top: top
      sources:
        - Any
      destinations:
        - Any
      services:
        - Any
      contents:
        - Any
      times:
        - Any
      installOns:
        - Policy Targets
      track:
        type: Log
        accounting: false
        alert: none
        enable_firewall_session: false
        per_connection: true
        per_session: false
      actionSettings: {}
      customFields: {}
      vpn: Any
  rule2:
    type: checkpoint:ManagementAccessRule
    properties:
      layer: Network
      position:
        below: ${rule1.name}
      enabled: true
      sources:
        - DMZNet
        - DMZZone
        - WirelessZone
      destinations:
        - InternalNet
        - CPDShield
      destinationNegate: true
      services:
        - Any
      contents:
        - Any
      times:
        - Any
      installOns:
        - Policy Targets
      track:
        type: Log
        accounting: false
        alert: none
        enable_firewall_session: false
        per_connection: true
        per_session: false
      actionSettings: {}
      customFields: {}
      vpn: All_GwToGw
  rule3:
    type: checkpoint:ManagementAccessRule
    properties:
      layer: Network
      position:
        below: ${rule2.name}
      action: Accept
      actionSettings:
        enable_identity_captive_portal: true
      sources:
        - DMZNet
      enabled: true
      destinations:
        - InternalNet
      destinationNegate: true
      services:
        - EDGE
      contents:
        - Any
      times:
        - Weekend
      installOns:
        - Policy Targets
      track:
        type: Log
        accounting: false
        alert: none
        enable_firewall_session: false
        per_connection: true
        per_session: false
      customFields: {}
      vpnCommunities:
        - StarCommunity
        - MeshedCommunity
  rule4:
    type: checkpoint:ManagementAccessRule
    properties:
      layer: Network
      position:
        below: ${rule3.name}
      enabled: false
      sources:
        - Any
      destinations:
        - Any
      services:
        - Any
      contents:
        - Any
      times:
        - Any
      installOns:
        - Policy Targets
      track:
        type: Log
        accounting: false
        alert: none
        enable_firewall_session: false
        per_connection: true
        per_session: false
      actionSettings: {}
      customFields: {}
      vpnDirectionals:
        - from: StarVpn
          to: MeshedCommunity
  rule5:
    type: checkpoint:ManagementAccessRule
    properties:
      layer: Network
      position:
        below: ${rule4.name}
      action: Accept
      actionSettings:
        enable_identity_captive_portal: false
      sources:
        - Any
      destinations:
        - Any
      services:
        - Any
      contents:
        - Any
      times:
        - Any
      installOns:
        - Policy Targets
      track:
        type: Log
        accounting: false
        alert: none
        enable_firewall_session: false
        per_connection: true
        per_session: false
      customFields: {}
      vpn: Any

var managementAccessRuleResource = new Checkpoint.ManagementAccessRule("managementAccessRuleResource", new()
{
    Layer = "string",
    Position = 
    {
        { "string", "string" },
    },
    InstallOns = new[]
    {
        "string",
    },
    Vpn = "string",
    ContentNegate = false,
    Contents = new[]
    {
        "string",
    },
    CustomFields = 
    {
        { "string", "string" },
    },
    DestinationNegate = false,
    Destinations = new[]
    {
        "string",
    },
    Enabled = false,
    FieldsWithUidIdentifiers = new[]
    {
        "string",
    },
    IgnoreErrors = false,
    IgnoreWarnings = false,
    ManagementAccessRuleId = "string",
    ContentDirection = "string",
    Action = "string",
    InlineLayer = "string",
    Name = "string",
    ActionSettings = 
    {
        { "string", "string" },
    },
    ServiceNegate = false,
    Services = new[]
    {
        "string",
    },
    SourceNegate = false,
    Sources = new[]
    {
        "string",
    },
    Times = new[]
    {
        "string",
    },
    Track = 
    {
        { "string", "string" },
    },
    UserCheck = new Checkpoint.Inputs.ManagementAccessRuleUserCheckArgs
    {
        Confirm = "string",
        CustomFrequency = new Checkpoint.Inputs.ManagementAccessRuleUserCheckCustomFrequencyArgs
        {
            Every = 0,
            Unit = "string",
        },
        Frequency = "string",
        Interaction = "string",
    },
    Comments = "string",
    VpnCommunities = new[]
    {
        "string",
    },
    VpnDirectionals = new[]
    {
        new Checkpoint.Inputs.ManagementAccessRuleVpnDirectionalArgs
        {
            From = "string",
            To = "string",
        },
    },
});

example, err := checkpoint.NewManagementAccessRule(ctx, "managementAccessRuleResource", &checkpoint.ManagementAccessRuleArgs{
	Layer: pulumi.String("string"),
	Position: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	InstallOns: pulumi.StringArray{
		pulumi.String("string"),
	},
	Vpn:           pulumi.String("string"),
	ContentNegate: pulumi.Bool(false),
	Contents: pulumi.StringArray{
		pulumi.String("string"),
	},
	CustomFields: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	DestinationNegate: pulumi.Bool(false),
	Destinations: pulumi.StringArray{
		pulumi.String("string"),
	},
	Enabled: pulumi.Bool(false),
	FieldsWithUidIdentifiers: pulumi.StringArray{
		pulumi.String("string"),
	},
	IgnoreErrors:           pulumi.Bool(false),
	IgnoreWarnings:         pulumi.Bool(false),
	ManagementAccessRuleId: pulumi.String("string"),
	ContentDirection:       pulumi.String("string"),
	Action:                 pulumi.String("string"),
	InlineLayer:            pulumi.String("string"),
	Name:                   pulumi.String("string"),
	ActionSettings: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	ServiceNegate: pulumi.Bool(false),
	Services: pulumi.StringArray{
		pulumi.String("string"),
	},
	SourceNegate: pulumi.Bool(false),
	Sources: pulumi.StringArray{
		pulumi.String("string"),
	},
	Times: pulumi.StringArray{
		pulumi.String("string"),
	},
	Track: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	UserCheck: &checkpoint.ManagementAccessRuleUserCheckArgs{
		Confirm: pulumi.String("string"),
		CustomFrequency: &checkpoint.ManagementAccessRuleUserCheckCustomFrequencyArgs{
			Every: pulumi.Float64(0),
			Unit:  pulumi.String("string"),
		},
		Frequency:   pulumi.String("string"),
		Interaction: pulumi.String("string"),
	},
	Comments: pulumi.String("string"),
	VpnCommunities: pulumi.StringArray{
		pulumi.String("string"),
	},
	VpnDirectionals: checkpoint.ManagementAccessRuleVpnDirectionalArray{
		&checkpoint.ManagementAccessRuleVpnDirectionalArgs{
			From: pulumi.String("string"),
			To:   pulumi.String("string"),
		},
	},
})