keycloak.getRealmClientRegistrationPolicy

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

const realm = new keycloak.Realm("realm", {realm: "my-realm"});
const trustedHosts = keycloak.getRealmClientRegistrationPolicyOutput({
    realmId: realm.id,
    name: "Trusted Hosts",
    providerId: "trusted-hosts",
    subType: "anonymous",
});
export const trustedHostsPolicyId = trustedHosts.apply(trustedHosts => trustedHosts.id);

import pulumi
import pulumi_keycloak as keycloak

realm = keycloak.Realm("realm", realm="my-realm")
trusted_hosts = keycloak.get_realm_client_registration_policy_output(realm_id=realm.id,
    name="Trusted Hosts",
    provider_id="trusted-hosts",
    sub_type="anonymous")
pulumi.export("trustedHostsPolicyId", trusted_hosts.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		realm, err := keycloak.NewRealm(ctx, "realm", &keycloak.RealmArgs{
			Realm: pulumi.String("my-realm"),
		})
		if err != nil {
			return err
		}
		trustedHosts := keycloak.GetRealmClientRegistrationPolicyOutput(ctx, keycloak.GetRealmClientRegistrationPolicyOutputArgs{
			RealmId:    realm.ID(),
			Name:       pulumi.String("Trusted Hosts"),
			ProviderId: pulumi.String("trusted-hosts"),
			SubType:    pulumi.String("anonymous"),
		}, nil)
		ctx.Export("trustedHostsPolicyId", trustedHosts.ApplyT(func(trustedHosts keycloak.GetRealmClientRegistrationPolicyResult) (*string, error) {
			return trustedHosts.Id, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var realm = new Keycloak.Realm("realm", new()
    {
        RealmName = "my-realm",
    });

    var trustedHosts = Keycloak.GetRealmClientRegistrationPolicy.Invoke(new()
    {
        RealmId = realm.Id,
        Name = "Trusted Hosts",
        ProviderId = "trusted-hosts",
        SubType = "anonymous",
    });

    return new Dictionary<string, object?>
    {
        ["trustedHostsPolicyId"] = trustedHosts.Apply(getRealmClientRegistrationPolicyResult => getRealmClientRegistrationPolicyResult.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.keycloak.Realm;
import com.pulumi.keycloak.RealmArgs;
import com.pulumi.keycloak.KeycloakFunctions;
import com.pulumi.keycloak.inputs.GetRealmClientRegistrationPolicyArgs;
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) {
        var realm = new Realm("realm", RealmArgs.builder()
            .realm("my-realm")
            .build());

        final var trustedHosts = KeycloakFunctions.getRealmClientRegistrationPolicy(GetRealmClientRegistrationPolicyArgs.builder()
            .realmId(realm.id())
            .name("Trusted Hosts")
            .providerId("trusted-hosts")
            .subType("anonymous")
            .build());

        ctx.export("trustedHostsPolicyId", trustedHosts.applyValue(_trustedHosts -> _trustedHosts.id()));
    }
}

resources:
  realm:
    type: keycloak:Realm
    properties:
      realm: my-realm
variables:
  trustedHosts:
    fn::invoke:
      function: keycloak:getRealmClientRegistrationPolicy
      arguments:
        realmId: ${realm.id}
        name: Trusted Hosts
        providerId: trusted-hosts
        subType: anonymous
outputs:
  trustedHostsPolicyId: ${trustedHosts.id}

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

data "keycloak_getrealmclientregistrationpolicy" "trustedHosts" {
  realm_id    = keycloak_realm.realm.id
  name        = "Trusted Hosts"
  provider_id = "trusted-hosts"
  sub_type    = "anonymous"
}

resource "keycloak_realm" "realm" {
  realm = "my-realm"
}
output "trustedHostsPolicyId" {
  value = data.keycloak_getrealmclientregistrationpolicy.trustedHosts.id
}

function getRealmClientRegistrationPolicy(args: GetRealmClientRegistrationPolicyArgs, opts?: InvokeOptions): Promise<GetRealmClientRegistrationPolicyResult>
function getRealmClientRegistrationPolicyOutput(args: GetRealmClientRegistrationPolicyOutputArgs, opts?: InvokeOptions): Output<GetRealmClientRegistrationPolicyResult>

def get_realm_client_registration_policy(name: Optional[str] = None,
                                         provider_id: Optional[str] = None,
                                         realm_id: Optional[str] = None,
                                         sub_type: Optional[str] = None,
                                         opts: Optional[InvokeOptions] = None) -> GetRealmClientRegistrationPolicyResult
def get_realm_client_registration_policy_output(name: pulumi.Input[Optional[str]] = None,
                                         provider_id: pulumi.Input[Optional[str]] = None,
                                         realm_id: pulumi.Input[Optional[str]] = None,
                                         sub_type: pulumi.Input[Optional[str]] = None,
                                         opts: Optional[InvokeOptions] = None) -> Output[GetRealmClientRegistrationPolicyResult]

func LookupRealmClientRegistrationPolicy(ctx *Context, args *LookupRealmClientRegistrationPolicyArgs, opts ...InvokeOption) (*LookupRealmClientRegistrationPolicyResult, error)
func LookupRealmClientRegistrationPolicyOutput(ctx *Context, args *LookupRealmClientRegistrationPolicyOutputArgs, opts ...InvokeOption) LookupRealmClientRegistrationPolicyResultOutput

public static class GetRealmClientRegistrationPolicy 
{
    public static Task<GetRealmClientRegistrationPolicyResult> InvokeAsync(GetRealmClientRegistrationPolicyArgs args, InvokeOptions? opts = null)
    public static Output<GetRealmClientRegistrationPolicyResult> Invoke(GetRealmClientRegistrationPolicyInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetRealmClientRegistrationPolicyResult> getRealmClientRegistrationPolicy(GetRealmClientRegistrationPolicyArgs args, InvokeOptions options)
public static Output<GetRealmClientRegistrationPolicyResult> getRealmClientRegistrationPolicy(GetRealmClientRegistrationPolicyArgs args, InvokeOptions options)

fn::invoke:
  function: keycloak:index/getRealmClientRegistrationPolicy:getRealmClientRegistrationPolicy
  arguments:
    # arguments dictionary

data "keycloak_get_realm_client_registration_policy" "name" {
    # arguments
}