ark-sdk-python 1.0.7__py3-none-any.whl → 1.1.1__py3-none-any.whl

ark_sdk_python/ark.py

@@ -17,7 +17,7 @@ from ark_sdk_python.actions import ArkAction, ArkCacheAction, ArkConfigureAction
 
 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 
-__version__ = '1.0.7'
+__version__ = '1.1.1'
 
 
 def main():

ark_sdk_python/ark_api.py

@@ -80,6 +80,54 @@ class ArkAPI:
         """
         return self.__profile
 
+    @property
+    def identity_directories(self) -> "ArkIdentityDirectoriesService":
+        """
+        Returns the Identity Directories Service if the appropriate authenticators were given
+
+        Returns:
+            ArkIdentityDirectoriesService: _description_
+        """
+        from ark_sdk_python.services.identity.directories import ArkIdentityDirectoriesService
+
+        return cast(ArkIdentityDirectoriesService, self.service(ArkIdentityDirectoriesService))
+
+    @property
+    def identity_policies(self) -> "ArkIdentityPoliciesService":
+        """
+        Returns the Identity Policies Service if the appropriate authenticators were given
+
+        Returns:
+            ArkIdentityPoliciesService: _description_
+        """
+        from ark_sdk_python.services.identity.policies import ArkIdentityPoliciesService
+
+        return cast(ArkIdentityPoliciesService, self.service(ArkIdentityPoliciesService))
+
+    @property
+    def identity_roles(self) -> "ArkIdentityRolesService":
+        """
+        Returns the Identity Roles Service if the appropriate authenticators were given
+
+        Returns:
+            ArkIdentityRolesService: _description_
+        """
+        from ark_sdk_python.services.identity.roles import ArkIdentityRolesService
+
+        return cast(ArkIdentityRolesService, self.service(ArkIdentityRolesService))
+
+    @property
+    def identity_users(self) -> "ArkIdentityUsersService":
+        """
+        Returns the Identity Users Service if the appropriate authenticators were given
+
+        Returns:
+            ArkIdentityUsersService: _description_
+        """
+        from ark_sdk_python.services.identity.users import ArkIdentityUsersService
+
+        return cast(ArkIdentityUsersService, self.service(ArkIdentityUsersService))
+
     @property
     def dpa_workspaces_db(self) -> "ArkDPADBWorkspaceService":
         """

ark_sdk_python/examples/create_identity_resources.py

@@ -0,0 +1,20 @@
+from ark_sdk_python.auth import ArkISPAuth
+from ark_sdk_python.models.auth import ArkAuthMethod, ArkAuthProfile, ArkSecret, IdentityArkAuthMethodSettings
+from ark_sdk_python.models.services.identity.roles import ArkIdentityCreateRole
+from ark_sdk_python.models.services.identity.users import ArkIdentityCreateUser
+from ark_sdk_python.services.identity import ArkIdentityAPI
+
+if __name__ == "__main__":
+    isp_auth = ArkISPAuth()
+    isp_auth.authenticate(
+        auth_profile=ArkAuthProfile(
+            username='CoolUser', auth_method=ArkAuthMethod.Identity, auth_method_settings=IdentityArkAuthMethodSettings()
+        ),
+        secret=ArkSecret(secret='CoolPassword'),
+    )
+
+    # Create an identity service to create some users and roles
+    print('Creating identity roles and users')
+    identity_api = ArkIdentityAPI(isp_auth)
+    identity_api.identity_roles.create_role(ArkIdentityCreateRole(role_name='IT'))
+    identity_api.identity_users.create_user(ArkIdentityCreateUser(username='it_user', password='CoolPassword', roles=['IT']))

ark_sdk_python/examples/default_suffix.py

@@ -0,0 +1,12 @@
+from ark_sdk_python.auth import ArkISPAuth
+from ark_sdk_python.models.ark_profile import ArkProfileLoader
+from ark_sdk_python.models.services.identity.directories import ArkIdentityListDirectoriesEntities
+from ark_sdk_python.services.identity import ArkIdentityAPI
+
+if __name__ == "__main__":
+    isp_auth = ArkISPAuth()
+    isp_auth.authenticate(ArkProfileLoader().load_default_profile())
+    identity_api = ArkIdentityAPI(isp_auth)
+    print(identity_api.identity_directories.tenant_default_suffix())
+    for page in identity_api.identity_directories.list_directories_entities(ArkIdentityListDirectoriesEntities()):
+        print([i.name for i in page.items])

ark_sdk_python/models/actions/services/__init__.py

@@ -1,14 +1,17 @@
 from typing import Any, List
 
 from ark_sdk_python.models.actions.services.ark_dpa_exec_action_consts import DPA_ACTIONS
+from ark_sdk_python.models.actions.services.ark_identity_exec_action_consts import IDENTITY_ACTIONS
 from ark_sdk_python.models.actions.services.ark_sm_exec_action_consts import SM_ACTIONS
 
 SUPPORTED_SERVICE_ACTIONS: List[Any] = [
+    IDENTITY_ACTIONS,
     DPA_ACTIONS,
     SM_ACTIONS,
 ]
 
 __all__ = [
+    'IDENTITY_ACTIONS',
     'DPA_ACTIONS',
     'SM_ACTIONS',
     'SUPPORTED_SERVICE_ACTIONS',

ark_sdk_python/models/actions/services/ark_identity_exec_action_consts.py

@@ -0,0 +1,114 @@
+from typing import Dict, Final, Optional, Type
+
+from ark_sdk_python.models import ArkModel
+from ark_sdk_python.models.actions.ark_service_action_definition import ArkServiceActionDefinition
+from ark_sdk_python.models.services.identity.directories import ArkIdentityListDirectories, ArkIdentityListDirectoriesEntities
+from ark_sdk_python.models.services.identity.policies import (
+    ArkIdentityAddAuthenticationProfile,
+    ArkIdentityAddPolicy,
+    ArkIdentityDisablePolicy,
+    ArkIdentityEnablePolicy,
+    ArkIdentityGetAuthenticationProfile,
+    ArkIdentityGetPolicy,
+    ArkIdentityRemoveAuthenticationProfile,
+    ArkIdentityRemovePolicy,
+)
+from ark_sdk_python.models.services.identity.roles import (
+    ArkIdentityAddAdminRightsToRole,
+    ArkIdentityAddGroupToRole,
+    ArkIdentityAddRoleToRole,
+    ArkIdentityAddUserToRole,
+    ArkIdentityCreateRole,
+    ArkIdentityDeleteRole,
+    ArkIdentityListRoleMembers,
+    ArkIdentityRemoveGroupFromRole,
+    ArkIdentityRemoveRoleFromRole,
+    ArkIdentityRemoveUserFromRole,
+    ArkIdentityRoleIdByName,
+    ArkIdentityUpdateRole,
+)
+from ark_sdk_python.models.services.identity.users import (
+    ArkIdentityCreateUser,
+    ArkIdentityDeleteUser,
+    ArkIdentityResetUserPassword,
+    ArkIdentityUpdateUser,
+    ArkIdentityUserByName,
+    ArkIdentityUserIdByName,
+)
+
+# Identity Definitions
+# Directories
+IDENTITY_DIRECTORIES_ACTION_TO_SCHEMA_MAP: Final[Dict[str, Optional[Type[ArkModel]]]] = {
+    'list-directories': ArkIdentityListDirectories,
+    'list-directories-entities': ArkIdentityListDirectoriesEntities,
+    'tenant-default-suffix': None,
+}
+IDENTITY_DIRECTORIES_ACTIONS: Final[ArkServiceActionDefinition] = ArkServiceActionDefinition(
+    action_name='directories',
+    schemas=IDENTITY_DIRECTORIES_ACTION_TO_SCHEMA_MAP,
+)
+
+# Policies
+IDENTITY_POLICIES_ACTION_TO_SCHEMA_MAP: Final[Dict[str, Optional[Type[ArkModel]]]] = {
+    'add-authentication-profile': ArkIdentityAddAuthenticationProfile,
+    'remove-authentication-profile': ArkIdentityRemoveAuthenticationProfile,
+    'list-authentication-profiles': None,
+    'authentication-profile': ArkIdentityGetAuthenticationProfile,
+    'add-policy': ArkIdentityAddPolicy,
+    'remove-policy': ArkIdentityRemovePolicy,
+    'list-policies': None,
+    'policy': ArkIdentityGetPolicy,
+    'enable-policy': ArkIdentityEnablePolicy,
+    'disable-policy': ArkIdentityDisablePolicy,
+    'enable-default-policy': None,
+    'disable-default-policy': None,
+}
+IDENTITY_POLICIES_ACTIONS: Final[ArkServiceActionDefinition] = ArkServiceActionDefinition(
+    action_name='policies',
+    schemas=IDENTITY_POLICIES_ACTION_TO_SCHEMA_MAP,
+)
+
+# Roles
+IDENTITY_ROLES_ACTION_TO_SCHEMA_MAP: Final[Dict[str, Optional[Type[ArkModel]]]] = {
+    'add-user-to-role': ArkIdentityAddUserToRole,
+    'add-group-to-role': ArkIdentityAddGroupToRole,
+    'add-role-to-role': ArkIdentityAddRoleToRole,
+    'remove-user-from-role': ArkIdentityRemoveUserFromRole,
+    'remove-group-from-role': ArkIdentityRemoveGroupFromRole,
+    'remove-role-from-role': ArkIdentityRemoveRoleFromRole,
+    'create-role': ArkIdentityCreateRole,
+    'update-role': ArkIdentityUpdateRole,
+    'delete-role': ArkIdentityDeleteRole,
+    'list-role-members': ArkIdentityListRoleMembers,
+    'add-admin-rights-to-role': ArkIdentityAddAdminRightsToRole,
+    'role-id-by-name': ArkIdentityRoleIdByName,
+}
+IDENTITY_ROLES_ACTIONS: Final[ArkServiceActionDefinition] = ArkServiceActionDefinition(
+    action_name='roles',
+    schemas=IDENTITY_ROLES_ACTION_TO_SCHEMA_MAP,
+)
+
+# Users
+IDENTITY_USERS_ACTION_TO_SCHEMA_MAP: Final[Dict[str, Optional[Type[ArkModel]]]] = {
+    'create-user': ArkIdentityCreateUser,
+    'update-user': ArkIdentityUpdateUser,
+    'delete-user': ArkIdentityDeleteUser,
+    'user-by-name': ArkIdentityUserByName,
+    'user-id-by-name': ArkIdentityUserIdByName,
+    'reset-user-password': ArkIdentityResetUserPassword,
+}
+IDENTITY_USERS_ACTIONS: Final[ArkServiceActionDefinition] = ArkServiceActionDefinition(
+    action_name='users',
+    schemas=IDENTITY_USERS_ACTION_TO_SCHEMA_MAP,
+)
+
+# Service Actions Definition
+IDENTITY_ACTIONS: Final[ArkServiceActionDefinition] = ArkServiceActionDefinition(
+    action_name='identity',
+    subactions=[
+        IDENTITY_DIRECTORIES_ACTIONS,
+        IDENTITY_POLICIES_ACTIONS,
+        IDENTITY_ROLES_ACTIONS,
+        IDENTITY_USERS_ACTIONS,
+    ],
+)

ark_sdk_python/models/common/identity/ark_identity_directory_schemas.py

@@ -94,6 +94,7 @@ class RoleRow(ArkModel):
     id: str = Field(alias='_ID')
     admin_rights: Optional[List[RoleAdminRight]] = Field(alias='AdministrativeRights')
     is_hidden: Optional[bool] = Field(alias='IsHidden')
+    description: Optional[str] = Field(alias='Description')
 
 
 class RoleResult(ArkModel):
@@ -113,6 +114,7 @@ class UserRow(ArkModel):
     directory_service_type: DirectoryService = Field(alias='ServiceType')
     email: Optional[str] = Field(alias='EMail')
     internal_id: Optional[str] = Field(alias='InternalName')
+    description: Optional[str] = Field(alias='Description')
 
 
 class UserResult(ArkModel):

ark_sdk_python/models/services/dpa/policies/db/ark_dpa_db_connection_data.py

@@ -4,11 +4,12 @@ from typing import Dict, List, Optional
 from pydantic import Field
 
 from ark_sdk_python.models.ark_model import ArkCamelizedModel
-from ark_sdk_python.models.services.dpa.policies.db.ark_dpa_db_enums import ArkDPADBMongoDatabaseBuiltinRole, ArkDPADBMongoGlobalBuiltinRole
-
-
-class ArkDPADBBaseAuth(ArkCamelizedModel):
-    pass
+from ark_sdk_python.models.services.dpa.policies.db.ark_dpa_db_enums import (
+    ArkDPADBMongoDatabaseBuiltinRole,
+    ArkDPADBMongoGlobalBuiltinRole,
+    ArkDPADBSqlServerDatabaseBuiltinRole,
+    ArkDPADBSqlServerGlobalBuiltinRole,
+)
 
 
 class ArkDPADBResourceIdentifierType(str, Enum):
@@ -21,29 +22,46 @@ class ArkDPADBAppliedTo(ArkCamelizedModel):
     type: ArkDPADBResourceIdentifierType = Field(description='Type of the resource')
 
 
+class ArkDPADBBaseAuth(ArkCamelizedModel):
+    applied_to: Optional[List[ArkDPADBAppliedTo]] = Field(description='Which resources to apply to')
+
+
 class ArkDPADBLDAPAuth(ArkDPADBBaseAuth):
     assign_groups: List[str] = Field(description='LDAP groups to assign the ephemeral user to')
-    applied_to: Optional[List[ArkDPADBAppliedTo]] = Field(description='Which resources to apply to')
 
 
 class ArkDPADBLocalDBAuth(ArkDPADBBaseAuth):
     roles: List[str] = Field(description='Local DB roles to assign the ephemeral user to')
-    applied_to: Optional[List[ArkDPADBAppliedTo]] = Field(description='Which resources to apply to')
 
 
 class ArkDPADBOracleDBAuth(ArkDPADBBaseAuth):
     roles: List[str] = Field(description='Local DB roles to assign the ephemeral user to')
-    applied_to: Optional[List[ArkDPADBAppliedTo]] = Field(description='Which resources to apply to')
     dba_role: bool = Field(description='Whether to apply to the ephemeral user the DBA role', default=False)
     sysdba_role: bool = Field(description='Whether to apply to the ephemeral user the SYSDBA role', default=False)
     sysoper_role: bool = Field(description='Whether to apply to the ephemeral user the SYSOPER role', default=False)
 
 
 class ArkDPADBMongoDBAuth(ArkDPADBBaseAuth):
-    global_builtin_roles: List[ArkDPADBMongoGlobalBuiltinRole] = Field(description='Global builtin roles across all databases')
-    database_builtin_roles: Dict[str, List[ArkDPADBMongoDatabaseBuiltinRole]] = Field(description='Per database builtin roles')
-    database_custom_roles: Dict[str, List[str]] = Field(description='Custom per database roles')
-    applied_to: Optional[List[ArkDPADBAppliedTo]] = Field(description='Which resources to apply to')
+    global_builtin_roles: List[ArkDPADBMongoGlobalBuiltinRole] = Field(
+        description='Global builtin roles across all databases', default_factory=list
+    )
+    database_builtin_roles: Dict[str, List[ArkDPADBMongoDatabaseBuiltinRole]] = Field(
+        description='Per database builtin roles', default_factory=dict
+    )
+    database_custom_roles: Dict[str, List[str]] = Field(description='Custom per database roles', default_factory=dict)
+
+
+class ArkDPADBRDSIAMUserAuth(ArkDPADBBaseAuth):
+    db_user: str = Field(description='The RDS DB User to use for the connection')
+
+
+class ArkDPADBSqlServerAuth(ArkDPADBBaseAuth):
+    global_builtin_roles: List[ArkDPADBSqlServerGlobalBuiltinRole] = Field(description='Global MSSQL built in roles', default_factory=list)
+    global_custom_roles: List[str] = Field(description='Global MSSQL custom roles', default_factory=list)
+    database_builtin_roles: Dict[str, List[ArkDPADBSqlServerDatabaseBuiltinRole]] = Field(
+        description='Per database builtin roles', default_factory=dict
+    )
+    database_custom_roles: Dict[str, List[str]] = Field(alias='Custom per database roles', default_factory=dict)
 
 
 class ArkDPADBConnectAs(ArkCamelizedModel):
@@ -53,3 +71,9 @@ class ArkDPADBConnectAs(ArkCamelizedModel):
     )
     oracle_auth: Optional[List[ArkDPADBOracleDBAuth]] = Field(description='Oracle DB related authentication, only applies to Oracle')
     mongo_auth: Optional[List[ArkDPADBMongoDBAuth]] = Field(description='Mongo DB related authentication, only applies to Mongo')
+    sqlserver_auth: Optional[List[ArkDPADBSqlServerAuth]] = Field(
+        description='SQL Server DB related authentication, only applies to SQL Server using local auth'
+    )
+    rds_iam_user_auth: Optional[List[ArkDPADBRDSIAMUserAuth]] = Field(
+        description='RDS IAM Related Authentication, only applies to RDS related DBs who support IAM Auth'
+    )

ark_sdk_python/models/services/dpa/policies/db/ark_dpa_db_enums.py

@@ -22,3 +22,27 @@ class ArkDPADBMongoDatabaseBuiltinRole(str, Enum):
     DbAdmin = 'dbAdmin'
     ReadWrite = 'readWrite'
     Read = 'read'
+
+
+class ArkDPADBSqlServerGlobalBuiltinRole(str, Enum):
+    SysAdmin = 'sysadmin'
+    ServerAdmin = 'serveradmin'
+    SecurityAdmin = 'securityadmin'
+    ProcessAdmin = 'processadmin'
+    SetupAdmin = 'setupadmin'
+    BulkAdmin = 'bulkadmin'
+    DiskAdmin = 'diskadmin'
+    DbCreator = 'dbcreator'
+    Public = 'public'
+
+
+class ArkDPADBSqlServerDatabaseBuiltinRole(str, Enum):
+    DbOwner = 'db_owner'
+    DbSecurityAdmin = 'db_securityadmin'
+    DbAccessAdmin = 'db_accessadmin'
+    DbBackupOperator = 'db_backupoperator'
+    DbDdlAdmin = 'db_ddladmin'
+    DbDataWriter = 'db_datawriter'
+    DbDataReader = 'db_datareader'
+    DbDenyDataWriter = 'db_denydatawriter'
+    DbDenyDataReader = 'db_denydatareader'

ark_sdk_python/models/services/dpa/secrets/db/ark_dpa_db_secret_type.py

@@ -4,4 +4,5 @@ from enum import Enum
 
 class ArkDPADBSecretType(str, Enum):
     UsernamePassword = 'username_password'
+    IAMUser = 'iam_user'
     CyberArkPAM = 'cyberark_pam'

ark_sdk_python/models/services/dpa/secrets/db/secrets_data/__init__.py

@@ -1,9 +1,13 @@
 from typing import Union
 
+from ark_sdk_python.models.services.dpa.secrets.db.secrets_data.ark_dpa_db_iam_user_secret_data import (
+    ArkDPADBExposedIAMUserSecretData,
+    ArkDPADBIAMUserSecretData,
+)
 from ark_sdk_python.models.services.dpa.secrets.db.secrets_data.ark_dpa_db_user_password_secret_data import (
     ArkDPADBExposedUserPasswordSecretData,
     ArkDPADBUserPasswordSecretData,
 )
 
-ArkDPADBSecretDataTypes = Union[ArkDPADBUserPasswordSecretData]
-ArkDPADBSecretExposedDataTypes = Union[ArkDPADBExposedUserPasswordSecretData]
+ArkDPADBSecretDataTypes = Union[ArkDPADBUserPasswordSecretData, ArkDPADBIAMUserSecretData]
+ArkDPADBSecretExposedDataTypes = Union[ArkDPADBExposedUserPasswordSecretData, ArkDPADBExposedIAMUserSecretData]

ark_sdk_python/models/services/dpa/secrets/db/secrets_data/ark_dpa_db_iam_user_secret_data.py

@@ -0,0 +1,20 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field, SecretStr
+
+
+class ArkDPADBIAMUserSecretData(BaseModel):
+    account: str = Field(description='Account number of the iam user')
+    region: Optional[str] = Field(description='Region associated with the iam user')
+    username: str = Field(description='Username portion in the ARN of the iam user')
+    access_key_id: SecretStr = Field(description='Access key id of the user')
+    secret_access_key: SecretStr = Field(description='Secret access key of the user')
+    metadata: Optional[Dict[str, Any]] = Field(description='Extra secret details')
+
+    class Config:
+        json_encoders = {SecretStr: lambda v: v.get_secret_value() if v else None}
+
+
+class ArkDPADBExposedIAMUserSecretData(BaseModel):
+    account: str = Field(description='Account number of the iam user')
+    username: str = Field(description='Username portion in the ARN of the iam user')

ark_sdk_python/models/services/dpa/workspaces/db/__init__.py

@@ -1,4 +1,10 @@
 from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_add_database import ArkDPADBAddDatabase
+from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_auth_method import (
+    ArkDPADBAuthMethod,
+    ArkDPADBAuthMethodType,
+    ArkDPADBDatabaseAuthMethod,
+    ArkDPADBDatabaseTargetConfiguredAuthMethod,
+)
 from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_database import ArkDPADBDatabase
 from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_database_info import ArkDPADBDatabaseInfo, ArkDPADBDatabaseInfoList
 from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_databases_filter import ArkDPADBDatabasesFilter
@@ -38,4 +44,8 @@ __all__ = [
     'ArkDPADBUpdateDatabase',
     'ArkDPADBWarning',
     'serialize_db_platform_type',
+    'ArkDPADBAuthMethod',
+    'ArkDPADBAuthMethodType',
+    'ArkDPADBDatabaseAuthMethod',
+    'ArkDPADBDatabaseTargetConfiguredAuthMethod',
 ]

ark_sdk_python/models/services/dpa/workspaces/db/ark_dpa_db_add_database.py

@@ -4,6 +4,7 @@ from pydantic import Field, validator
 
 from ark_sdk_python.models.ark_model import ArkCamelizedModel
 from ark_sdk_python.models.common.ark_workspace_type import ArkWorkspaceType
+from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_auth_method import ArkDPADBAuthMethodType
 from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_provider import ArkDPADBDatabaseEngineType
 from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_tag import ArkDPADBTag
 
@@ -14,6 +15,7 @@ class ArkDPADBAddDatabase(ArkCamelizedModel):
     platform: ArkWorkspaceType = Field(
         description='Platform of the database, as in, where it resides, defaulted to on premises', default=ArkWorkspaceType.ONPREM
     )
+    auth_database: str = Field(description='Authentication database used, most commonly used with mongodb', default='admin')
     services: Optional[List[str]] = Field(description='Services related to the database, most commonly used with oracle')
     domain: Optional[str] = Field(description='The domain the DB resides in')
     domain_controller_name: Optional[str] = Field(description='Domain controller name associated to this database')
@@ -33,6 +35,7 @@ class ArkDPADBAddDatabase(ArkCamelizedModel):
     port: Optional[int] = Field(description='Port of the database, if not given, the default one will be used')
     secret_id: Optional[str] = Field(description='Secret identifier stored in the secret service related to this database')
     tags: Optional[List[ArkDPADBTag]] = Field(description='Tags for the database')
+    configured_auth_method_type: Optional[ArkDPADBAuthMethodType] = Field(description='The target configured auth method type')
 
     # pylint: disable=no-self-use,no-self-argument
     @validator('platform')

ark_sdk_python/models/services/dpa/workspaces/db/ark_dpa_db_auth_method.py

@@ -0,0 +1,46 @@
+# pylint: disable=invalid-name
+from enum import Enum
+from typing import Dict, Final, List, Optional
+
+from pydantic import Field
+
+from ark_sdk_python.models.ark_model import ArkCamelizedModel
+from ark_sdk_python.models.common.ark_workspace_type import ArkWorkspaceType
+from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_provider import ArkDPADBDatabaseFamilyType
+
+
+class ArkDPADBAuthMethodType(str, Enum):
+    ADEphemeralUser = 'ad_ephemeral_user'
+    LocalEphemeralUser = 'local_ephemeral_user'
+    RDSIAMAuthentication = 'rds_iam_authentication'
+
+
+class ArkDPADBAuthMethod(ArkCamelizedModel):
+    id: int = Field(description='ID of the authentication method on the database')
+    auth_method_type: ArkDPADBAuthMethodType = Field(description='Type / name of the authentication method')
+    description: str = Field(description='Description about the authentication method')
+    workspaces: List[ArkWorkspaceType] = Field(description='Workspaces this authentication method is used in')
+
+
+class ArkDPADBDatabaseAuthMethod(ArkCamelizedModel):
+    id: int = Field(description='ID of the relation between the authentication method and the database type')
+    provider_family: ArkDPADBDatabaseFamilyType = Field(description='Name of the database family this authentication method is used for')
+    auth_method: ArkDPADBAuthMethodType = Field(description='The actual authentication method')
+    method_enabled: bool = Field(description='Whether this authentication method is enabled or not')
+
+
+class ArkDPADBDatabaseTargetConfiguredAuthMethod(ArkCamelizedModel):
+    database_auth_method: ArkDPADBDatabaseAuthMethod = Field(description='Identifier for the configured auth method')
+    database_target_id: int = Field(description='Database target identifier')
+    configured_auth_method_id: Optional[int] = Field(description='The configured auth method id for the target')
+
+
+DATABASES_FAMILIES_TO_DEFAULT_AUTH_METHOD: Final[Dict[ArkDPADBDatabaseFamilyType, ArkDPADBAuthMethodType]] = {
+    ArkDPADBDatabaseFamilyType.Postgres: ArkDPADBAuthMethodType.LocalEphemeralUser,
+    ArkDPADBDatabaseFamilyType.Oracle: ArkDPADBAuthMethodType.LocalEphemeralUser,
+    ArkDPADBDatabaseFamilyType.MSSQL: ArkDPADBAuthMethodType.ADEphemeralUser,
+    ArkDPADBDatabaseFamilyType.MySQL: ArkDPADBAuthMethodType.LocalEphemeralUser,
+    ArkDPADBDatabaseFamilyType.MariaDB: ArkDPADBAuthMethodType.LocalEphemeralUser,
+    ArkDPADBDatabaseFamilyType.DB2: ArkDPADBAuthMethodType.ADEphemeralUser,
+    ArkDPADBDatabaseFamilyType.Mongo: ArkDPADBAuthMethodType.LocalEphemeralUser,
+}

ark_sdk_python/models/services/dpa/workspaces/db/ark_dpa_db_database.py

@@ -4,6 +4,7 @@ from pydantic import Field, validator
 
 from ark_sdk_python.models.ark_model import ArkCamelizedModel
 from ark_sdk_python.models.common.ark_workspace_type import ArkWorkspaceType
+from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_auth_method import ArkDPADBDatabaseTargetConfiguredAuthMethod
 from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_provider import ArkDPADBDatabaseProvider
 from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_tag import ArkDPADBTag
 
@@ -13,10 +14,16 @@ class ArkDPADBDatabase(ArkCamelizedModel):
     name: str = Field(description='Name of the database, often referenced in policies and other APIs')
     network_name: str = Field(description='Name of the network the database resides in', default='OnPrem')
     platform: Optional[ArkWorkspaceType] = Field(description='Platform of the database, as in, where it resides')
+    auth_database: str = Field(description='Authentication database used, most commonly used with mongodb', default='admin')
     services: List[str] = Field(description='Services related to the database, most commonly used with oracle', default_factory=list)
     domain: Optional[str] = Field(description='The domain the DB resides in')
     domain_controller_name: Optional[str] = Field(description='Domain controller name associated to this database')
     domain_controller_netbios: Optional[str] = Field(description='Domain controller netbios associated to this database')
+    domain_controller_use_ldaps: bool = Field(description='Whether to work with LDAP secure or not', default=False)
+    domain_controller_enable_certificate_validation: bool = Field(
+        description='Whether to enforce certificate validation on TLS comm to the DC', default=True
+    )
+    domain_controller_ldaps_certificate: Optional[str] = Field(description='Certificate id to use for the domain controller TLS comm')
     provider_details: Optional[ArkDPADBDatabaseProvider] = Field(description='Provider details related to the database')
     enable_certificate_validation: bool = Field(description='Whether to enable and enforce certificate validation', default=True)
     certificate: Optional[str] = Field(description='Certificate id used for this database that resides in the certificates service')
@@ -25,6 +32,7 @@ class ArkDPADBDatabase(ArkCamelizedModel):
     port: Optional[int] = Field(description='Port of the database, if not given, the default one will be used')
     secret_id: Optional[str] = Field(description='Secret identifier stored in the secret service related to this database')
     tags: Optional[List[ArkDPADBTag]] = Field(description='Tags for the database')
+    configured_auth_method: Optional[ArkDPADBDatabaseTargetConfiguredAuthMethod] = Field(description='The target configured auth method')
 
     # pylint: disable=no-self-use,no-self-argument
     @validator('platform')

ark_sdk_python/models/services/dpa/workspaces/db/ark_dpa_db_database_info.py

@@ -4,6 +4,7 @@ from pydantic import Field, validator
 
 from ark_sdk_python.models.ark_model import ArkModel
 from ark_sdk_python.models.common.ark_workspace_type import ArkWorkspaceType
+from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_auth_method import ArkDPADBAuthMethodType
 from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_provider import ArkDPADBDatabaseProvider
 
 
@@ -16,6 +17,7 @@ class ArkDPADBDatabaseInfo(ArkModel):
     secret_id: Optional[str] = Field(description='Secret identifier stored in the secret service related to this database')
     platform: Optional[ArkWorkspaceType] = Field(description='Platform of the database, as in, where it resides')
     provider_info: ArkDPADBDatabaseProvider = Field(description='Provider details')
+    configured_auth_method_type: Optional[ArkDPADBAuthMethodType] = Field(description='The target configured auth method type')
 
     # pylint: disable=no-self-use,no-self-argument
     @validator('platform')

ark_sdk_python/models/services/dpa/workspaces/db/ark_dpa_db_databases_filter.py

@@ -3,6 +3,7 @@ from typing import List, Optional
 from pydantic import Field
 
 from ark_sdk_python.models.ark_model import ArkModel
+from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_auth_method import ArkDPADBAuthMethodType
 from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_provider import (
     ArkDPADBDatabaseEngineType,
     ArkDPADBDatabaseFamilyType,
@@ -17,5 +18,6 @@ class ArkDPADBDatabasesFilter(ArkModel):
     provider_family: Optional[ArkDPADBDatabaseFamilyType] = Field(description='List filter by family')
     provider_engine: Optional[ArkDPADBDatabaseEngineType] = Field(description='List filter by engine')
     provider_workspace: Optional[ArkDPADBDatabaseWorkspaceType] = Field(description='List filter by workspace')
+    auth_methods: Optional[List[ArkDPADBAuthMethodType]] = Field(description='Auth method types to filter on')
     tags: Optional[List[ArkDPADBTag]] = Field(description='List filter by tags')
     db_warnings_filter: Optional[ArkDPADBWarning] = Field(description='Filter by databases who are with warnings / incomplete')

ark_sdk_python/models/services/dpa/workspaces/db/ark_dpa_db_databases_stats.py

@@ -3,6 +3,7 @@ from typing import Dict
 from pydantic import Field
 
 from ark_sdk_python.models.ark_model import ArkModel
+from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_auth_method import ArkDPADBAuthMethodType
 from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_provider import (
     ArkDPADBDatabaseEngineType,
     ArkDPADBDatabaseFamilyType,
@@ -18,4 +19,5 @@ class ArkDPADBDatabasesStats(ArkModel):
     databases_count_by_engine: Dict[ArkDPADBDatabaseEngineType, int] = Field(description='Databases count per engine type')
     databases_count_by_family: Dict[ArkDPADBDatabaseFamilyType, int] = Field(description='Databases count per family type')
     databases_count_by_workspace: Dict[ArkDPADBDatabaseWorkspaceType, int] = Field(description='Databases count per workspace type')
+    databases_count_by_auth_method: Dict[ArkDPADBAuthMethodType, int] = Field(description='Databases count per auth type')
     databases_count_by_warning: Dict[ArkDPADBWarning, int] = Field(description='Databases count per warning type')

ark_sdk_python/models/services/dpa/workspaces/db/ark_dpa_db_update_database.py

@@ -4,6 +4,7 @@ from pydantic import Field, root_validator, validator
 
 from ark_sdk_python.models.ark_model import ArkCamelizedModel
 from ark_sdk_python.models.common.ark_workspace_type import ArkWorkspaceType
+from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_auth_method import ArkDPADBAuthMethodType
 from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_provider import ArkDPADBDatabaseEngineType
 from ark_sdk_python.models.services.dpa.workspaces.db.ark_dpa_db_tag import ArkDPADBTag
 
@@ -14,6 +15,7 @@ class ArkDPADBUpdateDatabase(ArkCamelizedModel):
     new_name: Optional[str] = Field(description='New name for the database')
     network_name: Optional[str] = Field(description='Name of the network the database resides in', default='ON-PREMISE')
     platform: Optional[ArkWorkspaceType] = Field(description='Platform of the database, as in, where it resides')
+    auth_database: str = Field(description='Authentication database used, most commonly used with mongodb', default='admin')
     services: Optional[List[str]] = Field(description='Services related to the database, most commonly used with oracle')
     domain: Optional[str] = Field(description='The domain the DB resides in')
     domain_controller_name: Optional[str] = Field(description='Domain controller name associated to this database')
@@ -33,6 +35,7 @@ class ArkDPADBUpdateDatabase(ArkCamelizedModel):
     port: Optional[int] = Field(description='Port of the database, if not given, the default one will be used')
     secret_id: Optional[str] = Field(description='Secret identifier stored in the secret service related to this database')
     tags: Optional[List[ArkDPADBTag]] = Field(description='Tags for the database')
+    configured_auth_method_type: Optional[ArkDPADBAuthMethodType] = Field(description='The target configured auth method type')
 
     # pylint: disable=no-self-use,no-self-argument
     @root_validator

ark_sdk_python/models/services/identity/directories/__init__.py

@@ -0,0 +1,21 @@
+from ark_sdk_python.models.services.identity.directories.ark_identity_directory import ArkIdentityDirectory
+from ark_sdk_python.models.services.identity.directories.ark_identity_entity import (
+    ArkIdentityEntity,
+    ArkIdentityEntityType,
+    ArkIdentityGroupEntity,
+    ArkIdentityRoleEntity,
+    ArkIdentityUserEntity,
+)
+from ark_sdk_python.models.services.identity.directories.ark_identity_list_directories import ArkIdentityListDirectories
+from ark_sdk_python.models.services.identity.directories.ark_identity_list_directories_entities import ArkIdentityListDirectoriesEntities
+
+__all__ = [
+    'ArkIdentityListDirectoriesEntities',
+    'ArkIdentityEntity',
+    'ArkIdentityEntityType',
+    'ArkIdentityGroupEntity',
+    'ArkIdentityRoleEntity',
+    'ArkIdentityUserEntity',
+    'ArkIdentityListDirectories',
+    'ArkIdentityDirectory',
+]

ark_sdk_python/models/services/identity/directories/ark_identity_directory.py

@@ -0,0 +1,9 @@
+from pydantic import Field
+
+from ark_sdk_python.models import ArkModel
+from ark_sdk_python.models.common.identity import DirectoryService
+
+
+class ArkIdentityDirectory(ArkModel):
+    directory: DirectoryService = Field(description='Name of the directory')
+    directory_service_uuid: str = Field(description='ID of the directory')