# 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, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'GetDomainsPasswordPolicyResult',
    'AwaitableGetDomainsPasswordPolicyResult',
    'get_domains_password_policy',
    'get_domains_password_policy_output',
]

@pulumi.output_type
class GetDomainsPasswordPolicyResult:
    """
    A collection of values returned by getDomainsPasswordPolicy.
    """
    def __init__(__self__, allowed_chars=None, attribute_sets=None, attributes=None, authorization=None, compartment_ocid=None, configured_password_policy_rules=None, delete_in_progress=None, description=None, dictionary_delimiter=None, dictionary_location=None, dictionary_word_disallowed=None, disallowed_chars=None, disallowed_substrings=None, domain_ocid=None, external_id=None, first_name_disallowed=None, force_password_reset=None, groups=None, id=None, idcs_created_bies=None, idcs_endpoint=None, idcs_last_modified_bies=None, idcs_last_upgraded_in_release=None, idcs_prevented_operations=None, last_name_disallowed=None, lockout_duration=None, max_incorrect_attempts=None, max_length=None, max_repeated_chars=None, max_special_chars=None, metas=None, min_alpha_numerals=None, min_alphas=None, min_length=None, min_lower_case=None, min_numerals=None, min_password_age=None, min_special_chars=None, min_unique_chars=None, min_upper_case=None, name=None, num_passwords_in_history=None, ocid=None, password_expire_warning=None, password_expires_after=None, password_policy_id=None, password_strength=None, priority=None, required_chars=None, resource_type_schema_version=None, schemas=None, starts_with_alphabet=None, tags=None, tenancy_ocid=None, user_name_disallowed=None):
        if allowed_chars and not isinstance(allowed_chars, str):
            raise TypeError("Expected argument 'allowed_chars' to be a str")
        pulumi.set(__self__, "allowed_chars", allowed_chars)
        if attribute_sets and not isinstance(attribute_sets, list):
            raise TypeError("Expected argument 'attribute_sets' to be a list")
        pulumi.set(__self__, "attribute_sets", attribute_sets)
        if attributes and not isinstance(attributes, str):
            raise TypeError("Expected argument 'attributes' to be a str")
        pulumi.set(__self__, "attributes", attributes)
        if authorization and not isinstance(authorization, str):
            raise TypeError("Expected argument 'authorization' to be a str")
        pulumi.set(__self__, "authorization", authorization)
        if compartment_ocid and not isinstance(compartment_ocid, str):
            raise TypeError("Expected argument 'compartment_ocid' to be a str")
        pulumi.set(__self__, "compartment_ocid", compartment_ocid)
        if configured_password_policy_rules and not isinstance(configured_password_policy_rules, list):
            raise TypeError("Expected argument 'configured_password_policy_rules' to be a list")
        pulumi.set(__self__, "configured_password_policy_rules", configured_password_policy_rules)
        if delete_in_progress and not isinstance(delete_in_progress, bool):
            raise TypeError("Expected argument 'delete_in_progress' to be a bool")
        pulumi.set(__self__, "delete_in_progress", delete_in_progress)
        if description and not isinstance(description, str):
            raise TypeError("Expected argument 'description' to be a str")
        pulumi.set(__self__, "description", description)
        if dictionary_delimiter and not isinstance(dictionary_delimiter, str):
            raise TypeError("Expected argument 'dictionary_delimiter' to be a str")
        pulumi.set(__self__, "dictionary_delimiter", dictionary_delimiter)
        if dictionary_location and not isinstance(dictionary_location, str):
            raise TypeError("Expected argument 'dictionary_location' to be a str")
        pulumi.set(__self__, "dictionary_location", dictionary_location)
        if dictionary_word_disallowed and not isinstance(dictionary_word_disallowed, bool):
            raise TypeError("Expected argument 'dictionary_word_disallowed' to be a bool")
        pulumi.set(__self__, "dictionary_word_disallowed", dictionary_word_disallowed)
        if disallowed_chars and not isinstance(disallowed_chars, str):
            raise TypeError("Expected argument 'disallowed_chars' to be a str")
        pulumi.set(__self__, "disallowed_chars", disallowed_chars)
        if disallowed_substrings and not isinstance(disallowed_substrings, list):
            raise TypeError("Expected argument 'disallowed_substrings' to be a list")
        pulumi.set(__self__, "disallowed_substrings", disallowed_substrings)
        if domain_ocid and not isinstance(domain_ocid, str):
            raise TypeError("Expected argument 'domain_ocid' to be a str")
        pulumi.set(__self__, "domain_ocid", domain_ocid)
        if external_id and not isinstance(external_id, str):
            raise TypeError("Expected argument 'external_id' to be a str")
        pulumi.set(__self__, "external_id", external_id)
        if first_name_disallowed and not isinstance(first_name_disallowed, bool):
            raise TypeError("Expected argument 'first_name_disallowed' to be a bool")
        pulumi.set(__self__, "first_name_disallowed", first_name_disallowed)
        if force_password_reset and not isinstance(force_password_reset, bool):
            raise TypeError("Expected argument 'force_password_reset' to be a bool")
        pulumi.set(__self__, "force_password_reset", force_password_reset)
        if groups and not isinstance(groups, list):
            raise TypeError("Expected argument 'groups' to be a list")
        pulumi.set(__self__, "groups", groups)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if idcs_created_bies and not isinstance(idcs_created_bies, list):
            raise TypeError("Expected argument 'idcs_created_bies' to be a list")
        pulumi.set(__self__, "idcs_created_bies", idcs_created_bies)
        if idcs_endpoint and not isinstance(idcs_endpoint, str):
            raise TypeError("Expected argument 'idcs_endpoint' to be a str")
        pulumi.set(__self__, "idcs_endpoint", idcs_endpoint)
        if idcs_last_modified_bies and not isinstance(idcs_last_modified_bies, list):
            raise TypeError("Expected argument 'idcs_last_modified_bies' to be a list")
        pulumi.set(__self__, "idcs_last_modified_bies", idcs_last_modified_bies)
        if idcs_last_upgraded_in_release and not isinstance(idcs_last_upgraded_in_release, str):
            raise TypeError("Expected argument 'idcs_last_upgraded_in_release' to be a str")
        pulumi.set(__self__, "idcs_last_upgraded_in_release", idcs_last_upgraded_in_release)
        if idcs_prevented_operations and not isinstance(idcs_prevented_operations, list):
            raise TypeError("Expected argument 'idcs_prevented_operations' to be a list")
        pulumi.set(__self__, "idcs_prevented_operations", idcs_prevented_operations)
        if last_name_disallowed and not isinstance(last_name_disallowed, bool):
            raise TypeError("Expected argument 'last_name_disallowed' to be a bool")
        pulumi.set(__self__, "last_name_disallowed", last_name_disallowed)
        if lockout_duration and not isinstance(lockout_duration, int):
            raise TypeError("Expected argument 'lockout_duration' to be a int")
        pulumi.set(__self__, "lockout_duration", lockout_duration)
        if max_incorrect_attempts and not isinstance(max_incorrect_attempts, int):
            raise TypeError("Expected argument 'max_incorrect_attempts' to be a int")
        pulumi.set(__self__, "max_incorrect_attempts", max_incorrect_attempts)
        if max_length and not isinstance(max_length, int):
            raise TypeError("Expected argument 'max_length' to be a int")
        pulumi.set(__self__, "max_length", max_length)
        if max_repeated_chars and not isinstance(max_repeated_chars, int):
            raise TypeError("Expected argument 'max_repeated_chars' to be a int")
        pulumi.set(__self__, "max_repeated_chars", max_repeated_chars)
        if max_special_chars and not isinstance(max_special_chars, int):
            raise TypeError("Expected argument 'max_special_chars' to be a int")
        pulumi.set(__self__, "max_special_chars", max_special_chars)
        if metas and not isinstance(metas, list):
            raise TypeError("Expected argument 'metas' to be a list")
        pulumi.set(__self__, "metas", metas)
        if min_alpha_numerals and not isinstance(min_alpha_numerals, int):
            raise TypeError("Expected argument 'min_alpha_numerals' to be a int")
        pulumi.set(__self__, "min_alpha_numerals", min_alpha_numerals)
        if min_alphas and not isinstance(min_alphas, int):
            raise TypeError("Expected argument 'min_alphas' to be a int")
        pulumi.set(__self__, "min_alphas", min_alphas)
        if min_length and not isinstance(min_length, int):
            raise TypeError("Expected argument 'min_length' to be a int")
        pulumi.set(__self__, "min_length", min_length)
        if min_lower_case and not isinstance(min_lower_case, int):
            raise TypeError("Expected argument 'min_lower_case' to be a int")
        pulumi.set(__self__, "min_lower_case", min_lower_case)
        if min_numerals and not isinstance(min_numerals, int):
            raise TypeError("Expected argument 'min_numerals' to be a int")
        pulumi.set(__self__, "min_numerals", min_numerals)
        if min_password_age and not isinstance(min_password_age, int):
            raise TypeError("Expected argument 'min_password_age' to be a int")
        pulumi.set(__self__, "min_password_age", min_password_age)
        if min_special_chars and not isinstance(min_special_chars, int):
            raise TypeError("Expected argument 'min_special_chars' to be a int")
        pulumi.set(__self__, "min_special_chars", min_special_chars)
        if min_unique_chars and not isinstance(min_unique_chars, int):
            raise TypeError("Expected argument 'min_unique_chars' to be a int")
        pulumi.set(__self__, "min_unique_chars", min_unique_chars)
        if min_upper_case and not isinstance(min_upper_case, int):
            raise TypeError("Expected argument 'min_upper_case' to be a int")
        pulumi.set(__self__, "min_upper_case", min_upper_case)
        if name and not isinstance(name, str):
            raise TypeError("Expected argument 'name' to be a str")
        pulumi.set(__self__, "name", name)
        if num_passwords_in_history and not isinstance(num_passwords_in_history, int):
            raise TypeError("Expected argument 'num_passwords_in_history' to be a int")
        pulumi.set(__self__, "num_passwords_in_history", num_passwords_in_history)
        if ocid and not isinstance(ocid, str):
            raise TypeError("Expected argument 'ocid' to be a str")
        pulumi.set(__self__, "ocid", ocid)
        if password_expire_warning and not isinstance(password_expire_warning, int):
            raise TypeError("Expected argument 'password_expire_warning' to be a int")
        pulumi.set(__self__, "password_expire_warning", password_expire_warning)
        if password_expires_after and not isinstance(password_expires_after, int):
            raise TypeError("Expected argument 'password_expires_after' to be a int")
        pulumi.set(__self__, "password_expires_after", password_expires_after)
        if password_policy_id and not isinstance(password_policy_id, str):
            raise TypeError("Expected argument 'password_policy_id' to be a str")
        pulumi.set(__self__, "password_policy_id", password_policy_id)
        if password_strength and not isinstance(password_strength, str):
            raise TypeError("Expected argument 'password_strength' to be a str")
        pulumi.set(__self__, "password_strength", password_strength)
        if priority and not isinstance(priority, int):
            raise TypeError("Expected argument 'priority' to be a int")
        pulumi.set(__self__, "priority", priority)
        if required_chars and not isinstance(required_chars, str):
            raise TypeError("Expected argument 'required_chars' to be a str")
        pulumi.set(__self__, "required_chars", required_chars)
        if resource_type_schema_version and not isinstance(resource_type_schema_version, str):
            raise TypeError("Expected argument 'resource_type_schema_version' to be a str")
        pulumi.set(__self__, "resource_type_schema_version", resource_type_schema_version)
        if schemas and not isinstance(schemas, list):
            raise TypeError("Expected argument 'schemas' to be a list")
        pulumi.set(__self__, "schemas", schemas)
        if starts_with_alphabet and not isinstance(starts_with_alphabet, bool):
            raise TypeError("Expected argument 'starts_with_alphabet' to be a bool")
        pulumi.set(__self__, "starts_with_alphabet", starts_with_alphabet)
        if tags and not isinstance(tags, list):
            raise TypeError("Expected argument 'tags' to be a list")
        pulumi.set(__self__, "tags", tags)
        if tenancy_ocid and not isinstance(tenancy_ocid, str):
            raise TypeError("Expected argument 'tenancy_ocid' to be a str")
        pulumi.set(__self__, "tenancy_ocid", tenancy_ocid)
        if user_name_disallowed and not isinstance(user_name_disallowed, bool):
            raise TypeError("Expected argument 'user_name_disallowed' to be a bool")
        pulumi.set(__self__, "user_name_disallowed", user_name_disallowed)

    @property
    @pulumi.getter(name="allowedChars")
    def allowed_chars(self) -> str:
        """
        A String value whose contents indicate a set of characters that can appear, in any sequence, in a password value
        """
        return pulumi.get(self, "allowed_chars")

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

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

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

    @property
    @pulumi.getter(name="compartmentOcid")
    def compartment_ocid(self) -> str:
        """
        Oracle Cloud Infrastructure Compartment Id (ocid) in which the resource lives.
        """
        return pulumi.get(self, "compartment_ocid")

    @property
    @pulumi.getter(name="configuredPasswordPolicyRules")
    def configured_password_policy_rules(self) -> Sequence['outputs.GetDomainsPasswordPolicyConfiguredPasswordPolicyRuleResult']:
        """
        List of password policy rules that have values set. This map of stringKey:stringValue pairs can be used to aid users while setting/resetting password
        """
        return pulumi.get(self, "configured_password_policy_rules")

    @property
    @pulumi.getter(name="deleteInProgress")
    def delete_in_progress(self) -> bool:
        """
        A boolean flag indicating this resource in the process of being deleted. Usually set to true when synchronous deletion of the resource would take too long.
        """
        return pulumi.get(self, "delete_in_progress")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        A String that describes the password policy
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="dictionaryDelimiter")
    def dictionary_delimiter(self) -> str:
        """
        A delimiter used to separate characters in the dictionary file
        """
        return pulumi.get(self, "dictionary_delimiter")

    @property
    @pulumi.getter(name="dictionaryLocation")
    def dictionary_location(self) -> str:
        """
        A Reference value that contains the URI of a dictionary of words not allowed to appear within a password value
        """
        return pulumi.get(self, "dictionary_location")

    @property
    @pulumi.getter(name="dictionaryWordDisallowed")
    def dictionary_word_disallowed(self) -> bool:
        """
        Indicates whether the password can match a dictionary word
        """
        return pulumi.get(self, "dictionary_word_disallowed")

    @property
    @pulumi.getter(name="disallowedChars")
    def disallowed_chars(self) -> str:
        """
        A String value whose contents indicate a set of characters that cannot appear, in any sequence, in a password value
        """
        return pulumi.get(self, "disallowed_chars")

    @property
    @pulumi.getter(name="disallowedSubstrings")
    def disallowed_substrings(self) -> Sequence[str]:
        """
        A String value whose contents indicate a set of substrings that cannot appear, in any sequence, in a password value
        """
        return pulumi.get(self, "disallowed_substrings")

    @property
    @pulumi.getter(name="domainOcid")
    def domain_ocid(self) -> str:
        """
        Oracle Cloud Infrastructure Domain Id (ocid) in which the resource lives.
        """
        return pulumi.get(self, "domain_ocid")

    @property
    @pulumi.getter(name="externalId")
    def external_id(self) -> str:
        """
        An identifier for the Resource as defined by the Service Consumer. The externalId may simplify identification of the Resource between Service Consumer and Service Provider by allowing the Consumer to refer to the Resource with its own identifier, obviating the need to store a local mapping between the local identifier of the Resource and the identifier used by the Service Provider. Each Resource MAY include a non-empty externalId value. The value of the externalId attribute is always issued by the Service Consumer and can never be specified by the Service Provider. The Service Provider MUST always interpret the externalId as scoped to the Service Consumer's tenant.
        """
        return pulumi.get(self, "external_id")

    @property
    @pulumi.getter(name="firstNameDisallowed")
    def first_name_disallowed(self) -> bool:
        """
        Indicates a sequence of characters that match the user's first name of given name cannot be the password. Password validation against policy will be ignored if length of first name is less than or equal to 3 characters.
        """
        return pulumi.get(self, "first_name_disallowed")

    @property
    @pulumi.getter(name="forcePasswordReset")
    def force_password_reset(self) -> bool:
        """
        Indicates whether all of the users should be forced to reset their password on the next login (to comply with new password policy changes)
        """
        return pulumi.get(self, "force_password_reset")

    @property
    @pulumi.getter
    def groups(self) -> Sequence['outputs.GetDomainsPasswordPolicyGroupResult']:
        """
        A list of groups that the password policy belongs to.
        """
        return pulumi.get(self, "groups")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Unique identifier for the SCIM Resource as defined by the Service Provider. Each representation of the Resource MUST include a non-empty id value. This identifier MUST be unique across the Service Provider's entire set of Resources. It MUST be a stable, non-reassignable identifier that does not change when the same Resource is returned in subsequent requests. The value of the id attribute is always issued by the Service Provider and MUST never be specified by the Service Consumer. bulkId: is a reserved keyword and MUST NOT be used in the unique identifier.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="idcsCreatedBies")
    def idcs_created_bies(self) -> Sequence['outputs.GetDomainsPasswordPolicyIdcsCreatedByResult']:
        """
        The User or App who created the Resource
        """
        return pulumi.get(self, "idcs_created_bies")

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

    @property
    @pulumi.getter(name="idcsLastModifiedBies")
    def idcs_last_modified_bies(self) -> Sequence['outputs.GetDomainsPasswordPolicyIdcsLastModifiedByResult']:
        """
        The User or App who modified the Resource
        """
        return pulumi.get(self, "idcs_last_modified_bies")

    @property
    @pulumi.getter(name="idcsLastUpgradedInRelease")
    def idcs_last_upgraded_in_release(self) -> str:
        """
        The release number when the resource was upgraded.
        """
        return pulumi.get(self, "idcs_last_upgraded_in_release")

    @property
    @pulumi.getter(name="idcsPreventedOperations")
    def idcs_prevented_operations(self) -> Sequence[str]:
        """
        Each value of this attribute specifies an operation that only an internal client may perform on this particular resource.
        """
        return pulumi.get(self, "idcs_prevented_operations")

    @property
    @pulumi.getter(name="lastNameDisallowed")
    def last_name_disallowed(self) -> bool:
        """
        Indicates a sequence of characters that match the user's last name of given name cannot be the password. Password validation against policy will be ignored if length of last name is less than or equal to 3 characters.
        """
        return pulumi.get(self, "last_name_disallowed")

    @property
    @pulumi.getter(name="lockoutDuration")
    def lockout_duration(self) -> int:
        """
        The time period in minutes to lock out a user account when the threshold of invalid login attempts is reached. The available range is from 5 through 1440 minutes (24 hours).
        """
        return pulumi.get(self, "lockout_duration")

    @property
    @pulumi.getter(name="maxIncorrectAttempts")
    def max_incorrect_attempts(self) -> int:
        """
        An integer that represents the maximum number of failed logins before an account is locked
        """
        return pulumi.get(self, "max_incorrect_attempts")

    @property
    @pulumi.getter(name="maxLength")
    def max_length(self) -> int:
        """
        The maximum password length (in characters). A value of 0 or no value indicates no maximum length restriction.
        """
        return pulumi.get(self, "max_length")

    @property
    @pulumi.getter(name="maxRepeatedChars")
    def max_repeated_chars(self) -> int:
        """
        The maximum number of repeated characters allowed in a password.  A value of 0 or no value indicates no such restriction.
        """
        return pulumi.get(self, "max_repeated_chars")

    @property
    @pulumi.getter(name="maxSpecialChars")
    def max_special_chars(self) -> int:
        """
        The maximum number of special characters in a password.  A value of 0 or no value indicates no maximum special characters restriction.
        """
        return pulumi.get(self, "max_special_chars")

    @property
    @pulumi.getter
    def metas(self) -> Sequence['outputs.GetDomainsPasswordPolicyMetaResult']:
        """
        A complex attribute that contains resource metadata. All sub-attributes are OPTIONAL.
        """
        return pulumi.get(self, "metas")

    @property
    @pulumi.getter(name="minAlphaNumerals")
    def min_alpha_numerals(self) -> int:
        """
        The minimum number of a combination of alphabetic and numeric characters in a password.  A value of 0 or no value indicates no minimum alphanumeric character restriction.
        """
        return pulumi.get(self, "min_alpha_numerals")

    @property
    @pulumi.getter(name="minAlphas")
    def min_alphas(self) -> int:
        """
        The minimum number of alphabetic characters in a password.  A value of 0 or no value indicates no minimum alphas restriction.
        """
        return pulumi.get(self, "min_alphas")

    @property
    @pulumi.getter(name="minLength")
    def min_length(self) -> int:
        """
        The minimum password length (in characters). A value of 0 or no value indicates no minimum length restriction.
        """
        return pulumi.get(self, "min_length")

    @property
    @pulumi.getter(name="minLowerCase")
    def min_lower_case(self) -> int:
        """
        The minimum number of lowercase alphabetic characters in a password.  A value of 0 or no value indicates no minimum lowercase restriction.
        """
        return pulumi.get(self, "min_lower_case")

    @property
    @pulumi.getter(name="minNumerals")
    def min_numerals(self) -> int:
        """
        The minimum number of numeric characters in a password.  A value of 0 or no value indicates no minimum numeric character restriction.
        """
        return pulumi.get(self, "min_numerals")

    @property
    @pulumi.getter(name="minPasswordAge")
    def min_password_age(self) -> int:
        """
        Minimum time after which the user can resubmit the reset password request
        """
        return pulumi.get(self, "min_password_age")

    @property
    @pulumi.getter(name="minSpecialChars")
    def min_special_chars(self) -> int:
        """
        The minimum number of special characters in a password. A value of 0 or no value indicates no minimum special characters restriction.
        """
        return pulumi.get(self, "min_special_chars")

    @property
    @pulumi.getter(name="minUniqueChars")
    def min_unique_chars(self) -> int:
        """
        The minimum number of unique characters in a password.  A value of 0 or no value indicates no minimum unique characters restriction.
        """
        return pulumi.get(self, "min_unique_chars")

    @property
    @pulumi.getter(name="minUpperCase")
    def min_upper_case(self) -> int:
        """
        The minimum number of uppercase alphabetic characters in a password. A value of 0 or no value indicates no minimum uppercase restriction.
        """
        return pulumi.get(self, "min_upper_case")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A String that is the name of the policy to display to the user. This is the only mandatory attribute for a password policy.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="numPasswordsInHistory")
    def num_passwords_in_history(self) -> int:
        """
        The number of passwords that will be kept in history that may not be used as a password
        """
        return pulumi.get(self, "num_passwords_in_history")

    @property
    @pulumi.getter
    def ocid(self) -> str:
        """
        Unique Oracle Cloud Infrastructure identifier for the SCIM Resource.
        """
        return pulumi.get(self, "ocid")

    @property
    @pulumi.getter(name="passwordExpireWarning")
    def password_expire_warning(self) -> int:
        """
        An integer indicating the number of days before which the user should be warned about password expiry.
        """
        return pulumi.get(self, "password_expire_warning")

    @property
    @pulumi.getter(name="passwordExpiresAfter")
    def password_expires_after(self) -> int:
        """
        The number of days after which the password expires automatically
        """
        return pulumi.get(self, "password_expires_after")

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

    @property
    @pulumi.getter(name="passwordStrength")
    def password_strength(self) -> str:
        """
        Indicates whether the password policy is configured as Simple, Standard, or Custom.
        """
        return pulumi.get(self, "password_strength")

    @property
    @pulumi.getter
    def priority(self) -> int:
        """
        Password policy priority
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter(name="requiredChars")
    def required_chars(self) -> str:
        """
        A String value whose contents indicate a set of characters that must appear, in any sequence, in a password value
        """
        return pulumi.get(self, "required_chars")

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

    @property
    @pulumi.getter
    def schemas(self) -> Sequence[str]:
        """
        REQUIRED. The schemas attribute is an array of Strings which allows introspection of the supported schema version for a SCIM representation as well any schema extensions supported by that representation. Each String value must be a unique URI. This specification defines URIs for User, Group, and a standard \\"enterprise\\" extension. All representations of SCIM schema MUST include a non-zero value array with value(s) of the URIs supported by that representation. Duplicate values MUST NOT be included. Value order is not specified and MUST not impact behavior.
        """
        return pulumi.get(self, "schemas")

    @property
    @pulumi.getter(name="startsWithAlphabet")
    def starts_with_alphabet(self) -> bool:
        """
        Indicates that the password must begin with an alphabetic character
        """
        return pulumi.get(self, "starts_with_alphabet")

    @property
    @pulumi.getter
    def tags(self) -> Sequence['outputs.GetDomainsPasswordPolicyTagResult']:
        """
        A list of tags on this resource.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="tenancyOcid")
    def tenancy_ocid(self) -> str:
        """
        Oracle Cloud Infrastructure Tenant Id (ocid) in which the resource lives.
        """
        return pulumi.get(self, "tenancy_ocid")

    @property
    @pulumi.getter(name="userNameDisallowed")
    def user_name_disallowed(self) -> bool:
        """
        Indicates a sequence of characters that match the username cannot be the password. Password validation against policy will be ignored if length of user name is less than or equal to 3 characters.
        """
        return pulumi.get(self, "user_name_disallowed")


class AwaitableGetDomainsPasswordPolicyResult(GetDomainsPasswordPolicyResult):
    # pylint: disable=using-constant-test
    def __await__(self):
        if False:
            yield self
        return GetDomainsPasswordPolicyResult(
            allowed_chars=self.allowed_chars,
            attribute_sets=self.attribute_sets,
            attributes=self.attributes,
            authorization=self.authorization,
            compartment_ocid=self.compartment_ocid,
            configured_password_policy_rules=self.configured_password_policy_rules,
            delete_in_progress=self.delete_in_progress,
            description=self.description,
            dictionary_delimiter=self.dictionary_delimiter,
            dictionary_location=self.dictionary_location,
            dictionary_word_disallowed=self.dictionary_word_disallowed,
            disallowed_chars=self.disallowed_chars,
            disallowed_substrings=self.disallowed_substrings,
            domain_ocid=self.domain_ocid,
            external_id=self.external_id,
            first_name_disallowed=self.first_name_disallowed,
            force_password_reset=self.force_password_reset,
            groups=self.groups,
            id=self.id,
            idcs_created_bies=self.idcs_created_bies,
            idcs_endpoint=self.idcs_endpoint,
            idcs_last_modified_bies=self.idcs_last_modified_bies,
            idcs_last_upgraded_in_release=self.idcs_last_upgraded_in_release,
            idcs_prevented_operations=self.idcs_prevented_operations,
            last_name_disallowed=self.last_name_disallowed,
            lockout_duration=self.lockout_duration,
            max_incorrect_attempts=self.max_incorrect_attempts,
            max_length=self.max_length,
            max_repeated_chars=self.max_repeated_chars,
            max_special_chars=self.max_special_chars,
            metas=self.metas,
            min_alpha_numerals=self.min_alpha_numerals,
            min_alphas=self.min_alphas,
            min_length=self.min_length,
            min_lower_case=self.min_lower_case,
            min_numerals=self.min_numerals,
            min_password_age=self.min_password_age,
            min_special_chars=self.min_special_chars,
            min_unique_chars=self.min_unique_chars,
            min_upper_case=self.min_upper_case,
            name=self.name,
            num_passwords_in_history=self.num_passwords_in_history,
            ocid=self.ocid,
            password_expire_warning=self.password_expire_warning,
            password_expires_after=self.password_expires_after,
            password_policy_id=self.password_policy_id,
            password_strength=self.password_strength,
            priority=self.priority,
            required_chars=self.required_chars,
            resource_type_schema_version=self.resource_type_schema_version,
            schemas=self.schemas,
            starts_with_alphabet=self.starts_with_alphabet,
            tags=self.tags,
            tenancy_ocid=self.tenancy_ocid,
            user_name_disallowed=self.user_name_disallowed)


def get_domains_password_policy(attribute_sets: Optional[Sequence[str]] = None,
                                attributes: Optional[str] = None,
                                authorization: Optional[str] = None,
                                idcs_endpoint: Optional[str] = None,
                                password_policy_id: Optional[str] = None,
                                resource_type_schema_version: Optional[str] = None,
                                opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDomainsPasswordPolicyResult:
    """
    This data source provides details about a specific Password Policy resource in Oracle Cloud Infrastructure Identity Domains service.

    Get a Password Policy

    ## Example Usage

    ```python
    import pulumi
    import pulumi_oci as oci

    test_password_policy = oci.Identity.get_domains_password_policy(idcs_endpoint=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
        password_policy_id=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
        attribute_sets=[],
        attributes="",
        authorization=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
        resource_type_schema_version=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
    ```


    :param Sequence[str] attribute_sets: A multi-valued list of strings indicating the return type of attribute definition. The specified set of attributes can be fetched by the return type of the attribute. One or more values can be given together to fetch more than one group of attributes. If 'attributes' query parameter is also available, union of the two is fetched. Valid values - all, always, never, request, default. Values are case-insensitive.
    :param str attributes: A comma-delimited string that specifies the names of resource attributes that should be returned in the response. By default, a response that contains resource attributes contains only attributes that are defined in the schema for that resource type as returned=always or returned=default. An attribute that is defined as returned=request is returned in a response only if the request specifies its name in the value of this query parameter. If a request specifies this query parameter, the response contains the attributes that this query parameter specifies, as well as any attribute that is defined as returned=always.
    :param str authorization: The Authorization field value consists of credentials containing the authentication information of the user agent for the realm of the resource being requested.
    :param str idcs_endpoint: The basic endpoint for the identity domain
    :param str password_policy_id: ID of the resource
    :param str resource_type_schema_version: An endpoint-specific schema version number to use in the Request. Allowed version values are Earliest Version or Latest Version as specified in each REST API endpoint description, or any sequential number inbetween. All schema attributes/body parameters are a part of version 1. After version 1, any attributes added or deprecated will be tagged with the version that they were added to or deprecated in. If no version is provided, the latest schema version is returned.
    """
    __args__ = dict()
    __args__['attributeSets'] = attribute_sets
    __args__['attributes'] = attributes
    __args__['authorization'] = authorization
    __args__['idcsEndpoint'] = idcs_endpoint
    __args__['passwordPolicyId'] = password_policy_id
    __args__['resourceTypeSchemaVersion'] = resource_type_schema_version
    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke('oci:Identity/getDomainsPasswordPolicy:getDomainsPasswordPolicy', __args__, opts=opts, typ=GetDomainsPasswordPolicyResult).value

    return AwaitableGetDomainsPasswordPolicyResult(
        allowed_chars=__ret__.allowed_chars,
        attribute_sets=__ret__.attribute_sets,
        attributes=__ret__.attributes,
        authorization=__ret__.authorization,
        compartment_ocid=__ret__.compartment_ocid,
        configured_password_policy_rules=__ret__.configured_password_policy_rules,
        delete_in_progress=__ret__.delete_in_progress,
        description=__ret__.description,
        dictionary_delimiter=__ret__.dictionary_delimiter,
        dictionary_location=__ret__.dictionary_location,
        dictionary_word_disallowed=__ret__.dictionary_word_disallowed,
        disallowed_chars=__ret__.disallowed_chars,
        disallowed_substrings=__ret__.disallowed_substrings,
        domain_ocid=__ret__.domain_ocid,
        external_id=__ret__.external_id,
        first_name_disallowed=__ret__.first_name_disallowed,
        force_password_reset=__ret__.force_password_reset,
        groups=__ret__.groups,
        id=__ret__.id,
        idcs_created_bies=__ret__.idcs_created_bies,
        idcs_endpoint=__ret__.idcs_endpoint,
        idcs_last_modified_bies=__ret__.idcs_last_modified_bies,
        idcs_last_upgraded_in_release=__ret__.idcs_last_upgraded_in_release,
        idcs_prevented_operations=__ret__.idcs_prevented_operations,
        last_name_disallowed=__ret__.last_name_disallowed,
        lockout_duration=__ret__.lockout_duration,
        max_incorrect_attempts=__ret__.max_incorrect_attempts,
        max_length=__ret__.max_length,
        max_repeated_chars=__ret__.max_repeated_chars,
        max_special_chars=__ret__.max_special_chars,
        metas=__ret__.metas,
        min_alpha_numerals=__ret__.min_alpha_numerals,
        min_alphas=__ret__.min_alphas,
        min_length=__ret__.min_length,
        min_lower_case=__ret__.min_lower_case,
        min_numerals=__ret__.min_numerals,
        min_password_age=__ret__.min_password_age,
        min_special_chars=__ret__.min_special_chars,
        min_unique_chars=__ret__.min_unique_chars,
        min_upper_case=__ret__.min_upper_case,
        name=__ret__.name,
        num_passwords_in_history=__ret__.num_passwords_in_history,
        ocid=__ret__.ocid,
        password_expire_warning=__ret__.password_expire_warning,
        password_expires_after=__ret__.password_expires_after,
        password_policy_id=__ret__.password_policy_id,
        password_strength=__ret__.password_strength,
        priority=__ret__.priority,
        required_chars=__ret__.required_chars,
        resource_type_schema_version=__ret__.resource_type_schema_version,
        schemas=__ret__.schemas,
        starts_with_alphabet=__ret__.starts_with_alphabet,
        tags=__ret__.tags,
        tenancy_ocid=__ret__.tenancy_ocid,
        user_name_disallowed=__ret__.user_name_disallowed)


@_utilities.lift_output_func(get_domains_password_policy)
def get_domains_password_policy_output(attribute_sets: Optional[pulumi.Input[Optional[Sequence[str]]]] = None,
                                       attributes: Optional[pulumi.Input[Optional[str]]] = None,
                                       authorization: Optional[pulumi.Input[Optional[str]]] = None,
                                       idcs_endpoint: Optional[pulumi.Input[str]] = None,
                                       password_policy_id: Optional[pulumi.Input[str]] = None,
                                       resource_type_schema_version: Optional[pulumi.Input[Optional[str]]] = None,
                                       opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetDomainsPasswordPolicyResult]:
    """
    This data source provides details about a specific Password Policy resource in Oracle Cloud Infrastructure Identity Domains service.

    Get a Password Policy

    ## Example Usage

    ```python
    import pulumi
    import pulumi_oci as oci

    test_password_policy = oci.Identity.get_domains_password_policy(idcs_endpoint=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
        password_policy_id=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
        attribute_sets=[],
        attributes="",
        authorization=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
        resource_type_schema_version=%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
    ```


    :param Sequence[str] attribute_sets: A multi-valued list of strings indicating the return type of attribute definition. The specified set of attributes can be fetched by the return type of the attribute. One or more values can be given together to fetch more than one group of attributes. If 'attributes' query parameter is also available, union of the two is fetched. Valid values - all, always, never, request, default. Values are case-insensitive.
    :param str attributes: A comma-delimited string that specifies the names of resource attributes that should be returned in the response. By default, a response that contains resource attributes contains only attributes that are defined in the schema for that resource type as returned=always or returned=default. An attribute that is defined as returned=request is returned in a response only if the request specifies its name in the value of this query parameter. If a request specifies this query parameter, the response contains the attributes that this query parameter specifies, as well as any attribute that is defined as returned=always.
    :param str authorization: The Authorization field value consists of credentials containing the authentication information of the user agent for the realm of the resource being requested.
    :param str idcs_endpoint: The basic endpoint for the identity domain
    :param str password_policy_id: ID of the resource
    :param str resource_type_schema_version: An endpoint-specific schema version number to use in the Request. Allowed version values are Earliest Version or Latest Version as specified in each REST API endpoint description, or any sequential number inbetween. All schema attributes/body parameters are a part of version 1. After version 1, any attributes added or deprecated will be tagged with the version that they were added to or deprecated in. If no version is provided, the latest schema version is returned.
    """
    ...
