pulumi-alicloud 3.77.0a1746076596__py3-none-any.whl → 3.77.0a1746220593__py3-none-any.whl

pulumi_alicloud/cloudsso/_inputs.py

@@ -18,8 +18,18 @@ from .. import _utilities
 __all__ = [
     'AccessConfigurationPermissionPolicyArgs',
     'AccessConfigurationPermissionPolicyArgsDict',
+    'DirectoryLoginPreferenceArgs',
+    'DirectoryLoginPreferenceArgsDict',
+    'DirectoryMfaAuthenticationSettingInfoArgs',
+    'DirectoryMfaAuthenticationSettingInfoArgsDict',
+    'DirectoryPasswordPolicyArgs',
+    'DirectoryPasswordPolicyArgsDict',
     'DirectorySamlIdentityProviderConfigurationArgs',
     'DirectorySamlIdentityProviderConfigurationArgsDict',
+    'DirectorySamlServiceProviderArgs',
+    'DirectorySamlServiceProviderArgsDict',
+    'DirectoryUserProvisioningConfigurationArgs',
+    'DirectoryUserProvisioningConfigurationArgsDict',
 ]
 
 MYPY = False
@@ -94,15 +104,399 @@ class AccessConfigurationPermissionPolicyArgs:
         pulumi.set(self, "permission_policy_document", value)
 
 
+if not MYPY:
+    class DirectoryLoginPreferenceArgsDict(TypedDict):
+        allow_user_to_get_credentials: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        Whether the user can obtain the program access credential in the portal after logging in.
+        """
+        login_network_masks: NotRequired[pulumi.Input[builtins.str]]
+        """
+        IP address whitelist
+        """
+elif False:
+    DirectoryLoginPreferenceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DirectoryLoginPreferenceArgs:
+    def __init__(__self__, *,
+                 allow_user_to_get_credentials: Optional[pulumi.Input[builtins.bool]] = None,
+                 login_network_masks: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.bool] allow_user_to_get_credentials: Whether the user can obtain the program access credential in the portal after logging in.
+        :param pulumi.Input[builtins.str] login_network_masks: IP address whitelist
+        """
+        if allow_user_to_get_credentials is not None:
+            pulumi.set(__self__, "allow_user_to_get_credentials", allow_user_to_get_credentials)
+        if login_network_masks is not None:
+            pulumi.set(__self__, "login_network_masks", login_network_masks)
+
+    @property
+    @pulumi.getter(name="allowUserToGetCredentials")
+    def allow_user_to_get_credentials(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Whether the user can obtain the program access credential in the portal after logging in.
+        """
+        return pulumi.get(self, "allow_user_to_get_credentials")
+
+    @allow_user_to_get_credentials.setter
+    def allow_user_to_get_credentials(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "allow_user_to_get_credentials", value)
+
+    @property
+    @pulumi.getter(name="loginNetworkMasks")
+    def login_network_masks(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        IP address whitelist
+        """
+        return pulumi.get(self, "login_network_masks")
+
+    @login_network_masks.setter
+    def login_network_masks(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "login_network_masks", value)
+
+
+if not MYPY:
+    class DirectoryMfaAuthenticationSettingInfoArgsDict(TypedDict):
+        mfa_authentication_advance_settings: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Global MFA validation policy
+        """
+        operation_for_risk_login: NotRequired[pulumi.Input[builtins.str]]
+        """
+        MFA verification policy for abnormal logon.
+        """
+elif False:
+    DirectoryMfaAuthenticationSettingInfoArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DirectoryMfaAuthenticationSettingInfoArgs:
+    def __init__(__self__, *,
+                 mfa_authentication_advance_settings: Optional[pulumi.Input[builtins.str]] = None,
+                 operation_for_risk_login: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] mfa_authentication_advance_settings: Global MFA validation policy
+        :param pulumi.Input[builtins.str] operation_for_risk_login: MFA verification policy for abnormal logon.
+        """
+        if mfa_authentication_advance_settings is not None:
+            pulumi.set(__self__, "mfa_authentication_advance_settings", mfa_authentication_advance_settings)
+        if operation_for_risk_login is not None:
+            pulumi.set(__self__, "operation_for_risk_login", operation_for_risk_login)
+
+    @property
+    @pulumi.getter(name="mfaAuthenticationAdvanceSettings")
+    def mfa_authentication_advance_settings(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Global MFA validation policy
+        """
+        return pulumi.get(self, "mfa_authentication_advance_settings")
+
+    @mfa_authentication_advance_settings.setter
+    def mfa_authentication_advance_settings(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "mfa_authentication_advance_settings", value)
+
+    @property
+    @pulumi.getter(name="operationForRiskLogin")
+    def operation_for_risk_login(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        MFA verification policy for abnormal logon.
+        """
+        return pulumi.get(self, "operation_for_risk_login")
+
+    @operation_for_risk_login.setter
+    def operation_for_risk_login(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "operation_for_risk_login", value)
+
+
+if not MYPY:
+    class DirectoryPasswordPolicyArgsDict(TypedDict):
+        hard_expire: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        Whether to restrict login after Password Expiration
+        """
+        max_login_attempts: NotRequired[pulumi.Input[builtins.int]]
+        """
+        Number of password retries.
+        """
+        max_password_age: NotRequired[pulumi.Input[builtins.int]]
+        """
+        Password validity period.
+        """
+        max_password_length: NotRequired[pulumi.Input[builtins.int]]
+        """
+        Maximum password length.
+        """
+        min_password_different_chars: NotRequired[pulumi.Input[builtins.int]]
+        """
+        The minimum number of different characters in a password.
+        """
+        min_password_length: NotRequired[pulumi.Input[builtins.int]]
+        """
+        Minimum password length.
+        """
+        password_not_contain_username: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        Whether the user name is not allowed in the password.
+        """
+        password_reuse_prevention: NotRequired[pulumi.Input[builtins.int]]
+        """
+        Historical password check policy.
+        """
+        require_lower_case_chars: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        Whether lowercase letters are required in the password.
+        """
+        require_numbers: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        Whether numbers are required in the password.
+        """
+        require_symbols: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        Whether symbols are required in the password.
+        """
+        require_upper_case_chars: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        Whether uppercase letters are required in the password.
+        """
+elif False:
+    DirectoryPasswordPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DirectoryPasswordPolicyArgs:
+    def __init__(__self__, *,
+                 hard_expire: Optional[pulumi.Input[builtins.bool]] = None,
+                 max_login_attempts: Optional[pulumi.Input[builtins.int]] = None,
+                 max_password_age: Optional[pulumi.Input[builtins.int]] = None,
+                 max_password_length: Optional[pulumi.Input[builtins.int]] = None,
+                 min_password_different_chars: Optional[pulumi.Input[builtins.int]] = None,
+                 min_password_length: Optional[pulumi.Input[builtins.int]] = None,
+                 password_not_contain_username: Optional[pulumi.Input[builtins.bool]] = None,
+                 password_reuse_prevention: Optional[pulumi.Input[builtins.int]] = None,
+                 require_lower_case_chars: Optional[pulumi.Input[builtins.bool]] = None,
+                 require_numbers: Optional[pulumi.Input[builtins.bool]] = None,
+                 require_symbols: Optional[pulumi.Input[builtins.bool]] = None,
+                 require_upper_case_chars: Optional[pulumi.Input[builtins.bool]] = None):
+        """
+        :param pulumi.Input[builtins.bool] hard_expire: Whether to restrict login after Password Expiration
+        :param pulumi.Input[builtins.int] max_login_attempts: Number of password retries.
+        :param pulumi.Input[builtins.int] max_password_age: Password validity period.
+        :param pulumi.Input[builtins.int] max_password_length: Maximum password length.
+        :param pulumi.Input[builtins.int] min_password_different_chars: The minimum number of different characters in a password.
+        :param pulumi.Input[builtins.int] min_password_length: Minimum password length.
+        :param pulumi.Input[builtins.bool] password_not_contain_username: Whether the user name is not allowed in the password.
+        :param pulumi.Input[builtins.int] password_reuse_prevention: Historical password check policy.
+        :param pulumi.Input[builtins.bool] require_lower_case_chars: Whether lowercase letters are required in the password.
+        :param pulumi.Input[builtins.bool] require_numbers: Whether numbers are required in the password.
+        :param pulumi.Input[builtins.bool] require_symbols: Whether symbols are required in the password.
+        :param pulumi.Input[builtins.bool] require_upper_case_chars: Whether uppercase letters are required in the password.
+        """
+        if hard_expire is not None:
+            pulumi.set(__self__, "hard_expire", hard_expire)
+        if max_login_attempts is not None:
+            pulumi.set(__self__, "max_login_attempts", max_login_attempts)
+        if max_password_age is not None:
+            pulumi.set(__self__, "max_password_age", max_password_age)
+        if max_password_length is not None:
+            pulumi.set(__self__, "max_password_length", max_password_length)
+        if min_password_different_chars is not None:
+            pulumi.set(__self__, "min_password_different_chars", min_password_different_chars)
+        if min_password_length is not None:
+            pulumi.set(__self__, "min_password_length", min_password_length)
+        if password_not_contain_username is not None:
+            pulumi.set(__self__, "password_not_contain_username", password_not_contain_username)
+        if password_reuse_prevention is not None:
+            pulumi.set(__self__, "password_reuse_prevention", password_reuse_prevention)
+        if require_lower_case_chars is not None:
+            pulumi.set(__self__, "require_lower_case_chars", require_lower_case_chars)
+        if require_numbers is not None:
+            pulumi.set(__self__, "require_numbers", require_numbers)
+        if require_symbols is not None:
+            pulumi.set(__self__, "require_symbols", require_symbols)
+        if require_upper_case_chars is not None:
+            pulumi.set(__self__, "require_upper_case_chars", require_upper_case_chars)
+
+    @property
+    @pulumi.getter(name="hardExpire")
+    def hard_expire(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Whether to restrict login after Password Expiration
+        """
+        return pulumi.get(self, "hard_expire")
+
+    @hard_expire.setter
+    def hard_expire(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "hard_expire", value)
+
+    @property
+    @pulumi.getter(name="maxLoginAttempts")
+    def max_login_attempts(self) -> Optional[pulumi.Input[builtins.int]]:
+        """
+        Number of password retries.
+        """
+        return pulumi.get(self, "max_login_attempts")
+
+    @max_login_attempts.setter
+    def max_login_attempts(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "max_login_attempts", value)
+
+    @property
+    @pulumi.getter(name="maxPasswordAge")
+    def max_password_age(self) -> Optional[pulumi.Input[builtins.int]]:
+        """
+        Password validity period.
+        """
+        return pulumi.get(self, "max_password_age")
+
+    @max_password_age.setter
+    def max_password_age(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "max_password_age", value)
+
+    @property
+    @pulumi.getter(name="maxPasswordLength")
+    def max_password_length(self) -> Optional[pulumi.Input[builtins.int]]:
+        """
+        Maximum password length.
+        """
+        return pulumi.get(self, "max_password_length")
+
+    @max_password_length.setter
+    def max_password_length(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "max_password_length", value)
+
+    @property
+    @pulumi.getter(name="minPasswordDifferentChars")
+    def min_password_different_chars(self) -> Optional[pulumi.Input[builtins.int]]:
+        """
+        The minimum number of different characters in a password.
+        """
+        return pulumi.get(self, "min_password_different_chars")
+
+    @min_password_different_chars.setter
+    def min_password_different_chars(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "min_password_different_chars", value)
+
+    @property
+    @pulumi.getter(name="minPasswordLength")
+    def min_password_length(self) -> Optional[pulumi.Input[builtins.int]]:
+        """
+        Minimum password length.
+        """
+        return pulumi.get(self, "min_password_length")
+
+    @min_password_length.setter
+    def min_password_length(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "min_password_length", value)
+
+    @property
+    @pulumi.getter(name="passwordNotContainUsername")
+    def password_not_contain_username(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Whether the user name is not allowed in the password.
+        """
+        return pulumi.get(self, "password_not_contain_username")
+
+    @password_not_contain_username.setter
+    def password_not_contain_username(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "password_not_contain_username", value)
+
+    @property
+    @pulumi.getter(name="passwordReusePrevention")
+    def password_reuse_prevention(self) -> Optional[pulumi.Input[builtins.int]]:
+        """
+        Historical password check policy.
+        """
+        return pulumi.get(self, "password_reuse_prevention")
+
+    @password_reuse_prevention.setter
+    def password_reuse_prevention(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "password_reuse_prevention", value)
+
+    @property
+    @pulumi.getter(name="requireLowerCaseChars")
+    def require_lower_case_chars(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Whether lowercase letters are required in the password.
+        """
+        return pulumi.get(self, "require_lower_case_chars")
+
+    @require_lower_case_chars.setter
+    def require_lower_case_chars(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "require_lower_case_chars", value)
+
+    @property
+    @pulumi.getter(name="requireNumbers")
+    def require_numbers(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Whether numbers are required in the password.
+        """
+        return pulumi.get(self, "require_numbers")
+
+    @require_numbers.setter
+    def require_numbers(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "require_numbers", value)
+
+    @property
+    @pulumi.getter(name="requireSymbols")
+    def require_symbols(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Whether symbols are required in the password.
+        """
+        return pulumi.get(self, "require_symbols")
+
+    @require_symbols.setter
+    def require_symbols(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "require_symbols", value)
+
+    @property
+    @pulumi.getter(name="requireUpperCaseChars")
+    def require_upper_case_chars(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Whether uppercase letters are required in the password.
+        """
+        return pulumi.get(self, "require_upper_case_chars")
+
+    @require_upper_case_chars.setter
+    def require_upper_case_chars(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "require_upper_case_chars", value)
+
+
 if not MYPY:
     class DirectorySamlIdentityProviderConfigurationArgsDict(TypedDict):
+        binding_type: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The Binding method for initiating a SAML request.
+        """
+        certificate_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
+        """
+        Certificate ID list
+        """
+        create_time: NotRequired[pulumi.Input[builtins.str]]
+        """
+        CreateTime
+        """
         encoded_metadata_document: NotRequired[pulumi.Input[builtins.str]]
         """
-        Base64 encoded IdP metadata document. **NOTE:** If the IdP Metadata has been uploaded, no update will be made if this parameter is not specified, otherwise the update will be made according to the parameter content. If IdP Metadata has not been uploaded, and the parameter `sso_status` is `Enabled`, this parameter must be provided. If the IdP Metadata has not been uploaded, and the parameter `sso_status` is `Disabled`, this parameter can be omitted, and the IdP Metadata will remain empty.
+        EncodedMetadataDocument
+        """
+        entity_id: NotRequired[pulumi.Input[builtins.str]]
+        """
+        EntityId
+        """
+        login_url: NotRequired[pulumi.Input[builtins.str]]
+        """
+        LoginUrl
         """
         sso_status: NotRequired[pulumi.Input[builtins.str]]
         """
-        SAML SSO login enabled status. Valid values: `Enabled` or `Disabled`. Default to `Disabled`.
+        SSOStatus
+        """
+        update_time: NotRequired[pulumi.Input[builtins.str]]
+        """
+        UpdateTime
+        """
+        want_request_signed: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        SP Request whether the signature is required
         """
 elif False:
     DirectorySamlIdentityProviderConfigurationArgsDict: TypeAlias = Mapping[str, Any]
@@ -110,22 +504,86 @@ elif False:
 @pulumi.input_type
 class DirectorySamlIdentityProviderConfigurationArgs:
     def __init__(__self__, *,
+                 binding_type: Optional[pulumi.Input[builtins.str]] = None,
+                 certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
+                 create_time: Optional[pulumi.Input[builtins.str]] = None,
                  encoded_metadata_document: Optional[pulumi.Input[builtins.str]] = None,
-                 sso_status: Optional[pulumi.Input[builtins.str]] = None):
+                 entity_id: Optional[pulumi.Input[builtins.str]] = None,
+                 login_url: Optional[pulumi.Input[builtins.str]] = None,
+                 sso_status: Optional[pulumi.Input[builtins.str]] = None,
+                 update_time: Optional[pulumi.Input[builtins.str]] = None,
+                 want_request_signed: Optional[pulumi.Input[builtins.bool]] = None):
         """
-        :param pulumi.Input[builtins.str] encoded_metadata_document: Base64 encoded IdP metadata document. **NOTE:** If the IdP Metadata has been uploaded, no update will be made if this parameter is not specified, otherwise the update will be made according to the parameter content. If IdP Metadata has not been uploaded, and the parameter `sso_status` is `Enabled`, this parameter must be provided. If the IdP Metadata has not been uploaded, and the parameter `sso_status` is `Disabled`, this parameter can be omitted, and the IdP Metadata will remain empty.
-        :param pulumi.Input[builtins.str] sso_status: SAML SSO login enabled status. Valid values: `Enabled` or `Disabled`. Default to `Disabled`.
+        :param pulumi.Input[builtins.str] binding_type: The Binding method for initiating a SAML request.
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] certificate_ids: Certificate ID list
+        :param pulumi.Input[builtins.str] create_time: CreateTime
+        :param pulumi.Input[builtins.str] encoded_metadata_document: EncodedMetadataDocument
+        :param pulumi.Input[builtins.str] entity_id: EntityId
+        :param pulumi.Input[builtins.str] login_url: LoginUrl
+        :param pulumi.Input[builtins.str] sso_status: SSOStatus
+        :param pulumi.Input[builtins.str] update_time: UpdateTime
+        :param pulumi.Input[builtins.bool] want_request_signed: SP Request whether the signature is required
         """
+        if binding_type is not None:
+            pulumi.set(__self__, "binding_type", binding_type)
+        if certificate_ids is not None:
+            pulumi.set(__self__, "certificate_ids", certificate_ids)
+        if create_time is not None:
+            pulumi.set(__self__, "create_time", create_time)
         if encoded_metadata_document is not None:
             pulumi.set(__self__, "encoded_metadata_document", encoded_metadata_document)
+        if entity_id is not None:
+            pulumi.set(__self__, "entity_id", entity_id)
+        if login_url is not None:
+            pulumi.set(__self__, "login_url", login_url)
         if sso_status is not None:
             pulumi.set(__self__, "sso_status", sso_status)
+        if update_time is not None:
+            pulumi.set(__self__, "update_time", update_time)
+        if want_request_signed is not None:
+            pulumi.set(__self__, "want_request_signed", want_request_signed)
+
+    @property
+    @pulumi.getter(name="bindingType")
+    def binding_type(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The Binding method for initiating a SAML request.
+        """
+        return pulumi.get(self, "binding_type")
+
+    @binding_type.setter
+    def binding_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "binding_type", value)
+
+    @property
+    @pulumi.getter(name="certificateIds")
+    def certificate_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
+        """
+        Certificate ID list
+        """
+        return pulumi.get(self, "certificate_ids")
+
+    @certificate_ids.setter
+    def certificate_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
+        pulumi.set(self, "certificate_ids", value)
+
+    @property
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        CreateTime
+        """
+        return pulumi.get(self, "create_time")
+
+    @create_time.setter
+    def create_time(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "create_time", value)
 
     @property
     @pulumi.getter(name="encodedMetadataDocument")
     def encoded_metadata_document(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        Base64 encoded IdP metadata document. **NOTE:** If the IdP Metadata has been uploaded, no update will be made if this parameter is not specified, otherwise the update will be made according to the parameter content. If IdP Metadata has not been uploaded, and the parameter `sso_status` is `Enabled`, this parameter must be provided. If the IdP Metadata has not been uploaded, and the parameter `sso_status` is `Disabled`, this parameter can be omitted, and the IdP Metadata will remain empty.
+        EncodedMetadataDocument
         """
         return pulumi.get(self, "encoded_metadata_document")
 
@@ -133,11 +591,35 @@ class DirectorySamlIdentityProviderConfigurationArgs:
     def encoded_metadata_document(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "encoded_metadata_document", value)
 
+    @property
+    @pulumi.getter(name="entityId")
+    def entity_id(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        EntityId
+        """
+        return pulumi.get(self, "entity_id")
+
+    @entity_id.setter
+    def entity_id(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "entity_id", value)
+
+    @property
+    @pulumi.getter(name="loginUrl")
+    def login_url(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        LoginUrl
+        """
+        return pulumi.get(self, "login_url")
+
+    @login_url.setter
+    def login_url(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "login_url", value)
+
     @property
     @pulumi.getter(name="ssoStatus")
     def sso_status(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        SAML SSO login enabled status. Valid values: `Enabled` or `Disabled`. Default to `Disabled`.
+        SSOStatus
         """
         return pulumi.get(self, "sso_status")
 
@@ -145,4 +627,212 @@ class DirectorySamlIdentityProviderConfigurationArgs:
     def sso_status(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "sso_status", value)
 
+    @property
+    @pulumi.getter(name="updateTime")
+    def update_time(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        UpdateTime
+        """
+        return pulumi.get(self, "update_time")
+
+    @update_time.setter
+    def update_time(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "update_time", value)
+
+    @property
+    @pulumi.getter(name="wantRequestSigned")
+    def want_request_signed(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        SP Request whether the signature is required
+        """
+        return pulumi.get(self, "want_request_signed")
+
+    @want_request_signed.setter
+    def want_request_signed(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "want_request_signed", value)
+
+
+if not MYPY:
+    class DirectorySamlServiceProviderArgsDict(TypedDict):
+        acs_url: NotRequired[pulumi.Input[builtins.str]]
+        """
+        ACS URL of SP.
+        """
+        authn_sign_algo: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Signature algorithms supported by AuthNRequest
+        """
+        certificate_type: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Type of certificate used for signing in the SSO process
+        """
+        encoded_metadata_document: NotRequired[pulumi.Input[builtins.str]]
+        """
+        SP metadata document (Base64 encoding).
+        """
+        entity_id: NotRequired[pulumi.Input[builtins.str]]
+        """
+        SP identity.
+        """
+        support_encrypted_assertion: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        Whether IdP-side encryption of Assertion is supported.
+        """
+elif False:
+    DirectorySamlServiceProviderArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DirectorySamlServiceProviderArgs:
+    def __init__(__self__, *,
+                 acs_url: Optional[pulumi.Input[builtins.str]] = None,
+                 authn_sign_algo: Optional[pulumi.Input[builtins.str]] = None,
+                 certificate_type: Optional[pulumi.Input[builtins.str]] = None,
+                 encoded_metadata_document: Optional[pulumi.Input[builtins.str]] = None,
+                 entity_id: Optional[pulumi.Input[builtins.str]] = None,
+                 support_encrypted_assertion: Optional[pulumi.Input[builtins.bool]] = None):
+        """
+        :param pulumi.Input[builtins.str] acs_url: ACS URL of SP.
+        :param pulumi.Input[builtins.str] authn_sign_algo: Signature algorithms supported by AuthNRequest
+        :param pulumi.Input[builtins.str] certificate_type: Type of certificate used for signing in the SSO process
+        :param pulumi.Input[builtins.str] encoded_metadata_document: SP metadata document (Base64 encoding).
+        :param pulumi.Input[builtins.str] entity_id: SP identity.
+        :param pulumi.Input[builtins.bool] support_encrypted_assertion: Whether IdP-side encryption of Assertion is supported.
+        """
+        if acs_url is not None:
+            pulumi.set(__self__, "acs_url", acs_url)
+        if authn_sign_algo is not None:
+            pulumi.set(__self__, "authn_sign_algo", authn_sign_algo)
+        if certificate_type is not None:
+            pulumi.set(__self__, "certificate_type", certificate_type)
+        if encoded_metadata_document is not None:
+            pulumi.set(__self__, "encoded_metadata_document", encoded_metadata_document)
+        if entity_id is not None:
+            pulumi.set(__self__, "entity_id", entity_id)
+        if support_encrypted_assertion is not None:
+            pulumi.set(__self__, "support_encrypted_assertion", support_encrypted_assertion)
+
+    @property
+    @pulumi.getter(name="acsUrl")
+    def acs_url(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        ACS URL of SP.
+        """
+        return pulumi.get(self, "acs_url")
+
+    @acs_url.setter
+    def acs_url(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "acs_url", value)
+
+    @property
+    @pulumi.getter(name="authnSignAlgo")
+    def authn_sign_algo(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Signature algorithms supported by AuthNRequest
+        """
+        return pulumi.get(self, "authn_sign_algo")
+
+    @authn_sign_algo.setter
+    def authn_sign_algo(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "authn_sign_algo", value)
+
+    @property
+    @pulumi.getter(name="certificateType")
+    def certificate_type(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Type of certificate used for signing in the SSO process
+        """
+        return pulumi.get(self, "certificate_type")
+
+    @certificate_type.setter
+    def certificate_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "certificate_type", value)
+
+    @property
+    @pulumi.getter(name="encodedMetadataDocument")
+    def encoded_metadata_document(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        SP metadata document (Base64 encoding).
+        """
+        return pulumi.get(self, "encoded_metadata_document")
+
+    @encoded_metadata_document.setter
+    def encoded_metadata_document(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "encoded_metadata_document", value)
+
+    @property
+    @pulumi.getter(name="entityId")
+    def entity_id(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        SP identity.
+        """
+        return pulumi.get(self, "entity_id")
+
+    @entity_id.setter
+    def entity_id(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "entity_id", value)
+
+    @property
+    @pulumi.getter(name="supportEncryptedAssertion")
+    def support_encrypted_assertion(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Whether IdP-side encryption of Assertion is supported.
+        """
+        return pulumi.get(self, "support_encrypted_assertion")
+
+    @support_encrypted_assertion.setter
+    def support_encrypted_assertion(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "support_encrypted_assertion", value)
+
+
+if not MYPY:
+    class DirectoryUserProvisioningConfigurationArgsDict(TypedDict):
+        default_landing_page: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The duration of the Session after the user logs in.
+        """
+        session_duration: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The duration of the Session after the user logs in.
+        """
+elif False:
+    DirectoryUserProvisioningConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DirectoryUserProvisioningConfigurationArgs:
+    def __init__(__self__, *,
+                 default_landing_page: Optional[pulumi.Input[builtins.str]] = None,
+                 session_duration: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] default_landing_page: The duration of the Session after the user logs in.
+        :param pulumi.Input[builtins.str] session_duration: The duration of the Session after the user logs in.
+        """
+        if default_landing_page is not None:
+            pulumi.set(__self__, "default_landing_page", default_landing_page)
+        if session_duration is not None:
+            pulumi.set(__self__, "session_duration", session_duration)
+
+    @property
+    @pulumi.getter(name="defaultLandingPage")
+    def default_landing_page(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The duration of the Session after the user logs in.
+        """
+        return pulumi.get(self, "default_landing_page")
+
+    @default_landing_page.setter
+    def default_landing_page(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "default_landing_page", value)
+
+    @property
+    @pulumi.getter(name="sessionDuration")
+    def session_duration(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The duration of the Session after the user logs in.
+        """
+        return pulumi.get(self, "session_duration")
+
+    @session_duration.setter
+    def session_duration(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "session_duration", value)
+