checkpoint.getManagementNetworkProbe

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

const example = new checkpoint.ManagementNetworkProbe("example", {
    icmpOptions: {
        destination: "host2",
        source: "host1",
    },
    installOns: [
        "gw1",
        "gw2",
    ],
    interval: 20,
    protocol: "icmp",
});
const data = checkpoint.getManagementNetworkProbeOutput({
    uid: example.managementNetworkProbeId,
});

import pulumi
import pulumi_checkpoint as checkpoint

example = checkpoint.ManagementNetworkProbe("example",
    icmp_options={
        "destination": "host2",
        "source": "host1",
    },
    install_ons=[
        "gw1",
        "gw2",
    ],
    interval=20,
    protocol="icmp")
data = checkpoint.get_management_network_probe_output(uid=example.management_network_probe_id)

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 {
		example, err := checkpoint.NewManagementNetworkProbe(ctx, "example", &checkpoint.ManagementNetworkProbeArgs{
			IcmpOptions: pulumi.StringMap{
				"destination": pulumi.String("host2"),
				"source":      pulumi.String("host1"),
			},
			InstallOns: pulumi.StringArray{
				pulumi.String("gw1"),
				pulumi.String("gw2"),
			},
			Interval: pulumi.Float64(20),
			Protocol: pulumi.String("icmp"),
		})
		if err != nil {
			return err
		}
		_ = checkpoint.LookupManagementNetworkProbeOutput(ctx, checkpoint.GetManagementNetworkProbeOutputArgs{
			Uid: example.ManagementNetworkProbeId,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Checkpoint.ManagementNetworkProbe("example", new()
    {
        IcmpOptions = 
        {
            { "destination", "host2" },
            { "source", "host1" },
        },
        InstallOns = new[]
        {
            "gw1",
            "gw2",
        },
        Interval = 20,
        Protocol = "icmp",
    });

    var data = Checkpoint.GetManagementNetworkProbe.Invoke(new()
    {
        Uid = example.ManagementNetworkProbeId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.checkpoint.ManagementNetworkProbe;
import com.pulumi.checkpoint.ManagementNetworkProbeArgs;
import com.pulumi.checkpoint.CheckpointFunctions;
import com.pulumi.checkpoint.inputs.GetManagementNetworkProbeArgs;
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 example = new ManagementNetworkProbe("example", ManagementNetworkProbeArgs.builder()
            .icmpOptions(Map.ofEntries(
                Map.entry("destination", "host2"),
                Map.entry("source", "host1")
            ))
            .installOns(            
                "gw1",
                "gw2")
            .interval("20")
            .protocol("icmp")
            .build());

        final var data = CheckpointFunctions.getManagementNetworkProbe(GetManagementNetworkProbeArgs.builder()
            .uid(example.managementNetworkProbeId())
            .build());

    }
}

resources:
  example:
    type: checkpoint:ManagementNetworkProbe
    properties:
      icmpOptions:
        destination: host2
        source: host1
      installOns:
        - gw1
        - gw2
      interval: '20'
      protocol: icmp
variables:
  data:
    fn::invoke:
      function: checkpoint:getManagementNetworkProbe
      arguments:
        uid: ${example.managementNetworkProbeId}

function getManagementNetworkProbe(args: GetManagementNetworkProbeArgs, opts?: InvokeOptions): Promise<GetManagementNetworkProbeResult>
function getManagementNetworkProbeOutput(args: GetManagementNetworkProbeOutputArgs, opts?: InvokeOptions): Output<GetManagementNetworkProbeResult>

def get_management_network_probe(id: Optional[str] = None,
                                 name: Optional[str] = None,
                                 uid: Optional[str] = None,
                                 opts: Optional[InvokeOptions] = None) -> GetManagementNetworkProbeResult
def get_management_network_probe_output(id: Optional[pulumi.Input[str]] = None,
                                 name: Optional[pulumi.Input[str]] = None,
                                 uid: Optional[pulumi.Input[str]] = None,
                                 opts: Optional[InvokeOptions] = None) -> Output[GetManagementNetworkProbeResult]

func LookupManagementNetworkProbe(ctx *Context, args *LookupManagementNetworkProbeArgs, opts ...InvokeOption) (*LookupManagementNetworkProbeResult, error)
func LookupManagementNetworkProbeOutput(ctx *Context, args *LookupManagementNetworkProbeOutputArgs, opts ...InvokeOption) LookupManagementNetworkProbeResultOutput

public static class GetManagementNetworkProbe 
{
    public static Task<GetManagementNetworkProbeResult> InvokeAsync(GetManagementNetworkProbeArgs args, InvokeOptions? opts = null)
    public static Output<GetManagementNetworkProbeResult> Invoke(GetManagementNetworkProbeInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagementNetworkProbeResult> getManagementNetworkProbe(GetManagementNetworkProbeArgs args, InvokeOptions options)
public static Output<GetManagementNetworkProbeResult> getManagementNetworkProbe(GetManagementNetworkProbeArgs args, InvokeOptions options)

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