Move request/response models (#1754)

src/Api/Models/Request/Accounts/DeleteRecoverRequestModel.cs

@@ -0,0 +1,12 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class DeleteRecoverRequestModel
+    {
+        [Required]
+        [EmailAddress]
+        [StringLength(256)]
+        public string Email { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/EmailRequestModel.cs

@@ -0,0 +1,20 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Utilities;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class EmailRequestModel : SecretVerificationRequestModel
+    {
+        [Required]
+        [StrictEmailAddress]
+        [StringLength(256)]
+        public string NewEmail { get; set; }
+        [Required]
+        [StringLength(300)]
+        public string NewMasterPasswordHash { get; set; }
+        [Required]
+        public string Token { get; set; }
+        [Required]
+        public string Key { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/EmailTokenRequestModel.cs

@@ -0,0 +1,13 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Utilities;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class EmailTokenRequestModel : SecretVerificationRequestModel
+    {
+        [Required]
+        [StrictEmailAddress]
+        [StringLength(256)]
+        public string NewEmail { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/ImportCiphersRequestModel.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class ImportCiphersRequestModel
+    {
+        public FolderRequestModel[] Folders { get; set; }
+        public CipherRequestModel[] Ciphers { get; set; }
+        public KeyValuePair<int, int>[] FolderRelationships { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/KdfRequestModel.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Enums;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class KdfRequestModel : PasswordRequestModel, IValidatableObject
+    {
+        [Required]
+        public KdfType? Kdf { get; set; }
+        [Required]
+        public int? KdfIterations { get; set; }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (Kdf.HasValue && KdfIterations.HasValue)
+            {
+                switch (Kdf.Value)
+                {
+                    case KdfType.PBKDF2_SHA256:
+                        if (KdfIterations.Value < 5000 || KdfIterations.Value > 2_000_000)
+                        {
+                            yield return new ValidationResult("KDF iterations must be between 5000 and 2000000.");
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+    }
+}

src/Api/Models/Request/Accounts/KeysRequestModel.cs

@@ -0,0 +1,27 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Models.Table;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class KeysRequestModel
+    {
+        public string PublicKey { get; set; }
+        [Required]
+        public string EncryptedPrivateKey { get; set; }
+
+        public User ToUser(User existingUser)
+        {
+            if (string.IsNullOrWhiteSpace(existingUser.PublicKey) && !string.IsNullOrWhiteSpace(PublicKey))
+            {
+                existingUser.PublicKey = PublicKey;
+            }
+
+            if (string.IsNullOrWhiteSpace(existingUser.PrivateKey))
+            {
+                existingUser.PrivateKey = EncryptedPrivateKey;
+            }
+
+            return existingUser;
+        }
+    }
+}

src/Api/Models/Request/Accounts/PasswordHintRequestModel.cs

@@ -0,0 +1,12 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class PasswordHintRequestModel
+    {
+        [Required]
+        [EmailAddress]
+        [StringLength(256)]
+        public string Email { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/PasswordRequestModel.cs

@@ -0,0 +1,13 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class PasswordRequestModel : SecretVerificationRequestModel
+    {
+        [Required]
+        [StringLength(300)]
+        public string NewMasterPasswordHash { get; set; }
+        [Required]
+        public string Key { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/PreloginRequestModel.cs

@@ -0,0 +1,12 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class PreloginRequestModel
+    {
+        [Required]
+        [EmailAddress]
+        [StringLength(256)]
+        public string Email { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/PremiumRequestModel.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Settings;
+using Microsoft.AspNetCore.Http;
+using Enums = Bit.Core.Enums;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class PremiumRequestModel : IValidatableObject
+    {
+        [Required]
+        public Enums.PaymentMethodType? PaymentMethodType { get; set; }
+        public string PaymentToken { get; set; }
+        [Range(0, 99)]
+        public short? AdditionalStorageGb { get; set; }
+        public IFormFile License { get; set; }
+        public string Country { get; set; }
+        public string PostalCode { get; set; }
+
+        public bool Validate(GlobalSettings globalSettings)
+        {
+            if (!(License == null && !globalSettings.SelfHosted) ||
+                (License != null && globalSettings.SelfHosted))
+            {
+                return false;
+            }
+            return globalSettings.SelfHosted || !string.IsNullOrWhiteSpace(Country);
+        }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            var creditType = PaymentMethodType.HasValue && PaymentMethodType.Value == Enums.PaymentMethodType.Credit;
+            if (string.IsNullOrWhiteSpace(PaymentToken) && !creditType && License == null)
+            {
+                yield return new ValidationResult("Payment token or license is required.");
+            }
+            if (Country == "US" && string.IsNullOrWhiteSpace(PostalCode))
+            {
+                yield return new ValidationResult("Zip / postal code is required.",
+                    new string[] { nameof(PostalCode) });
+            }
+        }
+    }
+}

src/Api/Models/Request/Accounts/RegenerateTwoFactorRequestModel.cs

@@ -0,0 +1,13 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class RegenerateTwoFactorRequestModel
+    {
+        [Required]
+        public string MasterPasswordHash { get; set; }
+        [Required]
+        [StringLength(50)]
+        public string Token { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/RegisterRequestModel.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Enums;
+using Bit.Core.Models.Api;
+using Bit.Core.Models.Table;
+using Bit.Core.Utilities;
+using Newtonsoft.Json;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class RegisterRequestModel : IValidatableObject, ICaptchaProtectedModel
+    {
+        [StringLength(50)]
+        public string Name { get; set; }
+        [Required]
+        [StrictEmailAddress]
+        [StringLength(256)]
+        public string Email { get; set; }
+        [Required]
+        [StringLength(1000)]
+        public string MasterPasswordHash { get; set; }
+        [StringLength(50)]
+        public string MasterPasswordHint { get; set; }
+        public string CaptchaResponse { get; set; }
+        public string Key { get; set; }
+        public KeysRequestModel Keys { get; set; }
+        public string Token { get; set; }
+        public Guid? OrganizationUserId { get; set; }
+        public KdfType? Kdf { get; set; }
+        public int? KdfIterations { get; set; }
+        public Dictionary<string, object> ReferenceData { get; set; }
+
+        public User ToUser()
+        {
+            var user = new User
+            {
+                Name = Name,
+                Email = Email,
+                MasterPasswordHint = MasterPasswordHint,
+                Kdf = Kdf.GetValueOrDefault(KdfType.PBKDF2_SHA256),
+                KdfIterations = KdfIterations.GetValueOrDefault(5000),
+            };
+
+            if (ReferenceData != null)
+            {
+                user.ReferenceData = JsonConvert.SerializeObject(ReferenceData);
+            }
+
+            if (Key != null)
+            {
+                user.Key = Key;
+            }
+
+            if (Keys != null)
+            {
+                Keys.ToUser(user);
+            }
+
+            return user;
+        }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (Kdf.HasValue && KdfIterations.HasValue)
+            {
+                switch (Kdf.Value)
+                {
+                    case KdfType.PBKDF2_SHA256:
+                        if (KdfIterations.Value < 5000 || KdfIterations.Value > 1_000_000)
+                        {
+                            yield return new ValidationResult("KDF iterations must be between 5000 and 1000000.");
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+    }
+}

src/Api/Models/Request/Accounts/SecretVerificationRequestModel.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class SecretVerificationRequestModel : IValidatableObject
+    {
+        [StringLength(300)]
+        public string MasterPasswordHash { get; set; }
+        public string OTP { get; set; }
+        public string Secret => !string.IsNullOrEmpty(MasterPasswordHash) ? MasterPasswordHash : OTP;
+
+        public virtual IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (string.IsNullOrEmpty(Secret))
+            {
+                yield return new ValidationResult("MasterPasswordHash or OTP must be supplied.");
+            }
+        }
+    }
+}

src/Api/Models/Request/Accounts/SetKeyConnectorKeyRequestModel.cs

@@ -0,0 +1,29 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Enums;
+using Bit.Core.Models.Table;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class SetKeyConnectorKeyRequestModel
+    {
+        [Required]
+        public string Key { get; set; }
+        [Required]
+        public KeysRequestModel Keys { get; set; }
+        [Required]
+        public KdfType Kdf { get; set; }
+        [Required]
+        public int KdfIterations { get; set; }
+        [Required]
+        public string OrgIdentifier { get; set; }
+
+        public User ToUser(User existingUser)
+        {
+            existingUser.Kdf = Kdf;
+            existingUser.KdfIterations = KdfIterations;
+            existingUser.Key = Key;
+            Keys.ToUser(existingUser);
+            return existingUser;
+        }
+    }
+}

src/Api/Models/Request/Accounts/SetPasswordRequestModel.cs

@@ -0,0 +1,34 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Enums;
+using Bit.Core.Models.Table;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class SetPasswordRequestModel
+    {
+        [Required]
+        [StringLength(300)]
+        public string MasterPasswordHash { get; set; }
+        [Required]
+        public string Key { get; set; }
+        [StringLength(50)]
+        public string MasterPasswordHint { get; set; }
+        [Required]
+        public KeysRequestModel Keys { get; set; }
+        [Required]
+        public KdfType Kdf { get; set; }
+        [Required]
+        public int KdfIterations { get; set; }
+        public string OrgIdentifier { get; set; }
+
+        public User ToUser(User existingUser)
+        {
+            existingUser.MasterPasswordHint = MasterPasswordHint;
+            existingUser.Kdf = Kdf;
+            existingUser.KdfIterations = KdfIterations;
+            existingUser.Key = Key;
+            Keys.ToUser(existingUser);
+            return existingUser;
+        }
+    }
+}

src/Api/Models/Request/Accounts/StorageRequestModel.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class StorageRequestModel : IValidatableObject
+    {
+        [Required]
+        public short? StorageGbAdjustment { get; set; }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (StorageGbAdjustment == 0)
+            {
+                yield return new ValidationResult("Storage adjustment cannot be 0.",
+                    new string[] { nameof(StorageGbAdjustment) });
+            }
+        }
+    }
+}

src/Api/Models/Request/Accounts/TaxInfoUpdateRequestModel.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class TaxInfoUpdateRequestModel : IValidatableObject
+    {
+        [Required]
+        public string Country { get; set; }
+        public string PostalCode { get; set; }
+
+        public virtual IEnumerable<ValidationResult> Validate (ValidationContext validationContext)
+        {
+            if (Country == "US" && string.IsNullOrWhiteSpace(PostalCode))
+            {
+                yield return new ValidationResult("Zip / postal code is required.",
+                    new string[] { nameof(PostalCode) });
+            }
+        }
+    }
+}

src/Api/Models/Request/Accounts/UpdateKeyRequestModel.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class UpdateKeyRequestModel
+    {
+        [Required]
+        [StringLength(300)]
+        public string MasterPasswordHash { get; set; }
+        [Required]
+        public IEnumerable<CipherWithIdRequestModel> Ciphers { get; set; }
+        [Required]
+        public IEnumerable<FolderWithIdRequestModel> Folders { get; set; }
+        public IEnumerable<SendWithIdRequestModel> Sends { get; set; }
+        [Required]
+        public string PrivateKey { get; set; }
+        [Required]
+        public string Key { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/UpdateProfileRequestModel.cs

@@ -0,0 +1,20 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Models.Table;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class UpdateProfileRequestModel
+    {
+        [StringLength(50)]
+        public string Name { get; set; }
+        [StringLength(50)]
+        public string MasterPasswordHint { get; set; }
+
+        public User ToUser(User existingUser)
+        {
+            existingUser.Name = Name;
+            existingUser.MasterPasswordHint = string.IsNullOrWhiteSpace(MasterPasswordHint) ? null : MasterPasswordHint;
+            return existingUser;
+        }
+    }
+}

src/Api/Models/Request/Accounts/UpdateTempPasswordRequestModel.cs

@@ -0,0 +1,11 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Api.Models.Request.Organizations;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class UpdateTempPasswordRequestModel : OrganizationUserResetPasswordRequestModel
+    {
+        [StringLength(50)]
+        public string MasterPasswordHint { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/VerifyDeleteRecoverRequestModel.cs

@@ -0,0 +1,12 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class VerifyDeleteRecoverRequestModel
+    {
+        [Required]
+        public string UserId { get; set; }
+        [Required]
+        public string Token { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/VerifyEmailRequestModel.cs

@@ -0,0 +1,12 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class VerifyEmailRequestModel
+    {
+        [Required]
+        public string UserId { get; set; }
+        [Required]
+        public string Token { get; set; }
+    }
+}

src/Api/Models/Request/Accounts/VerifyOTPRequestModel.cs

@@ -0,0 +1,10 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Accounts
+{
+    public class VerifyOTPRequestModel
+    {
+        [Required]
+        public string OTP { get; set; }
+    }
+}

src/Api/Models/Request/AttachmentRequestModel.cs

@@ -0,0 +1,10 @@
+namespace Bit.Api.Models.Request
+{
+    public class AttachmentRequestModel
+    {
+        public string Key { get; set; }
+        public string FileName { get; set; }
+        public long FileSize { get; set; }
+        public bool AdminRequest { get; set; } = false;
+    }
+}

src/Api/Models/Request/BitPayInvoiceRequestModel.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Settings;
+
+namespace Bit.Api.Models.Request
+{
+    public class BitPayInvoiceRequestModel : IValidatableObject
+    {
+        public Guid? UserId { get; set; }
+        public Guid? OrganizationId { get; set; }
+        public bool Credit { get; set; }
+        [Required]
+        public decimal? Amount { get; set; }
+        public string ReturnUrl { get; set; }
+        public string Name { get; set; }
+        public string Email { get; set; }
+
+        public BitPayLight.Models.Invoice.Invoice ToBitpayInvoice(GlobalSettings globalSettings)
+        {
+            var inv = new BitPayLight.Models.Invoice.Invoice
+            {
+                Price = Convert.ToDouble(Amount.Value),
+                Currency = "USD",
+                RedirectUrl = ReturnUrl,
+                Buyer = new BitPayLight.Models.Invoice.Buyer
+                {
+                    Email = Email,
+                    Name = Name
+                },
+                NotificationUrl = globalSettings.BitPay.NotificationUrl,
+                FullNotifications = true,
+                ExtendedNotifications = true
+            };
+
+            var posData = string.Empty;
+            if (UserId.HasValue)
+            {
+                posData = "userId:" + UserId.Value;
+            }
+            else if (OrganizationId.HasValue)
+            {
+                posData = "organizationId:" + OrganizationId.Value;
+            }
+
+            if (Credit)
+            {
+                posData += ",accountCredit:1";
+                inv.ItemDesc = "Bitwarden Account Credit";
+            }
+            else
+            {
+                inv.ItemDesc = "Bitwarden";
+            }
+
+            inv.PosData = posData;
+            return inv;
+        }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (!UserId.HasValue && !OrganizationId.HasValue)
+            {
+                yield return new ValidationResult("User or Ooganization is required.");
+            }
+        }
+    }
+}

src/Api/Models/Request/CipherPartialRequestModel.cs

@@ -0,0 +1,11 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request
+{
+    public class CipherPartialRequestModel
+    {
+        [StringLength(36)]
+        public string FolderId { get; set; }
+        public bool Favorite { get; set; }
+    }
+}

src/Api/Models/Request/CipherRequestModel.cs

@@ -0,0 +1,353 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using Bit.Core.Enums;
+using Bit.Core.Models.Data;
+using Bit.Core.Models.Table;
+using Bit.Core.Utilities;
+using Core.Models.Data;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Bit.Api.Models.Request
+{
+    public class CipherRequestModel
+    {
+        public CipherType Type { get; set; }
+
+        [StringLength(36)]
+        public string OrganizationId { get; set; }
+        public string FolderId { get; set; }
+        public bool Favorite { get; set; }
+        public CipherRepromptType Reprompt { get; set; }
+        [Required]
+        [EncryptedString]
+        [EncryptedStringLength(1000)]
+        public string Name { get; set; }
+        [EncryptedString]
+        [EncryptedStringLength(10000)]
+        public string Notes { get; set; }
+        public IEnumerable<CipherFieldModel> Fields { get; set; }
+        public IEnumerable<CipherPasswordHistoryModel> PasswordHistory { get; set; }
+        [Obsolete]
+        public Dictionary<string, string> Attachments { get; set; }
+        // TODO: Rename to Attachments whenever the above is finally removed.
+        public Dictionary<string, CipherAttachmentModel> Attachments2 { get; set; }
+
+        public CipherLoginModel Login { get; set; }
+        public CipherCardModel Card { get; set; }
+        public CipherIdentityModel Identity { get; set; }
+        public CipherSecureNoteModel SecureNote { get; set; }
+        public DateTime? LastKnownRevisionDate { get; set; } = null;
+
+        public CipherDetails ToCipherDetails(Guid userId, bool allowOrgIdSet = true)
+        {
+            var hasOrgId = !string.IsNullOrWhiteSpace(OrganizationId);
+            var cipher = new CipherDetails
+            {
+                Type = Type,
+                UserId = !hasOrgId ? (Guid?)userId : null,
+                OrganizationId = allowOrgIdSet && hasOrgId ? new Guid(OrganizationId) : (Guid?)null,
+                Edit = true,
+                ViewPassword = true,
+            };
+            ToCipherDetails(cipher);
+            return cipher;
+        }
+
+        public CipherDetails ToCipherDetails(CipherDetails existingCipher)
+        {
+            existingCipher.FolderId = string.IsNullOrWhiteSpace(FolderId) ? null : (Guid?)new Guid(FolderId);
+            existingCipher.Favorite = Favorite;
+            ToCipher(existingCipher);
+            return existingCipher;
+        }
+
+        public Cipher ToCipher(Cipher existingCipher)
+        {
+            switch (existingCipher.Type)
+            {
+                case CipherType.Login:
+                    var loginObj = JObject.FromObject(ToCipherLoginData(),
+                        new JsonSerializer { NullValueHandling = NullValueHandling.Ignore });
+                    loginObj[nameof(CipherLoginData.Uri)]?.Parent?.Remove();
+                    existingCipher.Data = loginObj.ToString(Formatting.None);
+                    break;
+                case CipherType.Card:
+                    existingCipher.Data = JsonConvert.SerializeObject(ToCipherCardData(),
+                        new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
+                    break;
+                case CipherType.Identity:
+                    existingCipher.Data = JsonConvert.SerializeObject(ToCipherIdentityData(),
+                        new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
+                    break;
+                case CipherType.SecureNote:
+                    existingCipher.Data = JsonConvert.SerializeObject(ToCipherSecureNoteData(),
+                        new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
+                    break;
+                default:
+                    throw new ArgumentException("Unsupported type: " + nameof(Type) + ".");
+            }
+
+            existingCipher.Reprompt = Reprompt;
+
+            var hasAttachments2 = (Attachments2?.Count ?? 0) > 0;
+            var hasAttachments = (Attachments?.Count ?? 0) > 0;
+
+            if (!hasAttachments2 && !hasAttachments)
+            {
+                return existingCipher;
+            }
+
+            var attachments = existingCipher.GetAttachments();
+            if ((attachments?.Count ?? 0) == 0)
+            {
+                return existingCipher;
+            }
+
+            if (hasAttachments2)
+            {
+                foreach (var attachment in attachments.Where(a => Attachments2.ContainsKey(a.Key)))
+                {
+                    var attachment2 = Attachments2[attachment.Key];
+                    attachment.Value.FileName = attachment2.FileName;
+                    attachment.Value.Key = attachment2.Key;
+                }
+            }
+            else if (hasAttachments)
+            {
+                foreach (var attachment in attachments.Where(a => Attachments.ContainsKey(a.Key)))
+                {
+                    attachment.Value.FileName = Attachments[attachment.Key];
+                    attachment.Value.Key = null;
+                }
+            }
+
+            existingCipher.SetAttachments(attachments);
+            return existingCipher;
+        }
+
+        public Cipher ToOrganizationCipher()
+        {
+            if (string.IsNullOrWhiteSpace(OrganizationId))
+            {
+                throw new ArgumentNullException(nameof(OrganizationId));
+            }
+
+            return ToCipher(new Cipher
+            {
+                Type = Type,
+                OrganizationId = new Guid(OrganizationId)
+            });
+        }
+
+        public CipherDetails ToOrganizationCipherDetails(Guid orgId)
+        {
+            return ToCipherDetails(new CipherDetails
+            {
+                Type = Type,
+                OrganizationId = orgId,
+                Edit = true
+            });
+        }
+
+        private CipherLoginData ToCipherLoginData()
+        {
+            return new CipherLoginData
+            {
+                Name = Name,
+                Notes = Notes,
+                Fields = Fields?.Select(f => f.ToCipherFieldData()),
+                PasswordHistory = PasswordHistory?.Select(ph => ph.ToCipherPasswordHistoryData()),
+
+                Uris =
+                    Login.Uris?.Where(u => u != null)
+                        .Select(u => u.ToCipherLoginUriData()),
+                Username = Login.Username,
+                Password = Login.Password,
+                PasswordRevisionDate = Login.PasswordRevisionDate,
+                Totp = Login.Totp,
+                AutofillOnPageLoad = Login.AutofillOnPageLoad,
+            };
+        }
+
+        private CipherIdentityData ToCipherIdentityData()
+        {
+            return new CipherIdentityData
+            {
+                Name = Name,
+                Notes = Notes,
+                Fields = Fields?.Select(f => f.ToCipherFieldData()),
+                PasswordHistory = PasswordHistory?.Select(ph => ph.ToCipherPasswordHistoryData()),
+
+                Title = Identity.Title,
+                FirstName = Identity.FirstName,
+                MiddleName = Identity.MiddleName,
+                LastName = Identity.LastName,
+                Address1 = Identity.Address1,
+                Address2 = Identity.Address2,
+                Address3 = Identity.Address3,
+                City = Identity.City,
+                State = Identity.State,
+                PostalCode = Identity.PostalCode,
+                Country = Identity.Country,
+                Company = Identity.Company,
+                Email = Identity.Email,
+                Phone = Identity.Phone,
+                SSN = Identity.SSN,
+                Username = Identity.Username,
+                PassportNumber = Identity.PassportNumber,
+                LicenseNumber = Identity.LicenseNumber,
+            };
+        }
+
+        private CipherCardData ToCipherCardData()
+        {
+            return new CipherCardData
+            {
+                Name = Name,
+                Notes = Notes,
+                Fields = Fields?.Select(f => f.ToCipherFieldData()),
+                PasswordHistory = PasswordHistory?.Select(ph => ph.ToCipherPasswordHistoryData()),
+
+                CardholderName = Card.CardholderName,
+                Brand = Card.Brand,
+                Number = Card.Number,
+                ExpMonth = Card.ExpMonth,
+                ExpYear = Card.ExpYear,
+                Code = Card.Code,
+            };
+        }
+
+        private CipherSecureNoteData ToCipherSecureNoteData()
+        {
+            return new CipherSecureNoteData
+            {
+                Name = Name,
+                Notes = Notes,
+                Fields = Fields?.Select(f => f.ToCipherFieldData()),
+                PasswordHistory = PasswordHistory?.Select(ph => ph.ToCipherPasswordHistoryData()),
+
+                Type = SecureNote.Type,
+            };
+        }
+    }
+
+    public class CipherWithIdRequestModel : CipherRequestModel
+    {
+        [Required]
+        public Guid? Id { get; set; }
+    }
+
+    public class CipherCreateRequestModel : IValidatableObject
+    {
+        public IEnumerable<Guid> CollectionIds { get; set; }
+        [Required]
+        public CipherRequestModel Cipher { get; set; }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (!string.IsNullOrWhiteSpace(Cipher.OrganizationId) && (!CollectionIds?.Any() ?? true))
+            {
+                yield return new ValidationResult("You must select at least one collection.",
+                   new string[] { nameof(CollectionIds) });
+            }
+        }
+    }
+
+    public class CipherShareRequestModel : IValidatableObject
+    {
+        [Required]
+        public IEnumerable<string> CollectionIds { get; set; }
+        [Required]
+        public CipherRequestModel Cipher { get; set; }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (string.IsNullOrWhiteSpace(Cipher.OrganizationId))
+            {
+                yield return new ValidationResult("Cipher OrganizationId is required.",
+                    new string[] { nameof(Cipher.OrganizationId) });
+            }
+
+            if (!CollectionIds?.Any() ?? true)
+            {
+                yield return new ValidationResult("You must select at least one collection.",
+                    new string[] { nameof(CollectionIds) });
+            }
+        }
+    }
+
+    public class CipherCollectionsRequestModel
+    {
+        [Required]
+        public IEnumerable<string> CollectionIds { get; set; }
+    }
+
+    public class CipherBulkDeleteRequestModel
+    {
+        [Required]
+        public IEnumerable<string> Ids { get; set; }
+        public string OrganizationId { get; set; }
+    }
+
+    public class CipherBulkRestoreRequestModel
+    {
+        [Required]
+        public IEnumerable<string> Ids { get; set; }
+    }
+
+    public class CipherBulkMoveRequestModel
+    {
+        [Required]
+        public IEnumerable<string> Ids { get; set; }
+        public string FolderId { get; set; }
+    }
+
+    public class CipherBulkShareRequestModel : IValidatableObject
+    {
+        [Required]
+        public IEnumerable<string> CollectionIds { get; set; }
+        [Required]
+        public IEnumerable<CipherWithIdRequestModel> Ciphers { get; set; }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (!Ciphers?.Any() ?? true)
+            {
+                yield return new ValidationResult("You must select at least one cipher.",
+                    new string[] { nameof(Ciphers) });
+            }
+            else
+            {
+                var allHaveIds = true;
+                var organizationIds = new HashSet<string>();
+                foreach (var c in Ciphers)
+                {
+                    organizationIds.Add(c.OrganizationId);
+                    if (allHaveIds)
+                    {
+                        allHaveIds = !(!c.Id.HasValue || string.IsNullOrWhiteSpace(c.OrganizationId));
+                    }
+                }
+
+                if (!allHaveIds)
+                {
+                    yield return new ValidationResult("All Ciphers must have an Id and OrganizationId.",
+                        new string[] { nameof(Ciphers) });
+                }
+                else if (organizationIds.Count != 1)
+                {
+                    yield return new ValidationResult("All ciphers must be for the same organization.");
+                }
+            }
+
+            if (!CollectionIds?.Any() ?? true)
+            {
+                yield return new ValidationResult("You must select at least one collection.",
+                    new string[] { nameof(CollectionIds) });
+            }
+        }
+    }
+}

src/Api/Models/Request/CollectionRequestModel.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Models.Table;
+using Bit.Core.Utilities;
+
+namespace Bit.Api.Models.Request
+{
+    public class CollectionRequestModel
+    {
+        [Required]
+        [EncryptedString]
+        [EncryptedStringLength(1000)]
+        public string Name { get; set; }
+        [StringLength(300)]
+        public string ExternalId { get; set; }
+        public IEnumerable<SelectionReadOnlyRequestModel> Groups { get; set; }
+
+        public Collection ToCollection(Guid orgId)
+        {
+            return ToCollection(new Collection
+            {
+                OrganizationId = orgId
+            });
+        }
+
+        public Collection ToCollection(Collection existingCollection)
+        {
+            existingCollection.Name = Name;
+            existingCollection.ExternalId = ExternalId;
+            return existingCollection;
+        }
+    }
+}

src/Api/Models/Request/DeviceRequestModels.cs

@@ -0,0 +1,51 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Enums;
+using Bit.Core.Models.Table;
+
+namespace Bit.Api.Models.Request
+{
+    public class DeviceRequestModel
+    {
+        [Required]
+        public DeviceType? Type { get; set; }
+        [Required]
+        [StringLength(50)]
+        public string Name { get; set; }
+        [Required]
+        [StringLength(50)]
+        public string Identifier { get; set; }
+        [StringLength(255)]
+        public string PushToken { get; set; }
+
+        public Device ToDevice(Guid? userId = null)
+        {
+            return ToDevice(new Device
+            {
+                UserId = userId == null ? default(Guid) : userId.Value
+            });
+        }
+
+        public Device ToDevice(Device existingDevice)
+        {
+            existingDevice.Name = Name;
+            existingDevice.Identifier = Identifier;
+            existingDevice.PushToken = PushToken;
+            existingDevice.Type = Type.Value;
+
+            return existingDevice;
+        }
+    }
+
+    public class DeviceTokenRequestModel
+    {
+        [StringLength(255)]
+        public string PushToken { get; set; }
+
+        public Device ToDevice(Device existingDevice)
+        {
+            existingDevice.PushToken = PushToken;
+            return existingDevice;
+        }
+    }
+}

src/Api/Models/Request/EmergencyAccessRequstModels.cs

@@ -0,0 +1,49 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Enums;
+using Bit.Core.Models.Table;
+using Bit.Core.Utilities;
+
+namespace Bit.Api.Models.Request
+{
+    public class EmergencyAccessInviteRequestModel
+    {
+        [Required]
+        [StrictEmailAddress]
+        [StringLength(256)]
+        public string Email { get; set; }
+        [Required]
+        public EmergencyAccessType? Type { get; set; }
+        [Required]
+        public int WaitTimeDays { get; set; }
+    }
+
+    public class EmergencyAccessUpdateRequestModel
+    {
+        [Required]
+        public EmergencyAccessType Type { get; set; }
+        [Required]
+        public int WaitTimeDays { get; set; }
+        public string KeyEncrypted { get; set; }
+
+        public EmergencyAccess ToEmergencyAccess(EmergencyAccess existingEmergencyAccess)
+        {
+            // Ensure we only set keys for a confirmed emergency access.
+            if (!string.IsNullOrWhiteSpace(existingEmergencyAccess.KeyEncrypted) && !string.IsNullOrWhiteSpace(KeyEncrypted))
+            {
+                existingEmergencyAccess.KeyEncrypted = KeyEncrypted;
+            }
+            existingEmergencyAccess.Type = Type;
+            existingEmergencyAccess.WaitTimeDays = WaitTimeDays;
+            return existingEmergencyAccess;
+        }
+    }
+
+    public class EmergencyAccessPasswordRequestModel
+    {
+        [Required]
+        [StringLength(300)]
+        public string NewMasterPasswordHash { get; set; }
+        [Required]
+        public string Key { get; set; }
+    }
+}

src/Api/Models/Request/FolderRequestModel.cs

@@ -0,0 +1,34 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Models.Table;
+using Bit.Core.Utilities;
+
+namespace Bit.Api.Models.Request
+{
+    public class FolderRequestModel
+    {
+        [Required]
+        [EncryptedString]
+        [EncryptedStringLength(1000)]
+        public string Name { get; set; }
+
+        public Folder ToFolder(Guid userId)
+        {
+            return ToFolder(new Folder
+            {
+                UserId = userId
+            });
+        }
+
+        public Folder ToFolder(Folder existingFolder)
+        {
+            existingFolder.Name = Name;
+            return existingFolder;
+        }
+    }
+
+    public class FolderWithIdRequestModel : FolderRequestModel
+    {
+        public Guid Id { get; set; }
+    }
+}

src/Api/Models/Request/GroupRequestModel.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Models.Table;
+
+namespace Bit.Api.Models.Request
+{
+    public class GroupRequestModel
+    {
+        [Required]
+        [StringLength(100)]
+        public string Name { get; set; }
+        [Required]
+        public bool? AccessAll { get; set; }
+        [StringLength(300)]
+        public string ExternalId { get; set; }
+        public IEnumerable<SelectionReadOnlyRequestModel> Collections { get; set; }
+
+        public Group ToGroup(Guid orgId)
+        {
+            return ToGroup(new Group
+            {
+                OrganizationId = orgId
+            });
+        }
+
+        public Group ToGroup(Group existingGroup)
+        {
+            existingGroup.Name = Name;
+            existingGroup.AccessAll = AccessAll.Value;
+            existingGroup.ExternalId = ExternalId;
+            return existingGroup;
+        }
+    }
+}

src/Api/Models/Request/IapCheckRequestModel.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Enums = Bit.Core.Enums;
+
+namespace Bit.Api.Models.Request
+{
+    public class IapCheckRequestModel : IValidatableObject
+    {
+        [Required]
+        public Enums.PaymentMethodType? PaymentMethodType { get; set; }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (PaymentMethodType != Enums.PaymentMethodType.AppleInApp)
+            {
+                yield return new ValidationResult("Not a supported in-app purchase payment method.",
+                    new string[] { nameof(PaymentMethodType) });
+            }
+        }
+    }
+}

src/Api/Models/Request/InstallationRequestModel.cs

@@ -0,0 +1,24 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Models.Table;
+using Bit.Core.Utilities;
+
+namespace Bit.Api.Models.Request
+{
+    public class InstallationRequestModel
+    {
+        [Required]
+        [EmailAddress]
+        [StringLength(256)]
+        public string Email { get; set; }
+
+        public Installation ToInstallation()
+        {
+            return new Installation
+            {
+                Key = CoreHelpers.SecureRandomString(20),
+                Email = Email,
+                Enabled = true
+            };
+        }
+    }
+}

src/Api/Models/Request/LicenseRequestModel.cs

@@ -0,0 +1,11 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.AspNetCore.Http;
+
+namespace Bit.Api.Models.Request
+{
+    public class LicenseRequestModel
+    {
+        [Required]
+        public IFormFile License { get; set; }
+    }
+}

src/Api/Models/Request/Organizations/ImportOrganizationCiphersRequestModel.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class ImportOrganizationCiphersRequestModel
+    {
+        public CollectionRequestModel[] Collections { get; set; }
+        public CipherRequestModel[] Ciphers { get; set; }
+        public KeyValuePair<int, int>[] CollectionRelationships { get; set; }
+    }
+}

src/Api/Models/Request/Organizations/ImportOrganizationUsersRequestModel.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Models.Business;
+using Table = Bit.Core.Models.Table;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class ImportOrganizationUsersRequestModel
+    {
+        public Group[] Groups { get; set; }
+        public User[] Users { get; set; }
+        public bool OverwriteExisting { get; set; }
+        public bool LargeImport { get; set; }
+
+        public class Group
+        {
+            [Required]
+            [StringLength(100)]
+            public string Name { get; set; }
+            [Required]
+            [StringLength(300)]
+            public string ExternalId { get; set; }
+            public IEnumerable<string> Users { get; set; }
+
+            public ImportedGroup ToImportedGroup(Guid organizationId)
+            {
+                var importedGroup = new ImportedGroup
+                {
+                    Group = new Table.Group
+                    {
+                        OrganizationId = organizationId,
+                        Name = Name,
+                        ExternalId = ExternalId
+                    },
+                    ExternalUserIds = new HashSet<string>(Users)
+                };
+
+                return importedGroup;
+            }
+        }
+
+        public class User : IValidatableObject
+        {
+            [EmailAddress]
+            [StringLength(256)]
+            public string Email { get; set; }
+            public bool Deleted { get; set; }
+            [Required]
+            [StringLength(300)]
+            public string ExternalId { get; set; }
+
+            public ImportedOrganizationUser ToImportedOrganizationUser()
+            {
+                var importedUser = new ImportedOrganizationUser
+                {
+                    Email = Email.ToLowerInvariant(),
+                    ExternalId = ExternalId
+                };
+
+                return importedUser;
+            }
+
+            public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+            {
+                if (string.IsNullOrWhiteSpace(Email) && !Deleted)
+                {
+                    yield return new ValidationResult("Email is required for enabled users.", new string[] { nameof(Email) });
+                }
+            }
+        }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationCreateLicenseRequestModel.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Utilities;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationCreateLicenseRequestModel : LicenseRequestModel
+    {
+        [Required]
+        public string Key { get; set; }
+        [EncryptedString]
+        [EncryptedStringLength(1000)]
+        public string CollectionName { get; set; }
+        public OrganizationKeysRequestModel Keys { get; set; }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationCreateRequestModel.cs

@@ -0,0 +1,103 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Enums;
+using Bit.Core.Models.Business;
+using Bit.Core.Models.Table;
+using Bit.Core.Utilities;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationCreateRequestModel : IValidatableObject
+    {
+        [Required]
+        [StringLength(50)]
+        public string Name { get; set; }
+        [StringLength(50)]
+        public string BusinessName { get; set; }
+        [Required]
+        [StringLength(256)]
+        [EmailAddress]
+        public string BillingEmail { get; set; }
+        public PlanType PlanType { get; set; }
+        [Required]
+        public string Key { get; set; }
+        public OrganizationKeysRequestModel Keys { get; set; }
+        public PaymentMethodType? PaymentMethodType { get; set; }
+        public string PaymentToken { get; set; }
+        [Range(0, int.MaxValue)]
+        public int AdditionalSeats { get; set; }
+        [Range(0, 99)]
+        public short? AdditionalStorageGb { get; set; }
+        public bool PremiumAccessAddon { get; set; }
+        [EncryptedString]
+        [EncryptedStringLength(1000)]
+        public string CollectionName { get; set; }
+        public string TaxIdNumber { get; set; }
+        public string BillingAddressLine1 { get; set; }
+        public string BillingAddressLine2 { get; set; }
+        public string BillingAddressCity { get; set; }
+        public string BillingAddressState { get; set; }
+        public string BillingAddressPostalCode { get; set; }
+        [StringLength(2)]
+        public string BillingAddressCountry { get; set; }
+        public int? MaxAutoscaleSeats { get; set; }
+
+        public virtual OrganizationSignup ToOrganizationSignup(User user)
+        {
+            var orgSignup = new OrganizationSignup
+            {
+                Owner = user,
+                OwnerKey = Key,
+                Name = Name,
+                Plan = PlanType,
+                PaymentMethodType = PaymentMethodType,
+                PaymentToken = PaymentToken,
+                AdditionalSeats = AdditionalSeats,
+                MaxAutoscaleSeats = MaxAutoscaleSeats,
+                AdditionalStorageGb = AdditionalStorageGb.GetValueOrDefault(0),
+                PremiumAccessAddon = PremiumAccessAddon,
+                BillingEmail = BillingEmail,
+                BusinessName = BusinessName,
+                CollectionName = CollectionName,
+                TaxInfo = new TaxInfo
+                {
+                    TaxIdNumber = TaxIdNumber,
+                    BillingAddressLine1 = BillingAddressLine1,
+                    BillingAddressLine2 = BillingAddressLine2,
+                    BillingAddressCity = BillingAddressCity,
+                    BillingAddressState = BillingAddressState,
+                    BillingAddressPostalCode = BillingAddressPostalCode,
+                    BillingAddressCountry = BillingAddressCountry,
+                },
+            };
+
+            Keys?.ToOrganizationSignup(orgSignup);
+
+            return orgSignup;
+        }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (PlanType != PlanType.Free && string.IsNullOrWhiteSpace(PaymentToken))
+            {
+                yield return new ValidationResult("Payment required.", new string[] { nameof(PaymentToken) });
+            }
+            if (PlanType != PlanType.Free && !PaymentMethodType.HasValue)
+            {
+                yield return new ValidationResult("Payment method type required.",
+                    new string[] { nameof(PaymentMethodType) });
+            }
+            if (PlanType != PlanType.Free && string.IsNullOrWhiteSpace(BillingAddressCountry))
+            {
+                yield return new ValidationResult("Country required.",
+                    new string[] { nameof(BillingAddressCountry) });
+            }
+            if (PlanType != PlanType.Free && BillingAddressCountry == "US" &&
+                string.IsNullOrWhiteSpace(BillingAddressPostalCode))
+            {
+                yield return new ValidationResult("Zip / postal code is required.",
+                    new string[] { nameof(BillingAddressPostalCode) });
+            }
+        }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationKeysRequestModel.cs

@@ -0,0 +1,59 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Models.Business;
+using Bit.Core.Models.Table;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationKeysRequestModel
+    {
+        [Required]
+        public string PublicKey { get; set; }
+        [Required]
+        public string EncryptedPrivateKey { get; set; }
+        
+        public OrganizationSignup ToOrganizationSignup(OrganizationSignup existingSignup)
+        {
+            if (string.IsNullOrWhiteSpace(existingSignup.PublicKey))
+            {
+                existingSignup.PublicKey = PublicKey;
+            }
+
+            if (string.IsNullOrWhiteSpace(existingSignup.PrivateKey))
+            {
+                existingSignup.PrivateKey = EncryptedPrivateKey;
+            }
+
+            return existingSignup;
+        }
+        
+        public OrganizationUpgrade ToOrganizationUpgrade(OrganizationUpgrade existingUpgrade)
+        {
+            if (string.IsNullOrWhiteSpace(existingUpgrade.PublicKey))
+            {
+                existingUpgrade.PublicKey = PublicKey;
+            }
+
+            if (string.IsNullOrWhiteSpace(existingUpgrade.PrivateKey))
+            {
+                existingUpgrade.PrivateKey = EncryptedPrivateKey;
+            }
+
+            return existingUpgrade;
+        }
+
+        public Organization ToOrganization(Organization existingOrg)
+        {
+            if (string.IsNullOrWhiteSpace(existingOrg.PublicKey))
+            {
+                existingOrg.PublicKey = PublicKey;
+            }
+
+            if (string.IsNullOrWhiteSpace(existingOrg.PrivateKey))
+            {
+                existingOrg.PrivateKey = EncryptedPrivateKey;
+            }
+
+            return existingOrg;
+        }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationSeatRequestModel.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationSeatRequestModel : IValidatableObject
+    {
+        [Required]
+        public int? SeatAdjustment { get; set; }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (SeatAdjustment == 0)
+            {
+                yield return new ValidationResult("Seat adjustment cannot be 0.", new string[] { nameof(SeatAdjustment) });
+            }
+        }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationSponsorshipRedeemRequestModel.cs

@@ -0,0 +1,14 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Enums;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationSponsorshipRedeemRequestModel
+    {
+        [Required]
+        public PlanSponsorshipType PlanSponsorshipType { get; set; }
+        [Required]
+        public Guid SponsoredOrganizationId { get; set; }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationSponsorshipRequestModel.cs

@@ -0,0 +1,20 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Enums;
+using Bit.Core.Utilities;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationSponsorshipRequestModel
+    {
+        [Required]
+        public PlanSponsorshipType PlanSponsorshipType { get; set; }
+
+        [Required]
+        [StringLength(256)]
+        [StrictEmailAddress]
+        public string SponsoredEmail { get; set; }
+
+        [StringLength(256)]
+        public string FriendlyName { get; set; }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationSsoRequestModel.cs

@@ -0,0 +1,239 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Security.Cryptography;
+using System.Security.Cryptography.X509Certificates;
+using System.Text.RegularExpressions;
+using Bit.Core.Enums;
+using Bit.Core.Models.Data;
+using Bit.Core.Models.Table;
+using Bit.Core.Services;
+using Bit.Core.Sso;
+using Microsoft.AspNetCore.Authentication.OpenIdConnect;
+using U2F.Core.Utils;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationSsoRequestModel
+    {
+        [Required]
+        public bool Enabled { get; set; }
+        [Required]
+        public SsoConfigurationDataRequest Data { get; set; }
+
+        public SsoConfig ToSsoConfig(Guid organizationId)
+        {
+            return ToSsoConfig(new SsoConfig { OrganizationId = organizationId });
+        }
+
+        public SsoConfig ToSsoConfig(SsoConfig existingConfig)
+        {
+            existingConfig.Enabled = Enabled;
+            var configurationData = Data.ToConfigurationData();
+            existingConfig.SetData(configurationData);
+            return existingConfig;
+        }
+    }
+
+    public class SsoConfigurationDataRequest : IValidatableObject
+    {
+        public SsoConfigurationDataRequest() {}
+
+        [Required]
+        public SsoType ConfigType { get; set; }
+
+        public bool KeyConnectorEnabled { get; set; }
+        public string KeyConnectorUrl { get; set; }
+
+        // OIDC
+        public string Authority { get; set; }
+        public string ClientId { get; set; }
+        public string ClientSecret { get; set; }
+        public string MetadataAddress { get; set; }
+        public OpenIdConnectRedirectBehavior RedirectBehavior { get; set; }
+        public bool? GetClaimsFromUserInfoEndpoint { get; set; }
+        public string AdditionalScopes { get; set; }
+        public string AdditionalUserIdClaimTypes { get; set; }
+        public string AdditionalEmailClaimTypes { get; set; }
+        public string AdditionalNameClaimTypes { get; set; }
+        public string AcrValues { get; set; }
+        public string ExpectedReturnAcrValue { get; set; }
+
+        // SAML2 SP
+        public Saml2NameIdFormat SpNameIdFormat { get; set; }
+        public string SpOutboundSigningAlgorithm { get; set; }
+        public Saml2SigningBehavior SpSigningBehavior { get; set; }
+        public bool? SpWantAssertionsSigned { get; set; }
+        public bool? SpValidateCertificates { get; set; }
+        public string SpMinIncomingSigningAlgorithm { get; set; }
+
+        // SAML2 IDP
+        public string IdpEntityId { get; set; }
+        public Saml2BindingType IdpBindingType { get; set; }
+        public string IdpSingleSignOnServiceUrl { get; set; }
+        public string IdpSingleLogoutServiceUrl { get; set; }
+        public string IdpArtifactResolutionServiceUrl { get; set; }
+        public string IdpX509PublicCert { get; set; }
+        public string IdpOutboundSigningAlgorithm { get; set; }
+        public bool? IdpAllowUnsolicitedAuthnResponse { get; set; }
+        public bool? IdpDisableOutboundLogoutRequests { get; set; }
+        public bool? IdpWantAuthnRequestsSigned { get; set; }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext context)
+        {
+            var i18nService = context.GetService(typeof(II18nService)) as I18nService;
+
+            if (ConfigType == SsoType.OpenIdConnect)
+            {
+                if (string.IsNullOrWhiteSpace(Authority))
+                {
+                    yield return new ValidationResult(i18nService.GetLocalizedHtmlString("AuthorityValidationError"),
+                        new[] { nameof(Authority) });
+                }
+
+                if (string.IsNullOrWhiteSpace(ClientId))
+                {
+                    yield return new ValidationResult(i18nService.GetLocalizedHtmlString("ClientIdValidationError"),
+                        new[] { nameof(ClientId) });
+                }
+
+                if (string.IsNullOrWhiteSpace(ClientSecret))
+                {
+                    yield return new ValidationResult(i18nService.GetLocalizedHtmlString("ClientSecretValidationError"),
+                        new[] { nameof(ClientSecret) });
+                }
+            }
+            else if (ConfigType == SsoType.Saml2)
+            {
+                if (string.IsNullOrWhiteSpace(IdpEntityId))
+                {
+                    yield return new ValidationResult(i18nService.GetLocalizedHtmlString("IdpEntityIdValidationError"),
+                        new[] { nameof(IdpEntityId) });
+                }
+
+                if (IdpBindingType == Saml2BindingType.Artifact && string.IsNullOrWhiteSpace(IdpArtifactResolutionServiceUrl))
+                {
+                    yield return new ValidationResult(i18nService.GetLocalizedHtmlString("Saml2BindingTypeValidationError"),
+                        new[] { nameof(IdpArtifactResolutionServiceUrl) });
+                }
+
+                if (!Uri.IsWellFormedUriString(IdpEntityId, UriKind.Absolute) && string.IsNullOrWhiteSpace(IdpSingleSignOnServiceUrl))
+                {
+                    yield return new ValidationResult(i18nService.GetLocalizedHtmlString("IdpSingleSignOnServiceUrlValidationError"),
+                        new[] { nameof(IdpSingleSignOnServiceUrl) });
+                }
+
+                if (InvalidServiceUrl(IdpSingleSignOnServiceUrl))
+                {
+                    yield return new ValidationResult(i18nService.GetLocalizedHtmlString("IdpSingleSignOnServiceUrlInvalid"),
+                        new[] { nameof(IdpSingleSignOnServiceUrl) });
+                }
+
+                if (InvalidServiceUrl(IdpArtifactResolutionServiceUrl))
+                {
+                    yield return new ValidationResult(i18nService.GetLocalizedHtmlString("IdpArtifactResolutionServiceUrlInvalid"),
+                        new[] { nameof(IdpArtifactResolutionServiceUrl) });
+                }
+
+                if (InvalidServiceUrl(IdpSingleLogoutServiceUrl))
+                {
+                    yield return new ValidationResult(i18nService.GetLocalizedHtmlString("IdpSingleLogoutServiceUrlInvalid"),
+                        new[] { nameof(IdpSingleLogoutServiceUrl) });
+                }
+
+                if (!string.IsNullOrWhiteSpace(IdpX509PublicCert))
+                {
+                    // Validate the certificate is in a valid format
+                    ValidationResult failedResult = null;
+                    try
+                    {
+                        var certData = StripPemCertificateElements(IdpX509PublicCert).Base64StringToByteArray();
+                        new X509Certificate2(certData);
+                    }
+                    catch (FormatException)
+                    {
+                        failedResult = new ValidationResult(i18nService.GetLocalizedHtmlString("IdpX509PublicCertInvalidFormatValidationError"),
+                            new[] { nameof(IdpX509PublicCert) });
+                    }
+                    catch (CryptographicException cryptoEx)
+                    {
+                        failedResult = new ValidationResult(i18nService.GetLocalizedHtmlString("IdpX509PublicCertCryptographicExceptionValidationError", cryptoEx.Message),
+                            new[] { nameof(IdpX509PublicCert) });
+                    }
+                    catch (Exception ex)
+                    {
+                        failedResult = new ValidationResult(i18nService.GetLocalizedHtmlString("IdpX509PublicCertValidationError", ex.Message),
+                            new[] { nameof(IdpX509PublicCert) });
+                    }
+                    if (failedResult != null)
+                    {
+                        yield return failedResult;
+                    }
+                }
+            }
+        }
+
+        public SsoConfigurationData ToConfigurationData()
+        {
+            return new SsoConfigurationData
+            {
+                ConfigType = ConfigType,
+                KeyConnectorEnabled = KeyConnectorEnabled,
+                KeyConnectorUrl = KeyConnectorUrl,
+                Authority = Authority,
+                ClientId = ClientId,
+                ClientSecret = ClientSecret,
+                MetadataAddress = MetadataAddress,
+                GetClaimsFromUserInfoEndpoint = GetClaimsFromUserInfoEndpoint.GetValueOrDefault(),
+                RedirectBehavior = RedirectBehavior,
+                IdpEntityId = IdpEntityId,
+                IdpBindingType = IdpBindingType,
+                IdpSingleSignOnServiceUrl = IdpSingleSignOnServiceUrl,
+                IdpSingleLogoutServiceUrl = IdpSingleLogoutServiceUrl,
+                IdpArtifactResolutionServiceUrl = IdpArtifactResolutionServiceUrl,
+                IdpX509PublicCert = StripPemCertificateElements(IdpX509PublicCert),
+                IdpOutboundSigningAlgorithm = IdpOutboundSigningAlgorithm,
+                IdpAllowUnsolicitedAuthnResponse = IdpAllowUnsolicitedAuthnResponse.GetValueOrDefault(),
+                IdpDisableOutboundLogoutRequests = IdpDisableOutboundLogoutRequests.GetValueOrDefault(),
+                IdpWantAuthnRequestsSigned = IdpWantAuthnRequestsSigned.GetValueOrDefault(),
+                SpNameIdFormat = SpNameIdFormat,
+                SpOutboundSigningAlgorithm = SpOutboundSigningAlgorithm ?? SamlSigningAlgorithms.Sha256,
+                SpSigningBehavior = SpSigningBehavior,
+                SpWantAssertionsSigned = SpWantAssertionsSigned.GetValueOrDefault(),
+                SpValidateCertificates = SpValidateCertificates.GetValueOrDefault(),
+                SpMinIncomingSigningAlgorithm = SpMinIncomingSigningAlgorithm,
+                AdditionalScopes = AdditionalScopes,
+                AdditionalUserIdClaimTypes = AdditionalUserIdClaimTypes,
+                AdditionalEmailClaimTypes = AdditionalEmailClaimTypes,
+                AdditionalNameClaimTypes = AdditionalNameClaimTypes,
+                AcrValues = AcrValues,
+                ExpectedReturnAcrValue = ExpectedReturnAcrValue,
+            };
+        }
+
+        private string StripPemCertificateElements(string certificateText)
+        {
+            if (string.IsNullOrWhiteSpace(certificateText))
+            {
+                return null;
+            }
+            return Regex.Replace(certificateText,
+                @"(((BEGIN|END) CERTIFICATE)|([\-\n\r\t\s\f]))",
+                string.Empty,
+                RegexOptions.Multiline | RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
+        }
+
+        private bool InvalidServiceUrl(string url)
+        {
+            if (string.IsNullOrWhiteSpace(url))
+            {
+                return false;
+            }
+            if (!url.StartsWith("http://") && !url.StartsWith("https://"))
+            {
+                return true;
+            }
+            return Regex.IsMatch(url, "[<>\"]");
+        }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationSubscriptionUpdateRequestModel.cs

@@ -0,0 +1,11 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationSubscriptionUpdateRequestModel
+    {
+        [Required]
+        public int SeatAdjustment { get; set; }
+        public int? MaxAutoscaleSeats { get; set; }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationTaxInfoUpdateRequestModel.cs

@@ -0,0 +1,13 @@
+using Bit.Api.Models.Request.Accounts;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationTaxInfoUpdateRequestModel : TaxInfoUpdateRequestModel
+    {
+        public string TaxId { get; set; }
+        public string Line1 { get; set; }
+        public string Line2 { get; set; }
+        public string City { get; set; }
+        public string State { get; set; }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationUpdateRequestModel.cs

@@ -0,0 +1,38 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Models.Data;
+using Bit.Core.Models.Table;
+using Bit.Core.Settings;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationUpdateRequestModel
+    {
+        [Required]
+        [StringLength(50)]
+        public string Name { get; set; }
+        [StringLength(50)]
+        public string BusinessName { get; set; }
+        [StringLength(50)]
+        public string Identifier { get; set; }
+        [EmailAddress]
+        [Required]
+        [StringLength(256)]
+        public string BillingEmail { get; set; }
+        public Permissions Permissions { get; set; }
+        public OrganizationKeysRequestModel Keys { get; set; }
+
+        public virtual Organization ToOrganization(Organization existingOrganization, GlobalSettings globalSettings)
+        {
+            if (!globalSettings.SelfHosted)
+            {
+                // These items come from the license file
+                existingOrganization.Name = Name;
+                existingOrganization.BusinessName = BusinessName;
+                existingOrganization.BillingEmail = BillingEmail?.ToLowerInvariant()?.Trim();
+            }
+            existingOrganization.Identifier = Identifier;
+            Keys?.ToOrganization(existingOrganization);
+            return existingOrganization;
+        }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationUpgradeRequestModel.cs

@@ -0,0 +1,42 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Enums;
+using Bit.Core.Models.Business;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationUpgradeRequestModel
+    {
+        [StringLength(50)]
+        public string BusinessName { get; set; }
+        public PlanType PlanType { get; set; }
+        [Range(0, int.MaxValue)]
+        public int AdditionalSeats { get; set; }
+        [Range(0, 99)]
+        public short? AdditionalStorageGb { get; set; }
+        public bool PremiumAccessAddon { get; set; }
+        public string BillingAddressCountry { get; set; }
+        public string BillingAddressPostalCode { get; set; }
+        public OrganizationKeysRequestModel Keys { get; set; }
+
+        public OrganizationUpgrade ToOrganizationUpgrade()
+        {
+            var orgUpgrade = new OrganizationUpgrade
+            {
+                AdditionalSeats = AdditionalSeats,
+                AdditionalStorageGb = AdditionalStorageGb.GetValueOrDefault(),
+                BusinessName = BusinessName,
+                Plan = PlanType,
+                PremiumAccessAddon = PremiumAccessAddon,
+                TaxInfo = new TaxInfo()
+                {
+                    BillingAddressCountry = BillingAddressCountry,
+                    BillingAddressPostalCode = BillingAddressPostalCode
+                }
+            };
+
+            Keys?.ToOrganizationUpgrade(orgUpgrade);
+
+            return orgUpgrade;
+        }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationUserRequestModels.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Text.Json;
+using Bit.Core.Enums;
+using Bit.Core.Models.Data;
+using Bit.Core.Models.Table;
+using Bit.Core.Utilities;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationUserInviteRequestModel
+    {
+        [Required]
+        [StrictEmailAddressList]
+        public IEnumerable<string> Emails { get; set; }
+        [Required]
+        public OrganizationUserType? Type { get; set; }
+        public bool AccessAll { get; set; }
+        public Permissions Permissions { get; set; }
+        public IEnumerable<SelectionReadOnlyRequestModel> Collections { get; set; }
+
+        public OrganizationUserInviteData ToData()
+        {
+            return new OrganizationUserInviteData
+            {
+                Emails = Emails,
+                Type = Type,
+                AccessAll = AccessAll,
+                Collections = Collections.Select(c => c.ToSelectionReadOnly()),
+                Permissions = Permissions,
+            };
+        }
+    }
+
+    public class OrganizationUserAcceptRequestModel
+    {
+        [Required]
+        public string Token { get; set; }
+    }
+
+    public class OrganizationUserConfirmRequestModel
+    {
+        [Required]
+        public string Key { get; set; }
+    }
+
+    public class OrganizationUserBulkConfirmRequestModelEntry
+    {
+        [Required]
+        public Guid Id { get; set; }
+        [Required]
+        public string Key { get; set; }
+    }
+
+    public class OrganizationUserBulkConfirmRequestModel
+    {
+        [Required]
+        public IEnumerable<OrganizationUserBulkConfirmRequestModelEntry> Keys { get; set; }
+
+        public Dictionary<Guid, string> ToDictionary()
+        {
+            return Keys.ToDictionary(e => e.Id, e => e.Key);
+        }
+    }
+
+    public class OrganizationUserUpdateRequestModel
+    {
+        [Required]
+        public OrganizationUserType? Type { get; set; }
+        public bool AccessAll { get; set; }
+        public Permissions Permissions { get; set; }
+        public IEnumerable<SelectionReadOnlyRequestModel> Collections { get; set; }
+
+        public OrganizationUser ToOrganizationUser(OrganizationUser existingUser)
+        {
+            existingUser.Type = Type.Value;
+            existingUser.Permissions = JsonSerializer.Serialize(Permissions, new JsonSerializerOptions
+            {
+                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+            });
+            existingUser.AccessAll = AccessAll;
+            return existingUser;
+        }
+    }
+
+    public class OrganizationUserUpdateGroupsRequestModel
+    {
+        [Required]
+        public IEnumerable<string> GroupIds { get; set; }
+    }
+    
+    public class OrganizationUserResetPasswordEnrollmentRequestModel
+    {
+        public string ResetPasswordKey { get; set; }
+    }
+
+    public class OrganizationUserBulkRequestModel
+    {
+        [Required]
+        public IEnumerable<Guid> Ids { get; set; }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationUserResetPasswordRequestModel.cs

@@ -0,0 +1,13 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationUserResetPasswordRequestModel
+    {
+        [Required]
+        [StringLength(300)]
+        public string NewMasterPasswordHash { get; set; }
+        [Required]
+        public string Key { get; set; }
+    }
+}

src/Api/Models/Request/Organizations/OrganizationVerifyBankRequestModel.cs

@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Organizations
+{
+    public class OrganizationVerifyBankRequestModel
+    {
+        [Required]
+        [Range(1, 99)]
+        public int? Amount1 { get; set; }
+        [Required]
+        [Range(1, 99)]
+        public int? Amount2 { get; set; }
+    }
+}

src/Api/Models/Request/PaymentRequestModel.cs

@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Api.Models.Request.Organizations;
+using Bit.Core.Enums;
+
+namespace Bit.Api.Models.Request
+{
+    public class PaymentRequestModel : OrganizationTaxInfoUpdateRequestModel
+    {
+        [Required]
+        public PaymentMethodType? PaymentMethodType { get; set; }
+        [Required]
+        public string PaymentToken { get; set; }
+    }
+}

src/Api/Models/Request/PolicyRequestModel.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Enums;
+using Bit.Core.Models.Table;
+using Newtonsoft.Json;
+
+namespace Bit.Api.Models.Request
+{
+    public class PolicyRequestModel
+    {
+        [Required]
+        public PolicyType? Type { get; set; }
+        [Required]
+        public bool? Enabled { get; set; }
+        public Dictionary<string, object> Data { get; set; }
+
+        public Policy ToPolicy(Guid orgId)
+        {
+            return ToPolicy(new Policy
+            {
+                Type = Type.Value,
+                OrganizationId = orgId
+            });
+        }
+
+        public Policy ToPolicy(Policy existingPolicy)
+        {
+            existingPolicy.Enabled = Enabled.GetValueOrDefault();
+            existingPolicy.Data = Data != null ? JsonConvert.SerializeObject(Data) : null;
+            return existingPolicy;
+        }
+    }
+}

src/Api/Models/Request/Providers/ProviderOrganizationAddRequestModel.cs

@@ -0,0 +1,14 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request.Providers
+{
+    public class ProviderOrganizationAddRequestModel
+    {
+        [Required]
+        public Guid OrganizationId { get; set; }
+
+        [Required]
+        public string Key { get; set; }
+    }
+}

src/Api/Models/Request/Providers/ProviderOrganizationCreateRequestModel.cs

@@ -0,0 +1,16 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Api.Models.Request.Organizations;
+using Bit.Core.Utilities;
+
+namespace Bit.Api.Models.Request.Providers
+{
+    public class ProviderOrganizationCreateRequestModel
+    {
+        [Required]
+        [StringLength(256)]
+        [StrictEmailAddress]
+        public string ClientOwnerEmail { get; set; }
+        [Required]
+        public OrganizationCreateRequestModel OrganizationCreateRequest { get; set; }
+    }
+}

src/Api/Models/Request/Providers/ProviderSetupRequestModel.cs

@@ -0,0 +1,31 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Models.Table.Provider;
+
+namespace Bit.Api.Models.Request.Providers
+{
+    public class ProviderSetupRequestModel
+    {
+        [Required]
+        [StringLength(50)]
+        public string Name { get; set; }
+        [StringLength(50)]
+        public string BusinessName { get; set; }
+        [Required]
+        [StringLength(256)]
+        [EmailAddress]
+        public string BillingEmail { get; set; }
+        [Required]
+        public string Token { get; set; }
+        [Required]
+        public string Key { get; set; }
+
+        public virtual Provider ToProvider(Provider provider)
+        {
+            provider.Name = Name;
+            provider.BusinessName = BusinessName;
+            provider.BillingEmail = BillingEmail;
+
+            return provider;
+        }
+    }
+}

src/Api/Models/Request/Providers/ProviderUpdateRequestModel.cs

@@ -0,0 +1,31 @@
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Models.Table.Provider;
+using Bit.Core.Settings;
+
+namespace Bit.Api.Models.Request.Providers
+{
+    public class ProviderUpdateRequestModel
+    {
+        [Required]
+        [StringLength(50)]
+        public string Name { get; set; }
+        [StringLength(50)]
+        public string BusinessName { get; set; }
+        [EmailAddress]
+        [Required]
+        [StringLength(256)]
+        public string BillingEmail { get; set; }
+
+        public virtual Provider ToProvider(Provider existingProvider, GlobalSettings globalSettings)
+        {
+            if (!globalSettings.SelfHosted)
+            {
+                // These items come from the license file
+                existingProvider.Name = Name;
+                existingProvider.BusinessName = BusinessName;
+                existingProvider.BillingEmail = BillingEmail?.ToLowerInvariant()?.Trim();
+            }
+            return existingProvider;
+        }
+    }
+}

src/Api/Models/Request/Providers/ProviderUserRequestModels.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using Bit.Core.Enums.Provider;
+using Bit.Core.Models.Table.Provider;
+using Bit.Core.Utilities;
+
+namespace Bit.Api.Models.Request.Providers
+{
+    public class ProviderUserInviteRequestModel
+    {
+        [Required]
+        [StrictEmailAddressList]
+        public IEnumerable<string> Emails { get; set; }
+        [Required]
+        public ProviderUserType? Type { get; set; }
+    }
+
+    public class ProviderUserAcceptRequestModel
+    {
+        [Required]
+        public string Token { get; set; }
+    }
+
+    public class ProviderUserConfirmRequestModel
+    {
+        [Required]
+        public string Key { get; set; }
+    }
+
+    public class ProviderUserBulkConfirmRequestModelEntry
+    {
+        [Required]
+        public Guid Id { get; set; }
+        [Required]
+        public string Key { get; set; }
+    }
+
+    public class ProviderUserBulkConfirmRequestModel
+    {
+        [Required]
+        public IEnumerable<ProviderUserBulkConfirmRequestModelEntry> Keys { get; set; }
+
+        public Dictionary<Guid, string> ToDictionary()
+        {
+            return Keys.ToDictionary(e => e.Id, e => e.Key);
+        }
+    }
+
+    public class ProviderUserUpdateRequestModel
+    {
+        [Required]
+        public ProviderUserType? Type { get; set; }
+
+        public ProviderUser ToProviderUser(ProviderUser existingUser)
+        {
+            existingUser.Type = Type.Value;
+            return existingUser;
+        }
+    }
+
+    public class ProviderUserBulkRequestModel
+    {
+        [Required]
+        public IEnumerable<Guid> Ids { get; set; }
+    }
+}

src/Api/Models/Request/SelectionReadOnlyRequestModel.cs

@@ -0,0 +1,24 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Models.Data;
+
+namespace Bit.Api.Models.Request
+{
+    public class SelectionReadOnlyRequestModel
+    {
+        [Required]
+        public string Id { get; set; }
+        public bool ReadOnly { get; set; }
+        public bool HidePasswords { get; set; }
+
+        public SelectionReadOnly ToSelectionReadOnly()
+        {
+            return new SelectionReadOnly
+            {
+                Id = new Guid(Id),
+                ReadOnly = ReadOnly,
+                HidePasswords = HidePasswords,
+            };
+        }
+    }
+}

src/Api/Models/Request/SendAccessRequestModel.cs

@@ -0,0 +1,10 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Bit.Api.Models.Request
+{
+    public class SendAccessRequestModel
+    {
+        [StringLength(300)]
+        public string Password { get; set; }
+    }
+}

src/Api/Models/Request/SendRequestModel.cs

@@ -0,0 +1,144 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Bit.Core.Enums;
+using Bit.Core.Exceptions;
+using Bit.Core.Models.Data;
+using Bit.Core.Models.Table;
+using Bit.Core.Services;
+using Bit.Core.Utilities;
+using Newtonsoft.Json;
+
+namespace Bit.Api.Models.Request
+{
+    public class SendRequestModel
+    {
+        public SendType Type { get; set; }
+        public long? FileLength { get; set; } = null;
+        [EncryptedString]
+        [EncryptedStringLength(1000)]
+        public string Name { get; set; }
+        [EncryptedString]
+        [EncryptedStringLength(1000)]
+        public string Notes { get; set; }
+        [Required]
+        [EncryptedString]
+        [EncryptedStringLength(1000)]
+        public string Key { get; set; }
+        [Range(1, int.MaxValue)]
+        public int? MaxAccessCount { get; set; }
+        public DateTime? ExpirationDate { get; set; }
+        [Required]
+        public DateTime? DeletionDate { get; set; }
+        public SendFileModel File { get; set; }
+        public SendTextModel Text { get; set; }
+        [StringLength(1000)]
+        public string Password { get; set; }
+        [Required]
+        public bool? Disabled { get; set; }
+        public bool? HideEmail { get; set; }
+
+        public Send ToSend(Guid userId, ISendService sendService)
+        {
+            var send = new Send
+            {
+                Type = Type,
+                UserId = (Guid?)userId
+            };
+            ToSend(send, sendService);
+            return send;
+        }
+
+        public (Send, SendFileData) ToSend(Guid userId, string fileName, ISendService sendService)
+        {
+            var send = ToSendBase(new Send
+            {
+                Type = Type,
+                UserId = (Guid?)userId
+            }, sendService);
+            var data = new SendFileData(Name, Notes, fileName);
+            return (send, data);
+        }
+
+        public Send ToSend(Send existingSend, ISendService sendService)
+        {
+            existingSend = ToSendBase(existingSend, sendService);
+            switch (existingSend.Type)
+            {
+                case SendType.File:
+                    var fileData = JsonConvert.DeserializeObject<SendFileData>(existingSend.Data);
+                    fileData.Name = Name;
+                    fileData.Notes = Notes;
+                    existingSend.Data = JsonConvert.SerializeObject(fileData,
+                        new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
+                    break;
+                case SendType.Text:
+                    existingSend.Data = JsonConvert.SerializeObject(ToSendData(),
+                        new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
+                    break;
+                default:
+                    throw new ArgumentException("Unsupported type: " + nameof(Type) + ".");
+            }
+            return existingSend;
+        }
+
+        public void ValidateCreation()
+        {
+            var now = DateTime.UtcNow;
+            // Add 1 minute for a sane buffer and client clock float
+            var nowPlus1Minute = now.AddMinutes(1);
+            if (ExpirationDate.HasValue && ExpirationDate.Value <= nowPlus1Minute)
+            {
+                throw new BadRequestException("You cannot create a Send that is already expired. " +
+                    "Adjust the expiration date and try again.");
+            }
+            ValidateEdit();
+        }
+
+        public void ValidateEdit()
+        {
+            var now = DateTime.UtcNow;
+            // Add 1 minute for a sane buffer and client clock float
+            var nowPlus1Minute = now.AddMinutes(1);
+            if (DeletionDate.HasValue)
+            {
+                if (DeletionDate.Value <= nowPlus1Minute)
+                {
+                    throw new BadRequestException("You cannot have a Send with a deletion date in the past. " +
+                        "Adjust the deletion date and try again.");
+                }
+                if (DeletionDate.Value > now.AddDays(31))
+                {
+                    throw new BadRequestException("You cannot have a Send with a deletion date that far " +
+                        "into the future. Adjust the Deletion Date to a value less than 31 days from now " +
+                        "and try again.");
+                }
+            }
+        }
+
+        private Send ToSendBase(Send existingSend, ISendService sendService)
+        {
+            existingSend.Key = Key;
+            existingSend.ExpirationDate = ExpirationDate;
+            existingSend.DeletionDate = DeletionDate.Value;
+            existingSend.MaxAccessCount = MaxAccessCount;
+            if (!string.IsNullOrWhiteSpace(Password))
+            {
+                existingSend.Password = sendService.HashPassword(Password);
+            }
+            existingSend.Disabled = Disabled.GetValueOrDefault();
+            existingSend.HideEmail = HideEmail.GetValueOrDefault();
+            return existingSend;
+        }
+
+        private SendData ToSendData()
+        {
+            return new SendTextData(Name, Notes, Text.Text, Text.Hidden);
+        }
+    }
+
+    public class SendWithIdRequestModel : SendRequestModel
+    {
+        [Required]
+        public Guid? Id { get; set; }
+    }
+}

src/Api/Models/Request/TwoFactorRequestModels.cs

@@ -0,0 +1,273 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Bit.Api.Models.Request.Accounts;
+using Bit.Core.Enums;
+using Bit.Core.Models;
+using Bit.Core.Models.Table;
+using Fido2NetLib;
+
+namespace Bit.Api.Models.Request
+{
+    public class UpdateTwoFactorAuthenticatorRequestModel : SecretVerificationRequestModel
+    {
+        [Required]
+        [StringLength(50)]
+        public string Token { get; set; }
+        [Required]
+        [StringLength(50)]
+        public string Key { get; set; }
+
+        public User ToUser(User extistingUser)
+        {
+            var providers = extistingUser.GetTwoFactorProviders();
+            if (providers == null)
+            {
+                providers = new Dictionary<TwoFactorProviderType, TwoFactorProvider>();
+            }
+            else if (providers.ContainsKey(TwoFactorProviderType.Authenticator))
+            {
+                providers.Remove(TwoFactorProviderType.Authenticator);
+            }
+
+            providers.Add(TwoFactorProviderType.Authenticator, new TwoFactorProvider
+            {
+                MetaData = new Dictionary<string, object> { ["Key"] = Key },
+                Enabled = true
+            });
+            extistingUser.SetTwoFactorProviders(providers);
+            return extistingUser;
+        }
+    }
+
+    public class UpdateTwoFactorDuoRequestModel : SecretVerificationRequestModel, IValidatableObject
+    {
+        [Required]
+        [StringLength(50)]
+        public string IntegrationKey { get; set; }
+        [Required]
+        [StringLength(50)]
+        public string SecretKey { get; set; }
+        [Required]
+        [StringLength(50)]
+        public string Host { get; set; }
+
+        public User ToUser(User extistingUser)
+        {
+            var providers = extistingUser.GetTwoFactorProviders();
+            if (providers == null)
+            {
+                providers = new Dictionary<TwoFactorProviderType, TwoFactorProvider>();
+            }
+            else if (providers.ContainsKey(TwoFactorProviderType.Duo))
+            {
+                providers.Remove(TwoFactorProviderType.Duo);
+            }
+
+            providers.Add(TwoFactorProviderType.Duo, new TwoFactorProvider
+            {
+                MetaData = new Dictionary<string, object>
+                {
+                    ["SKey"] = SecretKey,
+                    ["IKey"] = IntegrationKey,
+                    ["Host"] = Host
+                },
+                Enabled = true
+            });
+            extistingUser.SetTwoFactorProviders(providers);
+            return extistingUser;
+        }
+
+        public Organization ToOrganization(Organization extistingOrg)
+        {
+            var providers = extistingOrg.GetTwoFactorProviders();
+            if (providers == null)
+            {
+                providers = new Dictionary<TwoFactorProviderType, TwoFactorProvider>();
+            }
+            else if (providers.ContainsKey(TwoFactorProviderType.OrganizationDuo))
+            {
+                providers.Remove(TwoFactorProviderType.OrganizationDuo);
+            }
+
+            providers.Add(TwoFactorProviderType.OrganizationDuo, new TwoFactorProvider
+            {
+                MetaData = new Dictionary<string, object>
+                {
+                    ["SKey"] = SecretKey,
+                    ["IKey"] = IntegrationKey,
+                    ["Host"] = Host
+                },
+                Enabled = true
+            });
+            extistingOrg.SetTwoFactorProviders(providers);
+            return extistingOrg;
+        }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (!Host.StartsWith("api-") || (!Host.EndsWith(".duosecurity.com") && !Host.EndsWith(".duofederal.com")))
+            {
+                yield return new ValidationResult("Host is invalid.", new string[] { nameof(Host) });
+            }
+        }
+    }
+
+    public class UpdateTwoFactorYubicoOtpRequestModel : SecretVerificationRequestModel, IValidatableObject
+    {
+        public string Key1 { get; set; }
+        public string Key2 { get; set; }
+        public string Key3 { get; set; }
+        public string Key4 { get; set; }
+        public string Key5 { get; set; }
+        [Required]
+        public bool? Nfc { get; set; }
+
+        public User ToUser(User extistingUser)
+        {
+            var providers = extistingUser.GetTwoFactorProviders();
+            if (providers == null)
+            {
+                providers = new Dictionary<TwoFactorProviderType, TwoFactorProvider>();
+            }
+            else if (providers.ContainsKey(TwoFactorProviderType.YubiKey))
+            {
+                providers.Remove(TwoFactorProviderType.YubiKey);
+            }
+
+            providers.Add(TwoFactorProviderType.YubiKey, new TwoFactorProvider
+            {
+                MetaData = new Dictionary<string, object>
+                {
+                    ["Key1"] = FormatKey(Key1),
+                    ["Key2"] = FormatKey(Key2),
+                    ["Key3"] = FormatKey(Key3),
+                    ["Key4"] = FormatKey(Key4),
+                    ["Key5"] = FormatKey(Key5),
+                    ["Nfc"] = Nfc.Value
+                },
+                Enabled = true
+            });
+            extistingUser.SetTwoFactorProviders(providers);
+            return extistingUser;
+        }
+
+        private string FormatKey(string keyValue)
+        {
+            if (string.IsNullOrWhiteSpace(keyValue))
+            {
+                return null;
+            }
+
+            return keyValue.Substring(0, 12);
+        }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (string.IsNullOrWhiteSpace(Key1) && string.IsNullOrWhiteSpace(Key2) && string.IsNullOrWhiteSpace(Key3) &&
+                string.IsNullOrWhiteSpace(Key4) && string.IsNullOrWhiteSpace(Key5))
+            {
+                yield return new ValidationResult("A key is required.", new string[] { nameof(Key1) });
+            }
+
+            if (!string.IsNullOrWhiteSpace(Key1) && Key1.Length < 12)
+            {
+                yield return new ValidationResult("Key 1 in invalid.", new string[] { nameof(Key1) });
+            }
+
+            if (!string.IsNullOrWhiteSpace(Key2) && Key2.Length < 12)
+            {
+                yield return new ValidationResult("Key 2 in invalid.", new string[] { nameof(Key2) });
+            }
+
+            if (!string.IsNullOrWhiteSpace(Key3) && Key3.Length < 12)
+            {
+                yield return new ValidationResult("Key 3 in invalid.", new string[] { nameof(Key3) });
+            }
+
+            if (!string.IsNullOrWhiteSpace(Key4) && Key4.Length < 12)
+            {
+                yield return new ValidationResult("Key 4 in invalid.", new string[] { nameof(Key4) });
+            }
+
+            if (!string.IsNullOrWhiteSpace(Key5) && Key5.Length < 12)
+            {
+                yield return new ValidationResult("Key 5 in invalid.", new string[] { nameof(Key5) });
+            }
+        }
+    }
+
+    public class TwoFactorEmailRequestModel : SecretVerificationRequestModel
+    {
+        [Required]
+        [EmailAddress]
+        [StringLength(256)]
+        public string Email { get; set; }
+
+        public User ToUser(User extistingUser)
+        {
+            var providers = extistingUser.GetTwoFactorProviders();
+            if (providers == null)
+            {
+                providers = new Dictionary<TwoFactorProviderType, TwoFactorProvider>();
+            }
+            else if (providers.ContainsKey(TwoFactorProviderType.Email))
+            {
+                providers.Remove(TwoFactorProviderType.Email);
+            }
+
+            providers.Add(TwoFactorProviderType.Email, new TwoFactorProvider
+            {
+                MetaData = new Dictionary<string, object> { ["Email"] = Email.ToLowerInvariant() },
+                Enabled = true
+            });
+            extistingUser.SetTwoFactorProviders(providers);
+            return extistingUser;
+        }
+    }
+
+    public class TwoFactorWebAuthnRequestModel : TwoFactorWebAuthnDeleteRequestModel
+    {
+        [Required]
+        public AuthenticatorAttestationRawResponse DeviceResponse { get; set; }
+        public string Name { get; set; }
+    }
+
+    public class TwoFactorWebAuthnDeleteRequestModel : SecretVerificationRequestModel, IValidatableObject
+    {
+        [Required]
+        public int? Id { get; set; }
+
+        public override IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            foreach (var validationResult in base.Validate(validationContext))
+            {
+                yield return validationResult;
+            }
+
+            if (!Id.HasValue || Id < 0 || Id > 5)
+            {
+                yield return new ValidationResult("Invalid Key Id", new string[] { nameof(Id) });
+            }
+        }
+    }
+
+    public class UpdateTwoFactorEmailRequestModel : TwoFactorEmailRequestModel
+    {
+        [Required]
+        [StringLength(50)]
+        public string Token { get; set; }
+    }
+
+    public class TwoFactorProviderRequestModel : SecretVerificationRequestModel
+    {
+        [Required]
+        public TwoFactorProviderType? Type { get; set; }
+    }
+
+    public class TwoFactorRecoveryRequestModel : TwoFactorEmailRequestModel
+    {
+        [Required]
+        [StringLength(32)]
+        public string RecoveryCode { get; set; }
+    }
+}

src/Api/Models/Request/UpdateDomainsRequestModel.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using Bit.Core.Enums;
+using Bit.Core.Models.Table;
+using Newtonsoft.Json;
+
+namespace Bit.Api.Models.Request
+{
+    public class UpdateDomainsRequestModel
+    {
+        public IEnumerable<IEnumerable<string>> EquivalentDomains { get; set; }
+        public IEnumerable<GlobalEquivalentDomainsType> ExcludedGlobalEquivalentDomains { get; set; }
+
+        public User ToUser(User existingUser)
+        {
+            existingUser.EquivalentDomains = EquivalentDomains != null ? JsonConvert.SerializeObject(EquivalentDomains) : null;
+            existingUser.ExcludedGlobalEquivalentDomains = ExcludedGlobalEquivalentDomains != null ?
+                JsonConvert.SerializeObject(ExcludedGlobalEquivalentDomains) : null;
+            return existingUser;
+        }
+    }
+}