scm.getAddressGroup

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

// Look up the address group by its ID.
const scmAddressGroupDs = scm.getAddressGroup({
    id: "99802bce-76c6-42c9-801e-e2e4529bb335",
});
export const addressGroupOutputs = {
    groupId: scmAddressGroupDs.then(scmAddressGroupDs => scmAddressGroupDs.id),
    folder: scmAddressGroupDs.then(scmAddressGroupDs => scmAddressGroupDs.folder),
    name: scmAddressGroupDs.then(scmAddressGroupDs => scmAddressGroupDs.name),
    description: scmAddressGroupDs.then(scmAddressGroupDs => scmAddressGroupDs.description),
    static: scmAddressGroupDs.then(scmAddressGroupDs => scmAddressGroupDs.statics),
};

import pulumi
import pulumi_scm as scm

# Look up the address group by its ID.
scm_address_group_ds = scm.get_address_group(id="99802bce-76c6-42c9-801e-e2e4529bb335")
pulumi.export("addressGroupOutputs", {
    "groupId": scm_address_group_ds.id,
    "folder": scm_address_group_ds.folder,
    "name": scm_address_group_ds.name,
    "description": scm_address_group_ds.description,
    "static": scm_address_group_ds.statics,
})

package main

import (
	"github.com/pulumi/pulumi-scm/sdk/go/scm"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Look up the address group by its ID.
		scmAddressGroupDs, err := scm.LookupAddressGroup(ctx, &scm.LookupAddressGroupArgs{
			Id: "99802bce-76c6-42c9-801e-e2e4529bb335",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("addressGroupOutputs", pulumi.Map{
			"groupId":     scmAddressGroupDs.Id,
			"folder":      scmAddressGroupDs.Folder,
			"name":        scmAddressGroupDs.Name,
			"description": scmAddressGroupDs.Description,
			"static":      scmAddressGroupDs.Statics,
		})
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Look up the address group by its ID.
    var scmAddressGroupDs = Scm.GetAddressGroup.Invoke(new()
    {
        Id = "99802bce-76c6-42c9-801e-e2e4529bb335",
    });

    return new Dictionary<string, object?>
    {
        ["addressGroupOutputs"] = 
        {
            { "groupId", scmAddressGroupDs.Apply(getAddressGroupResult => getAddressGroupResult.Id) },
            { "folder", scmAddressGroupDs.Apply(getAddressGroupResult => getAddressGroupResult.Folder) },
            { "name", scmAddressGroupDs.Apply(getAddressGroupResult => getAddressGroupResult.Name) },
            { "description", scmAddressGroupDs.Apply(getAddressGroupResult => getAddressGroupResult.Description) },
            { "static", scmAddressGroupDs.Apply(getAddressGroupResult => getAddressGroupResult.Statics) },
        },
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scm.ScmFunctions;
import com.pulumi.scm.inputs.GetAddressGroupArgs;
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) {
        // Look up the address group by its ID.
        final var scmAddressGroupDs = ScmFunctions.getAddressGroup(GetAddressGroupArgs.builder()
            .id("99802bce-76c6-42c9-801e-e2e4529bb335")
            .build());

        ctx.export("addressGroupOutputs", Map.ofEntries(
            Map.entry("groupId", scmAddressGroupDs.id()),
            Map.entry("folder", scmAddressGroupDs.folder()),
            Map.entry("name", scmAddressGroupDs.name()),
            Map.entry("description", scmAddressGroupDs.description()),
            Map.entry("static", scmAddressGroupDs.statics())
        ));
    }
}

variables:
  # Look up the address group by its ID.
  scmAddressGroupDs:
    fn::invoke:
      function: scm:getAddressGroup
      arguments:
        id: 99802bce-76c6-42c9-801e-e2e4529bb335
outputs:
  # Output the static members of the address group.
  addressGroupOutputs:
    groupId: ${scmAddressGroupDs.id}
    folder: ${scmAddressGroupDs.folder}
    name: ${scmAddressGroupDs.name}
    description: ${scmAddressGroupDs.description}
    static: ${scmAddressGroupDs.statics}

function getAddressGroup(args: GetAddressGroupArgs, opts?: InvokeOptions): Promise<GetAddressGroupResult>
function getAddressGroupOutput(args: GetAddressGroupOutputArgs, opts?: InvokeOptions): Output<GetAddressGroupResult>

def get_address_group(id: Optional[str] = None,
                      name: Optional[str] = None,
                      opts: Optional[InvokeOptions] = None) -> GetAddressGroupResult
def get_address_group_output(id: Optional[pulumi.Input[str]] = None,
                      name: Optional[pulumi.Input[str]] = None,
                      opts: Optional[InvokeOptions] = None) -> Output[GetAddressGroupResult]

func LookupAddressGroup(ctx *Context, args *LookupAddressGroupArgs, opts ...InvokeOption) (*LookupAddressGroupResult, error)
func LookupAddressGroupOutput(ctx *Context, args *LookupAddressGroupOutputArgs, opts ...InvokeOption) LookupAddressGroupResultOutput

public static class GetAddressGroup 
{
    public static Task<GetAddressGroupResult> InvokeAsync(GetAddressGroupArgs args, InvokeOptions? opts = null)
    public static Output<GetAddressGroupResult> Invoke(GetAddressGroupInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAddressGroupResult> getAddressGroup(GetAddressGroupArgs args, InvokeOptions options)
public static Output<GetAddressGroupResult> getAddressGroup(GetAddressGroupArgs args, InvokeOptions options)

fn::invoke:
  function: scm:index/getAddressGroup:getAddressGroup
  arguments:
    # arguments dictionary