checkpoint.getManagementGenericDataCenterServer

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

const genericTest = new checkpoint.ManagementGenericDataCenterServer("generic_test", {
    name: "test",
    url: "MY_URL",
    interval: "60",
    comments: "testing generic data center",
    color: "crete blue",
    tags: ["terraform"],
});
const dataGenericDataCenterServer = checkpoint.getManagementGenericDataCenterServerOutput({
    name: genericTest.name,
});

import pulumi
import pulumi_checkpoint as checkpoint

generic_test = checkpoint.ManagementGenericDataCenterServer("generic_test",
    name="test",
    url="MY_URL",
    interval="60",
    comments="testing generic data center",
    color="crete blue",
    tags=["terraform"])
data_generic_data_center_server = checkpoint.get_management_generic_data_center_server_output(name=generic_test.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 {
		genericTest, err := checkpoint.NewManagementGenericDataCenterServer(ctx, "generic_test", &checkpoint.ManagementGenericDataCenterServerArgs{
			Name:     pulumi.String("test"),
			Url:      pulumi.String("MY_URL"),
			Interval: pulumi.String("60"),
			Comments: pulumi.String("testing generic data center"),
			Color:    pulumi.String("crete blue"),
			Tags: pulumi.StringArray{
				pulumi.String("terraform"),
			},
		})
		if err != nil {
			return err
		}
		_ = checkpoint.LookupManagementGenericDataCenterServerOutput(ctx, checkpoint.GetManagementGenericDataCenterServerOutputArgs{
			Name: genericTest.Name,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var genericTest = new Checkpoint.ManagementGenericDataCenterServer("generic_test", new()
    {
        Name = "test",
        Url = "MY_URL",
        Interval = "60",
        Comments = "testing generic data center",
        Color = "crete blue",
        Tags = new[]
        {
            "terraform",
        },
    });

    var dataGenericDataCenterServer = Checkpoint.GetManagementGenericDataCenterServer.Invoke(new()
    {
        Name = genericTest.Name,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.checkpoint.ManagementGenericDataCenterServer;
import com.pulumi.checkpoint.ManagementGenericDataCenterServerArgs;
import com.pulumi.checkpoint.CheckpointFunctions;
import com.pulumi.checkpoint.inputs.GetManagementGenericDataCenterServerArgs;
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 genericTest = new ManagementGenericDataCenterServer("genericTest", ManagementGenericDataCenterServerArgs.builder()
            .name("test")
            .url("MY_URL")
            .interval("60")
            .comments("testing generic data center")
            .color("crete blue")
            .tags("terraform")
            .build());

        final var dataGenericDataCenterServer = CheckpointFunctions.getManagementGenericDataCenterServer(GetManagementGenericDataCenterServerArgs.builder()
            .name(genericTest.name())
            .build());

    }
}

resources:
  genericTest:
    type: checkpoint:ManagementGenericDataCenterServer
    name: generic_test
    properties:
      name: test
      url: MY_URL
      interval: '60'
      comments: testing generic data center
      color: crete blue
      tags:
        - terraform
variables:
  dataGenericDataCenterServer:
    fn::invoke:
      function: checkpoint:getManagementGenericDataCenterServer
      arguments:
        name: ${genericTest.name}

function getManagementGenericDataCenterServer(args: GetManagementGenericDataCenterServerArgs, opts?: InvokeOptions): Promise<GetManagementGenericDataCenterServerResult>
function getManagementGenericDataCenterServerOutput(args: GetManagementGenericDataCenterServerOutputArgs, opts?: InvokeOptions): Output<GetManagementGenericDataCenterServerResult>

def get_management_generic_data_center_server(id: Optional[str] = None,
                                              name: Optional[str] = None,
                                              uid: Optional[str] = None,
                                              opts: Optional[InvokeOptions] = None) -> GetManagementGenericDataCenterServerResult
def get_management_generic_data_center_server_output(id: Optional[pulumi.Input[str]] = None,
                                              name: Optional[pulumi.Input[str]] = None,
                                              uid: Optional[pulumi.Input[str]] = None,
                                              opts: Optional[InvokeOptions] = None) -> Output[GetManagementGenericDataCenterServerResult]

func LookupManagementGenericDataCenterServer(ctx *Context, args *LookupManagementGenericDataCenterServerArgs, opts ...InvokeOption) (*LookupManagementGenericDataCenterServerResult, error)
func LookupManagementGenericDataCenterServerOutput(ctx *Context, args *LookupManagementGenericDataCenterServerOutputArgs, opts ...InvokeOption) LookupManagementGenericDataCenterServerResultOutput

public static class GetManagementGenericDataCenterServer 
{
    public static Task<GetManagementGenericDataCenterServerResult> InvokeAsync(GetManagementGenericDataCenterServerArgs args, InvokeOptions? opts = null)
    public static Output<GetManagementGenericDataCenterServerResult> Invoke(GetManagementGenericDataCenterServerInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagementGenericDataCenterServerResult> getManagementGenericDataCenterServer(GetManagementGenericDataCenterServerArgs args, InvokeOptions options)
public static Output<GetManagementGenericDataCenterServerResult> getManagementGenericDataCenterServer(GetManagementGenericDataCenterServerArgs args, InvokeOptions options)

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