checkpoint.getManagementDataThreatIndicator

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

const threatIndicator = new checkpoint.ManagementThreatIndicator("threatIndicator", {
    ignoreWarnings: true,
    observables: [{
        ipAddress: "5.4.7.1",
        name: "obs1",
    }],
});
const dataThreatIndicator = checkpoint.getManagementDataThreatIndicatorOutput({
    name: threatIndicator.name,
});

import pulumi
import pulumi_checkpoint as checkpoint

threat_indicator = checkpoint.ManagementThreatIndicator("threatIndicator",
    ignore_warnings=True,
    observables=[{
        "ip_address": "5.4.7.1",
        "name": "obs1",
    }])
data_threat_indicator = checkpoint.get_management_data_threat_indicator_output(name=threat_indicator.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 {
		threatIndicator, err := checkpoint.NewManagementThreatIndicator(ctx, "threatIndicator", &checkpoint.ManagementThreatIndicatorArgs{
			IgnoreWarnings: pulumi.Bool(true),
			Observables: checkpoint.ManagementThreatIndicatorObservableArray{
				&checkpoint.ManagementThreatIndicatorObservableArgs{
					IpAddress: pulumi.String("5.4.7.1"),
					Name:      pulumi.String("obs1"),
				},
			},
		})
		if err != nil {
			return err
		}
		_ = checkpoint.GetManagementDataThreatIndicatorOutput(ctx, checkpoint.GetManagementDataThreatIndicatorOutputArgs{
			Name: threatIndicator.Name,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var threatIndicator = new Checkpoint.ManagementThreatIndicator("threatIndicator", new()
    {
        IgnoreWarnings = true,
        Observables = new[]
        {
            new Checkpoint.Inputs.ManagementThreatIndicatorObservableArgs
            {
                IpAddress = "5.4.7.1",
                Name = "obs1",
            },
        },
    });

    var dataThreatIndicator = Checkpoint.GetManagementDataThreatIndicator.Invoke(new()
    {
        Name = threatIndicator.Name,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.checkpoint.ManagementThreatIndicator;
import com.pulumi.checkpoint.ManagementThreatIndicatorArgs;
import com.pulumi.checkpoint.inputs.ManagementThreatIndicatorObservableArgs;
import com.pulumi.checkpoint.CheckpointFunctions;
import com.pulumi.checkpoint.inputs.GetManagementDataThreatIndicatorArgs;
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 threatIndicator = new ManagementThreatIndicator("threatIndicator", ManagementThreatIndicatorArgs.builder()
            .ignoreWarnings(true)
            .observables(ManagementThreatIndicatorObservableArgs.builder()
                .ipAddress("5.4.7.1")
                .name("obs1")
                .build())
            .build());

        final var dataThreatIndicator = CheckpointFunctions.getManagementDataThreatIndicator(GetManagementDataThreatIndicatorArgs.builder()
            .name(threatIndicator.name())
            .build());

    }
}

resources:
  threatIndicator:
    type: checkpoint:ManagementThreatIndicator
    properties:
      ignoreWarnings: true
      observables:
        - ipAddress: 5.4.7.1
          name: obs1
variables:
  dataThreatIndicator:
    fn::invoke:
      function: checkpoint:getManagementDataThreatIndicator
      arguments:
        name: ${threatIndicator.name}

function getManagementDataThreatIndicator(args: GetManagementDataThreatIndicatorArgs, opts?: InvokeOptions): Promise<GetManagementDataThreatIndicatorResult>
function getManagementDataThreatIndicatorOutput(args: GetManagementDataThreatIndicatorOutputArgs, opts?: InvokeOptions): Output<GetManagementDataThreatIndicatorResult>

def get_management_data_threat_indicator(id: Optional[str] = None,
                                         name: Optional[str] = None,
                                         uid: Optional[str] = None,
                                         opts: Optional[InvokeOptions] = None) -> GetManagementDataThreatIndicatorResult
def get_management_data_threat_indicator_output(id: Optional[pulumi.Input[str]] = None,
                                         name: Optional[pulumi.Input[str]] = None,
                                         uid: Optional[pulumi.Input[str]] = None,
                                         opts: Optional[InvokeOptions] = None) -> Output[GetManagementDataThreatIndicatorResult]

func GetManagementDataThreatIndicator(ctx *Context, args *GetManagementDataThreatIndicatorArgs, opts ...InvokeOption) (*GetManagementDataThreatIndicatorResult, error)
func GetManagementDataThreatIndicatorOutput(ctx *Context, args *GetManagementDataThreatIndicatorOutputArgs, opts ...InvokeOption) GetManagementDataThreatIndicatorResultOutput

public static class GetManagementDataThreatIndicator 
{
    public static Task<GetManagementDataThreatIndicatorResult> InvokeAsync(GetManagementDataThreatIndicatorArgs args, InvokeOptions? opts = null)
    public static Output<GetManagementDataThreatIndicatorResult> Invoke(GetManagementDataThreatIndicatorInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagementDataThreatIndicatorResult> getManagementDataThreatIndicator(GetManagementDataThreatIndicatorArgs args, InvokeOptions options)
public static Output<GetManagementDataThreatIndicatorResult> getManagementDataThreatIndicator(GetManagementDataThreatIndicatorArgs args, InvokeOptions options)

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