ark-sdk-python 1.1.2__py3-none-any.whl → 1.2.0__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.1.2'
+__version__ = '1.2.0'
 
 
 def main():

ark_sdk_python/ark_api.py

@@ -235,3 +235,39 @@ class ArkAPI:
         from ark_sdk_python.services.sm import ArkSMService
 
         return cast(ArkSMService, self.service(ArkSMService))
+
+    @property
+    def pcloud_accounts(self) -> "ArkPCloudAccountsService":
+        """
+        Returns the PCloud Accounts service if the appropriate authenticators were given
+
+        Returns:
+            ArkPCloudAccountsService: _description_
+        """
+        from ark_sdk_python.services.pcloud.accounts import ArkPCloudAccountsService
+
+        return cast(ArkPCloudAccountsService, self.service(ArkPCloudAccountsService))
+
+    @property
+    def pcloud_safes(self) -> "ArkPCloudSafesService":
+        """
+        Returns the PCloud Safes service if the appropriate authenticators were given
+
+        Returns:
+            ArkPCloudSafesService: _description_
+        """
+        from ark_sdk_python.services.pcloud.safes import ArkPCloudSafesService
+
+        return cast(ArkPCloudSafesService, self.service(ArkPCloudSafesService))
+
+    @property
+    def pcloud_platforms(self) -> "ArkPCloudPlatformsService":
+        """
+        Returns the PCloud Platforms service if the appropriate authenticators were given
+
+        Returns:
+            ArkPCloudPlatformsService: _description_
+        """
+        from ark_sdk_python.services.pcloud.platforms import ArkPCloudPlatformsService
+
+        return cast(ArkPCloudPlatformsService, self.service(ArkPCloudPlatformsService))

ark_sdk_python/auth/identity/ark_identity.py

@@ -539,18 +539,21 @@ class ArkIdentity:
             return self.auth_identity(profile, interactive, force)
 
         self.__logger.debug('Attempting to refresh authenticate to Identity')
+        saved_cookies = None
+        if self.__session:
+            saved_cookies = self.__session.cookies.copy()
         self.__session = Session()
         self.__session.verify = self.__verify
         self.__session.headers.update(ArkIdentityFQDNResolver.default_headers())
         decoded_token = get_unverified_claims(self.__session_details.token)
         platform_tenant_id = decoded_token['tenant_id']
-        cookies = {
+        refresh_cookies = {
             f'refreshToken-{platform_tenant_id}': self.__session_details.refresh_token,
             f'idToken-{platform_tenant_id}': self.__session_details.token,
         }
         response = self.__session.post(
             url=f'{self.__identity_url}/OAuth2/RefreshPlatformToken',
-            cookies=cookies,
+            cookies=refresh_cookies,
         )
         if response.status_code != HTTPStatus.OK:
             raise ArkAuthException('Failed to refresh token')
@@ -558,6 +561,8 @@ class ArkIdentity:
         new_refresh_token = response.cookies.get(f'refreshToken-{platform_tenant_id}')
         if not new_token or not new_refresh_token:
             raise ArkAuthException('Failed to retrieve refresh tokens cookies')
+        if saved_cookies:
+            self.__session.cookies = saved_cookies
         self.__session_details.token = new_token
         self.__session_details.refresh_token = new_refresh_token
         self.__session_details.token_lifetime = (

ark_sdk_python/common/env/__init__.py

@@ -9,6 +9,7 @@ from ark_sdk_python.common.env.ark_env_mapping import (
     AwsEnv,
     check_if_identity_generated_suffix,
     get_deploy_env,
+    is_gov_cloud,
 )
 
 __all__ = [
@@ -22,4 +23,5 @@ __all__ = [
     'IDENTITY_TENANT_NAME',
     'SHELL_DOMAIN',
     'ROOT_DOMAIN',
+    'is_gov_cloud',
 ]

ark_sdk_python/common/env/ark_env_mapping.py

@@ -6,6 +6,7 @@ from typing import Dict, Final
 
 class AwsEnv(str, Enum):
     PROD = 'prod'
+    GOV_PROD = 'gov-prod'
 
 
 DEPLOY_ENV: Final[str] = 'DEPLOY_ENV'
@@ -44,3 +45,11 @@ def get_deploy_env() -> AwsEnv:
 def check_if_identity_generated_suffix(tenant_suffix, env: AwsEnv) -> bool:
     pattern = IDENTITY_GENERATED_SUFFIX_PATTERN.get(env)
     return re.match(pattern, tenant_suffix) is not None
+
+
+def is_gov_cloud() -> bool:
+    try:
+        region_name = os.getenv('AWS_REGION') or os.getenv('AWS_DEFAULT_REGION')
+        return region_name.startswith('us-gov')
+    except Exception:
+        return False

ark_sdk_python/examples/list_pcloud_accounts.py

@@ -0,0 +1,20 @@
+import pprint
+
+from ark_sdk_python.auth import ArkISPAuth
+from ark_sdk_python.models.auth import ArkAuthMethod, ArkAuthProfile, ArkSecret, IdentityArkAuthMethodSettings
+from ark_sdk_python.services.pcloud.accounts import ArkPCloudAccountsService
+
+if __name__ == '__main__':
+    isp_auth = ArkISPAuth(cache_authentication=False)
+    isp_auth.authenticate(
+        auth_profile=ArkAuthProfile(
+            username='user@cyberark.cloud.12345',
+            auth_method=ArkAuthMethod.Identity,
+            auth_method_settings=IdentityArkAuthMethodSettings(),
+        ),
+        secret=ArkSecret(secret="CoolPassword"),
+    )
+    accounts_service = ArkPCloudAccountsService(isp_auth=isp_auth)
+    for page in accounts_service.list_accounts():
+        for item in page:
+            pprint.pprint(item.dict())

ark_sdk_python/models/actions/services/__init__.py

@@ -2,17 +2,20 @@ 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_pcloud_exec_action_consts import PCLOUD_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,
+    PCLOUD_ACTIONS,
 ]
 
 __all__ = [
     'IDENTITY_ACTIONS',
     'DPA_ACTIONS',
     'SM_ACTIONS',
+    'PCLOUD_ACTIONS',
     'SUPPORTED_SERVICE_ACTIONS',
 ]

ark_sdk_python/models/actions/services/ark_pcloud_exec_action_consts.py

@@ -0,0 +1,131 @@
+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.pcloud.accounts import (
+    ArkPCloudAccountsFilter,
+    ArkPCloudAddAccount,
+    ArkPCloudChangeAccountCredentials,
+    ArkPCloudDeleteAccount,
+    ArkPCloudGenerateAccountCredentials,
+    ArkPCloudGetAccount,
+    ArkPCloudGetAccountCredentials,
+    ArkPCloudLinkAccount,
+    ArkPCloudListAccountSecretVersions,
+    ArkPCloudReconcileAccountCredentials,
+    ArkPCloudSetAccountNextCredentials,
+    ArkPCloudUnlinkAccount,
+    ArkPCloudUpdateAccount,
+    ArkPCloudUpdateAccountCredentialsInVault,
+    ArkPCloudVerifyAccountCredentials,
+)
+from ark_sdk_python.models.services.pcloud.platforms import (
+    ArkPCloudActivateTargetPlatform,
+    ArkPCloudDeactivateTargetPlatform,
+    ArkPCloudDeleteTargetPlatform,
+    ArkPCloudDuplicateTargetPlatform,
+    ArkPCloudExportPlatform,
+    ArkPCloudExportTargetPlatform,
+    ArkPCloudGetPlatform,
+    ArkPCloudGetTargetPlatform,
+    ArkPCloudImportPlatform,
+    ArkPCloudImportTargetPlatform,
+    ArkPCloudPlatformsFilter,
+    ArkPCloudTargetPlatformsFilter,
+)
+from ark_sdk_python.models.services.pcloud.safes import (
+    ArkPCloudAddSafe,
+    ArkPCloudAddSafeMember,
+    ArkPCloudDeleteSafe,
+    ArkPCloudDeleteSafeMember,
+    ArkPCloudGetSafe,
+    ArkPCloudGetSafeMember,
+    ArkPCloudGetSafeMembersStats,
+    ArkPCloudListSafeMembers,
+    ArkPCloudSafeMembersFilters,
+    ArkPCloudSafesFilters,
+    ArkPCloudUpdateSafe,
+    ArkPCloudUpdateSafeMember,
+)
+
+# PCloud Accounts Definitions
+PCLOUD_ACCOUNTS_ACTION_TO_SCHEMA_MAP: Final[Dict[str, Optional[Type[ArkModel]]]] = {
+    'add-account': ArkPCloudAddAccount,
+    'update-account': ArkPCloudUpdateAccount,
+    'delete-account': ArkPCloudDeleteAccount,
+    'account': ArkPCloudGetAccount,
+    'account-credentials': ArkPCloudGetAccountCredentials,
+    'list-accounts': None,
+    'list-accounts-by': ArkPCloudAccountsFilter,
+    'list-account-secret-versions': ArkPCloudListAccountSecretVersions,
+    'generate-account-credentials': ArkPCloudGenerateAccountCredentials,
+    'verify-account-credentials': ArkPCloudVerifyAccountCredentials,
+    'change-account-credentials': ArkPCloudChangeAccountCredentials,
+    'set-account-next-credentials': ArkPCloudSetAccountNextCredentials,
+    'update-account-credentials-in-vault': ArkPCloudUpdateAccountCredentialsInVault,
+    'reconcile-account-credentials': ArkPCloudReconcileAccountCredentials,
+    'accounts-stats': None,
+    'link-account': ArkPCloudLinkAccount,
+    'unlink-account': ArkPCloudUnlinkAccount,
+}
+PCLOUD_ACCOUNTS_ACTION: Final[ArkServiceActionDefinition] = ArkServiceActionDefinition(
+    action_name='accounts',
+    schemas=PCLOUD_ACCOUNTS_ACTION_TO_SCHEMA_MAP,
+)
+
+# PCloud Safes Definitions
+PCLOUD_SAFES_ACTION_TO_SCHEMA_MAP: Final[Dict[str, Optional[Type[ArkModel]]]] = {
+    'add-safe': ArkPCloudAddSafe,
+    'update-safe': ArkPCloudUpdateSafe,
+    'delete-safe': ArkPCloudDeleteSafe,
+    'safe': ArkPCloudGetSafe,
+    'list-safes': None,
+    'list-safes-by': ArkPCloudSafesFilters,
+    'safes-stats': None,
+    'add-safe-member': ArkPCloudAddSafeMember,
+    'update-safe-member': ArkPCloudUpdateSafeMember,
+    'delete-safe-member': ArkPCloudDeleteSafeMember,
+    'safe-member': ArkPCloudGetSafeMember,
+    'list-safe-members': ArkPCloudListSafeMembers,
+    'list-safe-members-by': ArkPCloudSafeMembersFilters,
+    'safe-members-stats': ArkPCloudGetSafeMembersStats,
+    'safes-members-stats': None,
+}
+PCLOUD_SAFES_ACTION: Final[ArkServiceActionDefinition] = ArkServiceActionDefinition(
+    action_name='safes',
+    schemas=PCLOUD_SAFES_ACTION_TO_SCHEMA_MAP,
+)
+
+# PCloud Platforms Definitions
+PCLOUD_PLATFORMS_ACTION_TO_SCHEMA_MAP: Final[Dict[str, Optional[Type[ArkModel]]]] = {
+    'list-platforms': None,
+    'list-platforms-by': ArkPCloudPlatformsFilter,
+    'import-platform': ArkPCloudImportPlatform,
+    'import-target-platform': ArkPCloudImportTargetPlatform,
+    'export-platform': ArkPCloudExportPlatform,
+    'export-target-platform': ArkPCloudExportTargetPlatform,
+    'platform': ArkPCloudGetPlatform,
+    'platforms-stats': None,
+    'activate-target-platform': ArkPCloudActivateTargetPlatform,
+    'deactivate-target-platform': ArkPCloudDeactivateTargetPlatform,
+    'list-target-platforms': None,
+    'list-target-platforms-by': ArkPCloudTargetPlatformsFilter,
+    'target-platform': ArkPCloudGetTargetPlatform,
+    'delete-target-platform': ArkPCloudDeleteTargetPlatform,
+    'duplicate-target-platform': ArkPCloudDuplicateTargetPlatform,
+    'target-platforms-stats': None,
+}
+PCLOUD_PLATFORMS_ACTION: Final[ArkServiceActionDefinition] = ArkServiceActionDefinition(
+    action_name='platforms',
+    schemas=PCLOUD_PLATFORMS_ACTION_TO_SCHEMA_MAP,
+)
+
+# Service Actions Definition
+PCLOUD_ACTIONS: Final[ArkServiceActionDefinition] = ArkServiceActionDefinition(
+    action_name='pcloud',
+    subactions=[
+        PCLOUD_ACCOUNTS_ACTION,
+        PCLOUD_PLATFORMS_ACTION,
+        PCLOUD_SAFES_ACTION,
+    ],
+)

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

@@ -32,5 +32,9 @@ class ArkDPADBAddSecret(ArkModel):
     iam_access_key_id: Optional[SecretStr] = Field(description='Access key id of the user')
     iam_secret_access_key: Optional[SecretStr] = Field(description='Secret access key of the user')
 
+    # Atlas Secret Type
+    atlas_public_key: Optional[str] = Field(description='Public part of mongo atlas access keys')
+    atlas_private_key: Optional[SecretStr] = Field(description='Private part of mongo atlas access keys')
+
     class Config:
         json_encoders = {SecretStr: lambda v: v.get_secret_value() if v else None}

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

@@ -6,3 +6,4 @@ class ArkDPADBSecretType(str, Enum):
     UsernamePassword = 'username_password'
     IAMUser = 'iam_user'
     CyberArkPAM = 'cyberark_pam'
+    AtlasAccessKeys = 'atlas_access_keys'

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

@@ -13,4 +13,6 @@ class ArkDPADBStoreType(str, Enum):
 SECRET_TYPE_TO_STORE_DICT: Final[Dict[ArkDPADBSecretType, ArkDPADBStoreType]] = {
     ArkDPADBSecretType.UsernamePassword: ArkDPADBStoreType.Managed,
     ArkDPADBSecretType.CyberArkPAM: ArkDPADBStoreType.PAM,
+    ArkDPADBSecretType.IAMUser: ArkDPADBStoreType.Managed,
+    ArkDPADBSecretType.AtlasAccessKeys: ArkDPADBStoreType.Managed,
 }

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

@@ -28,6 +28,10 @@ class ArkDPADBUpdateSecret(ArkModel):
     iam_access_key_id: Optional[SecretStr] = Field(description='Access key id of the user')
     iam_secret_access_key: Optional[SecretStr] = Field(description='Secret access key of the user')
 
+    # Atlas Secret Type
+    atlas_public_key: Optional[str] = Field(description='Public part of mongo atlas access keys')
+    atlas_private_key: Optional[SecretStr] = Field(description='Private part of mongo atlas access keys')
+
     class Config:
         json_encoders = {SecretStr: lambda v: v.get_secret_value() if v else None}
 

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

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

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

@@ -0,0 +1,16 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field, SecretStr
+
+
+class ArkDPADBAtlasAccessKeysSecretData(BaseModel):
+    public_key: str = Field(description='Public part of mongo atlas access keys')
+    private_key: SecretStr = Field(description='Private part of mongo atlas access keys')
+    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 ArkDPADBExposedAtlasAccessKeysSecretData(BaseModel):
+    public_key: str = Field(description='Public part of mongo atlas access keys')

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

@@ -25,6 +25,7 @@ class ArkDPADBAddDatabase(ArkCamelizedModel):
         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')
+    account: Optional[str] = Field(description='Account to be used for provider based databases such as snowflake or atlas')
     provider_engine: ArkDPADBDatabaseEngineType = Field(
         description='Provider engine, will be later deduced to the identifer of the provider'
     )

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

@@ -13,6 +13,7 @@ class ArkDPADBAuthMethodType(str, Enum):
     ADEphemeralUser = 'ad_ephemeral_user'
     LocalEphemeralUser = 'local_ephemeral_user'
     RDSIAMAuthentication = 'rds_iam_authentication'
+    AtlasEphemeralUser = 'atlas_ephemeral_user'
 
 
 class ArkDPADBAuthMethod(ArkCamelizedModel):

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

@@ -24,6 +24,7 @@ class ArkDPADBDatabase(ArkCamelizedModel):
         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')
+    account: Optional[str] = Field(description='Account to be used for provider based databases such as snowflake or atlas')
     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')

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

@@ -25,6 +25,7 @@ class ArkDPADBUpdateDatabase(ArkCamelizedModel):
         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')
+    account: Optional[str] = Field(description='Account to be used for provider based databases such as snowflake or atlas')
     provider_engine: Optional[ArkDPADBDatabaseEngineType] = Field(
         description='Provider engine, will be later deduced to the identifer of the provider'
     )

ark_sdk_python/models/services/pcloud/accounts/__init__.py

@@ -0,0 +1,53 @@
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_account import (
+    ArkPCloudAccount,
+    ArkPCloudAccountRemoteMachinesAccess,
+    ArkPCloudAccountSecretManagement,
+    ArkPCloudAccountSecretType,
+    ArkPCloudBaseAccount,
+)
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_account_credentials import ArkPCloudAccountCredentials
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_account_secret_version import ArkPCloudAccountSecretVersion
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_accounts_filter import ArkPCloudAccountsFilter
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_accounts_stats import ArkPCloudAccountsStats
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_add_account import ArkPCloudAddAccount
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_change_account_credentials import ArkPCloudChangeAccountCredentials
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_delete_account import ArkPCloudDeleteAccount
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_generate_account_credentials import ArkPCloudGenerateAccountCredentials
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_get_account import ArkPCloudGetAccount
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_get_account_credentials import ArkPCloudGetAccountCredentials
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_link_account import ArkPCloudLinkAccount
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_list_account_secret_versions import ArkPCloudListAccountSecretVersions
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_reconcile_account_credentials import ArkPCloudReconcileAccountCredentials
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_set_account_next_credentials import ArkPCloudSetAccountNextCredentials
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_unlink_account import ArkPCloudUnlinkAccount
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_update_account import ArkPCloudUpdateAccount
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_update_account_credentials_in_vault import (
+    ArkPCloudUpdateAccountCredentialsInVault,
+)
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_verify_account_credentias import ArkPCloudVerifyAccountCredentials
+
+__all__ = [
+    'ArkPCloudBaseAccount',
+    'ArkPCloudAccount',
+    'ArkPCloudAccountRemoteMachinesAccess',
+    'ArkPCloudAccountSecretManagement',
+    'ArkPCloudAccountSecretType',
+    'ArkPCloudAccountsFilter',
+    'ArkPCloudAccountsStats',
+    'ArkPCloudAddAccount',
+    'ArkPCloudDeleteAccount',
+    'ArkPCloudGetAccount',
+    'ArkPCloudUpdateAccount',
+    'ArkPCloudAccountSecretVersion',
+    'ArkPCloudListAccountSecretVersions',
+    'ArkPCloudAccountCredentials',
+    'ArkPCloudGenerateAccountCredentials',
+    'ArkPCloudVerifyAccountCredentials',
+    'ArkPCloudChangeAccountCredentials',
+    'ArkPCloudSetAccountNextCredentials',
+    'ArkPCloudUpdateAccountCredentialsInVault',
+    'ArkPCloudReconcileAccountCredentials',
+    'ArkPCloudGetAccountCredentials',
+    'ArkPCloudLinkAccount',
+    'ArkPCloudUnlinkAccount',
+]

ark_sdk_python/models/services/pcloud/accounts/ark_pcloud_account.py

@@ -0,0 +1,53 @@
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import Field, validator
+
+from ark_sdk_python.models import ArkCamelizedModel
+
+
+class ArkPCloudAccountSecretType(str, Enum):
+    Password = "password"
+    Key = "key"
+
+
+class ArkPCloudAccountSecretManagement(ArkCamelizedModel):
+    automatic_management_enabled: Optional[bool] = Field(description='Whether automatic management of the account is enabled or not')
+    manual_management_reason: Optional[str] = Field(description='The reason for disabling automatic management')
+    last_modified_time: Optional[int] = Field(description='Last time the management properties were modified')
+
+
+class ArkPCloudAccountRemoteMachinesAccess(ArkCamelizedModel):
+    remote_machines: Optional[Union[List[str], str]] = Field(description='Remote machines the access of this account is allowed')
+    access_restricted_to_remote_machines: Optional[bool] = Field(
+        description='Whether the access is only restricted to those remote machines'
+    )
+
+    # pylint: disable=no-self-use,no-self-argument
+    @validator('remote_machines')
+    def _validate_remote_machines(remote_machines):
+        # backward compatibility for when remote_machines was a comma separated string
+        if isinstance(remote_machines, str):
+            return remote_machines.split(',')
+        return remote_machines
+
+
+class ArkPCloudBaseAccount(ArkCamelizedModel):
+    name: str = Field(description='Name of the account')
+    safe_name: str = Field(description='Safe name to store the account in')
+    platform_id: Optional[str] = Field(description='Platform id to relate the account to')
+    user_name: Optional[str] = Field(description='Username of the account')
+    address: Optional[str] = Field(description='Address of the account')
+    secret_type: Optional[ArkPCloudAccountSecretType] = Field(description='Type of the secret of the account')
+    platform_account_properties: Optional[Dict[str, Any]] = Field(
+        description='Different properties related to the platform the account is related to'
+    )
+    secret_management: Optional[ArkPCloudAccountSecretManagement] = Field(description='Secret mgmt related properties')
+    remote_machines_access: Optional[ArkPCloudAccountRemoteMachinesAccess] = Field(description='Remote machines access related properties')
+
+
+class ArkPCloudAccount(ArkPCloudBaseAccount):
+    id: str = Field(description='ID of the account')
+    status: Optional[str] = Field(description='Status of the account')
+    created_time: Optional[int] = Field(description='Creation time of the account')
+    category_modification_time: Optional[int] = Field(description='Category modification time of the account')

ark_sdk_python/models/services/pcloud/accounts/ark_pcloud_account_credentials.py

@@ -0,0 +1,11 @@
+from pydantic import Field, SecretStr
+
+from ark_sdk_python.models import ArkModel
+
+
+class ArkPCloudAccountCredentials(ArkModel):
+    account_id: str = Field(description='The id of the account')
+    password: SecretStr = Field(description='The credentials')
+
+    class Config:
+        json_encoders = {SecretStr: lambda v: v.get_secret_value()}

ark_sdk_python/models/services/pcloud/accounts/ark_pcloud_account_secret_version.py

@@ -0,0 +1,12 @@
+from datetime import datetime
+
+from pydantic import Field
+
+from ark_sdk_python.models import ArkCamelizedModel
+
+
+class ArkPCloudAccountSecretVersion(ArkCamelizedModel):
+    is_temporary: bool = Field(description='Whether the secret is permenant or temporary')
+    modification_date: datetime = Field(description='Modification time of the secret')
+    modified_by: str = Field(description='Username who modified the secret')
+    version_id: int = Field(description='Version id of the secret')

ark_sdk_python/models/services/pcloud/accounts/ark_pcloud_accounts_filter.py

@@ -0,0 +1,15 @@
+from typing import Optional
+
+from pydantic import Field
+from typing_extensions import Literal
+
+from ark_sdk_python.models import ArkModel
+
+
+class ArkPCloudAccountsFilter(ArkModel):
+    search: Optional[str] = Field(description='Search by string')
+    search_type: Optional[Literal['contains', 'startswith']] = Field(description='Search type to filter with')
+    sort: Optional[str] = Field(description='Sort results by given key')
+    safe_name: Optional[str] = Field(description='Safe name to filter by')
+    offset: Optional[int] = Field(description='Offset to the accounts list')
+    limit: Optional[int] = Field(description='Limit of results')

ark_sdk_python/models/services/pcloud/accounts/ark_pcloud_accounts_stats.py

@@ -0,0 +1,11 @@
+from typing import Dict
+
+from pydantic import Field
+
+from ark_sdk_python.models import ArkModel
+
+
+class ArkPCloudAccountsStats(ArkModel):
+    accounts_count: int = Field(description='Overall accounts count')
+    accounts_count_by_platform_id: Dict[str, int] = Field(description='Accounts count by platform id')
+    accounts_count_by_safe_name: Dict[str, int] = Field(description='Accounts count by safe name')

ark_sdk_python/models/services/pcloud/accounts/ark_pcloud_add_account.py

@@ -0,0 +1,10 @@
+from pydantic import Field, SecretStr
+
+from ark_sdk_python.models.services.pcloud.accounts.ark_pcloud_account import ArkPCloudBaseAccount
+
+
+class ArkPCloudAddAccount(ArkPCloudBaseAccount):
+    secret: SecretStr = Field(description='The secret of the account')
+
+    class Config:
+        json_encoders = {SecretStr: lambda v: v.get_secret_value()}

ark_sdk_python/models/services/pcloud/accounts/ark_pcloud_change_account_credentials.py

@@ -0,0 +1,7 @@
+from pydantic import Field
+
+from ark_sdk_python.models import ArkModel
+
+
+class ArkPCloudChangeAccountCredentials(ArkModel):
+    account_id: str = Field(description='The id of the account to change the password for')

ark_sdk_python/models/services/pcloud/accounts/ark_pcloud_delete_account.py

@@ -0,0 +1,7 @@
+from pydantic import Field
+
+from ark_sdk_python.models import ArkModel
+
+
+class ArkPCloudDeleteAccount(ArkModel):
+    account_id: str = Field(description='The id of the account to delete')

ark_sdk_python/models/services/pcloud/accounts/ark_pcloud_generate_account_credentials.py

@@ -0,0 +1,7 @@
+from pydantic import Field
+
+from ark_sdk_python.models import ArkModel
+
+
+class ArkPCloudGenerateAccountCredentials(ArkModel):
+    account_id: str = Field(description='The id of the account to generate the password for')

ark_sdk_python/models/services/pcloud/accounts/ark_pcloud_get_account.py

@@ -0,0 +1,7 @@
+from pydantic import Field
+
+from ark_sdk_python.models import ArkModel
+
+
+class ArkPCloudGetAccount(ArkModel):
+    account_id: str = Field(description='The id of the account to retrieve')

ark_sdk_python/models/services/pcloud/accounts/ark_pcloud_get_account_credentials.py

@@ -0,0 +1,16 @@
+from typing import Optional
+
+from pydantic import Field
+from typing_extensions import Literal
+
+from ark_sdk_python.models import ArkModel
+
+
+class ArkPCloudGetAccountCredentials(ArkModel):
+    account_id: str = Field(description='The id of the account to retrieve the credentials for')
+    reason: Optional[str] = Field(description='Reason for retrieving the credentials')
+    ticketing_system_name: Optional[str] = Field(description='Ticketing system name to use for retrieval of the credentials')
+    ticket_id: Optional[str] = Field(description='Ticket id allowing retrieval of the credentials')
+    version: Optional[str] = Field(description='Version of the credentials to retrieve')
+    action_type: Optional[Literal['show', 'copy', 'connect']] = Field(description='Action type of the retrieval', default='show')
+    machine: Optional[str] = Field(description='The address of the remote machine to connect to with the credentials')

ark_sdk_python/models/services/pcloud/accounts/ark_pcloud_link_account.py

@@ -0,0 +1,11 @@
+from pydantic import Field
+
+from ark_sdk_python.models import ArkCamelizedModel
+
+
+class ArkPCloudLinkAccount(ArkCamelizedModel):
+    account_id: str = Field(description='The id of the account to link')
+    safe: str = Field(description='The safe in which the linked account is stored')
+    extra_password_index: int = Field(description='The linked account extra password index')
+    folder: str = Field(description='Folder of the linked account')
+    name: str = Field(description='The linked account name')