lxd.getAuthIdentityProviderGroup

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

const viewers = lxd.getAuthIdentityProviderGroup({
    name: "viewers",
});

import pulumi
import pulumi_lxd as lxd

viewers = lxd.get_auth_identity_provider_group(name="viewers")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lxd.LookupAuthIdentityProviderGroup(ctx, &lxd.LookupAuthIdentityProviderGroupArgs{
			Name: "viewers",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var viewers = Lxd.GetAuthIdentityProviderGroup.Invoke(new()
    {
        Name = "viewers",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.lxd.LxdFunctions;
import com.pulumi.lxd.inputs.GetAuthIdentityProviderGroupArgs;
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 viewers = LxdFunctions.getAuthIdentityProviderGroup(GetAuthIdentityProviderGroupArgs.builder()
            .name("viewers")
            .build());

    }
}

variables:
  viewers:
    fn::invoke:
      function: lxd:getAuthIdentityProviderGroup
      arguments:
        name: viewers

function getAuthIdentityProviderGroup(args: GetAuthIdentityProviderGroupArgs, opts?: InvokeOptions): Promise<GetAuthIdentityProviderGroupResult>
function getAuthIdentityProviderGroupOutput(args: GetAuthIdentityProviderGroupOutputArgs, opts?: InvokeOutputOptions): Output<GetAuthIdentityProviderGroupResult>

def get_auth_identity_provider_group(name: Optional[str] = None,
                                     remote: Optional[str] = None,
                                     opts: Optional[InvokeOptions] = None) -> GetAuthIdentityProviderGroupResult
def get_auth_identity_provider_group_output(name: pulumi.Input[Optional[str]] = None,
                                     remote: pulumi.Input[Optional[str]] = None,
                                     opts: Optional[InvokeOutputOptions] = None) -> Output[GetAuthIdentityProviderGroupResult]

func LookupAuthIdentityProviderGroup(ctx *Context, args *LookupAuthIdentityProviderGroupArgs, opts ...InvokeOption) (*LookupAuthIdentityProviderGroupResult, error)
func LookupAuthIdentityProviderGroupOutput(ctx *Context, args *LookupAuthIdentityProviderGroupOutputArgs, opts ...InvokeOption) LookupAuthIdentityProviderGroupResultOutput

public static class GetAuthIdentityProviderGroup 
{
    public static Task<GetAuthIdentityProviderGroupResult> InvokeAsync(GetAuthIdentityProviderGroupArgs args, InvokeOptions? opts = null)
    public static Output<GetAuthIdentityProviderGroupResult> Invoke(GetAuthIdentityProviderGroupInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetAuthIdentityProviderGroupResult> Invoke(GetAuthIdentityProviderGroupInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetAuthIdentityProviderGroupResult> getAuthIdentityProviderGroup(GetAuthIdentityProviderGroupArgs args, InvokeOptions options)
public static Output<GetAuthIdentityProviderGroupResult> getAuthIdentityProviderGroup(GetAuthIdentityProviderGroupArgs args, InvokeOptions options)
public static Output<GetAuthIdentityProviderGroupResult> getAuthIdentityProviderGroup(GetAuthIdentityProviderGroupArgs args, InvokeOutputOptions options)

fn::invoke:
  function: lxd:index/getAuthIdentityProviderGroup:getAuthIdentityProviderGroup
  arguments:
    # arguments dictionary

data "lxd_get_auth_identity_provider_group" "name" {
    # arguments
}