checkpoint.getManagementDataGroup

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

const group = new checkpoint.ManagementGroup("group", {});
const dataGroup = checkpoint.getManagementDataGroupOutput({
    name: group.name,
});

import pulumi
import pulumi_checkpoint as checkpoint

group = checkpoint.ManagementGroup("group")
data_group = checkpoint.get_management_data_group_output(name=group.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 {
		group, err := checkpoint.NewManagementGroup(ctx, "group", nil)
		if err != nil {
			return err
		}
		_ = checkpoint.GetManagementDataGroupOutput(ctx, checkpoint.GetManagementDataGroupOutputArgs{
			Name: group.Name,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var @group = new Checkpoint.ManagementGroup("group");

    var dataGroup = Checkpoint.GetManagementDataGroup.Invoke(new()
    {
        Name = @group.Name,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.checkpoint.ManagementGroup;
import com.pulumi.checkpoint.CheckpointFunctions;
import com.pulumi.checkpoint.inputs.GetManagementDataGroupArgs;
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 group = new ManagementGroup("group");

        final var dataGroup = CheckpointFunctions.getManagementDataGroup(GetManagementDataGroupArgs.builder()
            .name(group.name())
            .build());

    }
}

resources:
  group:
    type: checkpoint:ManagementGroup
variables:
  dataGroup:
    fn::invoke:
      function: checkpoint:getManagementDataGroup
      arguments:
        name: ${group.name}

function getManagementDataGroup(args: GetManagementDataGroupArgs, opts?: InvokeOptions): Promise<GetManagementDataGroupResult>
function getManagementDataGroupOutput(args: GetManagementDataGroupOutputArgs, opts?: InvokeOptions): Output<GetManagementDataGroupResult>

def get_management_data_group(id: Optional[str] = None,
                              name: Optional[str] = None,
                              uid: Optional[str] = None,
                              opts: Optional[InvokeOptions] = None) -> GetManagementDataGroupResult
def get_management_data_group_output(id: Optional[pulumi.Input[str]] = None,
                              name: Optional[pulumi.Input[str]] = None,
                              uid: Optional[pulumi.Input[str]] = None,
                              opts: Optional[InvokeOptions] = None) -> Output[GetManagementDataGroupResult]

func GetManagementDataGroup(ctx *Context, args *GetManagementDataGroupArgs, opts ...InvokeOption) (*GetManagementDataGroupResult, error)
func GetManagementDataGroupOutput(ctx *Context, args *GetManagementDataGroupOutputArgs, opts ...InvokeOption) GetManagementDataGroupResultOutput

public static class GetManagementDataGroup 
{
    public static Task<GetManagementDataGroupResult> InvokeAsync(GetManagementDataGroupArgs args, InvokeOptions? opts = null)
    public static Output<GetManagementDataGroupResult> Invoke(GetManagementDataGroupInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagementDataGroupResult> getManagementDataGroup(GetManagementDataGroupArgs args, InvokeOptions options)
public static Output<GetManagementDataGroupResult> getManagementDataGroup(GetManagementDataGroupArgs args, InvokeOptions options)

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