keycloak.saml.getClientScope

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

const mysamlscope = keycloak.saml.getClientScope({
    realmId: "my-realm",
    name: "mysamlscope",
});
const samlClient = new keycloak.saml.Client("saml_client", {
    realmId: "my-realm",
    clientId: "saml-client",
});
// use the data source
const _default = new keycloak.saml.ClientDefaultScope("default", {
    realmId: "my-realm",
    clientId: samlClient.id,
    defaultScopes: [mysamlscope.then(mysamlscope => mysamlscope.name)],
});

import pulumi
import pulumi_keycloak as keycloak

mysamlscope = keycloak.saml.get_client_scope(realm_id="my-realm",
    name="mysamlscope")
saml_client = keycloak.saml.Client("saml_client",
    realm_id="my-realm",
    client_id="saml-client")
# use the data source
default = keycloak.saml.ClientDefaultScope("default",
    realm_id="my-realm",
    client_id=saml_client.id,
    default_scopes=[mysamlscope.name])

package main

import (
	"github.com/pulumi/pulumi-keycloak/sdk/v6/go/keycloak/saml"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		mysamlscope, err := saml.LookupClientScope(ctx, &saml.LookupClientScopeArgs{
			RealmId: "my-realm",
			Name:    "mysamlscope",
		}, nil)
		if err != nil {
			return err
		}
		samlClient, err := saml.NewClient(ctx, "saml_client", &saml.ClientArgs{
			RealmId:  pulumi.String("my-realm"),
			ClientId: pulumi.String("saml-client"),
		})
		if err != nil {
			return err
		}
		// use the data source
		_, err = saml.NewClientDefaultScope(ctx, "default", &saml.ClientDefaultScopeArgs{
			RealmId:  pulumi.String("my-realm"),
			ClientId: samlClient.ID(),
			DefaultScopes: pulumi.StringArray{
				pulumi.String(mysamlscope.Name),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var mysamlscope = Keycloak.Saml.GetClientScope.Invoke(new()
    {
        RealmId = "my-realm",
        Name = "mysamlscope",
    });

    var samlClient = new Keycloak.Saml.Client("saml_client", new()
    {
        RealmId = "my-realm",
        ClientId = "saml-client",
    });

    // use the data source
    var @default = new Keycloak.Saml.ClientDefaultScope("default", new()
    {
        RealmId = "my-realm",
        ClientId = samlClient.Id,
        DefaultScopes = new[]
        {
            mysamlscope.Apply(getClientScopeResult => getClientScopeResult.Name),
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.keycloak.saml.SamlFunctions;
import com.pulumi.keycloak.saml.inputs.GetClientScopeArgs;
import com.pulumi.keycloak.saml.Client;
import com.pulumi.keycloak.saml.ClientArgs;
import com.pulumi.keycloak.saml.ClientDefaultScope;
import com.pulumi.keycloak.saml.ClientDefaultScopeArgs;
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 mysamlscope = SamlFunctions.getClientScope(GetClientScopeArgs.builder()
            .realmId("my-realm")
            .name("mysamlscope")
            .build());

        var samlClient = new Client("samlClient", ClientArgs.builder()
            .realmId("my-realm")
            .clientId("saml-client")
            .build());

        // use the data source
        var default_ = new ClientDefaultScope("default", ClientDefaultScopeArgs.builder()
            .realmId("my-realm")
            .clientId(samlClient.id())
            .defaultScopes(mysamlscope.name())
            .build());

    }
}

resources:
  samlClient:
    type: keycloak:saml:Client
    name: saml_client
    properties:
      realmId: my-realm
      clientId: saml-client
  # use the data source
  default:
    type: keycloak:saml:ClientDefaultScope
    properties:
      realmId: my-realm
      clientId: ${samlClient.id}
      defaultScopes:
        - ${mysamlscope.name}
variables:
  mysamlscope:
    fn::invoke:
      function: keycloak:saml:getClientScope
      arguments:
        realmId: my-realm
        name: mysamlscope

function getClientScope(args: GetClientScopeArgs, opts?: InvokeOptions): Promise<GetClientScopeResult>
function getClientScopeOutput(args: GetClientScopeOutputArgs, opts?: InvokeOptions): Output<GetClientScopeResult>

def get_client_scope(extra_config: Optional[Mapping[str, str]] = None,
                     name: Optional[str] = None,
                     realm_id: Optional[str] = None,
                     opts: Optional[InvokeOptions] = None) -> GetClientScopeResult
def get_client_scope_output(extra_config: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                     name: Optional[pulumi.Input[str]] = None,
                     realm_id: Optional[pulumi.Input[str]] = None,
                     opts: Optional[InvokeOptions] = None) -> Output[GetClientScopeResult]

func LookupClientScope(ctx *Context, args *LookupClientScopeArgs, opts ...InvokeOption) (*LookupClientScopeResult, error)
func LookupClientScopeOutput(ctx *Context, args *LookupClientScopeOutputArgs, opts ...InvokeOption) LookupClientScopeResultOutput

public static class GetClientScope 
{
    public static Task<GetClientScopeResult> InvokeAsync(GetClientScopeArgs args, InvokeOptions? opts = null)
    public static Output<GetClientScopeResult> Invoke(GetClientScopeInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetClientScopeResult> getClientScope(GetClientScopeArgs args, InvokeOptions options)
public static Output<GetClientScopeResult> getClientScope(GetClientScopeArgs args, InvokeOptions options)

fn::invoke:
  function: keycloak:saml/getClientScope:getClientScope
  arguments:
    # arguments dictionary