# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'UserPasswordHash',
    'GetUserSearchResult',
    'GetUsersSearchResult',
    'GetUsersUserResult',
]

@pulumi.output_type
class UserPasswordHash(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "saltOrder":
            suggest = "salt_order"
        elif key == "workFactor":
            suggest = "work_factor"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in UserPasswordHash. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        UserPasswordHash.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        UserPasswordHash.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 algorithm: str,
                 value: str,
                 salt: Optional[str] = None,
                 salt_order: Optional[str] = None,
                 work_factor: Optional[int] = None):
        """
        :param str algorithm: The algorithm used to generate the hash using the password
        :param str value: For SHA-512, SHA-256, SHA-1, MD5, This is the actual base64-encoded hash of the password (and salt, if used). This is the Base64 encoded value of the SHA-512/SHA-256/SHA-1/MD5 digest that was computed by either pre-fixing or post-fixing the salt to the password, depending on the saltOrder. If a salt was not used in the source system, then this should just be the the Base64 encoded value of the password's SHA-512/SHA-256/SHA-1/MD5 digest. For BCRYPT, This is the actual radix64-encoded hashed password.
        :param str salt: Only required for salted hashes
        :param str salt_order: Specifies whether salt was pre- or postfixed to the password before hashing
        :param int work_factor: Governs the strength of the hash and the time required to compute it. Only required for BCRYPT algorithm
        """
        UserPasswordHash._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            algorithm=algorithm,
            value=value,
            salt=salt,
            salt_order=salt_order,
            work_factor=work_factor,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             algorithm: str,
             value: str,
             salt: Optional[str] = None,
             salt_order: Optional[str] = None,
             work_factor: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'saltOrder' in kwargs:
            salt_order = kwargs['saltOrder']
        if 'workFactor' in kwargs:
            work_factor = kwargs['workFactor']

        _setter("algorithm", algorithm)
        _setter("value", value)
        if salt is not None:
            _setter("salt", salt)
        if salt_order is not None:
            _setter("salt_order", salt_order)
        if work_factor is not None:
            _setter("work_factor", work_factor)

    @property
    @pulumi.getter
    def algorithm(self) -> str:
        """
        The algorithm used to generate the hash using the password
        """
        return pulumi.get(self, "algorithm")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        For SHA-512, SHA-256, SHA-1, MD5, This is the actual base64-encoded hash of the password (and salt, if used). This is the Base64 encoded value of the SHA-512/SHA-256/SHA-1/MD5 digest that was computed by either pre-fixing or post-fixing the salt to the password, depending on the saltOrder. If a salt was not used in the source system, then this should just be the the Base64 encoded value of the password's SHA-512/SHA-256/SHA-1/MD5 digest. For BCRYPT, This is the actual radix64-encoded hashed password.
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def salt(self) -> Optional[str]:
        """
        Only required for salted hashes
        """
        return pulumi.get(self, "salt")

    @property
    @pulumi.getter(name="saltOrder")
    def salt_order(self) -> Optional[str]:
        """
        Specifies whether salt was pre- or postfixed to the password before hashing
        """
        return pulumi.get(self, "salt_order")

    @property
    @pulumi.getter(name="workFactor")
    def work_factor(self) -> Optional[int]:
        """
        Governs the strength of the hash and the time required to compute it. Only required for BCRYPT algorithm
        """
        return pulumi.get(self, "work_factor")


@pulumi.output_type
class GetUserSearchResult(dict):
    def __init__(__self__, *,
                 comparison: Optional[str] = None,
                 expression: Optional[str] = None,
                 name: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str expression: A raw search expression string. This requires the search feature be on. Please see Okta documentation on their filter API for users. https://developer.okta.com/docs/api/resources/users#list-users-with-search
        :param str name: Property name to search for. This requires the search feature be on. Please see Okta documentation on their filter API for users. https://developer.okta.com/docs/api/resources/users#list-users-with-search
        """
        GetUserSearchResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            comparison=comparison,
            expression=expression,
            name=name,
            value=value,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             comparison: Optional[str] = None,
             expression: Optional[str] = None,
             name: Optional[str] = None,
             value: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        if comparison is not None:
            _setter("comparison", comparison)
        if expression is not None:
            _setter("expression", expression)
        if name is not None:
            _setter("name", name)
        if value is not None:
            _setter("value", value)

    @property
    @pulumi.getter
    def comparison(self) -> Optional[str]:
        return pulumi.get(self, "comparison")

    @property
    @pulumi.getter
    def expression(self) -> Optional[str]:
        """
        A raw search expression string. This requires the search feature be on. Please see Okta documentation on their filter API for users. https://developer.okta.com/docs/api/resources/users#list-users-with-search
        """
        return pulumi.get(self, "expression")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        Property name to search for. This requires the search feature be on. Please see Okta documentation on their filter API for users. https://developer.okta.com/docs/api/resources/users#list-users-with-search
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetUsersSearchResult(dict):
    def __init__(__self__, *,
                 comparison: Optional[str] = None,
                 expression: Optional[str] = None,
                 name: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str expression: A raw search expression string. This requires the search feature be on. Please see Okta documentation on their filter API for users. https://developer.okta.com/docs/api/resources/users#list-users-with-search
        :param str name: Property name to search for. This requires the search feature be on. Please see Okta documentation on their filter API for users. https://developer.okta.com/docs/api/resources/users#list-users-with-search
        """
        GetUsersSearchResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            comparison=comparison,
            expression=expression,
            name=name,
            value=value,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             comparison: Optional[str] = None,
             expression: Optional[str] = None,
             name: Optional[str] = None,
             value: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):

        if comparison is not None:
            _setter("comparison", comparison)
        if expression is not None:
            _setter("expression", expression)
        if name is not None:
            _setter("name", name)
        if value is not None:
            _setter("value", value)

    @property
    @pulumi.getter
    def comparison(self) -> Optional[str]:
        return pulumi.get(self, "comparison")

    @property
    @pulumi.getter
    def expression(self) -> Optional[str]:
        """
        A raw search expression string. This requires the search feature be on. Please see Okta documentation on their filter API for users. https://developer.okta.com/docs/api/resources/users#list-users-with-search
        """
        return pulumi.get(self, "expression")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        Property name to search for. This requires the search feature be on. Please see Okta documentation on their filter API for users. https://developer.okta.com/docs/api/resources/users#list-users-with-search
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetUsersUserResult(dict):
    def __init__(__self__, *,
                 admin_roles: Sequence[str],
                 city: str,
                 cost_center: str,
                 country_code: str,
                 custom_profile_attributes: str,
                 department: str,
                 display_name: str,
                 division: str,
                 email: str,
                 employee_number: str,
                 first_name: str,
                 group_memberships: Sequence[str],
                 honorific_prefix: str,
                 honorific_suffix: str,
                 id: str,
                 last_name: str,
                 locale: str,
                 login: str,
                 manager: str,
                 manager_id: str,
                 middle_name: str,
                 mobile_phone: str,
                 nick_name: str,
                 organization: str,
                 postal_address: str,
                 preferred_language: str,
                 primary_phone: str,
                 profile_url: str,
                 roles: Sequence[str],
                 second_email: str,
                 state: str,
                 status: str,
                 street_address: str,
                 timezone: str,
                 title: str,
                 user_type: str,
                 zip_code: str):
        GetUsersUserResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            admin_roles=admin_roles,
            city=city,
            cost_center=cost_center,
            country_code=country_code,
            custom_profile_attributes=custom_profile_attributes,
            department=department,
            display_name=display_name,
            division=division,
            email=email,
            employee_number=employee_number,
            first_name=first_name,
            group_memberships=group_memberships,
            honorific_prefix=honorific_prefix,
            honorific_suffix=honorific_suffix,
            id=id,
            last_name=last_name,
            locale=locale,
            login=login,
            manager=manager,
            manager_id=manager_id,
            middle_name=middle_name,
            mobile_phone=mobile_phone,
            nick_name=nick_name,
            organization=organization,
            postal_address=postal_address,
            preferred_language=preferred_language,
            primary_phone=primary_phone,
            profile_url=profile_url,
            roles=roles,
            second_email=second_email,
            state=state,
            status=status,
            street_address=street_address,
            timezone=timezone,
            title=title,
            user_type=user_type,
            zip_code=zip_code,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             admin_roles: Sequence[str],
             city: str,
             cost_center: str,
             country_code: str,
             custom_profile_attributes: str,
             department: str,
             display_name: str,
             division: str,
             email: str,
             employee_number: str,
             first_name: str,
             group_memberships: Sequence[str],
             honorific_prefix: str,
             honorific_suffix: str,
             id: str,
             last_name: str,
             locale: str,
             login: str,
             manager: str,
             manager_id: str,
             middle_name: str,
             mobile_phone: str,
             nick_name: str,
             organization: str,
             postal_address: str,
             preferred_language: str,
             primary_phone: str,
             profile_url: str,
             roles: Sequence[str],
             second_email: str,
             state: str,
             status: str,
             street_address: str,
             timezone: str,
             title: str,
             user_type: str,
             zip_code: str,
             opts: Optional[pulumi.ResourceOptions]=None,
             **kwargs):
        if 'adminRoles' in kwargs:
            admin_roles = kwargs['adminRoles']
        if 'costCenter' in kwargs:
            cost_center = kwargs['costCenter']
        if 'countryCode' in kwargs:
            country_code = kwargs['countryCode']
        if 'customProfileAttributes' in kwargs:
            custom_profile_attributes = kwargs['customProfileAttributes']
        if 'displayName' in kwargs:
            display_name = kwargs['displayName']
        if 'employeeNumber' in kwargs:
            employee_number = kwargs['employeeNumber']
        if 'firstName' in kwargs:
            first_name = kwargs['firstName']
        if 'groupMemberships' in kwargs:
            group_memberships = kwargs['groupMemberships']
        if 'honorificPrefix' in kwargs:
            honorific_prefix = kwargs['honorificPrefix']
        if 'honorificSuffix' in kwargs:
            honorific_suffix = kwargs['honorificSuffix']
        if 'lastName' in kwargs:
            last_name = kwargs['lastName']
        if 'managerId' in kwargs:
            manager_id = kwargs['managerId']
        if 'middleName' in kwargs:
            middle_name = kwargs['middleName']
        if 'mobilePhone' in kwargs:
            mobile_phone = kwargs['mobilePhone']
        if 'nickName' in kwargs:
            nick_name = kwargs['nickName']
        if 'postalAddress' in kwargs:
            postal_address = kwargs['postalAddress']
        if 'preferredLanguage' in kwargs:
            preferred_language = kwargs['preferredLanguage']
        if 'primaryPhone' in kwargs:
            primary_phone = kwargs['primaryPhone']
        if 'profileUrl' in kwargs:
            profile_url = kwargs['profileUrl']
        if 'secondEmail' in kwargs:
            second_email = kwargs['secondEmail']
        if 'streetAddress' in kwargs:
            street_address = kwargs['streetAddress']
        if 'userType' in kwargs:
            user_type = kwargs['userType']
        if 'zipCode' in kwargs:
            zip_code = kwargs['zipCode']

        _setter("admin_roles", admin_roles)
        _setter("city", city)
        _setter("cost_center", cost_center)
        _setter("country_code", country_code)
        _setter("custom_profile_attributes", custom_profile_attributes)
        _setter("department", department)
        _setter("display_name", display_name)
        _setter("division", division)
        _setter("email", email)
        _setter("employee_number", employee_number)
        _setter("first_name", first_name)
        _setter("group_memberships", group_memberships)
        _setter("honorific_prefix", honorific_prefix)
        _setter("honorific_suffix", honorific_suffix)
        _setter("id", id)
        _setter("last_name", last_name)
        _setter("locale", locale)
        _setter("login", login)
        _setter("manager", manager)
        _setter("manager_id", manager_id)
        _setter("middle_name", middle_name)
        _setter("mobile_phone", mobile_phone)
        _setter("nick_name", nick_name)
        _setter("organization", organization)
        _setter("postal_address", postal_address)
        _setter("preferred_language", preferred_language)
        _setter("primary_phone", primary_phone)
        _setter("profile_url", profile_url)
        _setter("roles", roles)
        _setter("second_email", second_email)
        _setter("state", state)
        _setter("status", status)
        _setter("street_address", street_address)
        _setter("timezone", timezone)
        _setter("title", title)
        _setter("user_type", user_type)
        _setter("zip_code", zip_code)

    @property
    @pulumi.getter(name="adminRoles")
    def admin_roles(self) -> Sequence[str]:
        return pulumi.get(self, "admin_roles")

    @property
    @pulumi.getter
    def city(self) -> str:
        return pulumi.get(self, "city")

    @property
    @pulumi.getter(name="costCenter")
    def cost_center(self) -> str:
        return pulumi.get(self, "cost_center")

    @property
    @pulumi.getter(name="countryCode")
    def country_code(self) -> str:
        return pulumi.get(self, "country_code")

    @property
    @pulumi.getter(name="customProfileAttributes")
    def custom_profile_attributes(self) -> str:
        return pulumi.get(self, "custom_profile_attributes")

    @property
    @pulumi.getter
    def department(self) -> str:
        return pulumi.get(self, "department")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter
    def division(self) -> str:
        return pulumi.get(self, "division")

    @property
    @pulumi.getter
    def email(self) -> str:
        return pulumi.get(self, "email")

    @property
    @pulumi.getter(name="employeeNumber")
    def employee_number(self) -> str:
        return pulumi.get(self, "employee_number")

    @property
    @pulumi.getter(name="firstName")
    def first_name(self) -> str:
        return pulumi.get(self, "first_name")

    @property
    @pulumi.getter(name="groupMemberships")
    def group_memberships(self) -> Sequence[str]:
        return pulumi.get(self, "group_memberships")

    @property
    @pulumi.getter(name="honorificPrefix")
    def honorific_prefix(self) -> str:
        return pulumi.get(self, "honorific_prefix")

    @property
    @pulumi.getter(name="honorificSuffix")
    def honorific_suffix(self) -> str:
        return pulumi.get(self, "honorific_suffix")

    @property
    @pulumi.getter
    def id(self) -> str:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="lastName")
    def last_name(self) -> str:
        return pulumi.get(self, "last_name")

    @property
    @pulumi.getter
    def locale(self) -> str:
        return pulumi.get(self, "locale")

    @property
    @pulumi.getter
    def login(self) -> str:
        return pulumi.get(self, "login")

    @property
    @pulumi.getter
    def manager(self) -> str:
        return pulumi.get(self, "manager")

    @property
    @pulumi.getter(name="managerId")
    def manager_id(self) -> str:
        return pulumi.get(self, "manager_id")

    @property
    @pulumi.getter(name="middleName")
    def middle_name(self) -> str:
        return pulumi.get(self, "middle_name")

    @property
    @pulumi.getter(name="mobilePhone")
    def mobile_phone(self) -> str:
        return pulumi.get(self, "mobile_phone")

    @property
    @pulumi.getter(name="nickName")
    def nick_name(self) -> str:
        return pulumi.get(self, "nick_name")

    @property
    @pulumi.getter
    def organization(self) -> str:
        return pulumi.get(self, "organization")

    @property
    @pulumi.getter(name="postalAddress")
    def postal_address(self) -> str:
        return pulumi.get(self, "postal_address")

    @property
    @pulumi.getter(name="preferredLanguage")
    def preferred_language(self) -> str:
        return pulumi.get(self, "preferred_language")

    @property
    @pulumi.getter(name="primaryPhone")
    def primary_phone(self) -> str:
        return pulumi.get(self, "primary_phone")

    @property
    @pulumi.getter(name="profileUrl")
    def profile_url(self) -> str:
        return pulumi.get(self, "profile_url")

    @property
    @pulumi.getter
    def roles(self) -> Sequence[str]:
        return pulumi.get(self, "roles")

    @property
    @pulumi.getter(name="secondEmail")
    def second_email(self) -> str:
        return pulumi.get(self, "second_email")

    @property
    @pulumi.getter
    def state(self) -> str:
        return pulumi.get(self, "state")

    @property
    @pulumi.getter
    def status(self) -> str:
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="streetAddress")
    def street_address(self) -> str:
        return pulumi.get(self, "street_address")

    @property
    @pulumi.getter
    def timezone(self) -> str:
        return pulumi.get(self, "timezone")

    @property
    @pulumi.getter
    def title(self) -> str:
        return pulumi.get(self, "title")

    @property
    @pulumi.getter(name="userType")
    def user_type(self) -> str:
        return pulumi.get(self, "user_type")

    @property
    @pulumi.getter(name="zipCode")
    def zip_code(self) -> str:
        return pulumi.get(self, "zip_code")


