zpa.getSCIMGroups

import * as pulumi from "@pulumi/pulumi";
import * as zpa from "@bdzscaler/pulumi-zpa";

const engineering = zpa.getSCIMGroups({
    idpName: "idp_name",
    name: "Engineering",
});

import pulumi
import pulumi_zpa as zpa

engineering = zpa.get_scim_groups(idp_name="idp_name",
    name="Engineering")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := zpa.GetSCIMGroups(ctx, &zpa.GetSCIMGroupsArgs{
			IdpName: pulumi.StringRef("idp_name"),
			Name:    pulumi.StringRef("Engineering"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var engineering = Zpa.GetSCIMGroups.Invoke(new()
    {
        IdpName = "idp_name",
        Name = "Engineering",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.zpa.ZpaFunctions;
import com.pulumi.zpa.inputs.GetSCIMGroupsArgs;
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 engineering = ZpaFunctions.getSCIMGroups(GetSCIMGroupsArgs.builder()
            .idpName("idp_name")
            .name("Engineering")
            .build());

    }
}

variables:
  engineering:
    fn::invoke:
      function: zpa:getSCIMGroups
      arguments:
        idpName: idp_name
        name: Engineering

function getSCIMGroups(args: GetSCIMGroupsArgs, opts?: InvokeOptions): Promise<GetSCIMGroupsResult>
function getSCIMGroupsOutput(args: GetSCIMGroupsOutputArgs, opts?: InvokeOptions): Output<GetSCIMGroupsResult>

def get_scim_groups(id: Optional[str] = None,
                    idp_id: Optional[int] = None,
                    idp_name: Optional[str] = None,
                    name: Optional[str] = None,
                    opts: Optional[InvokeOptions] = None) -> GetSCIMGroupsResult
def get_scim_groups_output(id: Optional[pulumi.Input[str]] = None,
                    idp_id: Optional[pulumi.Input[int]] = None,
                    idp_name: Optional[pulumi.Input[str]] = None,
                    name: Optional[pulumi.Input[str]] = None,
                    opts: Optional[InvokeOptions] = None) -> Output[GetSCIMGroupsResult]

func GetSCIMGroups(ctx *Context, args *GetSCIMGroupsArgs, opts ...InvokeOption) (*GetSCIMGroupsResult, error)
func GetSCIMGroupsOutput(ctx *Context, args *GetSCIMGroupsOutputArgs, opts ...InvokeOption) GetSCIMGroupsResultOutput

public static class GetSCIMGroups 
{
    public static Task<GetSCIMGroupsResult> InvokeAsync(GetSCIMGroupsArgs args, InvokeOptions? opts = null)
    public static Output<GetSCIMGroupsResult> Invoke(GetSCIMGroupsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSCIMGroupsResult> getSCIMGroups(GetSCIMGroupsArgs args, InvokeOptions options)
public static Output<GetSCIMGroupsResult> getSCIMGroups(GetSCIMGroupsArgs args, InvokeOptions options)

fn::invoke:
  function: zpa:index/getSCIMGroups:getSCIMGroups
  arguments:
    # arguments dictionary