vcd.getOrgGroup

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

const org1 = vcd.getOrgGroup({
    org: "org1",
    name: "Org1-AdminGroup",
});
export const groupRole = org1.then(org1 => org1.role);

import pulumi
import pulumi_vcd as vcd

org1 = vcd.get_org_group(org="org1",
    name="Org1-AdminGroup")
pulumi.export("groupRole", org1.role)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/vcd/v3/vcd"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		org1, err := vcd.LookupOrgGroup(ctx, &vcd.LookupOrgGroupArgs{
			Org:  pulumi.StringRef("org1"),
			Name: "Org1-AdminGroup",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("groupRole", org1.Role)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var org1 = Vcd.GetOrgGroup.Invoke(new()
    {
        Org = "org1",
        Name = "Org1-AdminGroup",
    });

    return new Dictionary<string, object?>
    {
        ["groupRole"] = org1.Apply(getOrgGroupResult => getOrgGroupResult.Role),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vcd.VcdFunctions;
import com.pulumi.vcd.inputs.GetOrgGroupArgs;
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) {
        final var org1 = VcdFunctions.getOrgGroup(GetOrgGroupArgs.builder()
            .org("org1")
            .name("Org1-AdminGroup")
            .build());

        ctx.export("groupRole", org1.applyValue(getOrgGroupResult -> getOrgGroupResult.role()));
    }
}

variables:
  org1:
    fn::invoke:
      function: vcd:getOrgGroup
      arguments:
        org: org1
        name: Org1-AdminGroup
outputs:
  groupRole: ${org1.role}

function getOrgGroup(args: GetOrgGroupArgs, opts?: InvokeOptions): Promise<GetOrgGroupResult>
function getOrgGroupOutput(args: GetOrgGroupOutputArgs, opts?: InvokeOptions): Output<GetOrgGroupResult>

def get_org_group(id: Optional[str] = None,
                  name: Optional[str] = None,
                  org: Optional[str] = None,
                  opts: Optional[InvokeOptions] = None) -> GetOrgGroupResult
def get_org_group_output(id: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  org: Optional[pulumi.Input[str]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[GetOrgGroupResult]

func LookupOrgGroup(ctx *Context, args *LookupOrgGroupArgs, opts ...InvokeOption) (*LookupOrgGroupResult, error)
func LookupOrgGroupOutput(ctx *Context, args *LookupOrgGroupOutputArgs, opts ...InvokeOption) LookupOrgGroupResultOutput

public static class GetOrgGroup 
{
    public static Task<GetOrgGroupResult> InvokeAsync(GetOrgGroupArgs args, InvokeOptions? opts = null)
    public static Output<GetOrgGroupResult> Invoke(GetOrgGroupInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetOrgGroupResult> getOrgGroup(GetOrgGroupArgs args, InvokeOptions options)
public static Output<GetOrgGroupResult> getOrgGroup(GetOrgGroupArgs args, InvokeOptions options)

fn::invoke:
  function: vcd:index/getOrgGroup:getOrgGroup
  arguments:
    # arguments dictionary