bitwarden-sdk-secrets 0.1.0 → 1.0.0

data/lib/schemas.rb

@@ -10,7 +10,7 @@
 #   puts device_type == DeviceType::Android
 #
 #   command = Command.from_json! "{…}"
-#   puts command.projects&.delete&.ids.first
+#   puts command.generators&.generate_password.avoid_ambiguous
 #
 #   password_login_request = PasswordLoginRequest.from_json! "{…}"
 #   puts password_login_request.kdf.argon2_id&.iterations.even?
@@ -40,7 +40,7 @@
 #   puts sync_request.exclude_subdomains.nil?
 #
 #   secrets_command = SecretsCommand.from_json! "{…}"
-#   puts secrets_command.delete&.ids.first
+#   puts secrets_command.sync&.last_synced_date.nil?
 #
 #   secret_get_request = SecretGetRequest.from_json! "{…}"
 #   puts secret_get_request.id
@@ -60,6 +60,9 @@
 #   secrets_delete_request = SecretsDeleteRequest.from_json! "{…}"
 #   puts secrets_delete_request.ids.first
 #
+#   secrets_sync_request = SecretsSyncRequest.from_json! "{…}"
+#   puts secrets_sync_request.last_synced_date.nil?
+#
 #   projects_command = ProjectsCommand.from_json! "{…}"
 #   puts projects_command.delete&.ids.first
 #
@@ -78,6 +81,12 @@
 #   projects_delete_request = ProjectsDeleteRequest.from_json! "{…}"
 #   puts projects_delete_request.ids.first
 #
+#   generators_command = GeneratorsCommand.from_json! "{…}"
+#   puts generators_command.generate_password.avoid_ambiguous
+#
+#   password_generator_request = PasswordGeneratorRequest.from_json! "{…}"
+#   puts password_generator_request.avoid_ambiguous
+#
 #   response_for_api_key_login_response = ResponseForAPIKeyLoginResponse.from_json! "{…}"
 #   puts response_for_api_key_login_response.data&.authenticated
 #
@@ -150,6 +159,12 @@
 #   secret_delete_response = SecretDeleteResponse.from_json! "{…}"
 #   puts secret_delete_response.error.nil?
 #
+#   response_for_secrets_sync_response = ResponseForSecretsSyncResponse.from_json! "{…}"
+#   puts response_for_secrets_sync_response.data&.has_changes
+#
+#   secrets_sync_response = SecretsSyncResponse.from_json! "{…}"
+#   puts secrets_sync_response.has_changes
+#
 #   response_for_project_response = ResponseForProjectResponse.from_json! "{…}"
 #   puts response_for_project_response.data&.creation_date
 #
@@ -171,6 +186,9 @@
 #   project_delete_response = ProjectDeleteResponse.from_json! "{…}"
 #   puts project_delete_response.error.nil?
 #
+#   response_for_string = ResponseForString.from_json! "{…}"
+#   puts response_for_string.data.nil?
+#
 #   response_for_fingerprint_response = ResponseForFingerprintResponse.from_json! "{…}"
 #   puts response_for_fingerprint_response.data&.fingerprint
 #
@@ -178,10 +196,10 @@
 #   puts fingerprint_response.fingerprint
 #
 #   response_for_sync_response = ResponseForSyncResponse.from_json! "{…}"
-#   puts response_for_sync_response.data&.sends.first.access_count.even?
+#   puts response_for_sync_response.data&.profile.organizations.first.id
 #
 #   sync_response = SyncResponse.from_json! "{…}"
-#   puts sync_response.sends.first.access_count.even?
+#   puts sync_response.profile.organizations.first.id
 #
 #   profile_response = ProfileResponse.from_json! "{…}"
 #   puts profile_response.organizations.first.id
@@ -213,6 +231,9 @@
 #   uri_match_type = URIMatchType.from_json! "…"
 #   puts uri_match_type == URIMatchType::Domain
 #
+#   fido2_credential = Fido2Credential.from_json! "{…}"
+#   puts fido2_credential.counter
+#
 #   identity = Identity.from_json! "{…}"
 #   puts identity.address1.nil?
 #
@@ -261,24 +282,6 @@
 #   global_domains = GlobalDomains.from_json! "{…}"
 #   puts global_domains.domains.first
 #
-#   policy = Policy.from_json! "{…}"
-#   puts policy.data&["…"]
-#
-#   policy_type = PolicyType.from_json! "…"
-#   puts policy_type == PolicyType::ActivateAutofill
-#
-#   send = Send.from_json! "{…}"
-#   puts send.access_count.even?
-#
-#   send_type = SendType.from_json! "…"
-#   puts send_type == SendType::File
-#
-#   send_file = SendFile.from_json! "{…}"
-#   puts send_file.file_name
-#
-#   send_text = SendText.from_json! "{…}"
-#   puts send_text.hidden
-#
 #   response_for_user_api_key_response = ResponseForUserAPIKeyResponse.from_json! "{…}"
 #   puts response_for_user_api_key_response.data&.api_key
 #
@@ -307,8 +310,6 @@ module Types
   URIMatchType         = Strict::String.enum("domain", "exact", "host", "never", "regularExpression", "startsWith")
   CipherRepromptType   = Strict::String.enum("None", "Password")
   SecureNoteType       = Strict::String.enum("Generic")
-  PolicyType           = Strict::String.enum("ActivateAutofill", "DisablePersonalVaultExport", "DisableSend", "MasterPassword", "MaximumVaultTimeout", "PasswordGenerator", "PersonalOwnership", "RequireSso", "ResetPassword", "SendOptions", "SingleOrg", "TwoFactorAuthentication")
-  SendType             = Strict::String.enum("File", "Text")
   LoginLinkedIDType    = Strict::String.enum("Password", "Username")
   CardLinkedIDType     = Strict::String.enum("Brand", "CardholderName", "Code", "ExpMonth", "ExpYear", "Number")
   IdentityLinkedIDType = Strict::String.enum("Address1", "Address2", "Address3", "City", "Company", "Country", "Email", "FirstName", "FullName", "LastName", "LicenseNumber", "MiddleName", "PassportNumber", "Phone", "PostalCode", "Ssn", "State", "Title", "Username")
@@ -346,8 +347,8 @@ end
 #
 # 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(); ```
 class ClientSettings < Dry::Struct
@@ -393,38 +394,6 @@ class ClientSettings < Dry::Struct
   end
 end
 
-# Login to Bitwarden with access token
-class AccessTokenLoginRequest < Dry::Struct
-
-  # Bitwarden service API access token
-  attribute :access_token, Types::String
-
-  attribute :state_file, Types::String.optional.optional
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      access_token: d.fetch("accessToken"),
-      state_file:   d["stateFile"],
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "accessToken" => access_token,
-      "stateFile"   => state_file,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
 # Login to Bitwarden with Api Key
 class APIKeyLoginRequest < Dry::Struct
 
@@ -495,6 +464,113 @@ class FingerprintRequest < Dry::Struct
   end
 end
 
+# Password generator request options.
+class PasswordGeneratorRequest < Dry::Struct
+
+  # When set to true, the generated password will not contain ambiguous characters. The
+  # ambiguous characters are: I, O, l, 0, 1
+  attribute :avoid_ambiguous, Types::Bool
+
+  # The length of the generated password. Note that the password length must be greater than
+  # the sum of all the minimums.
+  attribute :length, Types::Integer
+
+  # Include lowercase characters (a-z).
+  attribute :lowercase, Types::Bool
+
+  # 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.
+  attribute :min_lowercase, Types::Integer.optional.optional
+
+  # 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.
+  attribute :min_number, Types::Integer.optional.optional
+
+  # 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.
+  attribute :min_special, Types::Integer.optional.optional
+
+  # 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.
+  attribute :min_uppercase, Types::Integer.optional.optional
+
+  # Include numbers (0-9).
+  attribute :numbers, Types::Bool
+
+  # Include special characters: ! @ # $ % ^ & *
+  attribute :special, Types::Bool
+
+  # Include uppercase characters (A-Z).
+  attribute :uppercase, Types::Bool
+
+  def self.from_dynamic!(d)
+    d = Types::Hash[d]
+    new(
+      avoid_ambiguous: d.fetch("avoidAmbiguous"),
+      length:          d.fetch("length"),
+      lowercase:       d.fetch("lowercase"),
+      min_lowercase:   d["minLowercase"],
+      min_number:      d["minNumber"],
+      min_special:     d["minSpecial"],
+      min_uppercase:   d["minUppercase"],
+      numbers:         d.fetch("numbers"),
+      special:         d.fetch("special"),
+      uppercase:       d.fetch("uppercase"),
+    )
+  end
+
+  def self.from_json!(json)
+    from_dynamic!(JSON.parse(json))
+  end
+
+  def to_dynamic
+    {
+      "avoidAmbiguous" => avoid_ambiguous,
+      "length"         => length,
+      "lowercase"      => lowercase,
+      "minLowercase"   => min_lowercase,
+      "minNumber"      => min_number,
+      "minSpecial"     => min_special,
+      "minUppercase"   => min_uppercase,
+      "numbers"        => numbers,
+      "special"        => special,
+      "uppercase"      => uppercase,
+    }
+  end
+
+  def to_json(options = nil)
+    JSON.generate(to_dynamic, options)
+  end
+end
+
+# Generate a password
+#
+# Returns: [String]
+class GeneratorsCommand < Dry::Struct
+  attribute :generate_password, PasswordGeneratorRequest
+
+  def self.from_dynamic!(d)
+    d = Types::Hash[d]
+    new(
+      generate_password: PasswordGeneratorRequest.from_dynamic!(d.fetch("generatePassword")),
+    )
+  end
+
+  def self.from_json!(json)
+    from_dynamic!(JSON.parse(json))
+  end
+
+  def to_dynamic
+    {
+      "generatePassword" => generate_password.to_dynamic,
+    }
+  end
+
+  def to_json(options = nil)
+    JSON.generate(to_dynamic, options)
+  end
+end
+
 class SecretVerificationRequest < Dry::Struct
 
   # The user's master password to use for user verification. If supplied, this will be used
@@ -530,6 +606,38 @@ class SecretVerificationRequest < Dry::Struct
   end
 end
 
+# Login to Bitwarden with access token
+class AccessTokenLoginRequest < Dry::Struct
+
+  # Bitwarden service API access token
+  attribute :access_token, Types::String
+
+  attribute :state_file, Types::String.optional.optional
+
+  def self.from_dynamic!(d)
+    d = Types::Hash[d]
+    new(
+      access_token: d.fetch("accessToken"),
+      state_file:   d["stateFile"],
+    )
+  end
+
+  def self.from_json!(json)
+    from_dynamic!(JSON.parse(json))
+  end
+
+  def to_dynamic
+    {
+      "accessToken" => access_token,
+      "stateFile"   => state_file,
+    }
+  end
+
+  def to_json(options = nil)
+    JSON.generate(to_dynamic, options)
+  end
+end
+
 class Argon2ID < Dry::Struct
   attribute :iterations,  Types::Integer
   attribute :memory,      Types::Integer
@@ -587,6 +695,11 @@ class PBKDF2 < Dry::Struct
 end
 
 # 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.
 class Kdf < Dry::Struct
   attribute :p_bkdf2,   PBKDF2.optional
   attribute :argon2_id, Argon2ID.optional
@@ -1065,6 +1178,38 @@ class SecretIdentifiersRequest < Dry::Struct
   end
 end
 
+class SecretsSyncRequest < Dry::Struct
+
+  # Optional date time a sync last occurred
+  attribute :last_synced_date, Types::String.optional.optional
+
+  # Organization to sync secrets from
+  attribute :organization_id, Types::String
+
+  def self.from_dynamic!(d)
+    d = Types::Hash[d]
+    new(
+      last_synced_date: d["lastSyncedDate"],
+      organization_id:  d.fetch("organizationId"),
+    )
+  end
+
+  def self.from_json!(json)
+    from_dynamic!(JSON.parse(json))
+  end
+
+  def to_dynamic
+    {
+      "lastSyncedDate" => last_synced_date,
+      "organizationId" => organization_id,
+    }
+  end
+
+  def to_json(options = nil)
+    JSON.generate(to_dynamic, options)
+  end
+end
+
 class SecretPutRequest < Dry::Struct
 
   # ID of the secret to modify
@@ -1143,6 +1288,13 @@ end
 #
 # 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)
 class SecretsCommand < Dry::Struct
   attribute :get,        SecretGetRequest.optional
   attribute :get_by_ids, SecretsGetRequest.optional
@@ -1150,6 +1302,7 @@ class SecretsCommand < Dry::Struct
   attribute :list,       SecretIdentifiersRequest.optional
   attribute :update,     SecretPutRequest.optional
   attribute :delete,     SecretsDeleteRequest.optional
+  attribute :sync,       SecretsSyncRequest.optional
 
   def self.from_dynamic!(d)
     d = Types::Hash[d]
@@ -1160,6 +1313,7 @@ class SecretsCommand < Dry::Struct
       list:       d["list"] ? SecretIdentifiersRequest.from_dynamic!(d["list"]) : nil,
       update:     d["update"] ? SecretPutRequest.from_dynamic!(d["update"]) : nil,
       delete:     d["delete"] ? SecretsDeleteRequest.from_dynamic!(d["delete"]) : nil,
+      sync:       d["sync"] ? SecretsSyncRequest.from_dynamic!(d["sync"]) : nil,
     )
   end
 
@@ -1175,6 +1329,7 @@ class SecretsCommand < Dry::Struct
       "list"     => list&.to_dynamic,
       "update"   => update&.to_dynamic,
       "delete"   => delete&.to_dynamic,
+      "sync"     => sync&.to_dynamic,
     }
   end
 
@@ -1243,28 +1398,30 @@ end
 # > 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)
 class Command < Dry::Struct
   attribute :password_login,     PasswordLoginRequest.optional
   attribute :api_key_login,      APIKeyLoginRequest.optional
-  attribute :access_token_login, AccessTokenLoginRequest.optional
+  attribute :login_access_token, AccessTokenLoginRequest.optional
   attribute :get_user_api_key,   SecretVerificationRequest.optional
   attribute :fingerprint,        FingerprintRequest.optional
   attribute :sync,               SyncRequest.optional
   attribute :secrets,            SecretsCommand.optional
   attribute :projects,           ProjectsCommand.optional
+  attribute :generators,         GeneratorsCommand.optional
 
   def self.from_dynamic!(d)
     d = Types::Hash[d]
     new(
       password_login:     d["passwordLogin"] ? PasswordLoginRequest.from_dynamic!(d["passwordLogin"]) : nil,
       api_key_login:      d["apiKeyLogin"] ? APIKeyLoginRequest.from_dynamic!(d["apiKeyLogin"]) : nil,
-      access_token_login: d["accessTokenLogin"] ? AccessTokenLoginRequest.from_dynamic!(d["accessTokenLogin"]) : nil,
+      login_access_token: d["loginAccessToken"] ? AccessTokenLoginRequest.from_dynamic!(d["loginAccessToken"]) : nil,
       get_user_api_key:   d["getUserApiKey"] ? SecretVerificationRequest.from_dynamic!(d["getUserApiKey"]) : nil,
       fingerprint:        d["fingerprint"] ? FingerprintRequest.from_dynamic!(d["fingerprint"]) : nil,
       sync:               d["sync"] ? SyncRequest.from_dynamic!(d["sync"]) : nil,
       secrets:            d["secrets"] ? SecretsCommand.from_dynamic!(d["secrets"]) : nil,
       projects:           d["projects"] ? ProjectsCommand.from_dynamic!(d["projects"]) : nil,
+      generators:         d["generators"] ? GeneratorsCommand.from_dynamic!(d["generators"]) : nil,
     )
   end
 
@@ -1276,12 +1433,13 @@ class Command < Dry::Struct
     {
       "passwordLogin"    => password_login&.to_dynamic,
       "apiKeyLogin"      => api_key_login&.to_dynamic,
-      "accessTokenLogin" => access_token_login&.to_dynamic,
+      "loginAccessToken" => login_access_token&.to_dynamic,
       "getUserApiKey"    => get_user_api_key&.to_dynamic,
       "fingerprint"      => fingerprint&.to_dynamic,
       "sync"             => sync&.to_dynamic,
       "secrets"          => secrets&.to_dynamic,
       "projects"         => projects&.to_dynamic,
+      "generators"       => generators&.to_dynamic,
     }
   end
 
@@ -2084,6 +2242,71 @@ class ResponseForSecretsDeleteResponse < Dry::Struct
   end
 end
 
+class SecretsSyncResponse < Dry::Struct
+  attribute :has_changes, Types::Bool
+  attribute :secrets,     Types.Array(SecretResponse).optional.optional
+
+  def self.from_dynamic!(d)
+    d = Types::Hash[d]
+    new(
+      has_changes: d.fetch("hasChanges"),
+      secrets:     d["secrets"]&.map { |x| SecretResponse.from_dynamic!(x) },
+    )
+  end
+
+  def self.from_json!(json)
+    from_dynamic!(JSON.parse(json))
+  end
+
+  def to_dynamic
+    {
+      "hasChanges" => has_changes,
+      "secrets"    => secrets&.map { |x| x.to_dynamic },
+    }
+  end
+
+  def to_json(options = nil)
+    JSON.generate(to_dynamic, options)
+  end
+end
+
+class ResponseForSecretsSyncResponse < Dry::Struct
+
+  # The response data. Populated if `success` is true.
+  attribute :data, SecretsSyncResponse.optional.optional
+
+  # A message for any error that may occur. Populated if `success` is false.
+  attribute :error_message, Types::String.optional.optional
+
+  # Whether or not the SDK request succeeded.
+  attribute :success, Types::Bool
+
+  def self.from_dynamic!(d)
+    d = Types::Hash[d]
+    new(
+      data:          d["data"] ? SecretsSyncResponse.from_dynamic!(d["data"]) : nil,
+      error_message: d["errorMessage"],
+      success:       d.fetch("success"),
+    )
+  end
+
+  def self.from_json!(json)
+    from_dynamic!(JSON.parse(json))
+  end
+
+  def to_dynamic
+    {
+      "data"         => data&.to_dynamic,
+      "errorMessage" => error_message,
+      "success"      => success,
+    }
+  end
+
+  def to_json(options = nil)
+    JSON.generate(to_dynamic, options)
+  end
+end
+
 class ProjectResponse < Dry::Struct
   attribute :creation_date,         Types::String
   attribute :id,                    Types::String
@@ -2310,6 +2533,43 @@ class ResponseForProjectsDeleteResponse < Dry::Struct
   end
 end
 
+class ResponseForString < Dry::Struct
+
+  # The response data. Populated if `success` is true.
+  attribute :data, Types::String.optional.optional
+
+  # A message for any error that may occur. Populated if `success` is false.
+  attribute :error_message, Types::String.optional.optional
+
+  # Whether or not the SDK request succeeded.
+  attribute :success, Types::Bool
+
+  def self.from_dynamic!(d)
+    d = Types::Hash[d]
+    new(
+      data:          d["data"],
+      error_message: d["errorMessage"],
+      success:       d.fetch("success"),
+    )
+  end
+
+  def self.from_json!(json)
+    from_dynamic!(JSON.parse(json))
+  end
+
+  def to_dynamic
+    {
+      "data"         => data,
+      "errorMessage" => error_message,
+      "success"      => success,
+    }
+  end
+
+  def to_json(options = nil)
+    JSON.generate(to_dynamic, options)
+  end
+end
+
 class FingerprintResponse < Dry::Struct
   attribute :fingerprint, Types::String
 
@@ -2636,6 +2896,67 @@ class LocalData < Dry::Struct
   end
 end
 
+class Fido2Credential < Dry::Struct
+  attribute :counter,           Types::String
+  attribute :creation_date,     Types::String
+  attribute :credential_id,     Types::String
+  attribute :discoverable,      Types::String
+  attribute :key_algorithm,     Types::String
+  attribute :key_curve,         Types::String
+  attribute :key_type,          Types::String
+  attribute :key_value,         Types::String
+  attribute :rp_id,             Types::String
+  attribute :rp_name,           Types::String.optional.optional
+  attribute :user_display_name, Types::String.optional.optional
+  attribute :user_handle,       Types::String.optional.optional
+  attribute :user_name,         Types::String.optional.optional
+
+  def self.from_dynamic!(d)
+    d = Types::Hash[d]
+    new(
+      counter:           d.fetch("counter"),
+      creation_date:     d.fetch("creationDate"),
+      credential_id:     d.fetch("credentialId"),
+      discoverable:      d.fetch("discoverable"),
+      key_algorithm:     d.fetch("keyAlgorithm"),
+      key_curve:         d.fetch("keyCurve"),
+      key_type:          d.fetch("keyType"),
+      key_value:         d.fetch("keyValue"),
+      rp_id:             d.fetch("rpId"),
+      rp_name:           d["rpName"],
+      user_display_name: d["userDisplayName"],
+      user_handle:       d["userHandle"],
+      user_name:         d["userName"],
+    )
+  end
+
+  def self.from_json!(json)
+    from_dynamic!(JSON.parse(json))
+  end
+
+  def to_dynamic
+    {
+      "counter"         => counter,
+      "creationDate"    => creation_date,
+      "credentialId"    => credential_id,
+      "discoverable"    => discoverable,
+      "keyAlgorithm"    => key_algorithm,
+      "keyCurve"        => key_curve,
+      "keyType"         => key_type,
+      "keyValue"        => key_value,
+      "rpId"            => rp_id,
+      "rpName"          => rp_name,
+      "userDisplayName" => user_display_name,
+      "userHandle"      => user_handle,
+      "userName"        => user_name,
+    }
+  end
+
+  def to_json(options = nil)
+    JSON.generate(to_dynamic, options)
+  end
+end
+
 module URIMatchType
   Domain            = "domain"
   Exact             = "exact"
@@ -2646,14 +2967,16 @@ module URIMatchType
 end
 
 class LoginURI < Dry::Struct
-  attribute :match, Types::URIMatchType.optional.optional
-  attribute :uri,   Types::String.optional.optional
+  attribute :match,        Types::URIMatchType.optional.optional
+  attribute :uri,          Types::String.optional.optional
+  attribute :uri_checksum, Types::String.optional.optional
 
   def self.from_dynamic!(d)
     d = Types::Hash[d]
     new(
-      match: d["match"],
-      uri:   d["uri"],
+      match:        d["match"],
+      uri:          d["uri"],
+      uri_checksum: d["uriChecksum"],
     )
   end
 
@@ -2663,8 +2986,9 @@ class LoginURI < Dry::Struct
 
   def to_dynamic
     {
-      "match" => match,
-      "uri"   => uri,
+      "match"       => match,
+      "uri"         => uri,
+      "uriChecksum" => uri_checksum,
     }
   end
 
@@ -2675,6 +2999,7 @@ end
 
 class Login < Dry::Struct
   attribute :autofill_on_page_load,  Types::Bool.optional.optional
+  attribute :fido2_credentials,      Types.Array(Fido2Credential).optional.optional
   attribute :password,               Types::String.optional.optional
   attribute :password_revision_date, Types::String.optional.optional
   attribute :totp,                   Types::String.optional.optional
@@ -2685,6 +3010,7 @@ class Login < Dry::Struct
     d = Types::Hash[d]
     new(
       autofill_on_page_load:  d["autofillOnPageLoad"],
+      fido2_credentials:      d["fido2Credentials"]&.map { |x| Fido2Credential.from_dynamic!(x) },
       password:               d["password"],
       password_revision_date: d["passwordRevisionDate"],
       totp:                   d["totp"],
@@ -2700,6 +3026,7 @@ class Login < Dry::Struct
   def to_dynamic
     {
       "autofillOnPageLoad"   => autofill_on_page_load,
+      "fido2Credentials"     => fido2_credentials&.map { |x| x.to_dynamic },
       "password"             => password,
       "passwordRevisionDate" => password_revision_date,
       "totp"                 => totp,
@@ -3003,58 +3330,6 @@ class Folder < Dry::Struct
   end
 end
 
-module PolicyType
-  ActivateAutofill           = "ActivateAutofill"
-  DisablePersonalVaultExport = "DisablePersonalVaultExport"
-  DisableSend                = "DisableSend"
-  MasterPassword             = "MasterPassword"
-  MaximumVaultTimeout        = "MaximumVaultTimeout"
-  PasswordGenerator          = "PasswordGenerator"
-  PersonalOwnership          = "PersonalOwnership"
-  RequireSso                 = "RequireSso"
-  ResetPassword              = "ResetPassword"
-  SendOptions                = "SendOptions"
-  SingleOrg                  = "SingleOrg"
-  TwoFactorAuthentication    = "TwoFactorAuthentication"
-end
-
-class Policy < Dry::Struct
-  attribute :data,            Types::Hash.meta(of: Types::Any).optional.optional
-  attribute :enabled,         Types::Bool
-  attribute :id,              Types::String
-  attribute :organization_id, Types::String
-  attribute :policy_type,     Types::PolicyType
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      data:            Types::Hash.optional[d["data"]]&.map { |k, v| [k, Types::Any[v]] }&.to_h,
-      enabled:         d.fetch("enabled"),
-      id:              d.fetch("id"),
-      organization_id: d.fetch("organization_id"),
-      policy_type:     d.fetch("type"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "data"            => data,
-      "enabled"         => enabled,
-      "id"              => id,
-      "organization_id" => organization_id,
-      "type"            => policy_type,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
 class ProfileOrganizationResponse < Dry::Struct
   attribute :id, Types::String
 
@@ -3116,145 +3391,6 @@ class ProfileResponse < Dry::Struct
   end
 end
 
-class SendFile < Dry::Struct
-  attribute :file_name, Types::String
-  attribute :id,        Types::String.optional.optional
-  attribute :size,      Types::String.optional.optional
-
-  # Readable size, ex: "4.2 KB" or "1.43 GB"
-  attribute :size_name, Types::String.optional.optional
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      file_name: d.fetch("fileName"),
-      id:        d["id"],
-      size:      d["size"],
-      size_name: d["sizeName"],
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "fileName" => file_name,
-      "id"       => id,
-      "size"     => size,
-      "sizeName" => size_name,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-module SendType
-  File = "File"
-  Text = "Text"
-end
-
-class SendText < Dry::Struct
-  attribute :hidden, Types::Bool
-  attribute :text,   Types::String.optional.optional
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      hidden: d.fetch("hidden"),
-      text:   d["text"],
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "hidden" => hidden,
-      "text"   => text,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
-class Send < Dry::Struct
-  attribute :access_count,     Types::Integer
-  attribute :access_id,        Types::String.optional.optional
-  attribute :deletion_date,    Types::String
-  attribute :disabled,         Types::Bool
-  attribute :expiration_date,  Types::String.optional.optional
-  attribute :file,             SendFile.optional.optional
-  attribute :hide_email,       Types::Bool
-  attribute :id,               Types::String.optional.optional
-  attribute :key,              Types::String
-  attribute :max_access_count, Types::Integer.optional.optional
-  attribute :send_name,        Types::String
-  attribute :notes,            Types::String.optional.optional
-  attribute :password,         Types::String.optional.optional
-  attribute :revision_date,    Types::String
-  attribute :text,             SendText.optional.optional
-  attribute :send_type,        Types::SendType
-
-  def self.from_dynamic!(d)
-    d = Types::Hash[d]
-    new(
-      access_count:     d.fetch("accessCount"),
-      access_id:        d["accessId"],
-      deletion_date:    d.fetch("deletionDate"),
-      disabled:         d.fetch("disabled"),
-      expiration_date:  d["expirationDate"],
-      file:             d["file"] ? SendFile.from_dynamic!(d["file"]) : nil,
-      hide_email:       d.fetch("hideEmail"),
-      id:               d["id"],
-      key:              d.fetch("key"),
-      max_access_count: d["maxAccessCount"],
-      send_name:        d.fetch("name"),
-      notes:            d["notes"],
-      password:         d["password"],
-      revision_date:    d.fetch("revisionDate"),
-      text:             d["text"] ? SendText.from_dynamic!(d["text"]) : nil,
-      send_type:        d.fetch("type"),
-    )
-  end
-
-  def self.from_json!(json)
-    from_dynamic!(JSON.parse(json))
-  end
-
-  def to_dynamic
-    {
-      "accessCount"    => access_count,
-      "accessId"       => access_id,
-      "deletionDate"   => deletion_date,
-      "disabled"       => disabled,
-      "expirationDate" => expiration_date,
-      "file"           => file&.to_dynamic,
-      "hideEmail"      => hide_email,
-      "id"             => id,
-      "key"            => key,
-      "maxAccessCount" => max_access_count,
-      "name"           => send_name,
-      "notes"          => notes,
-      "password"       => password,
-      "revisionDate"   => revision_date,
-      "text"           => text&.to_dynamic,
-      "type"           => send_type,
-    }
-  end
-
-  def to_json(options = nil)
-    JSON.generate(to_dynamic, options)
-  end
-end
-
 class SyncResponse < Dry::Struct
 
   # List of ciphers accessible by the user
@@ -3263,14 +3399,11 @@ class SyncResponse < Dry::Struct
   attribute :collections, Types.Array(Collection)
   attribute :domains,     DomainResponse.optional.optional
   attribute :folders,     Types.Array(Folder)
-  attribute :policies,    Types.Array(Policy)
 
   # Data about the user, including their encryption keys and the organizations they are a
   # part of
   attribute :profile, ProfileResponse
 
-  attribute :sends, Types.Array(Send)
-
   def self.from_dynamic!(d)
     d = Types::Hash[d]
     new(
@@ -3278,9 +3411,7 @@ class SyncResponse < Dry::Struct
       collections: d.fetch("collections").map { |x| Collection.from_dynamic!(x) },
       domains:     d["domains"] ? DomainResponse.from_dynamic!(d["domains"]) : nil,
       folders:     d.fetch("folders").map { |x| Folder.from_dynamic!(x) },
-      policies:    d.fetch("policies").map { |x| Policy.from_dynamic!(x) },
       profile:     ProfileResponse.from_dynamic!(d.fetch("profile")),
-      sends:       d.fetch("sends").map { |x| Send.from_dynamic!(x) },
     )
   end
 
@@ -3294,9 +3425,7 @@ class SyncResponse < Dry::Struct
       "collections" => collections.map { |x| x.to_dynamic },
       "domains"     => domains&.to_dynamic,
       "folders"     => folders.map { |x| x.to_dynamic },
-      "policies"    => policies.map { |x| x.to_dynamic },
       "profile"     => profile.to_dynamic,
-      "sends"       => sends.map { |x| x.to_dynamic },
     }
   end