temporalcloud.getScimGroup

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

const myScimGroup = new temporalcloud.index.ScimGroup("my_scim_group", {idpId: "usually-group-name"});
export const scimGroup = myScimGroupTemporalcloudScimGroup;

import pulumi
import pulumi_temporalcloud as temporalcloud

my_scim_group = temporalcloud.index.ScimGroup("my_scim_group", idp_id=usually-group-name)
pulumi.export("scimGroup", my_scim_group_temporalcloud_scim_group)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := temporalcloud.NewScimGroup(ctx, "my_scim_group", &temporalcloud.ScimGroupArgs{
			IdpId: "usually-group-name",
		})
		if err != nil {
			return err
		}
		ctx.Export("scimGroup", myScimGroupTemporalcloudScimGroup)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var myScimGroup = new Temporalcloud.Index.ScimGroup("my_scim_group", new()
    {
        IdpId = "usually-group-name",
    });

    return new Dictionary<string, object?>
    {
        ["scimGroup"] = myScimGroupTemporalcloudScimGroup,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.temporalcloud.ScimGroup;
import com.pulumi.temporalcloud.ScimGroupArgs;
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) {
        var myScimGroup = new ScimGroup("myScimGroup", ScimGroupArgs.builder()
            .idpId("usually-group-name")
            .build());

        ctx.export("scimGroup", myScimGroupTemporalcloudScimGroup);
    }
}

resources:
  myScimGroup:
    type: temporalcloud:ScimGroup
    name: my_scim_group
    properties:
      idpId: usually-group-name
outputs:
  scimGroup: ${myScimGroupTemporalcloudScimGroup}

function getScimGroup(args: GetScimGroupArgs, opts?: InvokeOptions): Promise<GetScimGroupResult>
function getScimGroupOutput(args: GetScimGroupOutputArgs, opts?: InvokeOptions): Output<GetScimGroupResult>

def get_scim_group(idp_id: Optional[str] = None,
                   opts: Optional[InvokeOptions] = None) -> GetScimGroupResult
def get_scim_group_output(idp_id: Optional[pulumi.Input[str]] = None,
                   opts: Optional[InvokeOptions] = None) -> Output[GetScimGroupResult]

func GetScimGroup(ctx *Context, args *GetScimGroupArgs, opts ...InvokeOption) (*GetScimGroupResult, error)
func GetScimGroupOutput(ctx *Context, args *GetScimGroupOutputArgs, opts ...InvokeOption) GetScimGroupResultOutput

public static class GetScimGroup 
{
    public static Task<GetScimGroupResult> InvokeAsync(GetScimGroupArgs args, InvokeOptions? opts = null)
    public static Output<GetScimGroupResult> Invoke(GetScimGroupInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetScimGroupResult> getScimGroup(GetScimGroupArgs args, InvokeOptions options)
public static Output<GetScimGroupResult> getScimGroup(GetScimGroupArgs args, InvokeOptions options)

fn::invoke:
  function: temporalcloud:index/getScimGroup:getScimGroup
  arguments:
    # arguments dictionary