auth0.getConnectionDirectorySynchronizedGroups

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

const myGroups = auth0.getConnectionDirectorySynchronizedGroups({
    connectionId: "con_xxxxxxxxxxxxxxxx",
});

import pulumi
import pulumi_auth0 as auth0

my_groups = auth0.get_connection_directory_synchronized_groups(connection_id="con_xxxxxxxxxxxxxxxx")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := auth0.GetConnectionDirectorySynchronizedGroups(ctx, &auth0.LookupConnectionDirectorySynchronizedGroupsArgs{
			ConnectionId: "con_xxxxxxxxxxxxxxxx",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var myGroups = Auth0.GetConnectionDirectorySynchronizedGroups.Invoke(new()
    {
        ConnectionId = "con_xxxxxxxxxxxxxxxx",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.auth0.Auth0Functions;
import com.pulumi.auth0.inputs.GetConnectionDirectorySynchronizedGroupsArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 myGroups = Auth0Functions.getConnectionDirectorySynchronizedGroups(GetConnectionDirectorySynchronizedGroupsArgs.builder()
            .connectionId("con_xxxxxxxxxxxxxxxx")
            .build());

    }
}

variables:
  myGroups:
    fn::invoke:
      function: auth0:getConnectionDirectorySynchronizedGroups
      arguments:
        connectionId: con_xxxxxxxxxxxxxxxx

pulumi {
  required_providers {
    auth0 = {
      source = "pulumi/auth0"
    }
  }
}

data "auth0_getconnectiondirectorysynchronizedgroups" "myGroups" {
  connection_id = "con_xxxxxxxxxxxxxxxx"
}

function getConnectionDirectorySynchronizedGroups(args: GetConnectionDirectorySynchronizedGroupsArgs, opts?: InvokeOptions): Promise<GetConnectionDirectorySynchronizedGroupsResult>
function getConnectionDirectorySynchronizedGroupsOutput(args: GetConnectionDirectorySynchronizedGroupsOutputArgs, opts?: InvokeOptions): Output<GetConnectionDirectorySynchronizedGroupsResult>

def get_connection_directory_synchronized_groups(connection_id: Optional[str] = None,
                                                 opts: Optional[InvokeOptions] = None) -> GetConnectionDirectorySynchronizedGroupsResult
def get_connection_directory_synchronized_groups_output(connection_id: pulumi.Input[Optional[str]] = None,
                                                 opts: Optional[InvokeOptions] = None) -> Output[GetConnectionDirectorySynchronizedGroupsResult]

func LookupConnectionDirectorySynchronizedGroups(ctx *Context, args *LookupConnectionDirectorySynchronizedGroupsArgs, opts ...InvokeOption) (*LookupConnectionDirectorySynchronizedGroupsResult, error)
func LookupConnectionDirectorySynchronizedGroupsOutput(ctx *Context, args *LookupConnectionDirectorySynchronizedGroupsOutputArgs, opts ...InvokeOption) LookupConnectionDirectorySynchronizedGroupsResultOutput

public static class GetConnectionDirectorySynchronizedGroups 
{
    public static Task<GetConnectionDirectorySynchronizedGroupsResult> InvokeAsync(GetConnectionDirectorySynchronizedGroupsArgs args, InvokeOptions? opts = null)
    public static Output<GetConnectionDirectorySynchronizedGroupsResult> Invoke(GetConnectionDirectorySynchronizedGroupsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetConnectionDirectorySynchronizedGroupsResult> getConnectionDirectorySynchronizedGroups(GetConnectionDirectorySynchronizedGroupsArgs args, InvokeOptions options)
public static Output<GetConnectionDirectorySynchronizedGroupsResult> getConnectionDirectorySynchronizedGroups(GetConnectionDirectorySynchronizedGroupsArgs args, InvokeOptions options)

fn::invoke:
  function: auth0:index/getConnectionDirectorySynchronizedGroups:getConnectionDirectorySynchronizedGroups
  arguments:
    # arguments dictionary

data "auth0_getconnectiondirectorysynchronizedgroups" "name" {
    # arguments
}