keycloak.RealmUserProfile

using Pulumi;
using Keycloak = Pulumi.Keycloak;

class MyStack : Stack
{
    public MyStack()
    {
        var realm = new Keycloak.Realm("realm", new Keycloak.RealmArgs
        {
            RealmName = "my-realm",
            Attributes = 
            {
                { "userProfileEnabled", true },
            },
        });
        var userprofile = new Keycloak.RealmUserProfile("userprofile", new Keycloak.RealmUserProfileArgs
        {
            RealmId = keycloak_realm.My_realm.Id,
            Attributes = 
            {
                new Keycloak.Inputs.RealmUserProfileAttributeArgs
                {
                    Name = "field1",
                    DisplayName = "Field 1",
                    Group = "group1",
                    EnabledWhenScopes = 
                    {
                        "offline_access",
                    },
                    RequiredForRoles = 
                    {
                        "user",
                    },
                    RequiredForScopes = 
                    {
                        "offline_access",
                    },
                    Permissions = new Keycloak.Inputs.RealmUserProfileAttributePermissionsArgs
                    {
                        Views = 
                        {
                            "admin",
                            "user",
                        },
                        Edits = 
                        {
                            "admin",
                            "user",
                        },
                    },
                    Validators = 
                    {
                        new Keycloak.Inputs.RealmUserProfileAttributeValidatorArgs
                        {
                            Name = "person-name-prohibited-characters",
                        },
                        new Keycloak.Inputs.RealmUserProfileAttributeValidatorArgs
                        {
                            Name = "pattern",
                            Config = 
                            {
                                { "pattern", "^[a-z]+$" },
                                { "error_message", "Nope" },
                            },
                        },
                    },
                    Annotations = 
                    {
                        { "foo", "bar" },
                    },
                },
                new Keycloak.Inputs.RealmUserProfileAttributeArgs
                {
                    Name = "field2",
                },
            },
            Groups = 
            {
                new Keycloak.Inputs.RealmUserProfileGroupArgs
                {
                    Name = "group1",
                    DisplayHeader = "Group 1",
                    DisplayDescription = "A first group",
                    Annotations = 
                    {
                        { "foo", "bar" },
                    },
                },
                new Keycloak.Inputs.RealmUserProfileGroupArgs
                {
                    Name = "group2",
                },
            },
        });
    }

}

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-keycloak/sdk/v4/go/keycloak"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := keycloak.NewRealm(ctx, "realm", &keycloak.RealmArgs{
			Realm: pulumi.String("my-realm"),
			Attributes: pulumi.AnyMap{
				"userProfileEnabled": pulumi.Any(true),
			},
		})
		if err != nil {
			return err
		}
		_, err = keycloak.NewRealmUserProfile(ctx, "userprofile", &keycloak.RealmUserProfileArgs{
			RealmId: pulumi.Any(keycloak_realm.My_realm.Id),
			Attributes: RealmUserProfileAttributeArray{
				&RealmUserProfileAttributeArgs{
					Name:        pulumi.String("field1"),
					DisplayName: pulumi.String("Field 1"),
					Group:       pulumi.String("group1"),
					EnabledWhenScopes: pulumi.StringArray{
						pulumi.String("offline_access"),
					},
					RequiredForRoles: pulumi.StringArray{
						pulumi.String("user"),
					},
					RequiredForScopes: pulumi.StringArray{
						pulumi.String("offline_access"),
					},
					Permissions: &RealmUserProfileAttributePermissionsArgs{
						Views: pulumi.StringArray{
							pulumi.String("admin"),
							pulumi.String("user"),
						},
						Edits: pulumi.StringArray{
							pulumi.String("admin"),
							pulumi.String("user"),
						},
					},
					Validators: RealmUserProfileAttributeValidatorArray{
						&RealmUserProfileAttributeValidatorArgs{
							Name: pulumi.String("person-name-prohibited-characters"),
						},
						&RealmUserProfileAttributeValidatorArgs{
							Name: pulumi.String("pattern"),
							Config: pulumi.StringMap{
								"pattern":       pulumi.String(fmt.Sprintf("^[a-z]+$")),
								"error_message": pulumi.String("Nope"),
							},
						},
					},
					Annotations: pulumi.StringMap{
						"foo": pulumi.String("bar"),
					},
				},
				&RealmUserProfileAttributeArgs{
					Name: pulumi.String("field2"),
				},
			},
			Groups: RealmUserProfileGroupArray{
				&RealmUserProfileGroupArgs{
					Name:               pulumi.String("group1"),
					DisplayHeader:      pulumi.String("Group 1"),
					DisplayDescription: pulumi.String("A first group"),
					Annotations: pulumi.StringMap{
						"foo": pulumi.String("bar"),
					},
				},
				&RealmUserProfileGroupArgs{
					Name: pulumi.String("group2"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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.RealmUserProfile;
import com.pulumi.keycloak.RealmUserProfileArgs;
import com.pulumi.keycloak.inputs.RealmUserProfileAttributeArgs;
import com.pulumi.keycloak.inputs.RealmUserProfileAttributePermissionsArgs;
import com.pulumi.keycloak.inputs.RealmUserProfileGroupArgs;
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 realm = new Realm("realm", RealmArgs.builder()        
            .realm("my-realm")
            .attributes(Map.of("userProfileEnabled", true))
            .build());

        var userprofile = new RealmUserProfile("userprofile", RealmUserProfileArgs.builder()        
            .realmId(keycloak_realm.my_realm().id())
            .attributes(            
                RealmUserProfileAttributeArgs.builder()
                    .name("field1")
                    .displayName("Field 1")
                    .group("group1")
                    .enabledWhenScopes("offline_access")
                    .requiredForRoles("user")
                    .requiredForScopes("offline_access")
                    .permissions(RealmUserProfileAttributePermissionsArgs.builder()
                        .views(                        
                            "admin",
                            "user")
                        .edits(                        
                            "admin",
                            "user")
                        .build())
                    .validators(                    
                        RealmUserProfileAttributeValidatorArgs.builder()
                            .name("person-name-prohibited-characters")
                            .build(),
                        RealmUserProfileAttributeValidatorArgs.builder()
                            .name("pattern")
                            .config(Map.ofEntries(
                                Map.entry("pattern", "^[a-z]+$"),
                                Map.entry("error_message", "Nope")
                            ))
                            .build())
                    .annotations(Map.of("foo", "bar"))
                    .build(),
                RealmUserProfileAttributeArgs.builder()
                    .name("field2")
                    .build())
            .groups(            
                RealmUserProfileGroupArgs.builder()
                    .name("group1")
                    .displayHeader("Group 1")
                    .displayDescription("A first group")
                    .annotations(Map.of("foo", "bar"))
                    .build(),
                RealmUserProfileGroupArgs.builder()
                    .name("group2")
                    .build())
            .build());

    }
}

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

const realm = new keycloak.Realm("realm", {
    realm: "my-realm",
    attributes: {
        userProfileEnabled: true,
    },
});
const userprofile = new keycloak.RealmUserProfile("userprofile", {
    realmId: keycloak_realm.my_realm.id,
    attributes: [
        {
            name: "field1",
            displayName: "Field 1",
            group: "group1",
            enabledWhenScopes: ["offline_access"],
            requiredForRoles: ["user"],
            requiredForScopes: ["offline_access"],
            permissions: {
                views: [
                    "admin",
                    "user",
                ],
                edits: [
                    "admin",
                    "user",
                ],
            },
            validators: [
                {
                    name: "person-name-prohibited-characters",
                },
                {
                    name: "pattern",
                    config: {
                        pattern: `^[a-z]+$`,
                        error_message: "Nope",
                    },
                },
            ],
            annotations: {
                foo: "bar",
            },
        },
        {
            name: "field2",
        },
    ],
    groups: [
        {
            name: "group1",
            displayHeader: "Group 1",
            displayDescription: "A first group",
            annotations: {
                foo: "bar",
            },
        },
        {
            name: "group2",
        },
    ],
});

import pulumi
import pulumi_keycloak as keycloak

realm = keycloak.Realm("realm",
    realm="my-realm",
    attributes={
        "userProfileEnabled": True,
    })
userprofile = keycloak.RealmUserProfile("userprofile",
    realm_id=keycloak_realm["my_realm"]["id"],
    attributes=[
        keycloak.RealmUserProfileAttributeArgs(
            name="field1",
            display_name="Field 1",
            group="group1",
            enabled_when_scopes=["offline_access"],
            required_for_roles=["user"],
            required_for_scopes=["offline_access"],
            permissions=keycloak.RealmUserProfileAttributePermissionsArgs(
                views=[
                    "admin",
                    "user",
                ],
                edits=[
                    "admin",
                    "user",
                ],
            ),
            validators=[
                keycloak.RealmUserProfileAttributeValidatorArgs(
                    name="person-name-prohibited-characters",
                ),
                keycloak.RealmUserProfileAttributeValidatorArgs(
                    name="pattern",
                    config={
                        "pattern": "^[a-z]+$",
                        "error_message": "Nope",
                    },
                ),
            ],
            annotations={
                "foo": "bar",
            },
        ),
        keycloak.RealmUserProfileAttributeArgs(
            name="field2",
        ),
    ],
    groups=[
        keycloak.RealmUserProfileGroupArgs(
            name="group1",
            display_header="Group 1",
            display_description="A first group",
            annotations={
                "foo": "bar",
            },
        ),
        keycloak.RealmUserProfileGroupArgs(
            name="group2",
        ),
    ])

resources:
  realm:
    type: keycloak:Realm
    properties:
      realm: my-realm
      attributes:
        userProfileEnabled: true
  userprofile:
    type: keycloak:RealmUserProfile
    properties:
      realmId: ${keycloak_realm.my_realm.id}
      attributes:
        - name: field1
          displayName: Field 1
          group: group1
          enabledWhenScopes:
            - offline_access
          requiredForRoles:
            - user
          requiredForScopes:
            - offline_access
          permissions:
            views:
              - admin
              - user
            edits:
              - admin
              - user
          validators:
            - name: person-name-prohibited-characters
            - name: pattern
              config:
                pattern: ^[a-z]+$
                error_message: Nope
          annotations:
            foo: bar
        - name: field2
      groups:
        - name: group1
          displayHeader: Group 1
          displayDescription: A first group
          annotations:
            foo: bar
        - name: group2