checkpoint.getManagementDataAccessRule

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

const accessRule = new checkpoint.ManagementAccessRule("accessRule", {
    contents: ["Any"],
    customFields: {},
    destinations: ["Any"],
    installOns: ["Policy Targets"],
    layer: "Network",
    position: {
        top: "top",
    },
    services: ["Any"],
    sources: ["Any"],
    times: ["Any"],
    track: {
        accounting: "false",
        alert: "none",
        enable_firewall_session: "false",
        per_connection: "true",
        per_session: "false",
        type: "Log",
    },
    vpn: "Any",
});
const dataAccessRule = checkpoint.getManagementDataAccessRuleOutput({
    layer: accessRule.layer,
    name: accessRule.name,
});

import pulumi
import pulumi_checkpoint as checkpoint

access_rule = checkpoint.ManagementAccessRule("accessRule",
    contents=["Any"],
    custom_fields={},
    destinations=["Any"],
    install_ons=["Policy Targets"],
    layer="Network",
    position={
        "top": "top",
    },
    services=["Any"],
    sources=["Any"],
    times=["Any"],
    track={
        "accounting": "false",
        "alert": "none",
        "enable_firewall_session": "false",
        "per_connection": "true",
        "per_session": "false",
        "type": "Log",
    },
    vpn="Any")
data_access_rule = checkpoint.get_management_data_access_rule_output(layer=access_rule.layer,
    name=access_rule.name)

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 {
		accessRule, err := checkpoint.NewManagementAccessRule(ctx, "accessRule", &checkpoint.ManagementAccessRuleArgs{
			Contents: pulumi.StringArray{
				pulumi.String("Any"),
			},
			CustomFields: pulumi.StringMap{},
			Destinations: pulumi.StringArray{
				pulumi.String("Any"),
			},
			InstallOns: pulumi.StringArray{
				pulumi.String("Policy Targets"),
			},
			Layer: pulumi.String("Network"),
			Position: pulumi.StringMap{
				"top": pulumi.String("top"),
			},
			Services: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Sources: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Times: pulumi.StringArray{
				pulumi.String("Any"),
			},
			Track: pulumi.StringMap{
				"accounting":              pulumi.String("false"),
				"alert":                   pulumi.String("none"),
				"enable_firewall_session": pulumi.String("false"),
				"per_connection":          pulumi.String("true"),
				"per_session":             pulumi.String("false"),
				"type":                    pulumi.String("Log"),
			},
			Vpn: pulumi.String("Any"),
		})
		if err != nil {
			return err
		}
		_ = checkpoint.GetManagementDataAccessRuleOutput(ctx, checkpoint.GetManagementDataAccessRuleOutputArgs{
			Layer: accessRule.Layer,
			Name:  accessRule.Name,
		}, nil)
		return nil
	})
}

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

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

    var dataAccessRule = Checkpoint.GetManagementDataAccessRule.Invoke(new()
    {
        Layer = accessRule.Layer,
        Name = accessRule.Name,
    });

});

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

        final var dataAccessRule = CheckpointFunctions.getManagementDataAccessRule(GetManagementDataAccessRuleArgs.builder()
            .layer(accessRule.layer())
            .name(accessRule.name())
            .build());

    }
}

resources:
  accessRule:
    type: checkpoint:ManagementAccessRule
    properties:
      contents:
        - Any
      customFields: {}
      destinations:
        - Any
      installOns:
        - Policy Targets
      layer: Network
      position:
        top: top
      services:
        - Any
      sources:
        - Any
      times:
        - Any
      track:
        accounting: false
        alert: none
        enable_firewall_session: false
        per_connection: true
        per_session: false
        type: Log
      vpn: Any
variables:
  dataAccessRule:
    fn::invoke:
      function: checkpoint:getManagementDataAccessRule
      arguments:
        layer: ${accessRule.layer}
        name: ${accessRule.name}

function getManagementDataAccessRule(args: GetManagementDataAccessRuleArgs, opts?: InvokeOptions): Promise<GetManagementDataAccessRuleResult>
function getManagementDataAccessRuleOutput(args: GetManagementDataAccessRuleOutputArgs, opts?: InvokeOptions): Output<GetManagementDataAccessRuleResult>

def get_management_data_access_rule(fields_with_uid_identifiers: Optional[Sequence[str]] = None,
                                    id: Optional[str] = None,
                                    layer: Optional[str] = None,
                                    name: Optional[str] = None,
                                    uid: Optional[str] = None,
                                    opts: Optional[InvokeOptions] = None) -> GetManagementDataAccessRuleResult
def get_management_data_access_rule_output(fields_with_uid_identifiers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                                    id: Optional[pulumi.Input[str]] = None,
                                    layer: Optional[pulumi.Input[str]] = None,
                                    name: Optional[pulumi.Input[str]] = None,
                                    uid: Optional[pulumi.Input[str]] = None,
                                    opts: Optional[InvokeOptions] = None) -> Output[GetManagementDataAccessRuleResult]

func GetManagementDataAccessRule(ctx *Context, args *GetManagementDataAccessRuleArgs, opts ...InvokeOption) (*GetManagementDataAccessRuleResult, error)
func GetManagementDataAccessRuleOutput(ctx *Context, args *GetManagementDataAccessRuleOutputArgs, opts ...InvokeOption) GetManagementDataAccessRuleResultOutput

public static class GetManagementDataAccessRule 
{
    public static Task<GetManagementDataAccessRuleResult> InvokeAsync(GetManagementDataAccessRuleArgs args, InvokeOptions? opts = null)
    public static Output<GetManagementDataAccessRuleResult> Invoke(GetManagementDataAccessRuleInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagementDataAccessRuleResult> getManagementDataAccessRule(GetManagementDataAccessRuleArgs args, InvokeOptions options)
public static Output<GetManagementDataAccessRuleResult> getManagementDataAccessRule(GetManagementDataAccessRuleArgs args, InvokeOptions options)

fn::invoke:
  function: checkpoint:index/getManagementDataAccessRule:getManagementDataAccessRule
  arguments:
    # arguments dictionary