bitwarden-sdk 0.1.0__cp37-none-win_amd64.whl → 1.0.0__cp37-none-win_amd64.whl

bitwarden_sdk/schemas.py

@@ -1,6 +1,6 @@
 from enum import Enum
 from dataclasses import dataclass
-from typing import Optional, Any, List, Dict, TypeVar, Type, cast, Callable
+from typing import Optional, Any, List, TypeVar, Type, cast, Callable
 from uuid import UUID
 from datetime import datetime
 import dateutil.parser
@@ -34,6 +34,11 @@ def to_enum(c: Type[EnumT], x: Any) -> EnumT:
     return x.value
 
 
+def from_bool(x: Any) -> bool:
+    assert isinstance(x, bool)
+    return x
+
+
 def from_int(x: Any) -> int:
     assert isinstance(x, int) and not isinstance(x, bool)
     return x
@@ -44,11 +49,6 @@ def to_class(c: Type[T], x: Any) -> dict:
     return cast(Any, x).to_dict()
 
 
-def from_bool(x: Any) -> bool:
-    assert isinstance(x, bool)
-    return x
-
-
 def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
     assert isinstance(x, list)
     return [f(y) for y in x]
@@ -58,13 +58,9 @@ def from_datetime(x: Any) -> datetime:
     return dateutil.parser.parse(x)
 
 
-def from_dict(f: Callable[[Any], T], x: Any) -> Dict[str, T]:
-    assert isinstance(x, dict)
-    return { k: f(v) for (k, v) in x.items() }
-
-
 class DeviceType(Enum):
     """Device type to send to Bitwarden. Defaults to SDK"""
+
     ANDROID = "Android"
     ANDROID_AMAZON = "AndroidAmazon"
     CHROME_BROWSER = "ChromeBrowser"
@@ -97,15 +93,17 @@ class ClientSettings:
     
     Defaults to
     
-    ``` # use bitwarden::client::client_settings::{ClientSettings, DeviceType}; let settings
-    = ClientSettings { identity_url: "https://identity.bitwarden.com".to_string(), api_url:
+    ``` # use bitwarden_core::{ClientSettings, DeviceType}; let settings = ClientSettings {
+    identity_url: "https://identity.bitwarden.com".to_string(), api_url:
     "https://api.bitwarden.com".to_string(), user_agent: "Bitwarden Rust-SDK".to_string(),
     device_type: DeviceType::SDK, }; let default = ClientSettings::default(); ```
     """
     api_url: Optional[str] = None
     """The api url of the targeted Bitwarden instance. Defaults to `https://api.bitwarden.com`"""
+
     device_type: Optional[DeviceType] = None
     """Device type to send to Bitwarden. Defaults to SDK"""
+
     identity_url: Optional[str] = None
     """The identity url of the targeted Bitwarden instance. Defaults to
     `https://identity.bitwarden.com`
@@ -135,35 +133,16 @@ class ClientSettings:
         return result
 
 
-@dataclass
-class AccessTokenLoginRequest:
-    """Login to Bitwarden with access token"""
-    access_token: str
-    """Bitwarden service API access token"""
-    state_file: Optional[str] = None
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'AccessTokenLoginRequest':
-        assert isinstance(obj, dict)
-        access_token = from_str(obj.get("accessToken"))
-        state_file = from_union([from_none, from_str], obj.get("stateFile"))
-        return AccessTokenLoginRequest(access_token, state_file)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["accessToken"] = from_str(self.access_token)
-        if self.state_file is not None:
-            result["stateFile"] = from_union([from_none, from_str], self.state_file)
-        return result
-
-
 @dataclass
 class APIKeyLoginRequest:
     """Login to Bitwarden with Api Key"""
+
     client_id: str
     """Bitwarden account client_id"""
+
     client_secret: str
     """Bitwarden account client_secret"""
+
     password: str
     """Bitwarden account master password"""
 
@@ -187,6 +166,7 @@ class APIKeyLoginRequest:
 class FingerprintRequest:
     fingerprint_material: str
     """The input material, used in the fingerprint generation process."""
+
     public_key: str
     """The user's public key encoded with base64."""
 
@@ -204,6 +184,101 @@ class FingerprintRequest:
         return result
 
 
+@dataclass
+class PasswordGeneratorRequest:
+    """Password generator request options."""
+
+    avoid_ambiguous: bool
+    """When set to true, the generated password will not contain ambiguous characters. The
+    ambiguous characters are: I, O, l, 0, 1
+    """
+    length: int
+    """The length of the generated password. Note that the password length must be greater than
+    the sum of all the minimums.
+    """
+    lowercase: bool
+    """Include lowercase characters (a-z)."""
+
+    numbers: bool
+    """Include numbers (0-9)."""
+
+    special: bool
+    """Include special characters: ! @ # $ % ^ & *"""
+
+    uppercase: bool
+    """Include uppercase characters (A-Z)."""
+
+    min_lowercase: Optional[int] = None
+    """The minimum number of lowercase characters in the generated password. When set, the value
+    must be between 1 and 9. This value is ignored if lowercase is false.
+    """
+    min_number: Optional[int] = None
+    """The minimum number of numbers in the generated password. When set, the value must be
+    between 1 and 9. This value is ignored if numbers is false.
+    """
+    min_special: Optional[int] = None
+    """The minimum number of special characters in the generated password. When set, the value
+    must be between 1 and 9. This value is ignored if special is false.
+    """
+    min_uppercase: Optional[int] = None
+    """The minimum number of uppercase characters in the generated password. When set, the value
+    must be between 1 and 9. This value is ignored if uppercase is false.
+    """
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PasswordGeneratorRequest':
+        assert isinstance(obj, dict)
+        avoid_ambiguous = from_bool(obj.get("avoidAmbiguous"))
+        length = from_int(obj.get("length"))
+        lowercase = from_bool(obj.get("lowercase"))
+        numbers = from_bool(obj.get("numbers"))
+        special = from_bool(obj.get("special"))
+        uppercase = from_bool(obj.get("uppercase"))
+        min_lowercase = from_union([from_none, from_int], obj.get("minLowercase"))
+        min_number = from_union([from_none, from_int], obj.get("minNumber"))
+        min_special = from_union([from_none, from_int], obj.get("minSpecial"))
+        min_uppercase = from_union([from_none, from_int], obj.get("minUppercase"))
+        return PasswordGeneratorRequest(avoid_ambiguous, length, lowercase, numbers, special, uppercase, min_lowercase, min_number, min_special, min_uppercase)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["avoidAmbiguous"] = from_bool(self.avoid_ambiguous)
+        result["length"] = from_int(self.length)
+        result["lowercase"] = from_bool(self.lowercase)
+        result["numbers"] = from_bool(self.numbers)
+        result["special"] = from_bool(self.special)
+        result["uppercase"] = from_bool(self.uppercase)
+        if self.min_lowercase is not None:
+            result["minLowercase"] = from_union([from_none, from_int], self.min_lowercase)
+        if self.min_number is not None:
+            result["minNumber"] = from_union([from_none, from_int], self.min_number)
+        if self.min_special is not None:
+            result["minSpecial"] = from_union([from_none, from_int], self.min_special)
+        if self.min_uppercase is not None:
+            result["minUppercase"] = from_union([from_none, from_int], self.min_uppercase)
+        return result
+
+
+@dataclass
+class GeneratorsCommand:
+    """Generate a password
+    
+    Returns: [String]
+    """
+    generate_password: PasswordGeneratorRequest
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'GeneratorsCommand':
+        assert isinstance(obj, dict)
+        generate_password = PasswordGeneratorRequest.from_dict(obj.get("generatePassword"))
+        return GeneratorsCommand(generate_password)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["generatePassword"] = to_class(PasswordGeneratorRequest, self.generate_password)
+        return result
+
+
 @dataclass
 class SecretVerificationRequest:
     master_password: Optional[str] = None
@@ -232,6 +307,30 @@ class SecretVerificationRequest:
         return result
 
 
+@dataclass
+class AccessTokenLoginRequest:
+    """Login to Bitwarden with access token"""
+
+    access_token: str
+    """Bitwarden service API access token"""
+
+    state_file: Optional[str] = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'AccessTokenLoginRequest':
+        assert isinstance(obj, dict)
+        access_token = from_str(obj.get("accessToken"))
+        state_file = from_union([from_none, from_str], obj.get("stateFile"))
+        return AccessTokenLoginRequest(access_token, state_file)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["accessToken"] = from_str(self.access_token)
+        if self.state_file is not None:
+            result["stateFile"] = from_union([from_none, from_str], self.state_file)
+        return result
+
+
 @dataclass
 class Argon2ID:
     iterations: int
@@ -272,7 +371,13 @@ class PBKDF2:
 
 @dataclass
 class Kdf:
-    """Kdf from prelogin"""
+    """Kdf from prelogin
+    
+    Key Derivation Function for Bitwarden Account
+    
+    In Bitwarden accounts can use multiple KDFs to derive their master key from their
+    password. This Enum represents all the possible KDFs.
+    """
     p_bkdf2: Optional[PBKDF2] = None
     argon2_id: Optional[Argon2ID] = None
 
@@ -294,6 +399,7 @@ class Kdf:
 
 class TwoFactorProvider(Enum):
     """Two-factor provider"""
+
     AUTHENTICATOR = "Authenticator"
     DUO = "Duo"
     EMAIL = "Email"
@@ -308,8 +414,10 @@ class TwoFactorProvider(Enum):
 class TwoFactorRequest:
     provider: TwoFactorProvider
     """Two-factor provider"""
+
     remember: bool
     """Two-factor remember"""
+
     token: str
     """Two-factor Token"""
 
@@ -332,12 +440,16 @@ class TwoFactorRequest:
 @dataclass
 class PasswordLoginRequest:
     """Login to Bitwarden with Username and Password"""
+
     email: str
     """Bitwarden account email address"""
+
     kdf: Kdf
     """Kdf from prelogin"""
+
     password: str
     """Bitwarden account master password"""
+
     two_factor: Optional[TwoFactorRequest] = None
 
     @staticmethod
@@ -434,6 +546,7 @@ class ProjectsListRequest:
 class ProjectPutRequest:
     id: UUID
     """ID of the project to modify"""
+
     name: str
     organization_id: UUID
     """Organization ID of the project to modify"""
@@ -519,6 +632,7 @@ class SecretCreateRequest:
     note: str
     organization_id: UUID
     """Organization where the secret will be created"""
+
     value: str
     project_ids: Optional[List[UUID]] = None
     """IDs of the projects that this secret will belong to"""
@@ -612,14 +726,39 @@ class SecretIdentifiersRequest:
         return result
 
 
+@dataclass
+class SecretsSyncRequest:
+    organization_id: UUID
+    """Organization to sync secrets from"""
+
+    last_synced_date: Optional[datetime] = None
+    """Optional date time a sync last occurred"""
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SecretsSyncRequest':
+        assert isinstance(obj, dict)
+        organization_id = UUID(obj.get("organizationId"))
+        last_synced_date = from_union([from_none, from_datetime], obj.get("lastSyncedDate"))
+        return SecretsSyncRequest(organization_id, last_synced_date)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["organizationId"] = str(self.organization_id)
+        if self.last_synced_date is not None:
+            result["lastSyncedDate"] = from_union([from_none, lambda x: x.isoformat()], self.last_synced_date)
+        return result
+
+
 @dataclass
 class SecretPutRequest:
     id: UUID
     """ID of the secret to modify"""
+
     key: str
     note: str
     organization_id: UUID
     """Organization ID of the secret to modify"""
+
     value: str
     project_ids: Optional[List[UUID]] = None
 
@@ -680,6 +819,13 @@ class SecretsCommand:
     
     Returns:
     [SecretsDeleteResponse](bitwarden::secrets_manager::secrets::SecretsDeleteResponse)
+    
+    > Requires Authentication > Requires using an Access Token for login Retrieve the secrets
+    accessible by the authenticated machine account Optionally, provide the last synced date
+    to assess whether any changes have occurred If changes are detected, retrieves all the
+    secrets accessible by the authenticated machine account
+    
+    Returns: [SecretsSyncResponse](bitwarden::secrets_manager::secrets::SecretsSyncResponse)
     """
     get: Optional[SecretGetRequest] = None
     get_by_ids: Optional[SecretsGetRequest] = None
@@ -687,6 +833,7 @@ class SecretsCommand:
     list: Optional[SecretIdentifiersRequest] = None
     update: Optional[SecretPutRequest] = None
     delete: Optional[SecretsDeleteRequest] = None
+    sync: Optional[SecretsSyncRequest] = None
 
     @staticmethod
     def from_dict(obj: Any) -> 'SecretsCommand':
@@ -697,7 +844,8 @@ class SecretsCommand:
         list = from_union([SecretIdentifiersRequest.from_dict, from_none], obj.get("list"))
         update = from_union([SecretPutRequest.from_dict, from_none], obj.get("update"))
         delete = from_union([SecretsDeleteRequest.from_dict, from_none], obj.get("delete"))
-        return SecretsCommand(get, get_by_ids, create, list, update, delete)
+        sync = from_union([SecretsSyncRequest.from_dict, from_none], obj.get("sync"))
+        return SecretsCommand(get, get_by_ids, create, list, update, delete, sync)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -713,6 +861,8 @@ class SecretsCommand:
             result["update"] = from_union([lambda x: to_class(SecretPutRequest, x), from_none], self.update)
         if self.delete is not None:
             result["delete"] = from_union([lambda x: to_class(SecretsDeleteRequest, x), from_none], self.delete)
+        if self.sync is not None:
+            result["sync"] = from_union([lambda x: to_class(SecretsSyncRequest, x), from_none], self.sync)
         return result
 
 
@@ -769,29 +919,31 @@ class Command:
     > Requires Authentication Retrieve all user data, ciphers and organizations the user is a
     part of
     
-    Returns: [SyncResponse](bitwarden::platform::SyncResponse)
+    Returns: [SyncResponse](bitwarden::vault::SyncResponse)
     """
     password_login: Optional[PasswordLoginRequest] = None
     api_key_login: Optional[APIKeyLoginRequest] = None
-    access_token_login: Optional[AccessTokenLoginRequest] = None
+    login_access_token: Optional[AccessTokenLoginRequest] = None
     get_user_api_key: Optional[SecretVerificationRequest] = None
     fingerprint: Optional[FingerprintRequest] = None
     sync: Optional[SyncRequest] = None
     secrets: Optional[SecretsCommand] = None
     projects: Optional[ProjectsCommand] = None
+    generators: Optional[GeneratorsCommand] = None
 
     @staticmethod
     def from_dict(obj: Any) -> 'Command':
         assert isinstance(obj, dict)
         password_login = from_union([PasswordLoginRequest.from_dict, from_none], obj.get("passwordLogin"))
         api_key_login = from_union([APIKeyLoginRequest.from_dict, from_none], obj.get("apiKeyLogin"))
-        access_token_login = from_union([AccessTokenLoginRequest.from_dict, from_none], obj.get("accessTokenLogin"))
+        login_access_token = from_union([AccessTokenLoginRequest.from_dict, from_none], obj.get("loginAccessToken"))
         get_user_api_key = from_union([SecretVerificationRequest.from_dict, from_none], obj.get("getUserApiKey"))
         fingerprint = from_union([FingerprintRequest.from_dict, from_none], obj.get("fingerprint"))
         sync = from_union([SyncRequest.from_dict, from_none], obj.get("sync"))
         secrets = from_union([SecretsCommand.from_dict, from_none], obj.get("secrets"))
         projects = from_union([ProjectsCommand.from_dict, from_none], obj.get("projects"))
-        return Command(password_login, api_key_login, access_token_login, get_user_api_key, fingerprint, sync, secrets, projects)
+        generators = from_union([GeneratorsCommand.from_dict, from_none], obj.get("generators"))
+        return Command(password_login, api_key_login, login_access_token, get_user_api_key, fingerprint, sync, secrets, projects, generators)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -799,8 +951,8 @@ class Command:
             result["passwordLogin"] = from_union([lambda x: to_class(PasswordLoginRequest, x), from_none], self.password_login)
         if self.api_key_login is not None:
             result["apiKeyLogin"] = from_union([lambda x: to_class(APIKeyLoginRequest, x), from_none], self.api_key_login)
-        if self.access_token_login is not None:
-            result["accessTokenLogin"] = from_union([lambda x: to_class(AccessTokenLoginRequest, x), from_none], self.access_token_login)
+        if self.login_access_token is not None:
+            result["loginAccessToken"] = from_union([lambda x: to_class(AccessTokenLoginRequest, x), from_none], self.login_access_token)
         if self.get_user_api_key is not None:
             result["getUserApiKey"] = from_union([lambda x: to_class(SecretVerificationRequest, x), from_none], self.get_user_api_key)
         if self.fingerprint is not None:
@@ -811,6 +963,8 @@ class Command:
             result["secrets"] = from_union([lambda x: to_class(SecretsCommand, x), from_none], self.secrets)
         if self.projects is not None:
             result["projects"] = from_union([lambda x: to_class(ProjectsCommand, x), from_none], self.projects)
+        if self.generators is not None:
+            result["generators"] = from_union([lambda x: to_class(GeneratorsCommand, x), from_none], self.generators)
         return result
 
 
@@ -914,14 +1068,19 @@ class TwoFactorProviders:
     authenticator: Optional[Authenticator] = None
     duo: Optional[Duo] = None
     """Duo-backed 2fa"""
+
     email: Optional[Email] = None
     """Email 2fa"""
+
     organization_duo: Optional[Duo] = None
     """Duo-backed 2fa operated by an organization the user is a member of"""
+
     remember: Optional[Remember] = None
     """Presence indicates the user has stored this device as bypassing 2fa"""
+
     web_authn: Optional[WebAuthn] = None
     """WebAuthn-backed 2fa"""
+
     yubi_key: Optional[YubiKey] = None
     """Yubikey-backed 2fa"""
 
@@ -961,8 +1120,10 @@ class APIKeyLoginResponse:
     authenticated: bool
     force_password_reset: bool
     """Whether or not the user is required to update their master password"""
+
     reset_master_password: bool
     """TODO: What does this do?"""
+
     two_factor: Optional[TwoFactorProviders] = None
 
     @staticmethod
@@ -988,8 +1149,10 @@ class APIKeyLoginResponse:
 class ResponseForAPIKeyLoginResponse:
     success: bool
     """Whether or not the SDK request succeeded."""
+
     data: Optional[APIKeyLoginResponse] = None
     """The response data. Populated if `success` is true."""
+
     error_message: Optional[str] = None
     """A message for any error that may occur. Populated if `success` is false."""
 
@@ -1033,8 +1196,10 @@ class PasswordLoginResponse:
     authenticated: bool
     force_password_reset: bool
     """Whether or not the user is required to update their master password"""
+
     reset_master_password: bool
     """TODO: What does this do?"""
+
     captcha: Optional[CAPTCHAResponse] = None
     """The information required to present the user with a captcha challenge. Only present when
     authentication fails due to requiring validation of a captcha challenge.
@@ -1070,8 +1235,10 @@ class PasswordLoginResponse:
 class ResponseForPasswordLoginResponse:
     success: bool
     """Whether or not the SDK request succeeded."""
+
     data: Optional[PasswordLoginResponse] = None
     """The response data. Populated if `success` is true."""
+
     error_message: Optional[str] = None
     """A message for any error that may occur. Populated if `success` is false."""
 
@@ -1098,8 +1265,10 @@ class AccessTokenLoginResponse:
     authenticated: bool
     force_password_reset: bool
     """Whether or not the user is required to update their master password"""
+
     reset_master_password: bool
     """TODO: What does this do?"""
+
     two_factor: Optional[TwoFactorProviders] = None
 
     @staticmethod
@@ -1125,8 +1294,10 @@ class AccessTokenLoginResponse:
 class ResponseForAccessTokenLoginResponse:
     success: bool
     """Whether or not the SDK request succeeded."""
+
     data: Optional[AccessTokenLoginResponse] = None
     """The response data. Populated if `success` is true."""
+
     error_message: Optional[str] = None
     """A message for any error that may occur. Populated if `success` is false."""
 
@@ -1190,8 +1361,10 @@ class SecretIdentifiersResponse:
 class ResponseForSecretIdentifiersResponse:
     success: bool
     """Whether or not the SDK request succeeded."""
+
     data: Optional[SecretIdentifiersResponse] = None
     """The response data. Populated if `success` is true."""
+
     error_message: Optional[str] = None
     """A message for any error that may occur. Populated if `success` is false."""
 
@@ -1255,8 +1428,10 @@ class SecretResponse:
 class ResponseForSecretResponse:
     success: bool
     """Whether or not the SDK request succeeded."""
+
     data: Optional[SecretResponse] = None
     """The response data. Populated if `success` is true."""
+
     error_message: Optional[str] = None
     """A message for any error that may occur. Populated if `success` is false."""
 
@@ -1298,8 +1473,10 @@ class SecretsResponse:
 class ResponseForSecretsResponse:
     success: bool
     """Whether or not the SDK request succeeded."""
+
     data: Optional[SecretsResponse] = None
     """The response data. Populated if `success` is true."""
+
     error_message: Optional[str] = None
     """A message for any error that may occur. Populated if `success` is false."""
 
@@ -1361,8 +1538,10 @@ class SecretsDeleteResponse:
 class ResponseForSecretsDeleteResponse:
     success: bool
     """Whether or not the SDK request succeeded."""
+
     data: Optional[SecretsDeleteResponse] = None
     """The response data. Populated if `success` is true."""
+
     error_message: Optional[str] = None
     """A message for any error that may occur. Populated if `success` is false."""
 
@@ -1384,6 +1563,55 @@ class ResponseForSecretsDeleteResponse:
         return result
 
 
+@dataclass
+class SecretsSyncResponse:
+    has_changes: bool
+    secrets: Optional[List[SecretResponse]] = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SecretsSyncResponse':
+        assert isinstance(obj, dict)
+        has_changes = from_bool(obj.get("hasChanges"))
+        secrets = from_union([from_none, lambda x: from_list(SecretResponse.from_dict, x)], obj.get("secrets"))
+        return SecretsSyncResponse(has_changes, secrets)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["hasChanges"] = from_bool(self.has_changes)
+        if self.secrets is not None:
+            result["secrets"] = from_union([from_none, lambda x: from_list(lambda x: to_class(SecretResponse, x), x)], self.secrets)
+        return result
+
+
+@dataclass
+class ResponseForSecretsSyncResponse:
+    success: bool
+    """Whether or not the SDK request succeeded."""
+
+    data: Optional[SecretsSyncResponse] = None
+    """The response data. Populated if `success` is true."""
+
+    error_message: Optional[str] = None
+    """A message for any error that may occur. Populated if `success` is false."""
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ResponseForSecretsSyncResponse':
+        assert isinstance(obj, dict)
+        success = from_bool(obj.get("success"))
+        data = from_union([SecretsSyncResponse.from_dict, from_none], obj.get("data"))
+        error_message = from_union([from_none, from_str], obj.get("errorMessage"))
+        return ResponseForSecretsSyncResponse(success, data, error_message)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["success"] = from_bool(self.success)
+        if self.data is not None:
+            result["data"] = from_union([lambda x: to_class(SecretsSyncResponse, x), from_none], self.data)
+        if self.error_message is not None:
+            result["errorMessage"] = from_union([from_none, from_str], self.error_message)
+        return result
+
+
 @dataclass
 class ProjectResponse:
     creation_date: datetime
@@ -1416,8 +1644,10 @@ class ProjectResponse:
 class ResponseForProjectResponse:
     success: bool
     """Whether or not the SDK request succeeded."""
+
     data: Optional[ProjectResponse] = None
     """The response data. Populated if `success` is true."""
+
     error_message: Optional[str] = None
     """A message for any error that may occur. Populated if `success` is false."""
 
@@ -1459,8 +1689,10 @@ class ProjectsResponse:
 class ResponseForProjectsResponse:
     success: bool
     """Whether or not the SDK request succeeded."""
+
     data: Optional[ProjectsResponse] = None
     """The response data. Populated if `success` is true."""
+
     error_message: Optional[str] = None
     """A message for any error that may occur. Populated if `success` is false."""
 
@@ -1522,8 +1754,10 @@ class ProjectsDeleteResponse:
 class ResponseForProjectsDeleteResponse:
     success: bool
     """Whether or not the SDK request succeeded."""
+
     data: Optional[ProjectsDeleteResponse] = None
     """The response data. Populated if `success` is true."""
+
     error_message: Optional[str] = None
     """A message for any error that may occur. Populated if `success` is false."""
 
@@ -1545,6 +1779,35 @@ class ResponseForProjectsDeleteResponse:
         return result
 
 
+@dataclass
+class ResponseForString:
+    success: bool
+    """Whether or not the SDK request succeeded."""
+
+    data: Optional[str] = None
+    """The response data. Populated if `success` is true."""
+
+    error_message: Optional[str] = None
+    """A message for any error that may occur. Populated if `success` is false."""
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'ResponseForString':
+        assert isinstance(obj, dict)
+        success = from_bool(obj.get("success"))
+        data = from_union([from_none, from_str], obj.get("data"))
+        error_message = from_union([from_none, from_str], obj.get("errorMessage"))
+        return ResponseForString(success, data, error_message)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["success"] = from_bool(self.success)
+        if self.data is not None:
+            result["data"] = from_union([from_none, from_str], self.data)
+        if self.error_message is not None:
+            result["errorMessage"] = from_union([from_none, from_str], self.error_message)
+        return result
+
+
 @dataclass
 class FingerprintResponse:
     fingerprint: str
@@ -1565,8 +1828,10 @@ class FingerprintResponse:
 class ResponseForFingerprintResponse:
     success: bool
     """Whether or not the SDK request succeeded."""
+
     data: Optional[FingerprintResponse] = None
     """The response data. Populated if `success` is true."""
+
     error_message: Optional[str] = None
     """A message for any error that may occur. Populated if `success` is false."""
 
@@ -1596,6 +1861,7 @@ class Attachment:
     size: Optional[str] = None
     size_name: Optional[str] = None
     """Readable size, ex: "4.2 KB" or "1.43 GB\""""
+
     url: Optional[str] = None
 
     @staticmethod
@@ -1833,6 +2099,62 @@ class LocalData:
         return result
 
 
+@dataclass
+class Fido2Credential:
+    counter: str
+    creation_date: datetime
+    credential_id: str
+    discoverable: str
+    key_algorithm: str
+    key_curve: str
+    key_type: str
+    key_value: str
+    rp_id: str
+    rp_name: Optional[str] = None
+    user_display_name: Optional[str] = None
+    user_handle: Optional[str] = None
+    user_name: Optional[str] = None
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Fido2Credential':
+        assert isinstance(obj, dict)
+        counter = from_str(obj.get("counter"))
+        creation_date = from_datetime(obj.get("creationDate"))
+        credential_id = from_str(obj.get("credentialId"))
+        discoverable = from_str(obj.get("discoverable"))
+        key_algorithm = from_str(obj.get("keyAlgorithm"))
+        key_curve = from_str(obj.get("keyCurve"))
+        key_type = from_str(obj.get("keyType"))
+        key_value = from_str(obj.get("keyValue"))
+        rp_id = from_str(obj.get("rpId"))
+        rp_name = from_union([from_none, from_str], obj.get("rpName"))
+        user_display_name = from_union([from_none, from_str], obj.get("userDisplayName"))
+        user_handle = from_union([from_none, from_str], obj.get("userHandle"))
+        user_name = from_union([from_none, from_str], obj.get("userName"))
+        return Fido2Credential(counter, creation_date, credential_id, discoverable, key_algorithm, key_curve, key_type, key_value, rp_id, rp_name, user_display_name, user_handle, user_name)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["counter"] = from_str(self.counter)
+        result["creationDate"] = self.creation_date.isoformat()
+        result["credentialId"] = from_str(self.credential_id)
+        result["discoverable"] = from_str(self.discoverable)
+        result["keyAlgorithm"] = from_str(self.key_algorithm)
+        result["keyCurve"] = from_str(self.key_curve)
+        result["keyType"] = from_str(self.key_type)
+        result["keyValue"] = from_str(self.key_value)
+        result["rpId"] = from_str(self.rp_id)
+        if self.rp_name is not None:
+            result["rpName"] = from_union([from_none, from_str], self.rp_name)
+        if self.user_display_name is not None:
+            result["userDisplayName"] = from_union([from_none, from_str], self.user_display_name)
+        if self.user_handle is not None:
+            result["userHandle"] = from_union([from_none, from_str], self.user_handle)
+        if self.user_name is not None:
+            result["userName"] = from_union([from_none, from_str], self.user_name)
+        return result
+
+
 class URIMatchType(Enum):
     DOMAIN = "domain"
     EXACT = "exact"
@@ -1846,13 +2168,15 @@ class URIMatchType(Enum):
 class LoginURI:
     match: Optional[URIMatchType] = None
     uri: Optional[str] = None
+    uri_checksum: Optional[str] = None
 
     @staticmethod
     def from_dict(obj: Any) -> 'LoginURI':
         assert isinstance(obj, dict)
         match = from_union([from_none, URIMatchType], obj.get("match"))
         uri = from_union([from_none, from_str], obj.get("uri"))
-        return LoginURI(match, uri)
+        uri_checksum = from_union([from_none, from_str], obj.get("uriChecksum"))
+        return LoginURI(match, uri, uri_checksum)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -1860,12 +2184,15 @@ class LoginURI:
             result["match"] = from_union([from_none, lambda x: to_enum(URIMatchType, x)], self.match)
         if self.uri is not None:
             result["uri"] = from_union([from_none, from_str], self.uri)
+        if self.uri_checksum is not None:
+            result["uriChecksum"] = from_union([from_none, from_str], self.uri_checksum)
         return result
 
 
 @dataclass
 class Login:
     autofill_on_page_load: Optional[bool] = None
+    fido2_credentials: Optional[List[Fido2Credential]] = None
     password: Optional[str] = None
     password_revision_date: Optional[datetime] = None
     totp: Optional[str] = None
@@ -1876,17 +2203,20 @@ class Login:
     def from_dict(obj: Any) -> 'Login':
         assert isinstance(obj, dict)
         autofill_on_page_load = from_union([from_none, from_bool], obj.get("autofillOnPageLoad"))
+        fido2_credentials = from_union([from_none, lambda x: from_list(Fido2Credential.from_dict, x)], obj.get("fido2Credentials"))
         password = from_union([from_none, from_str], obj.get("password"))
         password_revision_date = from_union([from_none, from_datetime], obj.get("passwordRevisionDate"))
         totp = from_union([from_none, from_str], obj.get("totp"))
         uris = from_union([from_none, lambda x: from_list(LoginURI.from_dict, x)], obj.get("uris"))
         username = from_union([from_none, from_str], obj.get("username"))
-        return Login(autofill_on_page_load, password, password_revision_date, totp, uris, username)
+        return Login(autofill_on_page_load, fido2_credentials, password, password_revision_date, totp, uris, username)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.autofill_on_page_load is not None:
             result["autofillOnPageLoad"] = from_union([from_none, from_bool], self.autofill_on_page_load)
+        if self.fido2_credentials is not None:
+            result["fido2Credentials"] = from_union([from_none, lambda x: from_list(lambda x: to_class(Fido2Credential, x), x)], self.fido2_credentials)
         if self.password is not None:
             result["password"] = from_union([from_none, from_str], self.password)
         if self.password_revision_date is not None:
@@ -2150,50 +2480,6 @@ class Folder:
         return result
 
 
-class PolicyType(Enum):
-    ACTIVATE_AUTOFILL = "ActivateAutofill"
-    DISABLE_PERSONAL_VAULT_EXPORT = "DisablePersonalVaultExport"
-    DISABLE_SEND = "DisableSend"
-    MASTER_PASSWORD = "MasterPassword"
-    MAXIMUM_VAULT_TIMEOUT = "MaximumVaultTimeout"
-    PASSWORD_GENERATOR = "PasswordGenerator"
-    PERSONAL_OWNERSHIP = "PersonalOwnership"
-    REQUIRE_SSO = "RequireSso"
-    RESET_PASSWORD = "ResetPassword"
-    SEND_OPTIONS = "SendOptions"
-    SINGLE_ORG = "SingleOrg"
-    TWO_FACTOR_AUTHENTICATION = "TwoFactorAuthentication"
-
-
-@dataclass
-class Policy:
-    enabled: bool
-    id: UUID
-    organization_id: UUID
-    type: PolicyType
-    data: Optional[Dict[str, Any]] = None
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'Policy':
-        assert isinstance(obj, dict)
-        enabled = from_bool(obj.get("enabled"))
-        id = UUID(obj.get("id"))
-        organization_id = UUID(obj.get("organization_id"))
-        type = PolicyType(obj.get("type"))
-        data = from_union([from_none, lambda x: from_dict(lambda x: x, x)], obj.get("data"))
-        return Policy(enabled, id, organization_id, type, data)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["enabled"] = from_bool(self.enabled)
-        result["id"] = str(self.id)
-        result["organization_id"] = str(self.organization_id)
-        result["type"] = to_enum(PolicyType, self.type)
-        if self.data is not None:
-            result["data"] = from_union([from_none, lambda x: from_dict(lambda x: x, x)], self.data)
-        return result
-
-
 @dataclass
 class ProfileOrganizationResponse:
     id: UUID
@@ -2238,141 +2524,17 @@ class ProfileResponse:
         return result
 
 
-@dataclass
-class SendFile:
-    file_name: str
-    id: Optional[str] = None
-    size: Optional[str] = None
-    size_name: Optional[str] = None
-    """Readable size, ex: "4.2 KB" or "1.43 GB\""""
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'SendFile':
-        assert isinstance(obj, dict)
-        file_name = from_str(obj.get("fileName"))
-        id = from_union([from_none, from_str], obj.get("id"))
-        size = from_union([from_none, from_str], obj.get("size"))
-        size_name = from_union([from_none, from_str], obj.get("sizeName"))
-        return SendFile(file_name, id, size, size_name)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["fileName"] = from_str(self.file_name)
-        if self.id is not None:
-            result["id"] = from_union([from_none, from_str], self.id)
-        if self.size is not None:
-            result["size"] = from_union([from_none, from_str], self.size)
-        if self.size_name is not None:
-            result["sizeName"] = from_union([from_none, from_str], self.size_name)
-        return result
-
-
-@dataclass
-class SendText:
-    hidden: bool
-    text: Optional[str] = None
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'SendText':
-        assert isinstance(obj, dict)
-        hidden = from_bool(obj.get("hidden"))
-        text = from_union([from_none, from_str], obj.get("text"))
-        return SendText(hidden, text)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["hidden"] = from_bool(self.hidden)
-        if self.text is not None:
-            result["text"] = from_union([from_none, from_str], self.text)
-        return result
-
-
-class SendType(Enum):
-    FILE = "File"
-    TEXT = "Text"
-
-
-@dataclass
-class Send:
-    access_count: int
-    deletion_date: datetime
-    disabled: bool
-    hide_email: bool
-    key: str
-    name: str
-    revision_date: datetime
-    type: SendType
-    access_id: Optional[str] = None
-    expiration_date: Optional[datetime] = None
-    file: Optional[SendFile] = None
-    id: Optional[UUID] = None
-    max_access_count: Optional[int] = None
-    notes: Optional[str] = None
-    password: Optional[str] = None
-    text: Optional[SendText] = None
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'Send':
-        assert isinstance(obj, dict)
-        access_count = from_int(obj.get("accessCount"))
-        deletion_date = from_datetime(obj.get("deletionDate"))
-        disabled = from_bool(obj.get("disabled"))
-        hide_email = from_bool(obj.get("hideEmail"))
-        key = from_str(obj.get("key"))
-        name = from_str(obj.get("name"))
-        revision_date = from_datetime(obj.get("revisionDate"))
-        type = SendType(obj.get("type"))
-        access_id = from_union([from_none, from_str], obj.get("accessId"))
-        expiration_date = from_union([from_none, from_datetime], obj.get("expirationDate"))
-        file = from_union([SendFile.from_dict, from_none], obj.get("file"))
-        id = from_union([from_none, lambda x: UUID(x)], obj.get("id"))
-        max_access_count = from_union([from_none, from_int], obj.get("maxAccessCount"))
-        notes = from_union([from_none, from_str], obj.get("notes"))
-        password = from_union([from_none, from_str], obj.get("password"))
-        text = from_union([SendText.from_dict, from_none], obj.get("text"))
-        return Send(access_count, deletion_date, disabled, hide_email, key, name, revision_date, type, access_id, expiration_date, file, id, max_access_count, notes, password, text)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["accessCount"] = from_int(self.access_count)
-        result["deletionDate"] = self.deletion_date.isoformat()
-        result["disabled"] = from_bool(self.disabled)
-        result["hideEmail"] = from_bool(self.hide_email)
-        result["key"] = from_str(self.key)
-        result["name"] = from_str(self.name)
-        result["revisionDate"] = self.revision_date.isoformat()
-        result["type"] = to_enum(SendType, self.type)
-        if self.access_id is not None:
-            result["accessId"] = from_union([from_none, from_str], self.access_id)
-        if self.expiration_date is not None:
-            result["expirationDate"] = from_union([from_none, lambda x: x.isoformat()], self.expiration_date)
-        if self.file is not None:
-            result["file"] = from_union([lambda x: to_class(SendFile, x), from_none], self.file)
-        if self.id is not None:
-            result["id"] = from_union([from_none, lambda x: str(x)], self.id)
-        if self.max_access_count is not None:
-            result["maxAccessCount"] = from_union([from_none, from_int], self.max_access_count)
-        if self.notes is not None:
-            result["notes"] = from_union([from_none, from_str], self.notes)
-        if self.password is not None:
-            result["password"] = from_union([from_none, from_str], self.password)
-        if self.text is not None:
-            result["text"] = from_union([lambda x: to_class(SendText, x), from_none], self.text)
-        return result
-
-
 @dataclass
 class SyncResponse:
     ciphers: List[Cipher]
     """List of ciphers accessible by the user"""
+
     collections: List[Collection]
     folders: List[Folder]
-    policies: List[Policy]
     profile: ProfileResponse
     """Data about the user, including their encryption keys and the organizations they are a
     part of
     """
-    sends: List[Send]
     domains: Optional[DomainResponse] = None
 
     @staticmethod
@@ -2381,20 +2543,16 @@ class SyncResponse:
         ciphers = from_list(Cipher.from_dict, obj.get("ciphers"))
         collections = from_list(Collection.from_dict, obj.get("collections"))
         folders = from_list(Folder.from_dict, obj.get("folders"))
-        policies = from_list(Policy.from_dict, obj.get("policies"))
         profile = ProfileResponse.from_dict(obj.get("profile"))
-        sends = from_list(Send.from_dict, obj.get("sends"))
         domains = from_union([DomainResponse.from_dict, from_none], obj.get("domains"))
-        return SyncResponse(ciphers, collections, folders, policies, profile, sends, domains)
+        return SyncResponse(ciphers, collections, folders, profile, domains)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["ciphers"] = from_list(lambda x: to_class(Cipher, x), self.ciphers)
         result["collections"] = from_list(lambda x: to_class(Collection, x), self.collections)
         result["folders"] = from_list(lambda x: to_class(Folder, x), self.folders)
-        result["policies"] = from_list(lambda x: to_class(Policy, x), self.policies)
         result["profile"] = to_class(ProfileResponse, self.profile)
-        result["sends"] = from_list(lambda x: to_class(Send, x), self.sends)
         if self.domains is not None:
             result["domains"] = from_union([lambda x: to_class(DomainResponse, x), from_none], self.domains)
         return result
@@ -2404,8 +2562,10 @@ class SyncResponse:
 class ResponseForSyncResponse:
     success: bool
     """Whether or not the SDK request succeeded."""
+
     data: Optional[SyncResponse] = None
     """The response data. Populated if `success` is true."""
+
     error_message: Optional[str] = None
     """A message for any error that may occur. Populated if `success` is false."""
 
@@ -2484,8 +2644,10 @@ class UserAPIKeyResponse:
 class ResponseForUserAPIKeyResponse:
     success: bool
     """Whether or not the SDK request succeeded."""
+
     data: Optional[UserAPIKeyResponse] = None
     """The response data. Populated if `success` is true."""
+
     error_message: Optional[str] = None
     """A message for any error that may occur. Populated if `success` is false."""
 
@@ -2659,6 +2821,14 @@ def secrets_delete_request_to_dict(x: SecretsDeleteRequest) -> Any:
     return to_class(SecretsDeleteRequest, x)
 
 
+def secrets_sync_request_from_dict(s: Any) -> SecretsSyncRequest:
+    return SecretsSyncRequest.from_dict(s)
+
+
+def secrets_sync_request_to_dict(x: SecretsSyncRequest) -> Any:
+    return to_class(SecretsSyncRequest, x)
+
+
 def projects_command_from_dict(s: Any) -> ProjectsCommand:
     return ProjectsCommand.from_dict(s)
 
@@ -2707,6 +2877,22 @@ def projects_delete_request_to_dict(x: ProjectsDeleteRequest) -> Any:
     return to_class(ProjectsDeleteRequest, x)
 
 
+def generators_command_from_dict(s: Any) -> GeneratorsCommand:
+    return GeneratorsCommand.from_dict(s)
+
+
+def generators_command_to_dict(x: GeneratorsCommand) -> Any:
+    return to_class(GeneratorsCommand, x)
+
+
+def password_generator_request_from_dict(s: Any) -> PasswordGeneratorRequest:
+    return PasswordGeneratorRequest.from_dict(s)
+
+
+def password_generator_request_to_dict(x: PasswordGeneratorRequest) -> Any:
+    return to_class(PasswordGeneratorRequest, x)
+
+
 def response_for_api_key_login_response_from_dict(s: Any) -> ResponseForAPIKeyLoginResponse:
     return ResponseForAPIKeyLoginResponse.from_dict(s)
 
@@ -2899,6 +3085,22 @@ def secret_delete_response_to_dict(x: SecretDeleteResponse) -> Any:
     return to_class(SecretDeleteResponse, x)
 
 
+def response_for_secrets_sync_response_from_dict(s: Any) -> ResponseForSecretsSyncResponse:
+    return ResponseForSecretsSyncResponse.from_dict(s)
+
+
+def response_for_secrets_sync_response_to_dict(x: ResponseForSecretsSyncResponse) -> Any:
+    return to_class(ResponseForSecretsSyncResponse, x)
+
+
+def secrets_sync_response_from_dict(s: Any) -> SecretsSyncResponse:
+    return SecretsSyncResponse.from_dict(s)
+
+
+def secrets_sync_response_to_dict(x: SecretsSyncResponse) -> Any:
+    return to_class(SecretsSyncResponse, x)
+
+
 def response_for_project_response_from_dict(s: Any) -> ResponseForProjectResponse:
     return ResponseForProjectResponse.from_dict(s)
 
@@ -2955,6 +3157,14 @@ def project_delete_response_to_dict(x: ProjectDeleteResponse) -> Any:
     return to_class(ProjectDeleteResponse, x)
 
 
+def response_for_string_from_dict(s: Any) -> ResponseForString:
+    return ResponseForString.from_dict(s)
+
+
+def response_for_string_to_dict(x: ResponseForString) -> Any:
+    return to_class(ResponseForString, x)
+
+
 def response_for_fingerprint_response_from_dict(s: Any) -> ResponseForFingerprintResponse:
     return ResponseForFingerprintResponse.from_dict(s)
 
@@ -3067,6 +3277,14 @@ def uri_match_type_to_dict(x: URIMatchType) -> Any:
     return to_enum(URIMatchType, x)
 
 
+def fido2_credential_from_dict(s: Any) -> Fido2Credential:
+    return Fido2Credential.from_dict(s)
+
+
+def fido2_credential_to_dict(x: Fido2Credential) -> Any:
+    return to_class(Fido2Credential, x)
+
+
 def identity_from_dict(s: Any) -> Identity:
     return Identity.from_dict(s)
 
@@ -3195,54 +3413,6 @@ def global_domains_to_dict(x: GlobalDomains) -> Any:
     return to_class(GlobalDomains, x)
 
 
-def policy_from_dict(s: Any) -> Policy:
-    return Policy.from_dict(s)
-
-
-def policy_to_dict(x: Policy) -> Any:
-    return to_class(Policy, x)
-
-
-def policy_type_from_dict(s: Any) -> PolicyType:
-    return PolicyType(s)
-
-
-def policy_type_to_dict(x: PolicyType) -> Any:
-    return to_enum(PolicyType, x)
-
-
-def send_from_dict(s: Any) -> Send:
-    return Send.from_dict(s)
-
-
-def send_to_dict(x: Send) -> Any:
-    return to_class(Send, x)
-
-
-def send_type_from_dict(s: Any) -> SendType:
-    return SendType(s)
-
-
-def send_type_to_dict(x: SendType) -> Any:
-    return to_enum(SendType, x)
-
-
-def send_file_from_dict(s: Any) -> SendFile:
-    return SendFile.from_dict(s)
-
-
-def send_file_to_dict(x: SendFile) -> Any:
-    return to_class(SendFile, x)
-
-
-def send_text_from_dict(s: Any) -> SendText:
-    return SendText.from_dict(s)
-
-
-def send_text_to_dict(x: SendText) -> Any:
-    return to_class(SendText, x)
-
-
 def response_for_user_api_key_response_from_dict(s: Any) -> ResponseForUserAPIKeyResponse:
     return ResponseForUserAPIKeyResponse.from_dict(s)