# coding=utf-8
# *** WARNING: this file was generated by pulumi-language-python. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins as _builtins
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from . import _utilities

__all__ = ['RoleArgs', 'Role']

@pulumi.input_type
class RoleArgs:
    def __init__(__self__, *,
                 realm_id: pulumi.Input[_builtins.str],
                 attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
                 client_id: Optional[pulumi.Input[_builtins.str]] = None,
                 composite_roles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 description: Optional[pulumi.Input[_builtins.str]] = None,
                 import_: Optional[pulumi.Input[_builtins.bool]] = None,
                 name: Optional[pulumi.Input[_builtins.str]] = None):
        """
        The set of arguments for constructing a Role resource.
        :param pulumi.Input[_builtins.str] realm_id: The realm this role exists within.
        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] attributes: A map representing attributes for the role. In order to add multivalue attributes, use `##` to seperate the values. Max length for each value is 255 chars
        :param pulumi.Input[_builtins.str] client_id: When specified, this role will be created as a client role attached to the client with the provided ID
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] composite_roles: When specified, this role will be a composite role, composed of all roles that have an ID present within this list.
        :param pulumi.Input[_builtins.str] description: The description of the role
        :param pulumi.Input[_builtins.bool] import_: When `true`, the role with the specified `name` is assumed to already exist, and it will be imported into state instead of being created. This attribute is useful when dealing with roles that Keycloak creates automatically during realm creation, such as the client roles `create-client`, `view-realm`, ... for the client `realm-management` created per realm. Note, that the role will not be removed during destruction if `import` is `true`.
        :param pulumi.Input[_builtins.str] name: The name of the role
        """
        pulumi.set(__self__, "realm_id", realm_id)
        if attributes is not None:
            pulumi.set(__self__, "attributes", attributes)
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if composite_roles is not None:
            pulumi.set(__self__, "composite_roles", composite_roles)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if import_ is not None:
            pulumi.set(__self__, "import_", import_)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter(name="realmId")
    def realm_id(self) -> pulumi.Input[_builtins.str]:
        """
        The realm this role exists within.
        """
        return pulumi.get(self, "realm_id")

    @realm_id.setter
    def realm_id(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "realm_id", value)

    @_builtins.property
    @pulumi.getter
    def attributes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
        """
        A map representing attributes for the role. In order to add multivalue attributes, use `##` to seperate the values. Max length for each value is 255 chars
        """
        return pulumi.get(self, "attributes")

    @attributes.setter
    def attributes(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "attributes", value)

    @_builtins.property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        When specified, this role will be created as a client role attached to the client with the provided ID
        """
        return pulumi.get(self, "client_id")

    @client_id.setter
    def client_id(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "client_id", value)

    @_builtins.property
    @pulumi.getter(name="compositeRoles")
    def composite_roles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        When specified, this role will be a composite role, composed of all roles that have an ID present within this list.
        """
        return pulumi.get(self, "composite_roles")

    @composite_roles.setter
    def composite_roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "composite_roles", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The description of the role
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)

    @_builtins.property
    @pulumi.getter(name="import")
    def import_(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        When `true`, the role with the specified `name` is assumed to already exist, and it will be imported into state instead of being created. This attribute is useful when dealing with roles that Keycloak creates automatically during realm creation, such as the client roles `create-client`, `view-realm`, ... for the client `realm-management` created per realm. Note, that the role will not be removed during destruction if `import` is `true`.
        """
        return pulumi.get(self, "import_")

    @import_.setter
    def import_(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "import_", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The name of the role
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class _RoleState:
    def __init__(__self__, *,
                 attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
                 client_id: Optional[pulumi.Input[_builtins.str]] = None,
                 composite_roles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 description: Optional[pulumi.Input[_builtins.str]] = None,
                 import_: Optional[pulumi.Input[_builtins.bool]] = None,
                 name: Optional[pulumi.Input[_builtins.str]] = None,
                 realm_id: Optional[pulumi.Input[_builtins.str]] = None):
        """
        Input properties used for looking up and filtering Role resources.
        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] attributes: A map representing attributes for the role. In order to add multivalue attributes, use `##` to seperate the values. Max length for each value is 255 chars
        :param pulumi.Input[_builtins.str] client_id: When specified, this role will be created as a client role attached to the client with the provided ID
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] composite_roles: When specified, this role will be a composite role, composed of all roles that have an ID present within this list.
        :param pulumi.Input[_builtins.str] description: The description of the role
        :param pulumi.Input[_builtins.bool] import_: When `true`, the role with the specified `name` is assumed to already exist, and it will be imported into state instead of being created. This attribute is useful when dealing with roles that Keycloak creates automatically during realm creation, such as the client roles `create-client`, `view-realm`, ... for the client `realm-management` created per realm. Note, that the role will not be removed during destruction if `import` is `true`.
        :param pulumi.Input[_builtins.str] name: The name of the role
        :param pulumi.Input[_builtins.str] realm_id: The realm this role exists within.
        """
        if attributes is not None:
            pulumi.set(__self__, "attributes", attributes)
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if composite_roles is not None:
            pulumi.set(__self__, "composite_roles", composite_roles)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if import_ is not None:
            pulumi.set(__self__, "import_", import_)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if realm_id is not None:
            pulumi.set(__self__, "realm_id", realm_id)

    @_builtins.property
    @pulumi.getter
    def attributes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
        """
        A map representing attributes for the role. In order to add multivalue attributes, use `##` to seperate the values. Max length for each value is 255 chars
        """
        return pulumi.get(self, "attributes")

    @attributes.setter
    def attributes(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "attributes", value)

    @_builtins.property
    @pulumi.getter(name="clientId")
    def client_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        When specified, this role will be created as a client role attached to the client with the provided ID
        """
        return pulumi.get(self, "client_id")

    @client_id.setter
    def client_id(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "client_id", value)

    @_builtins.property
    @pulumi.getter(name="compositeRoles")
    def composite_roles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        When specified, this role will be a composite role, composed of all roles that have an ID present within this list.
        """
        return pulumi.get(self, "composite_roles")

    @composite_roles.setter
    def composite_roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "composite_roles", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The description of the role
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)

    @_builtins.property
    @pulumi.getter(name="import")
    def import_(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        When `true`, the role with the specified `name` is assumed to already exist, and it will be imported into state instead of being created. This attribute is useful when dealing with roles that Keycloak creates automatically during realm creation, such as the client roles `create-client`, `view-realm`, ... for the client `realm-management` created per realm. Note, that the role will not be removed during destruction if `import` is `true`.
        """
        return pulumi.get(self, "import_")

    @import_.setter
    def import_(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "import_", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The name of the role
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "name", value)

    @_builtins.property
    @pulumi.getter(name="realmId")
    def realm_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The realm this role exists within.
        """
        return pulumi.get(self, "realm_id")

    @realm_id.setter
    def realm_id(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "realm_id", value)


@pulumi.type_token("keycloak:index/role:Role")
class Role(pulumi.CustomResource):
    @overload
    def __init__(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
                 client_id: Optional[pulumi.Input[_builtins.str]] = None,
                 composite_roles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 description: Optional[pulumi.Input[_builtins.str]] = None,
                 import_: Optional[pulumi.Input[_builtins.bool]] = None,
                 name: Optional[pulumi.Input[_builtins.str]] = None,
                 realm_id: Optional[pulumi.Input[_builtins.str]] = None,
                 __props__=None):
        """
        Allows for creating and managing roles within Keycloak.

        Roles allow you to define privileges within Keycloak and map them to users and groups.

        ## Example Usage

        ### Realm Role)

        ```python
        import pulumi
        import pulumi_keycloak as keycloak

        realm = keycloak.Realm("realm",
            realm="my-realm",
            enabled=True)
        realm_role = keycloak.Role("realm_role",
            realm_id=realm.id,
            name="my-realm-role",
            description="My Realm Role",
            attributes={
                "key": "value",
                "multivalue": "value1##value2",
            })
        ```

        ### Client Role)

        ```python
        import pulumi
        import pulumi_keycloak as keycloak

        realm = keycloak.Realm("realm",
            realm="my-realm",
            enabled=True)
        openid_client = keycloak.openid.Client("openid_client",
            realm_id=realm.id,
            client_id="client",
            name="client",
            enabled=True,
            access_type="CONFIDENTIAL",
            valid_redirect_uris=["http://localhost:8080/openid-callback"])
        client_role = keycloak.Role("client_role",
            realm_id=realm.id,
            client_id=openid_client_keycloak_client["id"],
            name="my-client-role",
            description="My Client Role",
            attributes={
                "key": "value",
            })
        ```

        ### Composite Role)

        ```python
        import pulumi
        import pulumi_keycloak as keycloak

        realm = keycloak.Realm("realm",
            realm="my-realm",
            enabled=True)
        # realm roles
        create_role = keycloak.Role("create_role",
            realm_id=realm.id,
            name="create",
            attributes={
                "key": "value",
            })
        read_role = keycloak.Role("read_role",
            realm_id=realm.id,
            name="read",
            attributes={
                "key": "value",
            })
        update_role = keycloak.Role("update_role",
            realm_id=realm.id,
            name="update",
            attributes={
                "key": "value",
            })
        delete_role = keycloak.Role("delete_role",
            realm_id=realm.id,
            name="delete",
            attributes={
                "key": "value",
            })
        # client role
        openid_client = keycloak.openid.Client("openid_client",
            realm_id=realm.id,
            client_id="client",
            name="client",
            enabled=True,
            access_type="CONFIDENTIAL",
            valid_redirect_uris=["http://localhost:8080/openid-callback"])
        client_role = keycloak.Role("client_role",
            realm_id=realm.id,
            client_id=openid_client_keycloak_client["id"],
            name="my-client-role",
            description="My Client Role",
            attributes={
                "key": "value",
            })
        admin_role = keycloak.Role("admin_role",
            realm_id=realm.id,
            name="admin",
            composite_roles=[
                create_role.id,
                read_role.id,
                update_role.id,
                delete_role.id,
                client_role.id,
            ],
            attributes={
                "key": "value",
            })
        ```

        ## Import

        Roles can be imported using the format `{{realm_id}}/{{role_id}}`, where `role_id` is the unique ID that Keycloak assigns

        to the role. The ID is not easy to find in the GUI, but it appears in the URL when editing the role.

        Example:

        bash

        ```sh
        $ pulumi import keycloak:index/role:Role role my-realm/7e8cf32a-8acb-4d34-89c4-04fb1d10ccad
        ```

        :param str resource_name: The name of the resource.
        :param pulumi.ResourceOptions opts: Options for the resource.
        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] attributes: A map representing attributes for the role. In order to add multivalue attributes, use `##` to seperate the values. Max length for each value is 255 chars
        :param pulumi.Input[_builtins.str] client_id: When specified, this role will be created as a client role attached to the client with the provided ID
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] composite_roles: When specified, this role will be a composite role, composed of all roles that have an ID present within this list.
        :param pulumi.Input[_builtins.str] description: The description of the role
        :param pulumi.Input[_builtins.bool] import_: When `true`, the role with the specified `name` is assumed to already exist, and it will be imported into state instead of being created. This attribute is useful when dealing with roles that Keycloak creates automatically during realm creation, such as the client roles `create-client`, `view-realm`, ... for the client `realm-management` created per realm. Note, that the role will not be removed during destruction if `import` is `true`.
        :param pulumi.Input[_builtins.str] name: The name of the role
        :param pulumi.Input[_builtins.str] realm_id: The realm this role exists within.
        """
        ...
    @overload
    def __init__(__self__,
                 resource_name: str,
                 args: RoleArgs,
                 opts: Optional[pulumi.ResourceOptions] = None):
        """
        Allows for creating and managing roles within Keycloak.

        Roles allow you to define privileges within Keycloak and map them to users and groups.

        ## Example Usage

        ### Realm Role)

        ```python
        import pulumi
        import pulumi_keycloak as keycloak

        realm = keycloak.Realm("realm",
            realm="my-realm",
            enabled=True)
        realm_role = keycloak.Role("realm_role",
            realm_id=realm.id,
            name="my-realm-role",
            description="My Realm Role",
            attributes={
                "key": "value",
                "multivalue": "value1##value2",
            })
        ```

        ### Client Role)

        ```python
        import pulumi
        import pulumi_keycloak as keycloak

        realm = keycloak.Realm("realm",
            realm="my-realm",
            enabled=True)
        openid_client = keycloak.openid.Client("openid_client",
            realm_id=realm.id,
            client_id="client",
            name="client",
            enabled=True,
            access_type="CONFIDENTIAL",
            valid_redirect_uris=["http://localhost:8080/openid-callback"])
        client_role = keycloak.Role("client_role",
            realm_id=realm.id,
            client_id=openid_client_keycloak_client["id"],
            name="my-client-role",
            description="My Client Role",
            attributes={
                "key": "value",
            })
        ```

        ### Composite Role)

        ```python
        import pulumi
        import pulumi_keycloak as keycloak

        realm = keycloak.Realm("realm",
            realm="my-realm",
            enabled=True)
        # realm roles
        create_role = keycloak.Role("create_role",
            realm_id=realm.id,
            name="create",
            attributes={
                "key": "value",
            })
        read_role = keycloak.Role("read_role",
            realm_id=realm.id,
            name="read",
            attributes={
                "key": "value",
            })
        update_role = keycloak.Role("update_role",
            realm_id=realm.id,
            name="update",
            attributes={
                "key": "value",
            })
        delete_role = keycloak.Role("delete_role",
            realm_id=realm.id,
            name="delete",
            attributes={
                "key": "value",
            })
        # client role
        openid_client = keycloak.openid.Client("openid_client",
            realm_id=realm.id,
            client_id="client",
            name="client",
            enabled=True,
            access_type="CONFIDENTIAL",
            valid_redirect_uris=["http://localhost:8080/openid-callback"])
        client_role = keycloak.Role("client_role",
            realm_id=realm.id,
            client_id=openid_client_keycloak_client["id"],
            name="my-client-role",
            description="My Client Role",
            attributes={
                "key": "value",
            })
        admin_role = keycloak.Role("admin_role",
            realm_id=realm.id,
            name="admin",
            composite_roles=[
                create_role.id,
                read_role.id,
                update_role.id,
                delete_role.id,
                client_role.id,
            ],
            attributes={
                "key": "value",
            })
        ```

        ## Import

        Roles can be imported using the format `{{realm_id}}/{{role_id}}`, where `role_id` is the unique ID that Keycloak assigns

        to the role. The ID is not easy to find in the GUI, but it appears in the URL when editing the role.

        Example:

        bash

        ```sh
        $ pulumi import keycloak:index/role:Role role my-realm/7e8cf32a-8acb-4d34-89c4-04fb1d10ccad
        ```

        :param str resource_name: The name of the resource.
        :param RoleArgs args: The arguments to use to populate this resource's properties.
        :param pulumi.ResourceOptions opts: Options for the resource.
        """
        ...
    def __init__(__self__, resource_name: str, *args, **kwargs):
        resource_args, opts = _utilities.get_resource_args_opts(RoleArgs, pulumi.ResourceOptions, *args, **kwargs)
        if resource_args is not None:
            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
        else:
            __self__._internal_init(resource_name, *args, **kwargs)

    def _internal_init(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
                 client_id: Optional[pulumi.Input[_builtins.str]] = None,
                 composite_roles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 description: Optional[pulumi.Input[_builtins.str]] = None,
                 import_: Optional[pulumi.Input[_builtins.bool]] = None,
                 name: Optional[pulumi.Input[_builtins.str]] = None,
                 realm_id: Optional[pulumi.Input[_builtins.str]] = None,
                 __props__=None):
        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
        if not isinstance(opts, pulumi.ResourceOptions):
            raise TypeError('Expected resource options to be a ResourceOptions instance')
        if opts.id is None:
            if __props__ is not None:
                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
            __props__ = RoleArgs.__new__(RoleArgs)

            __props__.__dict__["attributes"] = attributes
            __props__.__dict__["client_id"] = client_id
            __props__.__dict__["composite_roles"] = composite_roles
            __props__.__dict__["description"] = description
            __props__.__dict__["import_"] = import_
            __props__.__dict__["name"] = name
            if realm_id is None and not opts.urn:
                raise TypeError("Missing required property 'realm_id'")
            __props__.__dict__["realm_id"] = realm_id
        super(Role, __self__).__init__(
            'keycloak:index/role:Role',
            resource_name,
            __props__,
            opts)

    @staticmethod
    def get(resource_name: str,
            id: pulumi.Input[str],
            opts: Optional[pulumi.ResourceOptions] = None,
            attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
            client_id: Optional[pulumi.Input[_builtins.str]] = None,
            composite_roles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
            description: Optional[pulumi.Input[_builtins.str]] = None,
            import_: Optional[pulumi.Input[_builtins.bool]] = None,
            name: Optional[pulumi.Input[_builtins.str]] = None,
            realm_id: Optional[pulumi.Input[_builtins.str]] = None) -> 'Role':
        """
        Get an existing Role resource's state with the given name, id, and optional extra
        properties used to qualify the lookup.

        :param str resource_name: The unique name of the resulting resource.
        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
        :param pulumi.ResourceOptions opts: Options for the resource.
        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] attributes: A map representing attributes for the role. In order to add multivalue attributes, use `##` to seperate the values. Max length for each value is 255 chars
        :param pulumi.Input[_builtins.str] client_id: When specified, this role will be created as a client role attached to the client with the provided ID
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] composite_roles: When specified, this role will be a composite role, composed of all roles that have an ID present within this list.
        :param pulumi.Input[_builtins.str] description: The description of the role
        :param pulumi.Input[_builtins.bool] import_: When `true`, the role with the specified `name` is assumed to already exist, and it will be imported into state instead of being created. This attribute is useful when dealing with roles that Keycloak creates automatically during realm creation, such as the client roles `create-client`, `view-realm`, ... for the client `realm-management` created per realm. Note, that the role will not be removed during destruction if `import` is `true`.
        :param pulumi.Input[_builtins.str] name: The name of the role
        :param pulumi.Input[_builtins.str] realm_id: The realm this role exists within.
        """
        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))

        __props__ = _RoleState.__new__(_RoleState)

        __props__.__dict__["attributes"] = attributes
        __props__.__dict__["client_id"] = client_id
        __props__.__dict__["composite_roles"] = composite_roles
        __props__.__dict__["description"] = description
        __props__.__dict__["import_"] = import_
        __props__.__dict__["name"] = name
        __props__.__dict__["realm_id"] = realm_id
        return Role(resource_name, opts=opts, __props__=__props__)

    @_builtins.property
    @pulumi.getter
    def attributes(self) -> pulumi.Output[Mapping[str, _builtins.str]]:
        """
        A map representing attributes for the role. In order to add multivalue attributes, use `##` to seperate the values. Max length for each value is 255 chars
        """
        return pulumi.get(self, "attributes")

    @_builtins.property
    @pulumi.getter(name="clientId")
    def client_id(self) -> pulumi.Output[Optional[_builtins.str]]:
        """
        When specified, this role will be created as a client role attached to the client with the provided ID
        """
        return pulumi.get(self, "client_id")

    @_builtins.property
    @pulumi.getter(name="compositeRoles")
    def composite_roles(self) -> pulumi.Output[Sequence[_builtins.str]]:
        """
        When specified, this role will be a composite role, composed of all roles that have an ID present within this list.
        """
        return pulumi.get(self, "composite_roles")

    @_builtins.property
    @pulumi.getter
    def description(self) -> pulumi.Output[_builtins.str]:
        """
        The description of the role
        """
        return pulumi.get(self, "description")

    @_builtins.property
    @pulumi.getter(name="import")
    def import_(self) -> pulumi.Output[Optional[_builtins.bool]]:
        """
        When `true`, the role with the specified `name` is assumed to already exist, and it will be imported into state instead of being created. This attribute is useful when dealing with roles that Keycloak creates automatically during realm creation, such as the client roles `create-client`, `view-realm`, ... for the client `realm-management` created per realm. Note, that the role will not be removed during destruction if `import` is `true`.
        """
        return pulumi.get(self, "import_")

    @_builtins.property
    @pulumi.getter
    def name(self) -> pulumi.Output[_builtins.str]:
        """
        The name of the role
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="realmId")
    def realm_id(self) -> pulumi.Output[_builtins.str]:
        """
        The realm this role exists within.
        """
        return pulumi.get(self, "realm_id")

