scm.getDynamicUserGroup

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

// Look up the dynamic user group by its ID.
const scmDynamicUserGroupDs = scm.getDynamicUserGroup({
    id: "c8ac5c18-023b-4be5-bc39-65e585cff9c7",
});
export const dynamicUserGroupDetails = {
    id: scmDynamicUserGroupDs.then(scmDynamicUserGroupDs => scmDynamicUserGroupDs.id),
    name: scmDynamicUserGroupDs.then(scmDynamicUserGroupDs => scmDynamicUserGroupDs.name),
    folder: scmDynamicUserGroupDs.then(scmDynamicUserGroupDs => scmDynamicUserGroupDs.folder),
    description: scmDynamicUserGroupDs.then(scmDynamicUserGroupDs => scmDynamicUserGroupDs.description),
    filter: scmDynamicUserGroupDs.then(scmDynamicUserGroupDs => scmDynamicUserGroupDs.filter),
    tags: scmDynamicUserGroupDs.then(scmDynamicUserGroupDs => scmDynamicUserGroupDs.tags),
};

import pulumi
import pulumi_scm as scm

# Look up the dynamic user group by its ID.
scm_dynamic_user_group_ds = scm.get_dynamic_user_group(id="c8ac5c18-023b-4be5-bc39-65e585cff9c7")
pulumi.export("dynamicUserGroupDetails", {
    "id": scm_dynamic_user_group_ds.id,
    "name": scm_dynamic_user_group_ds.name,
    "folder": scm_dynamic_user_group_ds.folder,
    "description": scm_dynamic_user_group_ds.description,
    "filter": scm_dynamic_user_group_ds.filter,
    "tags": scm_dynamic_user_group_ds.tags,
})

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 dynamic user group by its ID.
		scmDynamicUserGroupDs, err := scm.LookupDynamicUserGroup(ctx, &scm.LookupDynamicUserGroupArgs{
			Id: "c8ac5c18-023b-4be5-bc39-65e585cff9c7",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("dynamicUserGroupDetails", pulumi.Map{
			"id":          scmDynamicUserGroupDs.Id,
			"name":        scmDynamicUserGroupDs.Name,
			"folder":      scmDynamicUserGroupDs.Folder,
			"description": scmDynamicUserGroupDs.Description,
			"filter":      scmDynamicUserGroupDs.Filter,
			"tags":        scmDynamicUserGroupDs.Tags,
		})
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Look up the dynamic user group by its ID.
    var scmDynamicUserGroupDs = Scm.GetDynamicUserGroup.Invoke(new()
    {
        Id = "c8ac5c18-023b-4be5-bc39-65e585cff9c7",
    });

    return new Dictionary<string, object?>
    {
        ["dynamicUserGroupDetails"] = 
        {
            { "id", scmDynamicUserGroupDs.Apply(getDynamicUserGroupResult => getDynamicUserGroupResult.Id) },
            { "name", scmDynamicUserGroupDs.Apply(getDynamicUserGroupResult => getDynamicUserGroupResult.Name) },
            { "folder", scmDynamicUserGroupDs.Apply(getDynamicUserGroupResult => getDynamicUserGroupResult.Folder) },
            { "description", scmDynamicUserGroupDs.Apply(getDynamicUserGroupResult => getDynamicUserGroupResult.Description) },
            { "filter", scmDynamicUserGroupDs.Apply(getDynamicUserGroupResult => getDynamicUserGroupResult.Filter) },
            { "tags", scmDynamicUserGroupDs.Apply(getDynamicUserGroupResult => getDynamicUserGroupResult.Tags) },
        },
    };
});

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.GetDynamicUserGroupArgs;
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 dynamic user group by its ID.
        final var scmDynamicUserGroupDs = ScmFunctions.getDynamicUserGroup(GetDynamicUserGroupArgs.builder()
            .id("c8ac5c18-023b-4be5-bc39-65e585cff9c7")
            .build());

        ctx.export("dynamicUserGroupDetails", Map.ofEntries(
            Map.entry("id", scmDynamicUserGroupDs.id()),
            Map.entry("name", scmDynamicUserGroupDs.name()),
            Map.entry("folder", scmDynamicUserGroupDs.folder()),
            Map.entry("description", scmDynamicUserGroupDs.description()),
            Map.entry("filter", scmDynamicUserGroupDs.filter()),
            Map.entry("tags", scmDynamicUserGroupDs.tags())
        ));
    }
}

variables:
  # Look up the dynamic user group by its ID.
  scmDynamicUserGroupDs:
    fn::invoke:
      function: scm:getDynamicUserGroup
      arguments:
        id: c8ac5c18-023b-4be5-bc39-65e585cff9c7
outputs:
  # Output the details of the dynamic user group.
  dynamicUserGroupDetails:
    id: ${scmDynamicUserGroupDs.id}
    name: ${scmDynamicUserGroupDs.name}
    folder: ${scmDynamicUserGroupDs.folder}
    description: ${scmDynamicUserGroupDs.description}
    filter: ${scmDynamicUserGroupDs.filter}
    tags: ${scmDynamicUserGroupDs.tags}

function getDynamicUserGroup(args: GetDynamicUserGroupArgs, opts?: InvokeOptions): Promise<GetDynamicUserGroupResult>
function getDynamicUserGroupOutput(args: GetDynamicUserGroupOutputArgs, opts?: InvokeOptions): Output<GetDynamicUserGroupResult>

def get_dynamic_user_group(device: Optional[str] = None,
                           folder: Optional[str] = None,
                           id: Optional[str] = None,
                           name: Optional[str] = None,
                           snippet: Optional[str] = None,
                           opts: Optional[InvokeOptions] = None) -> GetDynamicUserGroupResult
def get_dynamic_user_group_output(device: Optional[pulumi.Input[str]] = None,
                           folder: Optional[pulumi.Input[str]] = None,
                           id: Optional[pulumi.Input[str]] = None,
                           name: Optional[pulumi.Input[str]] = None,
                           snippet: Optional[pulumi.Input[str]] = None,
                           opts: Optional[InvokeOptions] = None) -> Output[GetDynamicUserGroupResult]

func LookupDynamicUserGroup(ctx *Context, args *LookupDynamicUserGroupArgs, opts ...InvokeOption) (*LookupDynamicUserGroupResult, error)
func LookupDynamicUserGroupOutput(ctx *Context, args *LookupDynamicUserGroupOutputArgs, opts ...InvokeOption) LookupDynamicUserGroupResultOutput

public static class GetDynamicUserGroup 
{
    public static Task<GetDynamicUserGroupResult> InvokeAsync(GetDynamicUserGroupArgs args, InvokeOptions? opts = null)
    public static Output<GetDynamicUserGroupResult> Invoke(GetDynamicUserGroupInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetDynamicUserGroupResult> getDynamicUserGroup(GetDynamicUserGroupArgs args, InvokeOptions options)
public static Output<GetDynamicUserGroupResult> getDynamicUserGroup(GetDynamicUserGroupArgs args, InvokeOptions options)

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