checkpoint.getManagementDataOpsecApplication

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

const myhost = new checkpoint.ManagementHost("myhost", {ipv4Address: "1.2.3.4"});
const opsecApplication = new checkpoint.ManagementOpsecApplication("opsecApplication", {
    cpmi: {
        administrator_profile: "read only all",
        enabled: "true",
        use_administrator_credentials: "false",
    },
    host: myhost.name,
    lea: {
        access_permissions: "show all",
        enabled: "true",
    },
});
const dataOpsecApplication = checkpoint.getManagementDataOpsecApplicationOutput({
    name: opsecApplication.name,
});

import pulumi
import pulumi_checkpoint as checkpoint

myhost = checkpoint.ManagementHost("myhost", ipv4_address="1.2.3.4")
opsec_application = checkpoint.ManagementOpsecApplication("opsecApplication",
    cpmi={
        "administrator_profile": "read only all",
        "enabled": "true",
        "use_administrator_credentials": "false",
    },
    host=myhost.name,
    lea={
        "access_permissions": "show all",
        "enabled": "true",
    })
data_opsec_application = checkpoint.get_management_data_opsec_application_output(name=opsec_application.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 {
		myhost, err := checkpoint.NewManagementHost(ctx, "myhost", &checkpoint.ManagementHostArgs{
			Ipv4Address: pulumi.String("1.2.3.4"),
		})
		if err != nil {
			return err
		}
		opsecApplication, err := checkpoint.NewManagementOpsecApplication(ctx, "opsecApplication", &checkpoint.ManagementOpsecApplicationArgs{
			Cpmi: pulumi.StringMap{
				"administrator_profile":         pulumi.String("read only all"),
				"enabled":                       pulumi.String("true"),
				"use_administrator_credentials": pulumi.String("false"),
			},
			Host: myhost.Name,
			Lea: pulumi.StringMap{
				"access_permissions": pulumi.String("show all"),
				"enabled":            pulumi.String("true"),
			},
		})
		if err != nil {
			return err
		}
		_ = checkpoint.GetManagementDataOpsecApplicationOutput(ctx, checkpoint.GetManagementDataOpsecApplicationOutputArgs{
			Name: opsecApplication.Name,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var myhost = new Checkpoint.ManagementHost("myhost", new()
    {
        Ipv4Address = "1.2.3.4",
    });

    var opsecApplication = new Checkpoint.ManagementOpsecApplication("opsecApplication", new()
    {
        Cpmi = 
        {
            { "administrator_profile", "read only all" },
            { "enabled", "true" },
            { "use_administrator_credentials", "false" },
        },
        Host = myhost.Name,
        Lea = 
        {
            { "access_permissions", "show all" },
            { "enabled", "true" },
        },
    });

    var dataOpsecApplication = Checkpoint.GetManagementDataOpsecApplication.Invoke(new()
    {
        Name = opsecApplication.Name,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.checkpoint.ManagementHost;
import com.pulumi.checkpoint.ManagementHostArgs;
import com.pulumi.checkpoint.ManagementOpsecApplication;
import com.pulumi.checkpoint.ManagementOpsecApplicationArgs;
import com.pulumi.checkpoint.CheckpointFunctions;
import com.pulumi.checkpoint.inputs.GetManagementDataOpsecApplicationArgs;
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 myhost = new ManagementHost("myhost", ManagementHostArgs.builder()
            .ipv4Address("1.2.3.4")
            .build());

        var opsecApplication = new ManagementOpsecApplication("opsecApplication", ManagementOpsecApplicationArgs.builder()
            .cpmi(Map.ofEntries(
                Map.entry("administrator_profile", "read only all"),
                Map.entry("enabled", true),
                Map.entry("use_administrator_credentials", false)
            ))
            .host(myhost.name())
            .lea(Map.ofEntries(
                Map.entry("access_permissions", "show all"),
                Map.entry("enabled", true)
            ))
            .build());

        final var dataOpsecApplication = CheckpointFunctions.getManagementDataOpsecApplication(GetManagementDataOpsecApplicationArgs.builder()
            .name(opsecApplication.name())
            .build());

    }
}

resources:
  myhost:
    type: checkpoint:ManagementHost
    properties:
      ipv4Address: 1.2.3.4
  opsecApplication:
    type: checkpoint:ManagementOpsecApplication
    properties:
      cpmi:
        administrator_profile: read only all
        enabled: true
        use_administrator_credentials: false
      host: ${myhost.name}
      lea:
        access_permissions: show all
        enabled: true
variables:
  dataOpsecApplication:
    fn::invoke:
      function: checkpoint:getManagementDataOpsecApplication
      arguments:
        name: ${opsecApplication.name}

function getManagementDataOpsecApplication(args: GetManagementDataOpsecApplicationArgs, opts?: InvokeOptions): Promise<GetManagementDataOpsecApplicationResult>
function getManagementDataOpsecApplicationOutput(args: GetManagementDataOpsecApplicationOutputArgs, opts?: InvokeOptions): Output<GetManagementDataOpsecApplicationResult>

def get_management_data_opsec_application(id: Optional[str] = None,
                                          name: Optional[str] = None,
                                          uid: Optional[str] = None,
                                          opts: Optional[InvokeOptions] = None) -> GetManagementDataOpsecApplicationResult
def get_management_data_opsec_application_output(id: Optional[pulumi.Input[str]] = None,
                                          name: Optional[pulumi.Input[str]] = None,
                                          uid: Optional[pulumi.Input[str]] = None,
                                          opts: Optional[InvokeOptions] = None) -> Output[GetManagementDataOpsecApplicationResult]

func GetManagementDataOpsecApplication(ctx *Context, args *GetManagementDataOpsecApplicationArgs, opts ...InvokeOption) (*GetManagementDataOpsecApplicationResult, error)
func GetManagementDataOpsecApplicationOutput(ctx *Context, args *GetManagementDataOpsecApplicationOutputArgs, opts ...InvokeOption) GetManagementDataOpsecApplicationResultOutput

public static class GetManagementDataOpsecApplication 
{
    public static Task<GetManagementDataOpsecApplicationResult> InvokeAsync(GetManagementDataOpsecApplicationArgs args, InvokeOptions? opts = null)
    public static Output<GetManagementDataOpsecApplicationResult> Invoke(GetManagementDataOpsecApplicationInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagementDataOpsecApplicationResult> getManagementDataOpsecApplication(GetManagementDataOpsecApplicationArgs args, InvokeOptions options)
public static Output<GetManagementDataOpsecApplicationResult> getManagementDataOpsecApplication(GetManagementDataOpsecApplicationArgs args, InvokeOptions options)

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