Move to libs

2025-12-13 23:03:32 +00:00 · 2022-06-03 16:24:40 +02:00
parent 28d15bfe2a
commit d7492e3cf3
878 changed files with 0 additions and 0 deletions
--- a/libs/common/src/abstractions/api.service.ts
+++ b/libs/common/src/abstractions/api.service.ts
@@ -0,0 +1,716 @@
+import { OrganizationConnectionType } from "jslib-common/enums/organizationConnectionType";
+import { OrganizationConnectionRequest } from "jslib-common/models/request/organizationConnectionRequest";
+import { BillingHistoryResponse } from "jslib-common/models/response/billingHistoryResponse";
+import { BillingPaymentResponse } from "jslib-common/models/response/billingPaymentResponse";
+import {
+  OrganizationConnectionConfigApis,
+  OrganizationConnectionResponse,
+} from "jslib-common/models/response/organizationConnectionResponse";
+import { SsoPreValidateResponse } from "jslib-common/models/response/ssoPreValidateResponse";
+
+import { PolicyType } from "../enums/policyType";
+import { SetKeyConnectorKeyRequest } from "../models/request/account/setKeyConnectorKeyRequest";
+import { VerifyOTPRequest } from "../models/request/account/verifyOTPRequest";
+import { AttachmentRequest } from "../models/request/attachmentRequest";
+import { BitPayInvoiceRequest } from "../models/request/bitPayInvoiceRequest";
+import { CipherBulkDeleteRequest } from "../models/request/cipherBulkDeleteRequest";
+import { CipherBulkMoveRequest } from "../models/request/cipherBulkMoveRequest";
+import { CipherBulkRestoreRequest } from "../models/request/cipherBulkRestoreRequest";
+import { CipherBulkShareRequest } from "../models/request/cipherBulkShareRequest";
+import { CipherCollectionsRequest } from "../models/request/cipherCollectionsRequest";
+import { CipherCreateRequest } from "../models/request/cipherCreateRequest";
+import { CipherRequest } from "../models/request/cipherRequest";
+import { CipherShareRequest } from "../models/request/cipherShareRequest";
+import { CollectionRequest } from "../models/request/collectionRequest";
+import { DeleteRecoverRequest } from "../models/request/deleteRecoverRequest";
+import { EmailRequest } from "../models/request/emailRequest";
+import { EmailTokenRequest } from "../models/request/emailTokenRequest";
+import { EmergencyAccessAcceptRequest } from "../models/request/emergencyAccessAcceptRequest";
+import { EmergencyAccessConfirmRequest } from "../models/request/emergencyAccessConfirmRequest";
+import { EmergencyAccessInviteRequest } from "../models/request/emergencyAccessInviteRequest";
+import { EmergencyAccessPasswordRequest } from "../models/request/emergencyAccessPasswordRequest";
+import { EmergencyAccessUpdateRequest } from "../models/request/emergencyAccessUpdateRequest";
+import { EventRequest } from "../models/request/eventRequest";
+import { FolderRequest } from "../models/request/folderRequest";
+import { GroupRequest } from "../models/request/groupRequest";
+import { IapCheckRequest } from "../models/request/iapCheckRequest";
+import { ApiTokenRequest } from "../models/request/identityToken/apiTokenRequest";
+import { PasswordTokenRequest } from "../models/request/identityToken/passwordTokenRequest";
+import { SsoTokenRequest } from "../models/request/identityToken/ssoTokenRequest";
+import { ImportCiphersRequest } from "../models/request/importCiphersRequest";
+import { ImportDirectoryRequest } from "../models/request/importDirectoryRequest";
+import { ImportOrganizationCiphersRequest } from "../models/request/importOrganizationCiphersRequest";
+import { KdfRequest } from "../models/request/kdfRequest";
+import { KeyConnectorUserKeyRequest } from "../models/request/keyConnectorUserKeyRequest";
+import { KeysRequest } from "../models/request/keysRequest";
+import { OrganizationSponsorshipCreateRequest } from "../models/request/organization/organizationSponsorshipCreateRequest";
+import { OrganizationSponsorshipRedeemRequest } from "../models/request/organization/organizationSponsorshipRedeemRequest";
+import { OrganizationSsoRequest } from "../models/request/organization/organizationSsoRequest";
+import { OrganizationApiKeyRequest } from "../models/request/organizationApiKeyRequest";
+import { OrganizationCreateRequest } from "../models/request/organizationCreateRequest";
+import { OrganizationImportRequest } from "../models/request/organizationImportRequest";
+import { OrganizationKeysRequest } from "../models/request/organizationKeysRequest";
+import { OrganizationSubscriptionUpdateRequest } from "../models/request/organizationSubscriptionUpdateRequest";
+import { OrganizationTaxInfoUpdateRequest } from "../models/request/organizationTaxInfoUpdateRequest";
+import { OrganizationUpdateRequest } from "../models/request/organizationUpdateRequest";
+import { OrganizationUpgradeRequest } from "../models/request/organizationUpgradeRequest";
+import { OrganizationUserAcceptRequest } from "../models/request/organizationUserAcceptRequest";
+import { OrganizationUserBulkConfirmRequest } from "../models/request/organizationUserBulkConfirmRequest";
+import { OrganizationUserBulkRequest } from "../models/request/organizationUserBulkRequest";
+import { OrganizationUserConfirmRequest } from "../models/request/organizationUserConfirmRequest";
+import { OrganizationUserInviteRequest } from "../models/request/organizationUserInviteRequest";
+import { OrganizationUserResetPasswordEnrollmentRequest } from "../models/request/organizationUserResetPasswordEnrollmentRequest";
+import { OrganizationUserResetPasswordRequest } from "../models/request/organizationUserResetPasswordRequest";
+import { OrganizationUserUpdateGroupsRequest } from "../models/request/organizationUserUpdateGroupsRequest";
+import { OrganizationUserUpdateRequest } from "../models/request/organizationUserUpdateRequest";
+import { PasswordHintRequest } from "../models/request/passwordHintRequest";
+import { PasswordRequest } from "../models/request/passwordRequest";
+import { PaymentRequest } from "../models/request/paymentRequest";
+import { PolicyRequest } from "../models/request/policyRequest";
+import { PreloginRequest } from "../models/request/preloginRequest";
+import { ProviderAddOrganizationRequest } from "../models/request/provider/providerAddOrganizationRequest";
+import { ProviderOrganizationCreateRequest } from "../models/request/provider/providerOrganizationCreateRequest";
+import { ProviderSetupRequest } from "../models/request/provider/providerSetupRequest";
+import { ProviderUpdateRequest } from "../models/request/provider/providerUpdateRequest";
+import { ProviderUserAcceptRequest } from "../models/request/provider/providerUserAcceptRequest";
+import { ProviderUserBulkConfirmRequest } from "../models/request/provider/providerUserBulkConfirmRequest";
+import { ProviderUserBulkRequest } from "../models/request/provider/providerUserBulkRequest";
+import { ProviderUserConfirmRequest } from "../models/request/provider/providerUserConfirmRequest";
+import { ProviderUserInviteRequest } from "../models/request/provider/providerUserInviteRequest";
+import { ProviderUserUpdateRequest } from "../models/request/provider/providerUserUpdateRequest";
+import { RegisterRequest } from "../models/request/registerRequest";
+import { SeatRequest } from "../models/request/seatRequest";
+import { SecretVerificationRequest } from "../models/request/secretVerificationRequest";
+import { SelectionReadOnlyRequest } from "../models/request/selectionReadOnlyRequest";
+import { SendAccessRequest } from "../models/request/sendAccessRequest";
+import { SendRequest } from "../models/request/sendRequest";
+import { SetPasswordRequest } from "../models/request/setPasswordRequest";
+import { StorageRequest } from "../models/request/storageRequest";
+import { TaxInfoUpdateRequest } from "../models/request/taxInfoUpdateRequest";
+import { TwoFactorEmailRequest } from "../models/request/twoFactorEmailRequest";
+import { TwoFactorProviderRequest } from "../models/request/twoFactorProviderRequest";
+import { TwoFactorRecoveryRequest } from "../models/request/twoFactorRecoveryRequest";
+import { UpdateDomainsRequest } from "../models/request/updateDomainsRequest";
+import { UpdateKeyRequest } from "../models/request/updateKeyRequest";
+import { UpdateProfileRequest } from "../models/request/updateProfileRequest";
+import { UpdateTempPasswordRequest } from "../models/request/updateTempPasswordRequest";
+import { UpdateTwoFactorAuthenticatorRequest } from "../models/request/updateTwoFactorAuthenticatorRequest";
+import { UpdateTwoFactorDuoRequest } from "../models/request/updateTwoFactorDuoRequest";
+import { UpdateTwoFactorEmailRequest } from "../models/request/updateTwoFactorEmailRequest";
+import { UpdateTwoFactorWebAuthnDeleteRequest } from "../models/request/updateTwoFactorWebAuthnDeleteRequest";
+import { UpdateTwoFactorWebAuthnRequest } from "../models/request/updateTwoFactorWebAuthnRequest";
+import { UpdateTwoFactorYubioOtpRequest } from "../models/request/updateTwoFactorYubioOtpRequest";
+import { VerifyBankRequest } from "../models/request/verifyBankRequest";
+import { VerifyDeleteRecoverRequest } from "../models/request/verifyDeleteRecoverRequest";
+import { VerifyEmailRequest } from "../models/request/verifyEmailRequest";
+import { ApiKeyResponse } from "../models/response/apiKeyResponse";
+import { AttachmentResponse } from "../models/response/attachmentResponse";
+import { AttachmentUploadDataResponse } from "../models/response/attachmentUploadDataResponse";
+import { BillingResponse } from "../models/response/billingResponse";
+import { BreachAccountResponse } from "../models/response/breachAccountResponse";
+import { CipherResponse } from "../models/response/cipherResponse";
+import {
+  CollectionGroupDetailsResponse,
+  CollectionResponse,
+} from "../models/response/collectionResponse";
+import { DomainsResponse } from "../models/response/domainsResponse";
+import {
+  EmergencyAccessGranteeDetailsResponse,
+  EmergencyAccessGrantorDetailsResponse,
+  EmergencyAccessTakeoverResponse,
+  EmergencyAccessViewResponse,
+} from "../models/response/emergencyAccessResponse";
+import { EventResponse } from "../models/response/eventResponse";
+import { FolderResponse } from "../models/response/folderResponse";
+import { GroupDetailsResponse, GroupResponse } from "../models/response/groupResponse";
+import { IdentityCaptchaResponse } from "../models/response/identityCaptchaResponse";
+import { IdentityTokenResponse } from "../models/response/identityTokenResponse";
+import { IdentityTwoFactorResponse } from "../models/response/identityTwoFactorResponse";
+import { KeyConnectorUserKeyResponse } from "../models/response/keyConnectorUserKeyResponse";
+import { ListResponse } from "../models/response/listResponse";
+import { OrganizationSsoResponse } from "../models/response/organization/organizationSsoResponse";
+import { OrganizationApiKeyInformationResponse } from "../models/response/organizationApiKeyInformationResponse";
+import { OrganizationAutoEnrollStatusResponse } from "../models/response/organizationAutoEnrollStatusResponse";
+import { OrganizationKeysResponse } from "../models/response/organizationKeysResponse";
+import { OrganizationResponse } from "../models/response/organizationResponse";
+import { OrganizationSponsorshipSyncStatusResponse } from "../models/response/organizationSponsorshipSyncStatusResponse";
+import { OrganizationSubscriptionResponse } from "../models/response/organizationSubscriptionResponse";
+import { OrganizationUserBulkPublicKeyResponse } from "../models/response/organizationUserBulkPublicKeyResponse";
+import { OrganizationUserBulkResponse } from "../models/response/organizationUserBulkResponse";
+import {
+  OrganizationUserDetailsResponse,
+  OrganizationUserResetPasswordDetailsReponse,
+  OrganizationUserUserDetailsResponse,
+} from "../models/response/organizationUserResponse";
+import { PaymentResponse } from "../models/response/paymentResponse";
+import { PlanResponse } from "../models/response/planResponse";
+import { PolicyResponse } from "../models/response/policyResponse";
+import { PreloginResponse } from "../models/response/preloginResponse";
+import { ProfileResponse } from "../models/response/profileResponse";
+import {
+  ProviderOrganizationOrganizationDetailsResponse,
+  ProviderOrganizationResponse,
+} from "../models/response/provider/providerOrganizationResponse";
+import { ProviderResponse } from "../models/response/provider/providerResponse";
+import { ProviderUserBulkPublicKeyResponse } from "../models/response/provider/providerUserBulkPublicKeyResponse";
+import { ProviderUserBulkResponse } from "../models/response/provider/providerUserBulkResponse";
+import {
+  ProviderUserResponse,
+  ProviderUserUserDetailsResponse,
+} from "../models/response/provider/providerUserResponse";
+import { SelectionReadOnlyResponse } from "../models/response/selectionReadOnlyResponse";
+import { SendAccessResponse } from "../models/response/sendAccessResponse";
+import { SendFileDownloadDataResponse } from "../models/response/sendFileDownloadDataResponse";
+import { SendFileUploadDataResponse } from "../models/response/sendFileUploadDataResponse";
+import { SendResponse } from "../models/response/sendResponse";
+import { SubscriptionResponse } from "../models/response/subscriptionResponse";
+import { SyncResponse } from "../models/response/syncResponse";
+import { TaxInfoResponse } from "../models/response/taxInfoResponse";
+import { TaxRateResponse } from "../models/response/taxRateResponse";
+import { TwoFactorAuthenticatorResponse } from "../models/response/twoFactorAuthenticatorResponse";
+import { TwoFactorDuoResponse } from "../models/response/twoFactorDuoResponse";
+import { TwoFactorEmailResponse } from "../models/response/twoFactorEmailResponse";
+import { TwoFactorProviderResponse } from "../models/response/twoFactorProviderResponse";
+import { TwoFactorRecoverResponse } from "../models/response/twoFactorRescoverResponse";
+import {
+  ChallengeResponse,
+  TwoFactorWebAuthnResponse,
+} from "../models/response/twoFactorWebAuthnResponse";
+import { TwoFactorYubiKeyResponse } from "../models/response/twoFactorYubiKeyResponse";
+import { UserKeyResponse } from "../models/response/userKeyResponse";
+import { SendAccessView } from "../models/view/sendAccessView";
+
+export abstract class ApiService {
+  postIdentityToken: (
+    request: PasswordTokenRequest | SsoTokenRequest | ApiTokenRequest
+  ) => Promise<IdentityTokenResponse | IdentityTwoFactorResponse | IdentityCaptchaResponse>;
+  refreshIdentityToken: () => Promise<any>;
+
+  getProfile: () => Promise<ProfileResponse>;
+  getUserSubscription: () => Promise<SubscriptionResponse>;
+  getTaxInfo: () => Promise<TaxInfoResponse>;
+  putProfile: (request: UpdateProfileRequest) => Promise<ProfileResponse>;
+  putTaxInfo: (request: TaxInfoUpdateRequest) => Promise<any>;
+  postPrelogin: (request: PreloginRequest) => Promise<PreloginResponse>;
+  postEmailToken: (request: EmailTokenRequest) => Promise<any>;
+  postEmail: (request: EmailRequest) => Promise<any>;
+  postPassword: (request: PasswordRequest) => Promise<any>;
+  setPassword: (request: SetPasswordRequest) => Promise<any>;
+  postSetKeyConnectorKey: (request: SetKeyConnectorKeyRequest) => Promise<any>;
+  postSecurityStamp: (request: SecretVerificationRequest) => Promise<any>;
+  deleteAccount: (request: SecretVerificationRequest) => Promise<any>;
+  getAccountRevisionDate: () => Promise<number>;
+  postPasswordHint: (request: PasswordHintRequest) => Promise<any>;
+  postRegister: (request: RegisterRequest) => Promise<any>;
+  postPremium: (data: FormData) => Promise<PaymentResponse>;
+  postIapCheck: (request: IapCheckRequest) => Promise<any>;
+  postReinstatePremium: () => Promise<any>;
+  postCancelPremium: () => Promise<any>;
+  postAccountStorage: (request: StorageRequest) => Promise<PaymentResponse>;
+  postAccountPayment: (request: PaymentRequest) => Promise<any>;
+  postAccountLicense: (data: FormData) => Promise<any>;
+  postAccountKey: (request: UpdateKeyRequest) => Promise<any>;
+  postAccountKeys: (request: KeysRequest) => Promise<any>;
+  postAccountVerifyEmail: () => Promise<any>;
+  postAccountVerifyEmailToken: (request: VerifyEmailRequest) => Promise<any>;
+  postAccountVerifyPassword: (request: SecretVerificationRequest) => Promise<any>;
+  postAccountRecoverDelete: (request: DeleteRecoverRequest) => Promise<any>;
+  postAccountRecoverDeleteToken: (request: VerifyDeleteRecoverRequest) => Promise<any>;
+  postAccountKdf: (request: KdfRequest) => Promise<any>;
+  postUserApiKey: (id: string, request: SecretVerificationRequest) => Promise<ApiKeyResponse>;
+  postUserRotateApiKey: (id: string, request: SecretVerificationRequest) => Promise<ApiKeyResponse>;
+  putUpdateTempPassword: (request: UpdateTempPasswordRequest) => Promise<any>;
+  postAccountRequestOTP: () => Promise<void>;
+  postAccountVerifyOTP: (request: VerifyOTPRequest) => Promise<void>;
+  postConvertToKeyConnector: () => Promise<void>;
+
+  getUserBillingHistory: () => Promise<BillingHistoryResponse>;
+  getUserBillingPayment: () => Promise<BillingPaymentResponse>;
+
+  getFolder: (id: string) => Promise<FolderResponse>;
+  postFolder: (request: FolderRequest) => Promise<FolderResponse>;
+  putFolder: (id: string, request: FolderRequest) => Promise<FolderResponse>;
+  deleteFolder: (id: string) => Promise<any>;
+
+  getSend: (id: string) => Promise<SendResponse>;
+  postSendAccess: (
+    id: string,
+    request: SendAccessRequest,
+    apiUrl?: string
+  ) => Promise<SendAccessResponse>;
+  getSends: () => Promise<ListResponse<SendResponse>>;
+  postSend: (request: SendRequest) => Promise<SendResponse>;
+  postFileTypeSend: (request: SendRequest) => Promise<SendFileUploadDataResponse>;
+  postSendFile: (sendId: string, fileId: string, data: FormData) => Promise<any>;
+  /**
+   * @deprecated Mar 25 2021: This method has been deprecated in favor of direct uploads.
+   * This method still exists for backward compatibility with old server versions.
+   */
+  postSendFileLegacy: (data: FormData) => Promise<SendResponse>;
+  putSend: (id: string, request: SendRequest) => Promise<SendResponse>;
+  putSendRemovePassword: (id: string) => Promise<SendResponse>;
+  deleteSend: (id: string) => Promise<any>;
+  getSendFileDownloadData: (
+    send: SendAccessView,
+    request: SendAccessRequest,
+    apiUrl?: string
+  ) => Promise<SendFileDownloadDataResponse>;
+  renewSendFileUploadUrl: (sendId: string, fileId: string) => Promise<SendFileUploadDataResponse>;
+
+  getCipher: (id: string) => Promise<CipherResponse>;
+  getCipherAdmin: (id: string) => Promise<CipherResponse>;
+  getAttachmentData: (
+    cipherId: string,
+    attachmentId: string,
+    emergencyAccessId?: string
+  ) => Promise<AttachmentResponse>;
+  getCiphersOrganization: (organizationId: string) => Promise<ListResponse<CipherResponse>>;
+  postCipher: (request: CipherRequest) => Promise<CipherResponse>;
+  postCipherCreate: (request: CipherCreateRequest) => Promise<CipherResponse>;
+  postCipherAdmin: (request: CipherCreateRequest) => Promise<CipherResponse>;
+  putCipher: (id: string, request: CipherRequest) => Promise<CipherResponse>;
+  putCipherAdmin: (id: string, request: CipherRequest) => Promise<CipherResponse>;
+  deleteCipher: (id: string) => Promise<any>;
+  deleteCipherAdmin: (id: string) => Promise<any>;
+  deleteManyCiphers: (request: CipherBulkDeleteRequest) => Promise<any>;
+  deleteManyCiphersAdmin: (request: CipherBulkDeleteRequest) => Promise<any>;
+  putMoveCiphers: (request: CipherBulkMoveRequest) => Promise<any>;
+  putShareCipher: (id: string, request: CipherShareRequest) => Promise<CipherResponse>;
+  putShareCiphers: (request: CipherBulkShareRequest) => Promise<any>;
+  putCipherCollections: (id: string, request: CipherCollectionsRequest) => Promise<any>;
+  putCipherCollectionsAdmin: (id: string, request: CipherCollectionsRequest) => Promise<any>;
+  postPurgeCiphers: (request: SecretVerificationRequest, organizationId?: string) => Promise<any>;
+  postImportCiphers: (request: ImportCiphersRequest) => Promise<any>;
+  postImportOrganizationCiphers: (
+    organizationId: string,
+    request: ImportOrganizationCiphersRequest
+  ) => Promise<any>;
+  putDeleteCipher: (id: string) => Promise<any>;
+  putDeleteCipherAdmin: (id: string) => Promise<any>;
+  putDeleteManyCiphers: (request: CipherBulkDeleteRequest) => Promise<any>;
+  putDeleteManyCiphersAdmin: (request: CipherBulkDeleteRequest) => Promise<any>;
+  putRestoreCipher: (id: string) => Promise<CipherResponse>;
+  putRestoreCipherAdmin: (id: string) => Promise<CipherResponse>;
+  putRestoreManyCiphers: (
+    request: CipherBulkRestoreRequest
+  ) => Promise<ListResponse<CipherResponse>>;
+
+  /**
+   * @deprecated Mar 25 2021: This method has been deprecated in favor of direct uploads.
+   * This method still exists for backward compatibility with old server versions.
+   */
+  postCipherAttachmentLegacy: (id: string, data: FormData) => Promise<CipherResponse>;
+  /**
+   * @deprecated Mar 25 2021: This method has been deprecated in favor of direct uploads.
+   * This method still exists for backward compatibility with old server versions.
+   */
+  postCipherAttachmentAdminLegacy: (id: string, data: FormData) => Promise<CipherResponse>;
+  postCipherAttachment: (
+    id: string,
+    request: AttachmentRequest
+  ) => Promise<AttachmentUploadDataResponse>;
+  deleteCipherAttachment: (id: string, attachmentId: string) => Promise<any>;
+  deleteCipherAttachmentAdmin: (id: string, attachmentId: string) => Promise<any>;
+  postShareCipherAttachment: (
+    id: string,
+    attachmentId: string,
+    data: FormData,
+    organizationId: string
+  ) => Promise<any>;
+  renewAttachmentUploadUrl: (
+    id: string,
+    attachmentId: string
+  ) => Promise<AttachmentUploadDataResponse>;
+  postAttachmentFile: (id: string, attachmentId: string, data: FormData) => Promise<any>;
+
+  getCollectionDetails: (
+    organizationId: string,
+    id: string
+  ) => Promise<CollectionGroupDetailsResponse>;
+  getUserCollections: () => Promise<ListResponse<CollectionResponse>>;
+  getCollections: (organizationId: string) => Promise<ListResponse<CollectionResponse>>;
+  getCollectionUsers: (organizationId: string, id: string) => Promise<SelectionReadOnlyResponse[]>;
+  postCollection: (
+    organizationId: string,
+    request: CollectionRequest
+  ) => Promise<CollectionResponse>;
+  putCollectionUsers: (
+    organizationId: string,
+    id: string,
+    request: SelectionReadOnlyRequest[]
+  ) => Promise<any>;
+  putCollection: (
+    organizationId: string,
+    id: string,
+    request: CollectionRequest
+  ) => Promise<CollectionResponse>;
+  deleteCollection: (organizationId: string, id: string) => Promise<any>;
+  deleteCollectionUser: (
+    organizationId: string,
+    id: string,
+    organizationUserId: string
+  ) => Promise<any>;
+
+  getGroupDetails: (organizationId: string, id: string) => Promise<GroupDetailsResponse>;
+  getGroups: (organizationId: string) => Promise<ListResponse<GroupResponse>>;
+  getGroupUsers: (organizationId: string, id: string) => Promise<string[]>;
+  postGroup: (organizationId: string, request: GroupRequest) => Promise<GroupResponse>;
+  putGroup: (organizationId: string, id: string, request: GroupRequest) => Promise<GroupResponse>;
+  putGroupUsers: (organizationId: string, id: string, request: string[]) => Promise<any>;
+  deleteGroup: (organizationId: string, id: string) => Promise<any>;
+  deleteGroupUser: (organizationId: string, id: string, organizationUserId: string) => Promise<any>;
+
+  getPolicy: (organizationId: string, type: PolicyType) => Promise<PolicyResponse>;
+  getPolicies: (organizationId: string) => Promise<ListResponse<PolicyResponse>>;
+  getPoliciesByToken: (
+    organizationId: string,
+    token: string,
+    email: string,
+    organizationUserId: string
+  ) => Promise<ListResponse<PolicyResponse>>;
+  getPoliciesByInvitedUser: (
+    organizationId: string,
+    userId: string
+  ) => Promise<ListResponse<PolicyResponse>>;
+  putPolicy: (
+    organizationId: string,
+    type: PolicyType,
+    request: PolicyRequest
+  ) => Promise<PolicyResponse>;
+
+  getOrganizationUser: (
+    organizationId: string,
+    id: string
+  ) => Promise<OrganizationUserDetailsResponse>;
+  getOrganizationUserGroups: (organizationId: string, id: string) => Promise<string[]>;
+  getOrganizationUsers: (
+    organizationId: string
+  ) => Promise<ListResponse<OrganizationUserUserDetailsResponse>>;
+  getOrganizationUserResetPasswordDetails: (
+    organizationId: string,
+    id: string
+  ) => Promise<OrganizationUserResetPasswordDetailsReponse>;
+  postOrganizationUserInvite: (
+    organizationId: string,
+    request: OrganizationUserInviteRequest
+  ) => Promise<any>;
+  postOrganizationUserReinvite: (organizationId: string, id: string) => Promise<any>;
+  postManyOrganizationUserReinvite: (
+    organizationId: string,
+    request: OrganizationUserBulkRequest
+  ) => Promise<ListResponse<OrganizationUserBulkResponse>>;
+  postOrganizationUserAccept: (
+    organizationId: string,
+    id: string,
+    request: OrganizationUserAcceptRequest
+  ) => Promise<any>;
+  postOrganizationUserConfirm: (
+    organizationId: string,
+    id: string,
+    request: OrganizationUserConfirmRequest
+  ) => Promise<any>;
+  postOrganizationUsersPublicKey: (
+    organizationId: string,
+    request: OrganizationUserBulkRequest
+  ) => Promise<ListResponse<OrganizationUserBulkPublicKeyResponse>>;
+  postOrganizationUserBulkConfirm: (
+    organizationId: string,
+    request: OrganizationUserBulkConfirmRequest
+  ) => Promise<ListResponse<OrganizationUserBulkResponse>>;
+
+  putOrganizationUser: (
+    organizationId: string,
+    id: string,
+    request: OrganizationUserUpdateRequest
+  ) => Promise<any>;
+  putOrganizationUserGroups: (
+    organizationId: string,
+    id: string,
+    request: OrganizationUserUpdateGroupsRequest
+  ) => Promise<any>;
+  putOrganizationUserResetPasswordEnrollment: (
+    organizationId: string,
+    userId: string,
+    request: OrganizationUserResetPasswordEnrollmentRequest
+  ) => Promise<any>;
+  putOrganizationUserResetPassword: (
+    organizationId: string,
+    id: string,
+    request: OrganizationUserResetPasswordRequest
+  ) => Promise<any>;
+  deleteOrganizationUser: (organizationId: string, id: string) => Promise<any>;
+  deleteManyOrganizationUsers: (
+    organizationId: string,
+    request: OrganizationUserBulkRequest
+  ) => Promise<ListResponse<OrganizationUserBulkResponse>>;
+
+  getSync: () => Promise<SyncResponse>;
+  postImportDirectory: (organizationId: string, request: ImportDirectoryRequest) => Promise<any>;
+  postPublicImportDirectory: (request: OrganizationImportRequest) => Promise<any>;
+
+  getSettingsDomains: () => Promise<DomainsResponse>;
+  putSettingsDomains: (request: UpdateDomainsRequest) => Promise<DomainsResponse>;
+
+  getTwoFactorProviders: () => Promise<ListResponse<TwoFactorProviderResponse>>;
+  getTwoFactorOrganizationProviders: (
+    organizationId: string
+  ) => Promise<ListResponse<TwoFactorProviderResponse>>;
+  getTwoFactorAuthenticator: (
+    request: SecretVerificationRequest
+  ) => Promise<TwoFactorAuthenticatorResponse>;
+  getTwoFactorEmail: (request: SecretVerificationRequest) => Promise<TwoFactorEmailResponse>;
+  getTwoFactorDuo: (request: SecretVerificationRequest) => Promise<TwoFactorDuoResponse>;
+  getTwoFactorOrganizationDuo: (
+    organizationId: string,
+    request: SecretVerificationRequest
+  ) => Promise<TwoFactorDuoResponse>;
+  getTwoFactorYubiKey: (request: SecretVerificationRequest) => Promise<TwoFactorYubiKeyResponse>;
+  getTwoFactorWebAuthn: (request: SecretVerificationRequest) => Promise<TwoFactorWebAuthnResponse>;
+  getTwoFactorWebAuthnChallenge: (request: SecretVerificationRequest) => Promise<ChallengeResponse>;
+  getTwoFactorRecover: (request: SecretVerificationRequest) => Promise<TwoFactorRecoverResponse>;
+  putTwoFactorAuthenticator: (
+    request: UpdateTwoFactorAuthenticatorRequest
+  ) => Promise<TwoFactorAuthenticatorResponse>;
+  putTwoFactorEmail: (request: UpdateTwoFactorEmailRequest) => Promise<TwoFactorEmailResponse>;
+  putTwoFactorDuo: (request: UpdateTwoFactorDuoRequest) => Promise<TwoFactorDuoResponse>;
+  putTwoFactorOrganizationDuo: (
+    organizationId: string,
+    request: UpdateTwoFactorDuoRequest
+  ) => Promise<TwoFactorDuoResponse>;
+  putTwoFactorYubiKey: (
+    request: UpdateTwoFactorYubioOtpRequest
+  ) => Promise<TwoFactorYubiKeyResponse>;
+  putTwoFactorWebAuthn: (
+    request: UpdateTwoFactorWebAuthnRequest
+  ) => Promise<TwoFactorWebAuthnResponse>;
+  deleteTwoFactorWebAuthn: (
+    request: UpdateTwoFactorWebAuthnDeleteRequest
+  ) => Promise<TwoFactorWebAuthnResponse>;
+  putTwoFactorDisable: (request: TwoFactorProviderRequest) => Promise<TwoFactorProviderResponse>;
+  putTwoFactorOrganizationDisable: (
+    organizationId: string,
+    request: TwoFactorProviderRequest
+  ) => Promise<TwoFactorProviderResponse>;
+  postTwoFactorRecover: (request: TwoFactorRecoveryRequest) => Promise<any>;
+  postTwoFactorEmailSetup: (request: TwoFactorEmailRequest) => Promise<any>;
+  postTwoFactorEmail: (request: TwoFactorEmailRequest) => Promise<any>;
+
+  getEmergencyAccessTrusted: () => Promise<ListResponse<EmergencyAccessGranteeDetailsResponse>>;
+  getEmergencyAccessGranted: () => Promise<ListResponse<EmergencyAccessGrantorDetailsResponse>>;
+  getEmergencyAccess: (id: string) => Promise<EmergencyAccessGranteeDetailsResponse>;
+  getEmergencyGrantorPolicies: (id: string) => Promise<ListResponse<PolicyResponse>>;
+  putEmergencyAccess: (id: string, request: EmergencyAccessUpdateRequest) => Promise<any>;
+  deleteEmergencyAccess: (id: string) => Promise<any>;
+  postEmergencyAccessInvite: (request: EmergencyAccessInviteRequest) => Promise<any>;
+  postEmergencyAccessReinvite: (id: string) => Promise<any>;
+  postEmergencyAccessAccept: (id: string, request: EmergencyAccessAcceptRequest) => Promise<any>;
+  postEmergencyAccessConfirm: (id: string, request: EmergencyAccessConfirmRequest) => Promise<any>;
+  postEmergencyAccessInitiate: (id: string) => Promise<any>;
+  postEmergencyAccessApprove: (id: string) => Promise<any>;
+  postEmergencyAccessReject: (id: string) => Promise<any>;
+  postEmergencyAccessTakeover: (id: string) => Promise<EmergencyAccessTakeoverResponse>;
+  postEmergencyAccessPassword: (
+    id: string,
+    request: EmergencyAccessPasswordRequest
+  ) => Promise<any>;
+  postEmergencyAccessView: (id: string) => Promise<EmergencyAccessViewResponse>;
+
+  getOrganization: (id: string) => Promise<OrganizationResponse>;
+  getOrganizationBilling: (id: string) => Promise<BillingResponse>;
+  getOrganizationSubscription: (id: string) => Promise<OrganizationSubscriptionResponse>;
+  getCloudCommunicationsEnabled: () => Promise<boolean>;
+  abstract getOrganizationConnection<TConfig extends OrganizationConnectionConfigApis>(
+    id: string,
+    type: OrganizationConnectionType,
+    configType: { new (response: any): TConfig }
+  ): Promise<OrganizationConnectionResponse<TConfig>>;
+  abstract createOrganizationConnection<TConfig extends OrganizationConnectionConfigApis>(
+    request: OrganizationConnectionRequest,
+    configType: { new (response: any): TConfig }
+  ): Promise<OrganizationConnectionResponse<TConfig>>;
+  abstract updateOrganizationConnection<TConfig extends OrganizationConnectionConfigApis>(
+    request: OrganizationConnectionRequest,
+    configType: { new (response: any): TConfig },
+    organizationConnectionId: string
+  ): Promise<OrganizationConnectionResponse<TConfig>>;
+  deleteOrganizationConnection: (id: string) => Promise<void>;
+  getOrganizationLicense: (id: string, installationId: string) => Promise<any>;
+  getOrganizationTaxInfo: (id: string) => Promise<TaxInfoResponse>;
+  getOrganizationAutoEnrollStatus: (
+    identifier: string
+  ) => Promise<OrganizationAutoEnrollStatusResponse>;
+  getOrganizationSso: (id: string) => Promise<OrganizationSsoResponse>;
+  postOrganization: (request: OrganizationCreateRequest) => Promise<OrganizationResponse>;
+  putOrganization: (
+    id: string,
+    request: OrganizationUpdateRequest
+  ) => Promise<OrganizationResponse>;
+  putOrganizationTaxInfo: (id: string, request: OrganizationTaxInfoUpdateRequest) => Promise<any>;
+  postLeaveOrganization: (id: string) => Promise<any>;
+  postOrganizationLicense: (data: FormData) => Promise<OrganizationResponse>;
+  postOrganizationLicenseUpdate: (id: string, data: FormData) => Promise<any>;
+  postOrganizationApiKey: (
+    id: string,
+    request: OrganizationApiKeyRequest
+  ) => Promise<ApiKeyResponse>;
+  getOrganizationApiKeyInformation: (
+    id: string
+  ) => Promise<ListResponse<OrganizationApiKeyInformationResponse>>;
+  postOrganizationRotateApiKey: (
+    id: string,
+    request: OrganizationApiKeyRequest
+  ) => Promise<ApiKeyResponse>;
+  postOrganizationSso: (
+    id: string,
+    request: OrganizationSsoRequest
+  ) => Promise<OrganizationSsoResponse>;
+  postOrganizationUpgrade: (
+    id: string,
+    request: OrganizationUpgradeRequest
+  ) => Promise<PaymentResponse>;
+  postOrganizationUpdateSubscription: (
+    id: string,
+    request: OrganizationSubscriptionUpdateRequest
+  ) => Promise<void>;
+  postOrganizationSeat: (id: string, request: SeatRequest) => Promise<PaymentResponse>;
+  postOrganizationStorage: (id: string, request: StorageRequest) => Promise<any>;
+  postOrganizationPayment: (id: string, request: PaymentRequest) => Promise<any>;
+  postOrganizationVerifyBank: (id: string, request: VerifyBankRequest) => Promise<any>;
+  postOrganizationCancel: (id: string) => Promise<any>;
+  postOrganizationReinstate: (id: string) => Promise<any>;
+  deleteOrganization: (id: string, request: SecretVerificationRequest) => Promise<any>;
+  getPlans: () => Promise<ListResponse<PlanResponse>>;
+  getTaxRates: () => Promise<ListResponse<TaxRateResponse>>;
+  getOrganizationKeys: (id: string) => Promise<OrganizationKeysResponse>;
+  postOrganizationKeys: (
+    id: string,
+    request: OrganizationKeysRequest
+  ) => Promise<OrganizationKeysResponse>;
+
+  postProviderSetup: (id: string, request: ProviderSetupRequest) => Promise<ProviderResponse>;
+  getProvider: (id: string) => Promise<ProviderResponse>;
+  putProvider: (id: string, request: ProviderUpdateRequest) => Promise<ProviderResponse>;
+
+  getProviderUsers: (providerId: string) => Promise<ListResponse<ProviderUserUserDetailsResponse>>;
+  getProviderUser: (providerId: string, id: string) => Promise<ProviderUserResponse>;
+  postProviderUserInvite: (providerId: string, request: ProviderUserInviteRequest) => Promise<any>;
+  postProviderUserReinvite: (providerId: string, id: string) => Promise<any>;
+  postManyProviderUserReinvite: (
+    providerId: string,
+    request: ProviderUserBulkRequest
+  ) => Promise<ListResponse<ProviderUserBulkResponse>>;
+  postProviderUserAccept: (
+    providerId: string,
+    id: string,
+    request: ProviderUserAcceptRequest
+  ) => Promise<any>;
+  postProviderUserConfirm: (
+    providerId: string,
+    id: string,
+    request: ProviderUserConfirmRequest
+  ) => Promise<any>;
+  postProviderUsersPublicKey: (
+    providerId: string,
+    request: ProviderUserBulkRequest
+  ) => Promise<ListResponse<ProviderUserBulkPublicKeyResponse>>;
+  postProviderUserBulkConfirm: (
+    providerId: string,
+    request: ProviderUserBulkConfirmRequest
+  ) => Promise<ListResponse<ProviderUserBulkResponse>>;
+  putProviderUser: (
+    providerId: string,
+    id: string,
+    request: ProviderUserUpdateRequest
+  ) => Promise<any>;
+  deleteProviderUser: (organizationId: string, id: string) => Promise<any>;
+  deleteManyProviderUsers: (
+    providerId: string,
+    request: ProviderUserBulkRequest
+  ) => Promise<ListResponse<ProviderUserBulkResponse>>;
+  getProviderClients: (
+    providerId: string
+  ) => Promise<ListResponse<ProviderOrganizationOrganizationDetailsResponse>>;
+  postProviderAddOrganization: (
+    providerId: string,
+    request: ProviderAddOrganizationRequest
+  ) => Promise<any>;
+  postProviderCreateOrganization: (
+    providerId: string,
+    request: ProviderOrganizationCreateRequest
+  ) => Promise<ProviderOrganizationResponse>;
+  deleteProviderOrganization: (providerId: string, organizationId: string) => Promise<any>;
+
+  getEvents: (start: string, end: string, token: string) => Promise<ListResponse<EventResponse>>;
+  getEventsCipher: (
+    id: string,
+    start: string,
+    end: string,
+    token: string
+  ) => Promise<ListResponse<EventResponse>>;
+  getEventsOrganization: (
+    id: string,
+    start: string,
+    end: string,
+    token: string
+  ) => Promise<ListResponse<EventResponse>>;
+  getEventsOrganizationUser: (
+    organizationId: string,
+    id: string,
+    start: string,
+    end: string,
+    token: string
+  ) => Promise<ListResponse<EventResponse>>;
+  getEventsProvider: (
+    id: string,
+    start: string,
+    end: string,
+    token: string
+  ) => Promise<ListResponse<EventResponse>>;
+  getEventsProviderUser: (
+    providerId: string,
+    id: string,
+    start: string,
+    end: string,
+    token: string
+  ) => Promise<ListResponse<EventResponse>>;
+  postEventsCollect: (request: EventRequest[]) => Promise<any>;
+
+  deleteSsoUser: (organizationId: string) => Promise<any>;
+  getSsoUserIdentifier: () => Promise<string>;
+
+  getUserPublicKey: (id: string) => Promise<UserKeyResponse>;
+
+  getHibpBreach: (username: string) => Promise<BreachAccountResponse[]>;
+
+  postBitPayInvoice: (request: BitPayInvoiceRequest) => Promise<string>;
+  postSetupPayment: () => Promise<string>;
+
+  getActiveBearerToken: () => Promise<string>;
+  fetch: (request: Request) => Promise<Response>;
+  nativeFetch: (request: Request) => Promise<Response>;
+
+  preValidateSso: (identifier: string) => Promise<SsoPreValidateResponse>;
+
+  postCreateSponsorship: (
+    sponsorshipOrgId: string,
+    request: OrganizationSponsorshipCreateRequest
+  ) => Promise<void>;
+  getSponsorshipSyncStatus: (
+    sponsoredOrgId: string
+  ) => Promise<OrganizationSponsorshipSyncStatusResponse>;
+  deleteRevokeSponsorship: (sponsoringOrganizationId: string) => Promise<void>;
+  deleteRemoveSponsorship: (sponsoringOrgId: string) => Promise<void>;
+  postPreValidateSponsorshipToken: (sponsorshipToken: string) => Promise<boolean>;
+  postRedeemSponsorship: (
+    sponsorshipToken: string,
+    request: OrganizationSponsorshipRedeemRequest
+  ) => Promise<void>;
+  postResendSponsorshipOffer: (sponsoringOrgId: string) => Promise<void>;
+
+  getUserKeyFromKeyConnector: (keyConnectorUrl: string) => Promise<KeyConnectorUserKeyResponse>;
+  postUserKeyToKeyConnector: (
+    keyConnectorUrl: string,
+    request: KeyConnectorUserKeyRequest
+  ) => Promise<void>;
+  getKeyConnectorAlive: (keyConnectorUrl: string) => Promise<void>;
+}
--- a/libs/common/src/abstractions/appId.service.ts
+++ b/libs/common/src/abstractions/appId.service.ts
@@ -0,0 +1,4 @@
+export abstract class AppIdService {
+  getAppId: () => Promise<string>;
+  getAnonymousAppId: () => Promise<string>;
+}
--- a/libs/common/src/abstractions/audit.service.ts
+++ b/libs/common/src/abstractions/audit.service.ts
@@ -0,0 +1,6 @@
+import { BreachAccountResponse } from "../models/response/breachAccountResponse";
+
+export abstract class AuditService {
+  passwordLeaked: (password: string) => Promise<number>;
+  breachedAccounts: (username: string) => Promise<BreachAccountResponse[]>;
+}
--- a/libs/common/src/abstractions/auth.service.ts
+++ b/libs/common/src/abstractions/auth.service.ts
@@ -0,0 +1,27 @@
+import { AuthenticationStatus } from "../enums/authenticationStatus";
+import { AuthResult } from "../models/domain/authResult";
+import {
+  ApiLogInCredentials,
+  PasswordLogInCredentials,
+  SsoLogInCredentials,
+} from "../models/domain/logInCredentials";
+import { SymmetricCryptoKey } from "../models/domain/symmetricCryptoKey";
+import { TokenRequestTwoFactor } from "../models/request/identityToken/tokenRequestTwoFactor";
+
+export abstract class AuthService {
+  masterPasswordHash: string;
+  email: string;
+  logIn: (
+    credentials: ApiLogInCredentials | PasswordLogInCredentials | SsoLogInCredentials
+  ) => Promise<AuthResult>;
+  logInTwoFactor: (
+    twoFactor: TokenRequestTwoFactor,
+    captchaResponse: string
+  ) => Promise<AuthResult>;
+  logOut: (callback: () => void) => void;
+  makePreloginKey: (masterPassword: string, email: string) => Promise<SymmetricCryptoKey>;
+  authingWithApiKey: () => boolean;
+  authingWithSso: () => boolean;
+  authingWithPassword: () => boolean;
+  getAuthStatus: (userId?: string) => Promise<AuthenticationStatus>;
+}
--- a/libs/common/src/abstractions/broadcaster.service.ts
+++ b/libs/common/src/abstractions/broadcaster.service.ts
@@ -0,0 +1,5 @@
+export abstract class BroadcasterService {
+  send: (message: any, id?: string) => void;
+  subscribe: (id: string, messageCallback: (message: any) => any) => void;
+  unsubscribe: (id: string) => void;
+}
--- a/libs/common/src/abstractions/cipher.service.ts
+++ b/libs/common/src/abstractions/cipher.service.ts
@@ -0,0 +1,79 @@
+import { CipherType } from "../enums/cipherType";
+import { UriMatchType } from "../enums/uriMatchType";
+import { CipherData } from "../models/data/cipherData";
+import { Cipher } from "../models/domain/cipher";
+import { Field } from "../models/domain/field";
+import { SymmetricCryptoKey } from "../models/domain/symmetricCryptoKey";
+import { CipherView } from "../models/view/cipherView";
+import { FieldView } from "../models/view/fieldView";
+
+export abstract class CipherService {
+  clearCache: (userId?: string) => Promise<void>;
+  encrypt: (
+    model: CipherView,
+    key?: SymmetricCryptoKey,
+    originalCipher?: Cipher
+  ) => Promise<Cipher>;
+  encryptFields: (fieldsModel: FieldView[], key: SymmetricCryptoKey) => Promise<Field[]>;
+  encryptField: (fieldModel: FieldView, key: SymmetricCryptoKey) => Promise<Field>;
+  get: (id: string) => Promise<Cipher>;
+  getAll: () => Promise<Cipher[]>;
+  getAllDecrypted: () => Promise<CipherView[]>;
+  getAllDecryptedForGrouping: (groupingId: string, folder?: boolean) => Promise<CipherView[]>;
+  getAllDecryptedForUrl: (
+    url: string,
+    includeOtherTypes?: CipherType[],
+    defaultMatch?: UriMatchType
+  ) => Promise<CipherView[]>;
+  getAllFromApiForOrganization: (organizationId: string) => Promise<CipherView[]>;
+  getLastUsedForUrl: (url: string, autofillOnPageLoad: boolean) => Promise<CipherView>;
+  getLastLaunchedForUrl: (url: string, autofillOnPageLoad: boolean) => Promise<CipherView>;
+  getNextCipherForUrl: (url: string) => Promise<CipherView>;
+  updateLastUsedIndexForUrl: (url: string) => void;
+  updateLastUsedDate: (id: string) => Promise<void>;
+  updateLastLaunchedDate: (id: string) => Promise<void>;
+  saveNeverDomain: (domain: string) => Promise<void>;
+  saveWithServer: (cipher: Cipher) => Promise<any>;
+  shareWithServer: (
+    cipher: CipherView,
+    organizationId: string,
+    collectionIds: string[]
+  ) => Promise<any>;
+  shareManyWithServer: (
+    ciphers: CipherView[],
+    organizationId: string,
+    collectionIds: string[]
+  ) => Promise<any>;
+  saveAttachmentWithServer: (
+    cipher: Cipher,
+    unencryptedFile: any,
+    admin?: boolean
+  ) => Promise<Cipher>;
+  saveAttachmentRawWithServer: (
+    cipher: Cipher,
+    filename: string,
+    data: ArrayBuffer,
+    admin?: boolean
+  ) => Promise<Cipher>;
+  saveCollectionsWithServer: (cipher: Cipher) => Promise<any>;
+  upsert: (cipher: CipherData | CipherData[]) => Promise<any>;
+  replace: (ciphers: { [id: string]: CipherData }) => Promise<any>;
+  clear: (userId: string) => Promise<any>;
+  moveManyWithServer: (ids: string[], folderId: string) => Promise<any>;
+  delete: (id: string | string[]) => Promise<any>;
+  deleteWithServer: (id: string) => Promise<any>;
+  deleteManyWithServer: (ids: string[]) => Promise<any>;
+  deleteAttachment: (id: string, attachmentId: string) => Promise<void>;
+  deleteAttachmentWithServer: (id: string, attachmentId: string) => Promise<void>;
+  sortCiphersByLastUsed: (a: any, b: any) => number;
+  sortCiphersByLastUsedThenName: (a: any, b: any) => number;
+  getLocaleSortingFunction: () => (a: CipherView, b: CipherView) => number;
+  softDelete: (id: string | string[]) => Promise<any>;
+  softDeleteWithServer: (id: string) => Promise<any>;
+  softDeleteManyWithServer: (ids: string[]) => Promise<any>;
+  restore: (
+    cipher: { id: string; revisionDate: string } | { id: string; revisionDate: string }[]
+  ) => Promise<any>;
+  restoreWithServer: (id: string) => Promise<any>;
+  restoreManyWithServer: (ids: string[]) => Promise<any>;
+}
--- a/libs/common/src/abstractions/collection.service.ts
+++ b/libs/common/src/abstractions/collection.service.ts
@@ -0,0 +1,19 @@
+import { CollectionData } from "../models/data/collectionData";
+import { Collection } from "../models/domain/collection";
+import { TreeNode } from "../models/domain/treeNode";
+import { CollectionView } from "../models/view/collectionView";
+
+export abstract class CollectionService {
+  clearCache: (userId?: string) => Promise<void>;
+  encrypt: (model: CollectionView) => Promise<Collection>;
+  decryptMany: (collections: Collection[]) => Promise<CollectionView[]>;
+  get: (id: string) => Promise<Collection>;
+  getAll: () => Promise<Collection[]>;
+  getAllDecrypted: () => Promise<CollectionView[]>;
+  getAllNested: (collections?: CollectionView[]) => Promise<TreeNode<CollectionView>[]>;
+  getNested: (id: string) => Promise<TreeNode<CollectionView>>;
+  upsert: (collection: CollectionData | CollectionData[]) => Promise<any>;
+  replace: (collections: { [id: string]: CollectionData }) => Promise<any>;
+  clear: (userId: string) => Promise<any>;
+  delete: (id: string | string[]) => Promise<any>;
+}
--- a/libs/common/src/abstractions/crypto.service.ts
+++ b/libs/common/src/abstractions/crypto.service.ts
@@ -0,0 +1,86 @@
+import { HashPurpose } from "../enums/hashPurpose";
+import { KdfType } from "../enums/kdfType";
+import { KeySuffixOptions } from "../enums/keySuffixOptions";
+import { EncArrayBuffer } from "../models/domain/encArrayBuffer";
+import { EncString } from "../models/domain/encString";
+import { SymmetricCryptoKey } from "../models/domain/symmetricCryptoKey";
+import { ProfileOrganizationResponse } from "../models/response/profileOrganizationResponse";
+import { ProfileProviderOrganizationResponse } from "../models/response/profileProviderOrganizationResponse";
+import { ProfileProviderResponse } from "../models/response/profileProviderResponse";
+
+export abstract class CryptoService {
+  setKey: (key: SymmetricCryptoKey) => Promise<any>;
+  setKeyHash: (keyHash: string) => Promise<void>;
+  setEncKey: (encKey: string) => Promise<void>;
+  setEncPrivateKey: (encPrivateKey: string) => Promise<void>;
+  setOrgKeys: (
+    orgs: ProfileOrganizationResponse[],
+    providerOrgs: ProfileProviderOrganizationResponse[]
+  ) => Promise<void>;
+  setProviderKeys: (orgs: ProfileProviderResponse[]) => Promise<void>;
+  getKey: (keySuffix?: KeySuffixOptions, userId?: string) => Promise<SymmetricCryptoKey>;
+  getKeyFromStorage: (keySuffix: KeySuffixOptions, userId?: string) => Promise<SymmetricCryptoKey>;
+  getKeyHash: () => Promise<string>;
+  compareAndUpdateKeyHash: (masterPassword: string, key: SymmetricCryptoKey) => Promise<boolean>;
+  getEncKey: (key?: SymmetricCryptoKey) => Promise<SymmetricCryptoKey>;
+  getPublicKey: () => Promise<ArrayBuffer>;
+  getPrivateKey: () => Promise<ArrayBuffer>;
+  getFingerprint: (userId: string, publicKey?: ArrayBuffer) => Promise<string[]>;
+  getOrgKeys: () => Promise<Map<string, SymmetricCryptoKey>>;
+  getOrgKey: (orgId: string) => Promise<SymmetricCryptoKey>;
+  getProviderKey: (providerId: string) => Promise<SymmetricCryptoKey>;
+  hasKey: () => Promise<boolean>;
+  hasKeyInMemory: (userId?: string) => Promise<boolean>;
+  hasKeyStored: (keySuffix?: KeySuffixOptions, userId?: string) => Promise<boolean>;
+  hasEncKey: () => Promise<boolean>;
+  clearKey: (clearSecretStorage?: boolean, userId?: string) => Promise<any>;
+  clearKeyHash: () => Promise<any>;
+  clearEncKey: (memoryOnly?: boolean, userId?: string) => Promise<any>;
+  clearKeyPair: (memoryOnly?: boolean, userId?: string) => Promise<any>;
+  clearOrgKeys: (memoryOnly?: boolean, userId?: string) => Promise<any>;
+  clearProviderKeys: (memoryOnly?: boolean) => Promise<any>;
+  clearPinProtectedKey: () => Promise<any>;
+  clearKeys: (userId?: string) => Promise<any>;
+  toggleKey: () => Promise<any>;
+  makeKey: (
+    password: string,
+    salt: string,
+    kdf: KdfType,
+    kdfIterations: number
+  ) => Promise<SymmetricCryptoKey>;
+  makeKeyFromPin: (
+    pin: string,
+    salt: string,
+    kdf: KdfType,
+    kdfIterations: number,
+    protectedKeyCs?: EncString
+  ) => Promise<SymmetricCryptoKey>;
+  makeShareKey: () => Promise<[EncString, SymmetricCryptoKey]>;
+  makeKeyPair: (key?: SymmetricCryptoKey) => Promise<[string, EncString]>;
+  makePinKey: (
+    pin: string,
+    salt: string,
+    kdf: KdfType,
+    kdfIterations: number
+  ) => Promise<SymmetricCryptoKey>;
+  makeSendKey: (keyMaterial: ArrayBuffer) => Promise<SymmetricCryptoKey>;
+  hashPassword: (
+    password: string,
+    key: SymmetricCryptoKey,
+    hashPurpose?: HashPurpose
+  ) => Promise<string>;
+  makeEncKey: (key: SymmetricCryptoKey) => Promise<[SymmetricCryptoKey, EncString]>;
+  remakeEncKey: (
+    key: SymmetricCryptoKey,
+    encKey?: SymmetricCryptoKey
+  ) => Promise<[SymmetricCryptoKey, EncString]>;
+  encrypt: (plainValue: string | ArrayBuffer, key?: SymmetricCryptoKey) => Promise<EncString>;
+  encryptToBytes: (plainValue: ArrayBuffer, key?: SymmetricCryptoKey) => Promise<EncArrayBuffer>;
+  rsaEncrypt: (data: ArrayBuffer, publicKey?: ArrayBuffer) => Promise<EncString>;
+  rsaDecrypt: (encValue: string, privateKeyValue?: ArrayBuffer) => Promise<ArrayBuffer>;
+  decryptToBytes: (encString: EncString, key?: SymmetricCryptoKey) => Promise<ArrayBuffer>;
+  decryptToUtf8: (encString: EncString, key?: SymmetricCryptoKey) => Promise<string>;
+  decryptFromBytes: (encBuf: ArrayBuffer, key: SymmetricCryptoKey) => Promise<ArrayBuffer>;
+  randomNumber: (min: number, max: number) => Promise<number>;
+  validateKey: (key: SymmetricCryptoKey) => Promise<boolean>;
+}
--- a/libs/common/src/abstractions/cryptoFunction.service.ts
+++ b/libs/common/src/abstractions/cryptoFunction.service.ts
@@ -0,0 +1,62 @@
+import { DecryptParameters } from "../models/domain/decryptParameters";
+import { SymmetricCryptoKey } from "../models/domain/symmetricCryptoKey";
+
+export abstract class CryptoFunctionService {
+  pbkdf2: (
+    password: string | ArrayBuffer,
+    salt: string | ArrayBuffer,
+    algorithm: "sha256" | "sha512",
+    iterations: number
+  ) => Promise<ArrayBuffer>;
+  hkdf: (
+    ikm: ArrayBuffer,
+    salt: string | ArrayBuffer,
+    info: string | ArrayBuffer,
+    outputByteSize: number,
+    algorithm: "sha256" | "sha512"
+  ) => Promise<ArrayBuffer>;
+  hkdfExpand: (
+    prk: ArrayBuffer,
+    info: string | ArrayBuffer,
+    outputByteSize: number,
+    algorithm: "sha256" | "sha512"
+  ) => Promise<ArrayBuffer>;
+  hash: (
+    value: string | ArrayBuffer,
+    algorithm: "sha1" | "sha256" | "sha512" | "md5"
+  ) => Promise<ArrayBuffer>;
+  hmac: (
+    value: ArrayBuffer,
+    key: ArrayBuffer,
+    algorithm: "sha1" | "sha256" | "sha512"
+  ) => Promise<ArrayBuffer>;
+  compare: (a: ArrayBuffer, b: ArrayBuffer) => Promise<boolean>;
+  hmacFast: (
+    value: ArrayBuffer | string,
+    key: ArrayBuffer | string,
+    algorithm: "sha1" | "sha256" | "sha512"
+  ) => Promise<ArrayBuffer | string>;
+  compareFast: (a: ArrayBuffer | string, b: ArrayBuffer | string) => Promise<boolean>;
+  aesEncrypt: (data: ArrayBuffer, iv: ArrayBuffer, key: ArrayBuffer) => Promise<ArrayBuffer>;
+  aesDecryptFastParameters: (
+    data: string,
+    iv: string,
+    mac: string,
+    key: SymmetricCryptoKey
+  ) => DecryptParameters<ArrayBuffer | string>;
+  aesDecryptFast: (parameters: DecryptParameters<ArrayBuffer | string>) => Promise<string>;
+  aesDecrypt: (data: ArrayBuffer, iv: ArrayBuffer, key: ArrayBuffer) => Promise<ArrayBuffer>;
+  rsaEncrypt: (
+    data: ArrayBuffer,
+    publicKey: ArrayBuffer,
+    algorithm: "sha1" | "sha256"
+  ) => Promise<ArrayBuffer>;
+  rsaDecrypt: (
+    data: ArrayBuffer,
+    privateKey: ArrayBuffer,
+    algorithm: "sha1" | "sha256"
+  ) => Promise<ArrayBuffer>;
+  rsaExtractPublicKey: (privateKey: ArrayBuffer) => Promise<ArrayBuffer>;
+  rsaGenerateKeyPair: (length: 1024 | 2048 | 4096) => Promise<[ArrayBuffer, ArrayBuffer]>;
+  randomBytes: (length: number) => Promise<ArrayBuffer>;
+}
--- a/libs/common/src/abstractions/environment.service.ts
+++ b/libs/common/src/abstractions/environment.service.ts
@@ -0,0 +1,34 @@
+import { Observable } from "rxjs";
+
+export type Urls = {
+  base?: string;
+  webVault?: string;
+  api?: string;
+  identity?: string;
+  icons?: string;
+  notifications?: string;
+  events?: string;
+  keyConnector?: string;
+};
+
+export type PayPalConfig = {
+  businessId?: string;
+  buttonAction?: string;
+};
+
+export abstract class EnvironmentService {
+  urls: Observable<Urls>;
+
+  hasBaseUrl: () => boolean;
+  getNotificationsUrl: () => string;
+  getWebVaultUrl: () => string;
+  getSendUrl: () => string;
+  getIconsUrl: () => string;
+  getApiUrl: () => string;
+  getIdentityUrl: () => string;
+  getEventsUrl: () => string;
+  getKeyConnectorUrl: () => string;
+  setUrlsFromStorage: () => Promise<void>;
+  setUrls: (urls: Urls) => Promise<Urls>;
+  getUrls: () => Urls;
+}
--- a/libs/common/src/abstractions/event.service.ts
+++ b/libs/common/src/abstractions/event.service.ts
@@ -0,0 +1,7 @@
+import { EventType } from "../enums/eventType";
+
+export abstract class EventService {
+  collect: (eventType: EventType, cipherId?: string, uploadImmediately?: boolean) => Promise<any>;
+  uploadEvents: (userId?: string) => Promise<any>;
+  clearEvents: (userId?: string) => Promise<any>;
+}
--- a/libs/common/src/abstractions/export.service.ts
+++ b/libs/common/src/abstractions/export.service.ts
@@ -0,0 +1,11 @@
+import { EventView } from "../models/view/eventView";
+
+export type ExportFormat = "csv" | "json" | "encrypted_json";
+
+export abstract class ExportService {
+  getExport: (format?: ExportFormat, organizationId?: string) => Promise<string>;
+  getPasswordProtectedExport: (password: string, organizationId?: string) => Promise<string>;
+  getOrganizationExport: (organizationId: string, format?: ExportFormat) => Promise<string>;
+  getEventExport: (events: EventView[]) => Promise<string>;
+  getFileName: (prefix?: string, extension?: string) => string;
+}
--- a/libs/common/src/abstractions/fileUpload.service.ts
+++ b/libs/common/src/abstractions/fileUpload.service.ts
@@ -0,0 +1,18 @@
+import { EncArrayBuffer } from "../models/domain/encArrayBuffer";
+import { EncString } from "../models/domain/encString";
+import { AttachmentUploadDataResponse } from "../models/response/attachmentUploadDataResponse";
+import { SendFileUploadDataResponse } from "../models/response/sendFileUploadDataResponse";
+
+export abstract class FileUploadService {
+  uploadSendFile: (
+    uploadData: SendFileUploadDataResponse,
+    fileName: EncString,
+    encryptedFileData: EncArrayBuffer
+  ) => Promise<any>;
+  uploadCipherAttachment: (
+    admin: boolean,
+    uploadData: AttachmentUploadDataResponse,
+    fileName: EncString,
+    encryptedFileData: EncArrayBuffer
+  ) => Promise<any>;
+}
--- a/libs/common/src/abstractions/folder.service.ts
+++ b/libs/common/src/abstractions/folder.service.ts
@@ -0,0 +1,21 @@
+import { FolderData } from "../models/data/folderData";
+import { Folder } from "../models/domain/folder";
+import { SymmetricCryptoKey } from "../models/domain/symmetricCryptoKey";
+import { TreeNode } from "../models/domain/treeNode";
+import { FolderView } from "../models/view/folderView";
+
+export abstract class FolderService {
+  clearCache: (userId?: string) => Promise<void>;
+  encrypt: (model: FolderView, key?: SymmetricCryptoKey) => Promise<Folder>;
+  get: (id: string) => Promise<Folder>;
+  getAll: () => Promise<Folder[]>;
+  getAllDecrypted: () => Promise<FolderView[]>;
+  getAllNested: (folders?: FolderView[]) => Promise<TreeNode<FolderView>[]>;
+  getNested: (id: string) => Promise<TreeNode<FolderView>>;
+  saveWithServer: (folder: Folder) => Promise<any>;
+  upsert: (folder: FolderData | FolderData[]) => Promise<any>;
+  replace: (folders: { [id: string]: FolderData }) => Promise<any>;
+  clear: (userId: string) => Promise<any>;
+  delete: (id: string | string[]) => Promise<any>;
+  deleteWithServer: (id: string) => Promise<any>;
+}
--- a/libs/common/src/abstractions/i18n.service.ts
+++ b/libs/common/src/abstractions/i18n.service.ts
@@ -0,0 +1,9 @@
+export abstract class I18nService {
+  locale: string;
+  supportedTranslationLocales: string[];
+  translationLocale: string;
+  collator: Intl.Collator;
+  localeNames: Map<string, string>;
+  t: (id: string, p1?: string, p2?: string, p3?: string) => string;
+  translate: (id: string, p1?: string, p2?: string, p3?: string) => string;
+}
--- a/libs/common/src/abstractions/import.service.ts
+++ b/libs/common/src/abstractions/import.service.ts
@@ -0,0 +1,19 @@
+import { ImportOption, ImportType } from "../enums/importOptions";
+import { ImportError } from "../importers/importError";
+import { Importer } from "../importers/importer";
+
+export abstract class ImportService {
+  featuredImportOptions: readonly ImportOption[];
+  regularImportOptions: readonly ImportOption[];
+  getImportOptions: () => ImportOption[];
+  import: (
+    importer: Importer,
+    fileContents: string,
+    organizationId?: string
+  ) => Promise<ImportError>;
+  getImporter: (
+    format: ImportType | "bitwardenpasswordprotected",
+    organizationId: string,
+    password?: string
+  ) => Importer;
+}
--- a/libs/common/src/abstractions/keyConnector.service.ts
+++ b/libs/common/src/abstractions/keyConnector.service.ts
@@ -0,0 +1,19 @@
+import { Organization } from "../models/domain/organization";
+import { IdentityTokenResponse } from "../models/response/identityTokenResponse";
+
+export abstract class KeyConnectorService {
+  getAndSetKey: (url?: string) => Promise<void>;
+  getManagingOrganization: () => Promise<Organization>;
+  getUsesKeyConnector: () => Promise<boolean>;
+  migrateUser: () => Promise<void>;
+  userNeedsMigration: () => Promise<boolean>;
+  convertNewSsoUserToKeyConnector: (
+    tokenResponse: IdentityTokenResponse,
+    orgId: string
+  ) => Promise<void>;
+  setUsesKeyConnector: (enabled: boolean) => Promise<void>;
+  setConvertAccountRequired: (status: boolean) => Promise<void>;
+  getConvertAccountRequired: () => Promise<boolean>;
+  removeConvertAccountRequired: () => Promise<void>;
+  clear: () => Promise<void>;
+}
--- a/libs/common/src/abstractions/log.service.ts
+++ b/libs/common/src/abstractions/log.service.ts
@@ -0,0 +1,11 @@
+import { LogLevelType } from "../enums/logLevelType";
+
+export abstract class LogService {
+  debug: (message: string) => void;
+  info: (message: string) => void;
+  warning: (message: string) => void;
+  error: (message: string) => void;
+  write: (level: LogLevelType, message: string) => void;
+  time: (label: string) => void;
+  timeEnd: (label: string) => [number, number];
+}
--- a/libs/common/src/abstractions/messaging.service.ts
+++ b/libs/common/src/abstractions/messaging.service.ts
@@ -0,0 +1,3 @@
+export abstract class MessagingService {
+  send: (subscriber: string, arg?: any) => void;
+}
--- a/libs/common/src/abstractions/notifications.service.ts
+++ b/libs/common/src/abstractions/notifications.service.ts
@@ -0,0 +1,6 @@
+export abstract class NotificationsService {
+  init: () => Promise<void>;
+  updateConnection: (sync?: boolean) => Promise<void>;
+  reconnectFromActivity: () => Promise<void>;
+  disconnectFromInactivity: () => Promise<void>;
+}
--- a/libs/common/src/abstractions/organization.service.ts
+++ b/libs/common/src/abstractions/organization.service.ts
@@ -0,0 +1,11 @@
+import { OrganizationData } from "../models/data/organizationData";
+import { Organization } from "../models/domain/organization";
+
+export abstract class OrganizationService {
+  get: (id: string) => Promise<Organization>;
+  getByIdentifier: (identifier: string) => Promise<Organization>;
+  getAll: (userId?: string) => Promise<Organization[]>;
+  save: (orgs: { [id: string]: OrganizationData }) => Promise<any>;
+  canManageSponsorships: () => Promise<boolean>;
+  hasOrganizations: (userId?: string) => Promise<boolean>;
+}
--- a/libs/common/src/abstractions/passwordGeneration.service.ts
+++ b/libs/common/src/abstractions/passwordGeneration.service.ts
@@ -0,0 +1,20 @@
+import * as zxcvbn from "zxcvbn";
+
+import { GeneratedPasswordHistory } from "../models/domain/generatedPasswordHistory";
+import { PasswordGeneratorPolicyOptions } from "../models/domain/passwordGeneratorPolicyOptions";
+
+export abstract class PasswordGenerationService {
+  generatePassword: (options: any) => Promise<string>;
+  generatePassphrase: (options: any) => Promise<string>;
+  getOptions: () => Promise<[any, PasswordGeneratorPolicyOptions]>;
+  enforcePasswordGeneratorPoliciesOnOptions: (
+    options: any
+  ) => Promise<[any, PasswordGeneratorPolicyOptions]>;
+  getPasswordGeneratorPolicyOptions: () => Promise<PasswordGeneratorPolicyOptions>;
+  saveOptions: (options: any) => Promise<any>;
+  getHistory: () => Promise<GeneratedPasswordHistory[]>;
+  addHistory: (password: string) => Promise<any>;
+  clear: (userId?: string) => Promise<any>;
+  passwordStrength: (password: string, userInputs?: string[]) => zxcvbn.ZXCVBNResult;
+  normalizeOptions: (options: any, enforcedPolicyOptions: PasswordGeneratorPolicyOptions) => void;
+}
--- a/libs/common/src/abstractions/passwordReprompt.service.ts
+++ b/libs/common/src/abstractions/passwordReprompt.service.ts
@@ -0,0 +1,5 @@
+export abstract class PasswordRepromptService {
+  protectedFields: () => string[];
+  showPasswordPrompt: () => Promise<boolean>;
+  enabled: () => Promise<boolean>;
+}
--- a/libs/common/src/abstractions/platformUtils.service.ts
+++ b/libs/common/src/abstractions/platformUtils.service.ts
@@ -0,0 +1,52 @@
+import { ClientType } from "../enums/clientType";
+import { DeviceType } from "../enums/deviceType";
+import { ThemeType } from "../enums/themeType";
+
+interface ToastOptions {
+  timeout?: number;
+}
+
+export abstract class PlatformUtilsService {
+  getDevice: () => DeviceType;
+  getDeviceString: () => string;
+  getClientType: () => ClientType;
+  isFirefox: () => boolean;
+  isChrome: () => boolean;
+  isEdge: () => boolean;
+  isOpera: () => boolean;
+  isVivaldi: () => boolean;
+  isSafari: () => boolean;
+  isMacAppStore: () => boolean;
+  isViewOpen: () => Promise<boolean>;
+  launchUri: (uri: string, options?: any) => void;
+  saveFile: (win: Window, blobData: any, blobOptions: any, fileName: string) => void;
+  getApplicationVersion: () => Promise<string>;
+  supportsWebAuthn: (win: Window) => boolean;
+  supportsDuo: () => boolean;
+  showToast: (
+    type: "error" | "success" | "warning" | "info",
+    title: string,
+    text: string | string[],
+    options?: ToastOptions
+  ) => void;
+  showDialog: (
+    body: string,
+    title?: string,
+    confirmText?: string,
+    cancelText?: string,
+    type?: string,
+    bodyIsHtml?: boolean
+  ) => Promise<boolean>;
+  isDev: () => boolean;
+  isSelfHost: () => boolean;
+  copyToClipboard: (text: string, options?: any) => void | boolean;
+  readFromClipboard: (options?: any) => Promise<string>;
+  supportsBiometric: () => Promise<boolean>;
+  authenticateBiometric: () => Promise<boolean>;
+  getDefaultSystemTheme: () => Promise<ThemeType.Light | ThemeType.Dark>;
+  onDefaultSystemThemeChange: (
+    callback: (theme: ThemeType.Light | ThemeType.Dark) => unknown
+  ) => unknown;
+  getEffectiveTheme: () => Promise<ThemeType>;
+  supportsSecureStorage: () => boolean;
+}
--- a/libs/common/src/abstractions/policy.service.ts
+++ b/libs/common/src/abstractions/policy.service.ts
@@ -0,0 +1,32 @@
+import { PolicyType } from "../enums/policyType";
+import { PolicyData } from "../models/data/policyData";
+import { MasterPasswordPolicyOptions } from "../models/domain/masterPasswordPolicyOptions";
+import { Policy } from "../models/domain/policy";
+import { ResetPasswordPolicyOptions } from "../models/domain/resetPasswordPolicyOptions";
+import { ListResponse } from "../models/response/listResponse";
+import { PolicyResponse } from "../models/response/policyResponse";
+
+export abstract class PolicyService {
+  clearCache: () => void;
+  getAll: (type?: PolicyType, userId?: string) => Promise<Policy[]>;
+  getPolicyForOrganization: (policyType: PolicyType, organizationId: string) => Promise<Policy>;
+  replace: (policies: { [id: string]: PolicyData }) => Promise<any>;
+  clear: (userId?: string) => Promise<any>;
+  getMasterPasswordPoliciesForInvitedUsers: (orgId: string) => Promise<MasterPasswordPolicyOptions>;
+  getMasterPasswordPolicyOptions: (policies?: Policy[]) => Promise<MasterPasswordPolicyOptions>;
+  evaluateMasterPassword: (
+    passwordStrength: number,
+    newPassword: string,
+    enforcedPolicyOptions?: MasterPasswordPolicyOptions
+  ) => boolean;
+  getResetPasswordPolicyOptions: (
+    policies: Policy[],
+    orgId: string
+  ) => [ResetPasswordPolicyOptions, boolean];
+  mapPoliciesFromToken: (policiesResponse: ListResponse<PolicyResponse>) => Policy[];
+  policyAppliesToUser: (
+    policyType: PolicyType,
+    policyFilter?: (policy: Policy) => boolean,
+    userId?: string
+  ) => Promise<boolean>;
+}
--- a/libs/common/src/abstractions/provider.service.ts
+++ b/libs/common/src/abstractions/provider.service.ts
@@ -0,0 +1,8 @@
+import { ProviderData } from "../models/data/providerData";
+import { Provider } from "../models/domain/provider";
+
+export abstract class ProviderService {
+  get: (id: string) => Promise<Provider>;
+  getAll: () => Promise<Provider[]>;
+  save: (providers: { [id: string]: ProviderData }) => Promise<any>;
+}
--- a/libs/common/src/abstractions/search.service.ts
+++ b/libs/common/src/abstractions/search.service.ts
@@ -0,0 +1,16 @@
+import { CipherView } from "../models/view/cipherView";
+import { SendView } from "../models/view/sendView";
+
+export abstract class SearchService {
+  indexedEntityId?: string = null;
+  clearIndex: () => void;
+  isSearchable: (query: string) => boolean;
+  indexCiphers: (indexedEntityGuid?: string, ciphersToIndex?: CipherView[]) => Promise<void>;
+  searchCiphers: (
+    query: string,
+    filter?: ((cipher: CipherView) => boolean) | ((cipher: CipherView) => boolean)[],
+    ciphers?: CipherView[]
+  ) => Promise<CipherView[]>;
+  searchCiphersBasic: (ciphers: CipherView[], query: string, deleted?: boolean) => CipherView[];
+  searchSends: (sends: SendView[], query: string) => SendView[];
+}
--- a/libs/common/src/abstractions/send.service.ts
+++ b/libs/common/src/abstractions/send.service.ts
@@ -0,0 +1,25 @@
+import { SendData } from "../models/data/sendData";
+import { EncArrayBuffer } from "../models/domain/encArrayBuffer";
+import { Send } from "../models/domain/send";
+import { SymmetricCryptoKey } from "../models/domain/symmetricCryptoKey";
+import { SendView } from "../models/view/sendView";
+
+export abstract class SendService {
+  clearCache: () => Promise<void>;
+  encrypt: (
+    model: SendView,
+    file: File | ArrayBuffer,
+    password: string,
+    key?: SymmetricCryptoKey
+  ) => Promise<[Send, EncArrayBuffer]>;
+  get: (id: string) => Promise<Send>;
+  getAll: () => Promise<Send[]>;
+  getAllDecrypted: () => Promise<SendView[]>;
+  saveWithServer: (sendData: [Send, EncArrayBuffer]) => Promise<any>;
+  upsert: (send: SendData | SendData[]) => Promise<any>;
+  replace: (sends: { [id: string]: SendData }) => Promise<any>;
+  clear: (userId: string) => Promise<any>;
+  delete: (id: string | string[]) => Promise<any>;
+  deleteWithServer: (id: string) => Promise<any>;
+  removePasswordWithServer: (id: string) => Promise<any>;
+}
--- a/libs/common/src/abstractions/settings.service.ts
+++ b/libs/common/src/abstractions/settings.service.ts
@@ -0,0 +1,6 @@
+export abstract class SettingsService {
+  clearCache: () => Promise<void>;
+  getEquivalentDomains: () => Promise<any>;
+  setEquivalentDomains: (equivalentDomains: string[][]) => Promise<any>;
+  clear: (userId?: string) => Promise<void>;
+}
--- a/libs/common/src/abstractions/state.service.ts
+++ b/libs/common/src/abstractions/state.service.ts
@@ -0,0 +1,306 @@
+import { BehaviorSubject } from "rxjs";
+
+import { KdfType } from "../enums/kdfType";
+import { ThemeType } from "../enums/themeType";
+import { UriMatchType } from "../enums/uriMatchType";
+import { CipherData } from "../models/data/cipherData";
+import { CollectionData } from "../models/data/collectionData";
+import { EventData } from "../models/data/eventData";
+import { FolderData } from "../models/data/folderData";
+import { OrganizationData } from "../models/data/organizationData";
+import { PolicyData } from "../models/data/policyData";
+import { ProviderData } from "../models/data/providerData";
+import { SendData } from "../models/data/sendData";
+import { Account } from "../models/domain/account";
+import { EncString } from "../models/domain/encString";
+import { EnvironmentUrls } from "../models/domain/environmentUrls";
+import { GeneratedPasswordHistory } from "../models/domain/generatedPasswordHistory";
+import { Policy } from "../models/domain/policy";
+import { StorageOptions } from "../models/domain/storageOptions";
+import { SymmetricCryptoKey } from "../models/domain/symmetricCryptoKey";
+import { WindowState } from "../models/domain/windowState";
+import { CipherView } from "../models/view/cipherView";
+import { CollectionView } from "../models/view/collectionView";
+import { FolderView } from "../models/view/folderView";
+import { SendView } from "../models/view/sendView";
+
+export abstract class StateService<T extends Account = Account> {
+  accounts: BehaviorSubject<{ [userId: string]: T }>;
+  activeAccount: BehaviorSubject<string>;
+
+  addAccount: (account: T) => Promise<void>;
+  setActiveUser: (userId: string) => Promise<void>;
+  clean: (options?: StorageOptions) => Promise<void>;
+  init: () => Promise<void>;
+
+  getAccessToken: (options?: StorageOptions) => Promise<string>;
+  setAccessToken: (value: string, options?: StorageOptions) => Promise<void>;
+  getAddEditCipherInfo: (options?: StorageOptions) => Promise<any>;
+  setAddEditCipherInfo: (value: any, options?: StorageOptions) => Promise<void>;
+  getAlwaysShowDock: (options?: StorageOptions) => Promise<boolean>;
+  setAlwaysShowDock: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getApiKeyClientId: (options?: StorageOptions) => Promise<string>;
+  setApiKeyClientId: (value: string, options?: StorageOptions) => Promise<void>;
+  getApiKeyClientSecret: (options?: StorageOptions) => Promise<string>;
+  setApiKeyClientSecret: (value: string, options?: StorageOptions) => Promise<void>;
+  getAutoConfirmFingerPrints: (options?: StorageOptions) => Promise<boolean>;
+  setAutoConfirmFingerprints: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getAutoFillOnPageLoadDefault: (options?: StorageOptions) => Promise<boolean>;
+  setAutoFillOnPageLoadDefault: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getBiometricAwaitingAcceptance: (options?: StorageOptions) => Promise<boolean>;
+  setBiometricAwaitingAcceptance: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getBiometricFingerprintValidated: (options?: StorageOptions) => Promise<boolean>;
+  setBiometricFingerprintValidated: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getBiometricLocked: (options?: StorageOptions) => Promise<boolean>;
+  setBiometricLocked: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getBiometricText: (options?: StorageOptions) => Promise<string>;
+  setBiometricText: (value: string, options?: StorageOptions) => Promise<void>;
+  getBiometricUnlock: (options?: StorageOptions) => Promise<boolean>;
+  setBiometricUnlock: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getCanAccessPremium: (options?: StorageOptions) => Promise<boolean>;
+  setCanAccessPremium: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getClearClipboard: (options?: StorageOptions) => Promise<number>;
+  setClearClipboard: (value: number, options?: StorageOptions) => Promise<void>;
+  getCollapsedGroupings: (options?: StorageOptions) => Promise<string[]>;
+  setCollapsedGroupings: (value: string[], options?: StorageOptions) => Promise<void>;
+  getConvertAccountToKeyConnector: (options?: StorageOptions) => Promise<boolean>;
+  setConvertAccountToKeyConnector: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getCryptoMasterKey: (options?: StorageOptions) => Promise<SymmetricCryptoKey>;
+  setCryptoMasterKey: (value: SymmetricCryptoKey, options?: StorageOptions) => Promise<void>;
+  getCryptoMasterKeyAuto: (options?: StorageOptions) => Promise<string>;
+  setCryptoMasterKeyAuto: (value: string, options?: StorageOptions) => Promise<void>;
+  getCryptoMasterKeyB64: (options?: StorageOptions) => Promise<string>;
+  setCryptoMasterKeyB64: (value: string, options?: StorageOptions) => Promise<void>;
+  getCryptoMasterKeyBiometric: (options?: StorageOptions) => Promise<string>;
+  hasCryptoMasterKeyBiometric: (options?: StorageOptions) => Promise<boolean>;
+  setCryptoMasterKeyBiometric: (value: string, options?: StorageOptions) => Promise<void>;
+  getDecodedToken: (options?: StorageOptions) => Promise<any>;
+  setDecodedToken: (value: any, options?: StorageOptions) => Promise<void>;
+  getDecryptedCiphers: (options?: StorageOptions) => Promise<CipherView[]>;
+  setDecryptedCiphers: (value: CipherView[], options?: StorageOptions) => Promise<void>;
+  getDecryptedCollections: (options?: StorageOptions) => Promise<CollectionView[]>;
+  setDecryptedCollections: (value: CollectionView[], options?: StorageOptions) => Promise<void>;
+  getDecryptedCryptoSymmetricKey: (options?: StorageOptions) => Promise<SymmetricCryptoKey>;
+  setDecryptedCryptoSymmetricKey: (
+    value: SymmetricCryptoKey,
+    options?: StorageOptions
+  ) => Promise<void>;
+  getDecryptedFolders: (options?: StorageOptions) => Promise<FolderView[]>;
+  setDecryptedFolders: (value: FolderView[], options?: StorageOptions) => Promise<void>;
+  getDecryptedOrganizationKeys: (
+    options?: StorageOptions
+  ) => Promise<Map<string, SymmetricCryptoKey>>;
+  setDecryptedOrganizationKeys: (
+    value: Map<string, SymmetricCryptoKey>,
+    options?: StorageOptions
+  ) => Promise<void>;
+  getDecryptedPasswordGenerationHistory: (
+    options?: StorageOptions
+  ) => Promise<GeneratedPasswordHistory[]>;
+  setDecryptedPasswordGenerationHistory: (
+    value: GeneratedPasswordHistory[],
+    options?: StorageOptions
+  ) => Promise<void>;
+  getDecryptedPinProtected: (options?: StorageOptions) => Promise<EncString>;
+  setDecryptedPinProtected: (value: EncString, options?: StorageOptions) => Promise<void>;
+  getDecryptedPolicies: (options?: StorageOptions) => Promise<Policy[]>;
+  setDecryptedPolicies: (value: Policy[], options?: StorageOptions) => Promise<void>;
+  getDecryptedPrivateKey: (options?: StorageOptions) => Promise<ArrayBuffer>;
+  setDecryptedPrivateKey: (value: ArrayBuffer, options?: StorageOptions) => Promise<void>;
+  getDecryptedProviderKeys: (options?: StorageOptions) => Promise<Map<string, SymmetricCryptoKey>>;
+  setDecryptedProviderKeys: (
+    value: Map<string, SymmetricCryptoKey>,
+    options?: StorageOptions
+  ) => Promise<void>;
+  getDecryptedSends: (options?: StorageOptions) => Promise<SendView[]>;
+  setDecryptedSends: (value: SendView[], options?: StorageOptions) => Promise<void>;
+  getDefaultUriMatch: (options?: StorageOptions) => Promise<UriMatchType>;
+  setDefaultUriMatch: (value: UriMatchType, options?: StorageOptions) => Promise<void>;
+  getDisableAddLoginNotification: (options?: StorageOptions) => Promise<boolean>;
+  setDisableAddLoginNotification: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getDisableAutoBiometricsPrompt: (options?: StorageOptions) => Promise<boolean>;
+  setDisableAutoBiometricsPrompt: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getDisableAutoTotpCopy: (options?: StorageOptions) => Promise<boolean>;
+  setDisableAutoTotpCopy: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getDisableBadgeCounter: (options?: StorageOptions) => Promise<boolean>;
+  setDisableBadgeCounter: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getDisableChangedPasswordNotification: (options?: StorageOptions) => Promise<boolean>;
+  setDisableChangedPasswordNotification: (
+    value: boolean,
+    options?: StorageOptions
+  ) => Promise<void>;
+  getDisableContextMenuItem: (options?: StorageOptions) => Promise<boolean>;
+  setDisableContextMenuItem: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getDisableFavicon: (options?: StorageOptions) => Promise<boolean>;
+  setDisableFavicon: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getDisableGa: (options?: StorageOptions) => Promise<boolean>;
+  setDisableGa: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getDontShowCardsCurrentTab: (options?: StorageOptions) => Promise<boolean>;
+  setDontShowCardsCurrentTab: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getDontShowIdentitiesCurrentTab: (options?: StorageOptions) => Promise<boolean>;
+  setDontShowIdentitiesCurrentTab: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getEmail: (options?: StorageOptions) => Promise<string>;
+  setEmail: (value: string, options?: StorageOptions) => Promise<void>;
+  getEmailVerified: (options?: StorageOptions) => Promise<boolean>;
+  setEmailVerified: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getEnableAlwaysOnTop: (options?: StorageOptions) => Promise<boolean>;
+  setEnableAlwaysOnTop: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getEnableAutoFillOnPageLoad: (options?: StorageOptions) => Promise<boolean>;
+  setEnableAutoFillOnPageLoad: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getEnableBiometric: (options?: StorageOptions) => Promise<boolean>;
+  setEnableBiometric: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getEnableBrowserIntegration: (options?: StorageOptions) => Promise<boolean>;
+  setEnableBrowserIntegration: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getEnableBrowserIntegrationFingerprint: (options?: StorageOptions) => Promise<boolean>;
+  setEnableBrowserIntegrationFingerprint: (
+    value: boolean,
+    options?: StorageOptions
+  ) => Promise<void>;
+  getEnableCloseToTray: (options?: StorageOptions) => Promise<boolean>;
+  setEnableCloseToTray: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getEnableFullWidth: (options?: StorageOptions) => Promise<boolean>;
+  setEnableFullWidth: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getEnableGravitars: (options?: StorageOptions) => Promise<boolean>;
+  setEnableGravitars: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getEnableMinimizeToTray: (options?: StorageOptions) => Promise<boolean>;
+  setEnableMinimizeToTray: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getEnableStartToTray: (options?: StorageOptions) => Promise<boolean>;
+  setEnableStartToTray: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getEnableTray: (options?: StorageOptions) => Promise<boolean>;
+  setEnableTray: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getEncryptedCiphers: (options?: StorageOptions) => Promise<{ [id: string]: CipherData }>;
+  setEncryptedCiphers: (
+    value: { [id: string]: CipherData },
+    options?: StorageOptions
+  ) => Promise<void>;
+  getEncryptedCollections: (options?: StorageOptions) => Promise<{ [id: string]: CollectionData }>;
+  setEncryptedCollections: (
+    value: { [id: string]: CollectionData },
+    options?: StorageOptions
+  ) => Promise<void>;
+  getEncryptedCryptoSymmetricKey: (options?: StorageOptions) => Promise<string>;
+  setEncryptedCryptoSymmetricKey: (value: string, options?: StorageOptions) => Promise<void>;
+  getEncryptedFolders: (options?: StorageOptions) => Promise<{ [id: string]: FolderData }>;
+  setEncryptedFolders: (
+    value: { [id: string]: FolderData },
+    options?: StorageOptions
+  ) => Promise<void>;
+  getEncryptedOrganizationKeys: (options?: StorageOptions) => Promise<any>;
+  setEncryptedOrganizationKeys: (
+    value: Map<string, SymmetricCryptoKey>,
+    options?: StorageOptions
+  ) => Promise<void>;
+  getEncryptedPasswordGenerationHistory: (
+    options?: StorageOptions
+  ) => Promise<GeneratedPasswordHistory[]>;
+  setEncryptedPasswordGenerationHistory: (
+    value: GeneratedPasswordHistory[],
+    options?: StorageOptions
+  ) => Promise<void>;
+  getEncryptedPinProtected: (options?: StorageOptions) => Promise<string>;
+  setEncryptedPinProtected: (value: string, options?: StorageOptions) => Promise<void>;
+  getEncryptedPolicies: (options?: StorageOptions) => Promise<{ [id: string]: PolicyData }>;
+  setEncryptedPolicies: (
+    value: { [id: string]: PolicyData },
+    options?: StorageOptions
+  ) => Promise<void>;
+  getEncryptedPrivateKey: (options?: StorageOptions) => Promise<string>;
+  setEncryptedPrivateKey: (value: string, options?: StorageOptions) => Promise<void>;
+  getEncryptedProviderKeys: (options?: StorageOptions) => Promise<any>;
+  setEncryptedProviderKeys: (value: any, options?: StorageOptions) => Promise<void>;
+  getEncryptedSends: (options?: StorageOptions) => Promise<{ [id: string]: SendData }>;
+  setEncryptedSends: (value: { [id: string]: SendData }, options?: StorageOptions) => Promise<void>;
+  getEntityId: (options?: StorageOptions) => Promise<string>;
+  setEntityId: (value: string, options?: StorageOptions) => Promise<void>;
+  getEntityType: (options?: StorageOptions) => Promise<any>;
+  setEntityType: (value: string, options?: StorageOptions) => Promise<void>;
+  getEnvironmentUrls: (options?: StorageOptions) => Promise<EnvironmentUrls>;
+  setEnvironmentUrls: (value: EnvironmentUrls, options?: StorageOptions) => Promise<void>;
+  getEquivalentDomains: (options?: StorageOptions) => Promise<any>;
+  setEquivalentDomains: (value: string, options?: StorageOptions) => Promise<void>;
+  getEventCollection: (options?: StorageOptions) => Promise<EventData[]>;
+  setEventCollection: (value: EventData[], options?: StorageOptions) => Promise<void>;
+  getEverBeenUnlocked: (options?: StorageOptions) => Promise<boolean>;
+  setEverBeenUnlocked: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getForcePasswordReset: (options?: StorageOptions) => Promise<boolean>;
+  setForcePasswordReset: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getInstalledVersion: (options?: StorageOptions) => Promise<string>;
+  setInstalledVersion: (value: string, options?: StorageOptions) => Promise<void>;
+  getIsAuthenticated: (options?: StorageOptions) => Promise<boolean>;
+  getKdfIterations: (options?: StorageOptions) => Promise<number>;
+  setKdfIterations: (value: number, options?: StorageOptions) => Promise<void>;
+  getKdfType: (options?: StorageOptions) => Promise<KdfType>;
+  setKdfType: (value: KdfType, options?: StorageOptions) => Promise<void>;
+  getKeyHash: (options?: StorageOptions) => Promise<string>;
+  setKeyHash: (value: string, options?: StorageOptions) => Promise<void>;
+  getLastActive: (options?: StorageOptions) => Promise<number>;
+  setLastActive: (value: number, options?: StorageOptions) => Promise<void>;
+  getLastSync: (options?: StorageOptions) => Promise<string>;
+  setLastSync: (value: string, options?: StorageOptions) => Promise<void>;
+  getLegacyEtmKey: (options?: StorageOptions) => Promise<SymmetricCryptoKey>;
+  setLegacyEtmKey: (value: SymmetricCryptoKey, options?: StorageOptions) => Promise<void>;
+  getLocalData: (options?: StorageOptions) => Promise<any>;
+  setLocalData: (value: string, options?: StorageOptions) => Promise<void>;
+  getLocale: (options?: StorageOptions) => Promise<string>;
+  setLocale: (value: string, options?: StorageOptions) => Promise<void>;
+  getMainWindowSize: (options?: StorageOptions) => Promise<number>;
+  setMainWindowSize: (value: number, options?: StorageOptions) => Promise<void>;
+  getMinimizeOnCopyToClipboard: (options?: StorageOptions) => Promise<boolean>;
+  setMinimizeOnCopyToClipboard: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getNeverDomains: (options?: StorageOptions) => Promise<{ [id: string]: any }>;
+  setNeverDomains: (value: { [id: string]: any }, options?: StorageOptions) => Promise<void>;
+  getNoAutoPromptBiometrics: (options?: StorageOptions) => Promise<boolean>;
+  setNoAutoPromptBiometrics: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getNoAutoPromptBiometricsText: (options?: StorageOptions) => Promise<string>;
+  setNoAutoPromptBiometricsText: (value: string, options?: StorageOptions) => Promise<void>;
+  getOpenAtLogin: (options?: StorageOptions) => Promise<boolean>;
+  setOpenAtLogin: (value: boolean, options?: StorageOptions) => Promise<void>;
+  getOrganizationInvitation: (options?: StorageOptions) => Promise<any>;
+  setOrganizationInvitation: (value: any, options?: StorageOptions) => Promise<void>;
+  getOrganizations: (options?: StorageOptions) => Promise<{ [id: string]: OrganizationData }>;
+  setOrganizations: (
+    value: { [id: string]: OrganizationData },
+    options?: StorageOptions
+  ) => Promise<void>;
+  getPasswordGenerationOptions: (options?: StorageOptions) => Promise<any>;
+  setPasswordGenerationOptions: (value: any, options?: StorageOptions) => Promise<void>;
+  getUsernameGenerationOptions: (options?: StorageOptions) => Promise<any>;
+  setUsernameGenerationOptions: (value: any, options?: StorageOptions) => Promise<void>;
+  getGeneratorOptions: (options?: StorageOptions) => Promise<any>;
+  setGeneratorOptions: (value: any, options?: StorageOptions) => Promise<void>;
+  getProtectedPin: (options?: StorageOptions) => Promise<string>;
+  setProtectedPin: (value: string, options?: StorageOptions) => Promise<void>;
+  getProviders: (options?: StorageOptions) => Promise<{ [id: string]: ProviderData }>;
+  setProviders: (value: { [id: string]: ProviderData }, options?: StorageOptions) => Promise<void>;
+  getPublicKey: (options?: StorageOptions) => Promise<ArrayBuffer>;
+  setPublicKey: (value: ArrayBuffer, options?: StorageOptions) => Promise<void>;
+  getRefreshToken: (options?: StorageOptions) => Promise<string>;
+  setRefreshToken: (value: string, options?: StorageOptions) => Promise<void>;
+  getRememberedEmail: (options?: StorageOptions) => Promise<string>;
+  setRememberedEmail: (value: string, options?: StorageOptions) => Promise<void>;
+  getSecurityStamp: (options?: StorageOptions) => Promise<string>;
+  setSecurityStamp: (value: string, options?: StorageOptions) => Promise<void>;
+  getSettings: (options?: StorageOptions) => Promise<any>;
+  setSettings: (value: string, options?: StorageOptions) => Promise<void>;
+  getSsoCodeVerifier: (options?: StorageOptions) => Promise<string>;
+  setSsoCodeVerifier: (value: string, options?: StorageOptions) => Promise<void>;
+  getSsoOrgIdentifier: (options?: StorageOptions) => Promise<string>;
+  setSsoOrganizationIdentifier: (value: string, options?: StorageOptions) => Promise<void>;
+  getSsoState: (options?: StorageOptions) => Promise<string>;
+  setSsoState: (value: string, options?: StorageOptions) => Promise<void>;
+  getTheme: (options?: StorageOptions) => Promise<ThemeType>;
+  setTheme: (value: ThemeType, options?: StorageOptions) => Promise<void>;
+  getTwoFactorToken: (options?: StorageOptions) => Promise<string>;
+  setTwoFactorToken: (value: string, options?: StorageOptions) => Promise<void>;
+  getUserId: (options?: StorageOptions) => Promise<string>;
+  getUsesKeyConnector: (options?: StorageOptions) => Promise<boolean>;
+  setUsesKeyConnector: (vaule: boolean, options?: StorageOptions) => Promise<void>;
+  getVaultTimeout: (options?: StorageOptions) => Promise<number>;
+  setVaultTimeout: (value: number, options?: StorageOptions) => Promise<void>;
+  getVaultTimeoutAction: (options?: StorageOptions) => Promise<string>;
+  setVaultTimeoutAction: (value: string, options?: StorageOptions) => Promise<void>;
+  getStateVersion: () => Promise<number>;
+  setStateVersion: (value: number) => Promise<void>;
+  getWindow: () => Promise<WindowState>;
+  setWindow: (value: WindowState) => Promise<void>;
+}
--- a/libs/common/src/abstractions/stateMigration.service.ts
+++ b/libs/common/src/abstractions/stateMigration.service.ts
@@ -0,0 +1,4 @@
+export abstract class StateMigrationService {
+  needsMigration: () => Promise<boolean>;
+  migrate: () => Promise<void>;
+}
--- a/libs/common/src/abstractions/storage.service.ts
+++ b/libs/common/src/abstractions/storage.service.ts
@@ -0,0 +1,8 @@
+import { StorageOptions } from "../models/domain/storageOptions";
+
+export abstract class StorageService {
+  get: <T>(key: string, options?: StorageOptions) => Promise<T>;
+  has: (key: string, options?: StorageOptions) => Promise<boolean>;
+  save: (key: string, obj: any, options?: StorageOptions) => Promise<any>;
+  remove: (key: string, options?: StorageOptions) => Promise<any>;
+}
--- a/libs/common/src/abstractions/sync.service.ts
+++ b/libs/common/src/abstractions/sync.service.ts
@@ -0,0 +1,19 @@
+import {
+  SyncCipherNotification,
+  SyncFolderNotification,
+  SyncSendNotification,
+} from "../models/response/notificationResponse";
+
+export abstract class SyncService {
+  syncInProgress: boolean;
+
+  getLastSync: () => Promise<Date>;
+  setLastSync: (date: Date, userId?: string) => Promise<any>;
+  fullSync: (forceSync: boolean, allowThrowOnError?: boolean) => Promise<boolean>;
+  syncUpsertFolder: (notification: SyncFolderNotification, isEdit: boolean) => Promise<boolean>;
+  syncDeleteFolder: (notification: SyncFolderNotification) => Promise<boolean>;
+  syncUpsertCipher: (notification: SyncCipherNotification, isEdit: boolean) => Promise<boolean>;
+  syncDeleteCipher: (notification: SyncFolderNotification) => Promise<boolean>;
+  syncUpsertSend: (notification: SyncSendNotification, isEdit: boolean) => Promise<boolean>;
+  syncDeleteSend: (notification: SyncSendNotification) => Promise<boolean>;
+}
--- a/libs/common/src/abstractions/system.service.ts
+++ b/libs/common/src/abstractions/system.service.ts
@@ -0,0 +1,6 @@
+export abstract class SystemService {
+  startProcessReload: () => Promise<void>;
+  cancelProcessReload: () => void;
+  clearClipboard: (clipboardValue: string, timeoutMs?: number) => Promise<void>;
+  clearPendingClipboard: () => Promise<any>;
+}
--- a/libs/common/src/abstractions/token.service.ts
+++ b/libs/common/src/abstractions/token.service.ts
@@ -0,0 +1,32 @@
+import { IdentityTokenResponse } from "../models/response/identityTokenResponse";
+
+export abstract class TokenService {
+  setTokens: (
+    accessToken: string,
+    refreshToken: string,
+    clientIdClientSecret: [string, string]
+  ) => Promise<any>;
+  setToken: (token: string) => Promise<any>;
+  getToken: () => Promise<string>;
+  setRefreshToken: (refreshToken: string) => Promise<any>;
+  getRefreshToken: () => Promise<string>;
+  setClientId: (clientId: string) => Promise<any>;
+  getClientId: () => Promise<string>;
+  setClientSecret: (clientSecret: string) => Promise<any>;
+  getClientSecret: () => Promise<string>;
+  setTwoFactorToken: (tokenResponse: IdentityTokenResponse) => Promise<any>;
+  getTwoFactorToken: () => Promise<string>;
+  clearTwoFactorToken: () => Promise<any>;
+  clearToken: (userId?: string) => Promise<any>;
+  decodeToken: (token?: string) => any;
+  getTokenExpirationDate: () => Promise<Date>;
+  tokenSecondsRemaining: (offsetSeconds?: number) => Promise<number>;
+  tokenNeedsRefresh: (minutes?: number) => Promise<boolean>;
+  getUserId: () => Promise<string>;
+  getEmail: () => Promise<string>;
+  getEmailVerified: () => Promise<boolean>;
+  getName: () => Promise<string>;
+  getPremium: () => Promise<boolean>;
+  getIssuer: () => Promise<string>;
+  getIsExternal: () => Promise<boolean>;
+}
--- a/libs/common/src/abstractions/totp.service.ts
+++ b/libs/common/src/abstractions/totp.service.ts
@@ -0,0 +1,5 @@
+export abstract class TotpService {
+  getCode: (key: string) => Promise<string>;
+  getTimeInterval: (key: string) => number;
+  isAutoCopyEnabled: () => Promise<boolean>;
+}
--- a/libs/common/src/abstractions/twoFactor.service.ts
+++ b/libs/common/src/abstractions/twoFactor.service.ts
@@ -0,0 +1,23 @@
+import { TwoFactorProviderType } from "../enums/twoFactorProviderType";
+import { IdentityTwoFactorResponse } from "../models/response/identityTwoFactorResponse";
+
+export interface TwoFactorProviderDetails {
+  type: TwoFactorProviderType;
+  name: string;
+  description: string;
+  priority: number;
+  sort: number;
+  premium: boolean;
+}
+
+export abstract class TwoFactorService {
+  init: () => void;
+  getSupportedProviders: (win: Window) => TwoFactorProviderDetails[];
+  getDefaultProvider: (webAuthnSupported: boolean) => TwoFactorProviderType;
+  setSelectedProvider: (type: TwoFactorProviderType) => void;
+  clearSelectedProvider: () => void;
+
+  setProviders: (response: IdentityTwoFactorResponse) => void;
+  clearProviders: () => void;
+  getProviders: () => Map<TwoFactorProviderType, { [key: string]: string }>;
+}
--- a/libs/common/src/abstractions/userVerification.service.ts
+++ b/libs/common/src/abstractions/userVerification.service.ts
@@ -0,0 +1,12 @@
+import { SecretVerificationRequest } from "../models/request/secretVerificationRequest";
+import { Verification } from "../types/verification";
+
+export abstract class UserVerificationService {
+  buildRequest: <T extends SecretVerificationRequest>(
+    verification: Verification,
+    requestClass?: new () => T,
+    alreadyHashed?: boolean
+  ) => Promise<T>;
+  verifyUser: (verification: Verification) => Promise<boolean>;
+  requestOTP: () => Promise<void>;
+}
--- a/libs/common/src/abstractions/usernameGeneration.service.ts
+++ b/libs/common/src/abstractions/usernameGeneration.service.ts
@@ -0,0 +1,9 @@
+export abstract class UsernameGenerationService {
+  generateUsername: (options: any) => Promise<string>;
+  generateWord: (options: any) => Promise<string>;
+  generateSubaddress: (options: any) => Promise<string>;
+  generateCatchall: (options: any) => Promise<string>;
+  generateForwarded: (options: any) => Promise<string>;
+  getOptions: () => Promise<any>;
+  saveOptions: (options: any) => Promise<void>;
+}
--- a/libs/common/src/abstractions/vaultTimeout.service.ts
+++ b/libs/common/src/abstractions/vaultTimeout.service.ts
@@ -0,0 +1,10 @@
+export abstract class VaultTimeoutService {
+  checkVaultTimeout: () => Promise<void>;
+  lock: (allowSoftLock?: boolean, userId?: string) => Promise<void>;
+  logOut: (userId?: string) => Promise<void>;
+  setVaultTimeoutOptions: (vaultTimeout: number, vaultTimeoutAction: string) => Promise<void>;
+  getVaultTimeout: () => Promise<number>;
+  isPinLockSet: () => Promise<[boolean, boolean]>;
+  isBiometricLockSet: () => Promise<boolean>;
+  clear: (userId?: string) => Promise<any>;
+}
--- a/libs/common/src/enums/authenticationStatus.ts
+++ b/libs/common/src/enums/authenticationStatus.ts
@@ -0,0 +1,5 @@
+export enum AuthenticationStatus {
+  LoggedOut = 0,
+  Locked = 1,
+  Unlocked = 2,
+}
--- a/libs/common/src/enums/authenticationType.ts
+++ b/libs/common/src/enums/authenticationType.ts
@@ -0,0 +1,5 @@
+export enum AuthenticationType {
+  Password = 0,
+  Sso = 1,
+  Api = 2,
+}
--- a/libs/common/src/enums/cipherRepromptType.ts
+++ b/libs/common/src/enums/cipherRepromptType.ts
@@ -0,0 +1,4 @@
+export enum CipherRepromptType {
+  None = 0,
+  Password = 1,
+}
--- a/libs/common/src/enums/cipherType.ts
+++ b/libs/common/src/enums/cipherType.ts
@@ -0,0 +1,6 @@
+export enum CipherType {
+  Login = 1,
+  SecureNote = 2,
+  Card = 3,
+  Identity = 4,
+}
--- a/libs/common/src/enums/clientType.ts
+++ b/libs/common/src/enums/clientType.ts
@@ -0,0 +1,8 @@
+export enum ClientType {
+  Web = "web",
+  Browser = "browser",
+  Desktop = "desktop",
+  Mobile = "mobile",
+  Cli = "cli",
+  DirectoryConnector = "connector",
+}
--- a/libs/common/src/enums/deviceType.ts
+++ b/libs/common/src/enums/deviceType.ts
@@ -0,0 +1,23 @@
+export enum DeviceType {
+  Android = 0,
+  iOS = 1,
+  ChromeExtension = 2,
+  FirefoxExtension = 3,
+  OperaExtension = 4,
+  EdgeExtension = 5,
+  WindowsDesktop = 6,
+  MacOsDesktop = 7,
+  LinuxDesktop = 8,
+  ChromeBrowser = 9,
+  FirefoxBrowser = 10,
+  OperaBrowser = 11,
+  EdgeBrowser = 12,
+  IEBrowser = 13,
+  UnknownBrowser = 14,
+  AndroidAmazon = 15,
+  UWP = 16,
+  SafariBrowser = 17,
+  VivaldiBrowser = 18,
+  VivaldiExtension = 19,
+  SafariExtension = 20,
+}
--- a/libs/common/src/enums/emergencyAccessStatusType.ts
+++ b/libs/common/src/enums/emergencyAccessStatusType.ts
@@ -0,0 +1,7 @@
+export enum EmergencyAccessStatusType {
+  Invited = 0,
+  Accepted = 1,
+  Confirmed = 2,
+  RecoveryInitiated = 3,
+  RecoveryApproved = 4,
+}
--- a/libs/common/src/enums/emergencyAccessType.ts
+++ b/libs/common/src/enums/emergencyAccessType.ts
@@ -0,0 +1,4 @@
+export enum EmergencyAccessType {
+  View = 0,
+  Takeover = 1,
+}
--- a/libs/common/src/enums/encryptionType.ts
+++ b/libs/common/src/enums/encryptionType.ts
@@ -0,0 +1,9 @@
+export enum EncryptionType {
+  AesCbc256_B64 = 0,
+  AesCbc128_HmacSha256_B64 = 1,
+  AesCbc256_HmacSha256_B64 = 2,
+  Rsa2048_OaepSha256_B64 = 3,
+  Rsa2048_OaepSha1_B64 = 4,
+  Rsa2048_OaepSha256_HmacSha256_B64 = 5,
+  Rsa2048_OaepSha1_HmacSha256_B64 = 6,
+}
--- a/libs/common/src/enums/eventType.ts
+++ b/libs/common/src/enums/eventType.ts
@@ -0,0 +1,73 @@
+export enum EventType {
+  User_LoggedIn = 1000,
+  User_ChangedPassword = 1001,
+  User_Updated2fa = 1002,
+  User_Disabled2fa = 1003,
+  User_Recovered2fa = 1004,
+  User_FailedLogIn = 1005,
+  User_FailedLogIn2fa = 1006,
+  User_ClientExportedVault = 1007,
+  User_UpdatedTempPassword = 1008,
+  User_MigratedKeyToKeyConnector = 1009,
+
+  Cipher_Created = 1100,
+  Cipher_Updated = 1101,
+  Cipher_Deleted = 1102,
+  Cipher_AttachmentCreated = 1103,
+  Cipher_AttachmentDeleted = 1104,
+  Cipher_Shared = 1105,
+  Cipher_UpdatedCollections = 1106,
+  Cipher_ClientViewed = 1107,
+  Cipher_ClientToggledPasswordVisible = 1108,
+  Cipher_ClientToggledHiddenFieldVisible = 1109,
+  Cipher_ClientToggledCardCodeVisible = 1110,
+  Cipher_ClientCopiedPassword = 1111,
+  Cipher_ClientCopiedHiddenField = 1112,
+  Cipher_ClientCopiedCardCode = 1113,
+  Cipher_ClientAutofilled = 1114,
+  Cipher_SoftDeleted = 1115,
+  Cipher_Restored = 1116,
+  Cipher_ClientToggledCardNumberVisible = 1117,
+
+  Collection_Created = 1300,
+  Collection_Updated = 1301,
+  Collection_Deleted = 1302,
+
+  Group_Created = 1400,
+  Group_Updated = 1401,
+  Group_Deleted = 1402,
+
+  OrganizationUser_Invited = 1500,
+  OrganizationUser_Confirmed = 1501,
+  OrganizationUser_Updated = 1502,
+  OrganizationUser_Removed = 1503,
+  OrganizationUser_UpdatedGroups = 1504,
+  OrganizationUser_UnlinkedSso = 1505,
+  OrganizationUser_ResetPassword_Enroll = 1506,
+  OrganizationUser_ResetPassword_Withdraw = 1507,
+  OrganizationUser_AdminResetPassword = 1508,
+  OrganizationUser_ResetSsoLink = 1509,
+  OrganizationUser_FirstSsoLogin = 1510,
+
+  Organization_Updated = 1600,
+  Organization_PurgedVault = 1601,
+  // Organization_ClientExportedVault = 1602,
+  Organization_VaultAccessed = 1603,
+  Organization_EnabledSso = 1604,
+  Organization_DisabledSso = 1605,
+  Organization_EnabledKeyConnector = 1606,
+  Organization_DisabledKeyConnector = 1607,
+  Organization_SponsorshipsSynced = 1608,
+
+  Policy_Updated = 1700,
+
+  ProviderUser_Invited = 1800,
+  ProviderUser_Confirmed = 1801,
+  ProviderUser_Updated = 1802,
+  ProviderUser_Removed = 1803,
+
+  ProviderOrganization_Created = 1900,
+  ProviderOrganization_Added = 1901,
+  ProviderOrganization_Removed = 1902,
+  ProviderOrganization_VaultAccessed = 1903,
+}
--- a/libs/common/src/enums/fieldType.ts
+++ b/libs/common/src/enums/fieldType.ts
@@ -0,0 +1,6 @@
+export enum FieldType {
+  Text = 0,
+  Hidden = 1,
+  Boolean = 2,
+  Linked = 3,
+}
--- a/libs/common/src/enums/fileUploadType.ts
+++ b/libs/common/src/enums/fileUploadType.ts
@@ -0,0 +1,4 @@
+export enum FileUploadType {
+  Direct = 0,
+  Azure = 1,
+}
--- a/libs/common/src/enums/hashPurpose.ts
+++ b/libs/common/src/enums/hashPurpose.ts
@@ -0,0 +1,4 @@
+export enum HashPurpose {
+  ServerAuthorization = 1,
+  LocalAuthorization = 2,
+}
--- a/libs/common/src/enums/htmlStorageLocation.ts
+++ b/libs/common/src/enums/htmlStorageLocation.ts
@@ -0,0 +1,5 @@
+export enum HtmlStorageLocation {
+  Local = "local",
+  Memory = "memory",
+  Session = "session",
+}
--- a/libs/common/src/enums/importOptions.ts
+++ b/libs/common/src/enums/importOptions.ts
@@ -0,0 +1,74 @@
+export interface ImportOption {
+  id: string;
+  name: string;
+}
+
+export const featuredImportOptions = [
+  { id: "bitwardenjson", name: "Bitwarden (json)" },
+  { id: "bitwardencsv", name: "Bitwarden (csv)" },
+  { id: "chromecsv", name: "Chrome (csv)" },
+  { id: "dashlanecsv", name: "Dashlane (csv)" },
+  { id: "firefoxcsv", name: "Firefox (csv)" },
+  { id: "keepass2xml", name: "KeePass 2 (xml)" },
+  { id: "lastpasscsv", name: "LastPass (csv)" },
+  { id: "safaricsv", name: "Safari and macOS (csv)" },
+  { id: "1password1pux", name: "1Password (1pux)" },
+] as const;
+
+export const regularImportOptions = [
+  { id: "keepassxcsv", name: "KeePassX (csv)" },
+  { id: "1password1pif", name: "1Password (1pif)" },
+  { id: "1passwordwincsv", name: "1Password 6 and 7 Windows (csv)" },
+  { id: "1passwordmaccsv", name: "1Password 6 and 7 Mac (csv)" },
+  { id: "dashlanejson", name: "Dashlane (json)" },
+  { id: "roboformcsv", name: "RoboForm (csv)" },
+  { id: "keepercsv", name: "Keeper (csv)" },
+  // Temporarily remove this option for the Feb release
+  // { id: "keeperjson", name: "Keeper (json)" },
+  { id: "enpasscsv", name: "Enpass (csv)" },
+  { id: "enpassjson", name: "Enpass (json)" },
+  { id: "safeincloudxml", name: "SafeInCloud (xml)" },
+  { id: "pwsafexml", name: "Password Safe (xml)" },
+  { id: "stickypasswordxml", name: "Sticky Password (xml)" },
+  { id: "msecurecsv", name: "mSecure (csv)" },
+  { id: "truekeycsv", name: "True Key (csv)" },
+  { id: "passwordbossjson", name: "Password Boss (json)" },
+  { id: "zohovaultcsv", name: "Zoho Vault (csv)" },
+  { id: "splashidcsv", name: "SplashID (csv)" },
+  { id: "passworddragonxml", name: "Password Dragon (xml)" },
+  { id: "padlockcsv", name: "Padlock (csv)" },
+  { id: "passboltcsv", name: "Passbolt (csv)" },
+  { id: "clipperzhtml", name: "Clipperz (html)" },
+  { id: "aviracsv", name: "Avira (csv)" },
+  { id: "saferpasscsv", name: "SaferPass (csv)" },
+  { id: "upmcsv", name: "Universal Password Manager (csv)" },
+  { id: "ascendocsv", name: "Ascendo DataVault (csv)" },
+  { id: "meldiumcsv", name: "Meldium (csv)" },
+  { id: "passkeepcsv", name: "PassKeep (csv)" },
+  { id: "operacsv", name: "Opera (csv)" },
+  { id: "vivaldicsv", name: "Vivaldi (csv)" },
+  { id: "gnomejson", name: "GNOME Passwords and Keys/Seahorse (json)" },
+  { id: "blurcsv", name: "Blur (csv)" },
+  { id: "passwordagentcsv", name: "Password Agent (csv)" },
+  { id: "passpackcsv", name: "Passpack (csv)" },
+  { id: "passmanjson", name: "Passman (json)" },
+  { id: "avastcsv", name: "Avast Passwords (csv)" },
+  { id: "avastjson", name: "Avast Passwords (json)" },
+  { id: "fsecurefsk", name: "F-Secure KEY (fsk)" },
+  { id: "kasperskytxt", name: "Kaspersky Password Manager (txt)" },
+  { id: "remembearcsv", name: "RememBear (csv)" },
+  { id: "passwordwallettxt", name: "PasswordWallet (txt)" },
+  { id: "mykicsv", name: "Myki (csv)" },
+  { id: "securesafecsv", name: "SecureSafe (csv)" },
+  { id: "logmeoncecsv", name: "LogMeOnce (csv)" },
+  { id: "blackberrycsv", name: "BlackBerry Password Keeper (csv)" },
+  { id: "buttercupcsv", name: "Buttercup (csv)" },
+  { id: "codebookcsv", name: "Codebook (csv)" },
+  { id: "encryptrcsv", name: "Encryptr (csv)" },
+  { id: "yoticsv", name: "Yoti (csv)" },
+  { id: "nordpasscsv", name: "Nordpass (csv)" },
+] as const;
+
+export type ImportType =
+  | typeof featuredImportOptions[number]["id"]
+  | typeof regularImportOptions[number]["id"];
--- a/libs/common/src/enums/kdfType.ts
+++ b/libs/common/src/enums/kdfType.ts
@@ -0,0 +1,7 @@
+export enum KdfType {
+  PBKDF2_SHA256 = 0,
+}
+
+export const DEFAULT_KDF_TYPE = KdfType.PBKDF2_SHA256;
+export const DEFAULT_KDF_ITERATIONS = 100000;
+export const SEND_KDF_ITERATIONS = 100000;
--- a/libs/common/src/enums/keySuffixOptions.ts
+++ b/libs/common/src/enums/keySuffixOptions.ts
@@ -0,0 +1,4 @@
+export enum KeySuffixOptions {
+  Auto = "auto",
+  Biometric = "biometric",
+}
--- a/libs/common/src/enums/linkedIdType.ts
+++ b/libs/common/src/enums/linkedIdType.ts
@@ -0,0 +1,40 @@
+export type LinkedIdType = LoginLinkedId | CardLinkedId | IdentityLinkedId;
+
+// LoginView
+export enum LoginLinkedId {
+  Username = 100,
+  Password = 101,
+}
+
+// CardView
+export enum CardLinkedId {
+  CardholderName = 300,
+  ExpMonth = 301,
+  ExpYear = 302,
+  Code = 303,
+  Brand = 304,
+  Number = 305,
+}
+
+// IdentityView
+export enum IdentityLinkedId {
+  Title = 400,
+  MiddleName = 401,
+  Address1 = 402,
+  Address2 = 403,
+  Address3 = 404,
+  City = 405,
+  State = 406,
+  PostalCode = 407,
+  Country = 408,
+  Company = 409,
+  Email = 410,
+  Phone = 411,
+  Ssn = 412,
+  Username = 413,
+  PassportNumber = 414,
+  LicenseNumber = 415,
+  FirstName = 416,
+  LastName = 417,
+  FullName = 418,
+}
--- a/libs/common/src/enums/logLevelType.ts
+++ b/libs/common/src/enums/logLevelType.ts
@@ -0,0 +1,6 @@
+export enum LogLevelType {
+  Debug,
+  Info,
+  Warning,
+  Error,
+}
--- a/libs/common/src/enums/notificationType.ts
+++ b/libs/common/src/enums/notificationType.ts
@@ -0,0 +1,20 @@
+export enum NotificationType {
+  SyncCipherUpdate = 0,
+  SyncCipherCreate = 1,
+  SyncLoginDelete = 2,
+  SyncFolderDelete = 3,
+  SyncCiphers = 4,
+
+  SyncVault = 5,
+  SyncOrgKeys = 6,
+  SyncFolderCreate = 7,
+  SyncFolderUpdate = 8,
+  SyncCipherDelete = 9,
+  SyncSettings = 10,
+
+  LogOut = 11,
+
+  SyncSendCreate = 12,
+  SyncSendUpdate = 13,
+  SyncSendDelete = 14,
+}
--- a/libs/common/src/enums/organizationApiKeyType.ts
+++ b/libs/common/src/enums/organizationApiKeyType.ts
@@ -0,0 +1,4 @@
+export enum OrganizationApiKeyType {
+  Default = 0,
+  BillingSync = 1,
+}
--- a/libs/common/src/enums/organizationConnectionType.ts
+++ b/libs/common/src/enums/organizationConnectionType.ts
@@ -0,0 +1,3 @@
+export enum OrganizationConnectionType {
+  CloudBillingSync = 1,
+}
--- a/libs/common/src/enums/organizationUserStatusType.ts
+++ b/libs/common/src/enums/organizationUserStatusType.ts
@@ -0,0 +1,5 @@
+export enum OrganizationUserStatusType {
+  Invited = 0,
+  Accepted = 1,
+  Confirmed = 2,
+}
--- a/libs/common/src/enums/organizationUserType.ts
+++ b/libs/common/src/enums/organizationUserType.ts
@@ -0,0 +1,7 @@
+export enum OrganizationUserType {
+  Owner = 0,
+  Admin = 1,
+  User = 2,
+  Manager = 3,
+  Custom = 4,
+}
--- a/libs/common/src/enums/paymentMethodType.ts
+++ b/libs/common/src/enums/paymentMethodType.ts
@@ -0,0 +1,11 @@
+export enum PaymentMethodType {
+  Card = 0,
+  BankAccount = 1,
+  PayPal = 2,
+  BitPay = 3,
+  Credit = 4,
+  WireTransfer = 5,
+  AppleInApp = 6,
+  GoogleInApp = 7,
+  Check = 8,
+}
--- a/libs/common/src/enums/permissions.ts
+++ b/libs/common/src/enums/permissions.ts
@@ -0,0 +1,28 @@
+export enum Permissions {
+  AccessEventLogs,
+  AccessImportExport,
+  AccessReports,
+  /**
+   * @deprecated Sep 29 2021: This permission has been split out to `createNewCollections`, `editAnyCollection`, and
+   * `deleteAnyCollection`. It exists here for backwards compatibility with Server versions <= 1.43.0
+   */
+  ManageAllCollections,
+  /**
+   * @deprecated Sep 29 2021: This permission has been split out to `editAssignedCollections` and
+   * `deleteAssignedCollections`. It exists here for backwards compatibility with Server versions <= 1.43.0
+   */
+  ManageAssignedCollections,
+  ManageGroups,
+  ManageOrganization,
+  ManagePolicies,
+  ManageProvider,
+  ManageUsers,
+  ManageUsersPassword,
+  CreateNewCollections,
+  EditAnyCollection,
+  DeleteAnyCollection,
+  EditAssignedCollections,
+  DeleteAssignedCollections,
+  ManageSso,
+  ManageBilling,
+}
--- a/libs/common/src/enums/planSponsorshipType.ts
+++ b/libs/common/src/enums/planSponsorshipType.ts
@@ -0,0 +1,3 @@
+export enum PlanSponsorshipType {
+  FamiliesForEnterprise = 0,
+}
--- a/libs/common/src/enums/planType.ts
+++ b/libs/common/src/enums/planType.ts
@@ -0,0 +1,14 @@
+export enum PlanType {
+  Free = 0,
+  FamiliesAnnually2019 = 1,
+  TeamsMonthly2019 = 2,
+  TeamsAnnually2019 = 3,
+  EnterpriseMonthly2019 = 4,
+  EnterpriseAnnually2019 = 5,
+  Custom = 6,
+  FamiliesAnnually = 7,
+  TeamsMonthly = 8,
+  TeamsAnnually = 9,
+  EnterpriseMonthly = 10,
+  EnterpriseAnnually = 11,
+}
--- a/libs/common/src/enums/policyType.ts
+++ b/libs/common/src/enums/policyType.ts
@@ -0,0 +1,13 @@
+export enum PolicyType {
+  TwoFactorAuthentication = 0, // Requires users to have 2fa enabled
+  MasterPassword = 1, // Sets minimum requirements for master password complexity
+  PasswordGenerator = 2, // Sets minimum requirements/default type for generated passwords/passphrases
+  SingleOrg = 3, // Allows users to only be apart of one organization
+  RequireSso = 4, // Requires users to authenticate with SSO
+  PersonalOwnership = 5, // Disables personal vault ownership for adding/cloning items
+  DisableSend = 6, // Disables the ability to create and edit Bitwarden Sends
+  SendOptions = 7, // Sets restrictions or defaults for Bitwarden Sends
+  ResetPassword = 8, // Allows orgs to use reset password : also can enable auto-enrollment during invite flow
+  MaximumVaultTimeout = 9, // Sets the maximum allowed vault timeout
+  DisablePersonalVaultExport = 10, // Disable personal vault export
+}
--- a/libs/common/src/enums/productType.ts
+++ b/libs/common/src/enums/productType.ts
@@ -0,0 +1,6 @@
+export enum ProductType {
+  Free = 0,
+  Families = 1,
+  Teams = 2,
+  Enterprise = 3,
+}
--- a/libs/common/src/enums/providerUserStatusType.ts
+++ b/libs/common/src/enums/providerUserStatusType.ts
@@ -0,0 +1,5 @@
+export enum ProviderUserStatusType {
+  Invited = 0,
+  Accepted = 1,
+  Confirmed = 2,
+}
--- a/libs/common/src/enums/providerUserType.ts
+++ b/libs/common/src/enums/providerUserType.ts
@@ -0,0 +1,4 @@
+export enum ProviderUserType {
+  ProviderAdmin = 0,
+  ServiceUser = 1,
+}
--- a/libs/common/src/enums/secureNoteType.ts
+++ b/libs/common/src/enums/secureNoteType.ts
@@ -0,0 +1,3 @@
+export enum SecureNoteType {
+  Generic = 0,
+}
--- a/libs/common/src/enums/sendType.ts
+++ b/libs/common/src/enums/sendType.ts
@@ -0,0 +1,4 @@
+export enum SendType {
+  Text = 0,
+  File = 1,
+}
--- a/libs/common/src/enums/ssoEnums.ts
+++ b/libs/common/src/enums/ssoEnums.ts
@@ -0,0 +1,33 @@
+export enum SsoType {
+  None = 0,
+  OpenIdConnect = 1,
+  Saml2 = 2,
+}
+
+export enum OpenIdConnectRedirectBehavior {
+  RedirectGet = 0,
+  FormPost = 1,
+}
+
+export enum Saml2BindingType {
+  HttpRedirect = 1,
+  HttpPost = 2,
+}
+
+export enum Saml2NameIdFormat {
+  NotConfigured = 0,
+  Unspecified = 1,
+  EmailAddress = 2,
+  X509SubjectName = 3,
+  WindowsDomainQualifiedName = 4,
+  KerberosPrincipalName = 5,
+  EntityIdentifier = 6,
+  Persistent = 7,
+  Transient = 8,
+}
+
+export enum Saml2SigningBehavior {
+  IfIdpWantAuthnRequestsSigned = 0,
+  Always = 1,
+  Never = 3,
+}
--- a/libs/common/src/enums/stateVersion.ts
+++ b/libs/common/src/enums/stateVersion.ts
@@ -0,0 +1,7 @@
+export enum StateVersion {
+  One = 1, // Original flat key/value pair store
+  Two = 2, // Move to a typed State object
+  Three = 3, // Fix migration of users' premium status
+  Four = 4, // Fix 'Never Lock' option by removing stale data
+  Latest = Four,
+}
--- a/libs/common/src/enums/storageLocation.ts
+++ b/libs/common/src/enums/storageLocation.ts
@@ -0,0 +1,5 @@
+export enum StorageLocation {
+  Both = "both",
+  Disk = "disk",
+  Memory = "memory",
+}
--- a/libs/common/src/enums/themeType.ts
+++ b/libs/common/src/enums/themeType.ts
@@ -0,0 +1,7 @@
+export enum ThemeType {
+  System = "system",
+  Light = "light",
+  Dark = "dark",
+  Nord = "nord",
+  SolarizedDark = "solarizedDark",
+}
--- a/libs/common/src/enums/transactionType.ts
+++ b/libs/common/src/enums/transactionType.ts
@@ -0,0 +1,7 @@
+export enum TransactionType {
+  Charge = 0,
+  Credit = 1,
+  PromotionalCredit = 2,
+  ReferralCredit = 3,
+  Refund = 4,
+}
--- a/libs/common/src/enums/twoFactorProviderType.ts
+++ b/libs/common/src/enums/twoFactorProviderType.ts
@@ -0,0 +1,10 @@
+export enum TwoFactorProviderType {
+  Authenticator = 0,
+  Email = 1,
+  Duo = 2,
+  Yubikey = 3,
+  U2f = 4,
+  Remember = 5,
+  OrganizationDuo = 6,
+  WebAuthn = 7,
+}
--- a/libs/common/src/enums/uriMatchType.ts
+++ b/libs/common/src/enums/uriMatchType.ts
@@ -0,0 +1,8 @@
+export enum UriMatchType {
+  Domain = 0,
+  Host = 1,
+  StartsWith = 2,
+  Exact = 3,
+  RegularExpression = 4,
+  Never = 5,
+}
--- a/libs/common/src/enums/verificationType.ts
+++ b/libs/common/src/enums/verificationType.ts
@@ -0,0 +1,4 @@
+export enum VerificationType {
+  MasterPassword = 0,
+  OTP = 1,
+}
--- a/libs/common/src/factories/accountFactory.ts
+++ b/libs/common/src/factories/accountFactory.ts
@@ -0,0 +1,13 @@
+import { Account } from "../models/domain/account";
+
+export class AccountFactory<T extends Account = Account> {
+  private accountConstructor: new (init: Partial<T>) => T;
+
+  constructor(accountConstructor: new (init: Partial<T>) => T) {
+    this.accountConstructor = accountConstructor;
+  }
+
+  create(args: Partial<T>) {
+    return new this.accountConstructor(args);
+  }
+}
--- a/libs/common/src/factories/globalStateFactory.ts
+++ b/libs/common/src/factories/globalStateFactory.ts
@@ -0,0 +1,13 @@
+import { GlobalState } from "../models/domain/globalState";
+
+export class GlobalStateFactory<T extends GlobalState = GlobalState> {
+  private globalStateConstructor: new (init: Partial<T>) => T;
+
+  constructor(globalStateConstructor: new (init: Partial<T>) => T) {
+    this.globalStateConstructor = globalStateConstructor;
+  }
+
+  create(args?: Partial<T>) {
+    return new this.globalStateConstructor(args);
+  }
+}
--- a/libs/common/src/factories/stateFactory.ts
+++ b/libs/common/src/factories/stateFactory.ts
@@ -0,0 +1,29 @@
+import { Account } from "../models/domain/account";
+import { GlobalState } from "../models/domain/globalState";
+
+import { AccountFactory } from "./accountFactory";
+import { GlobalStateFactory } from "./globalStateFactory";
+
+export class StateFactory<
+  TGlobal extends GlobalState = GlobalState,
+  TAccount extends Account = Account
+> {
+  private globalStateFactory: GlobalStateFactory<TGlobal>;
+  private accountFactory: AccountFactory<TAccount>;
+
+  constructor(
+    globalStateConstructor: new (init: Partial<TGlobal>) => TGlobal,
+    accountConstructor: new (init: Partial<TAccount>) => TAccount
+  ) {
+    this.globalStateFactory = new GlobalStateFactory(globalStateConstructor);
+    this.accountFactory = new AccountFactory(accountConstructor);
+  }
+
+  createGlobal(args: Partial<TGlobal>): TGlobal {
+    return this.globalStateFactory.create(args);
+  }
+
+  createAccount(args: Partial<TAccount>): TAccount {
+    return this.accountFactory.create(args);
+  }
+}
--- a/libs/common/src/globals.d.ts
+++ b/libs/common/src/globals.d.ts
@@ -0,0 +1,2 @@
+declare function escape(s: string): string;
+declare function unescape(s: string): string;
--- a/libs/common/src/importers/ascendoCsvImporter.ts
+++ b/libs/common/src/importers/ascendoCsvImporter.ts
@@ -0,0 +1,59 @@
+import { ImportResult } from "../models/domain/importResult";
+
+import { BaseImporter } from "./baseImporter";
+import { Importer } from "./importer";
+
+export class AscendoCsvImporter extends BaseImporter implements Importer {
+  parse(data: string): Promise<ImportResult> {
+    const result = new ImportResult();
+    const results = this.parseCsv(data, false);
+    if (results == null) {
+      result.success = false;
+      return Promise.resolve(result);
+    }
+
+    results.forEach((value) => {
+      if (value.length < 2) {
+        return;
+      }
+
+      const cipher = this.initLoginCipher();
+      cipher.notes = this.getValueOrDefault(value[value.length - 1]);
+      cipher.name = this.getValueOrDefault(value[0], "--");
+
+      if (value.length > 2 && value.length % 2 === 0) {
+        for (let i = 0; i < value.length - 2; i += 2) {
+          const val: string = value[i + 2];
+          const field: string = value[i + 1];
+          if (this.isNullOrWhitespace(val) || this.isNullOrWhitespace(field)) {
+            continue;
+          }
+
+          const fieldLower = field.toLowerCase();
+          if (cipher.login.password == null && this.passwordFieldNames.indexOf(fieldLower) > -1) {
+            cipher.login.password = this.getValueOrDefault(val);
+          } else if (
+            cipher.login.username == null &&
+            this.usernameFieldNames.indexOf(fieldLower) > -1
+          ) {
+            cipher.login.username = this.getValueOrDefault(val);
+          } else if (
+            (cipher.login.uris == null || cipher.login.uris.length === 0) &&
+            this.uriFieldNames.indexOf(fieldLower) > -1
+          ) {
+            cipher.login.uris = this.makeUriArray(val);
+          } else {
+            this.processKvp(cipher, field, val);
+          }
+        }
+      }
+
+      this.convertToNoteIfNeeded(cipher);
+      this.cleanupCipher(cipher);
+      result.ciphers.push(cipher);
+    });
+
+    result.success = true;
+    return Promise.resolve(result);
+  }
+}
--- a/libs/common/src/importers/avastCsvImporter.ts
+++ b/libs/common/src/importers/avastCsvImporter.ts
@@ -0,0 +1,28 @@
+import { ImportResult } from "../models/domain/importResult";
+
+import { BaseImporter } from "./baseImporter";
+import { Importer } from "./importer";
+
+export class AvastCsvImporter extends BaseImporter implements Importer {
+  parse(data: string): Promise<ImportResult> {
+    const result = new ImportResult();
+    const results = this.parseCsv(data, true);
+    if (results == null) {
+      result.success = false;
+      return Promise.resolve(result);
+    }
+
+    results.forEach((value) => {
+      const cipher = this.initLoginCipher();
+      cipher.name = this.getValueOrDefault(value.name);
+      cipher.login.uris = this.makeUriArray(value.web);
+      cipher.login.password = this.getValueOrDefault(value.password);
+      cipher.login.username = this.getValueOrDefault(value.login);
+      this.cleanupCipher(cipher);
+      result.ciphers.push(cipher);
+    });
+
+    result.success = true;
+    return Promise.resolve(result);
+  }
+}
--- a/libs/common/src/importers/avastJsonImporter.ts
+++ b/libs/common/src/importers/avastJsonImporter.ts
@@ -0,0 +1,68 @@
+import { CipherType } from "../enums/cipherType";
+import { SecureNoteType } from "../enums/secureNoteType";
+import { ImportResult } from "../models/domain/importResult";
+
+import { BaseImporter } from "./baseImporter";
+import { Importer } from "./importer";
+
+export class AvastJsonImporter extends BaseImporter implements Importer {
+  parse(data: string): Promise<ImportResult> {
+    const result = new ImportResult();
+    const results = JSON.parse(data);
+    if (results == null) {
+      result.success = false;
+      return Promise.resolve(result);
+    }
+
+    if (results.logins != null) {
+      results.logins.forEach((value: any) => {
+        const cipher = this.initLoginCipher();
+        cipher.name = this.getValueOrDefault(value.custName);
+        cipher.notes = this.getValueOrDefault(value.note);
+        cipher.login.uris = this.makeUriArray(value.url);
+        cipher.login.password = this.getValueOrDefault(value.pwd);
+        cipher.login.username = this.getValueOrDefault(value.loginName);
+        this.cleanupCipher(cipher);
+        result.ciphers.push(cipher);
+      });
+    }
+
+    if (results.notes != null) {
+      results.notes.forEach((value: any) => {
+        const cipher = this.initLoginCipher();
+        cipher.type = CipherType.SecureNote;
+        cipher.secureNote.type = SecureNoteType.Generic;
+        cipher.name = this.getValueOrDefault(value.label);
+        cipher.notes = this.getValueOrDefault(value.text);
+        this.cleanupCipher(cipher);
+        result.ciphers.push(cipher);
+      });
+    }
+
+    if (results.cards != null) {
+      results.cards.forEach((value: any) => {
+        const cipher = this.initLoginCipher();
+        cipher.type = CipherType.Card;
+        cipher.name = this.getValueOrDefault(value.custName);
+        cipher.notes = this.getValueOrDefault(value.note);
+        cipher.card.cardholderName = this.getValueOrDefault(value.holderName);
+        cipher.card.number = this.getValueOrDefault(value.cardNumber);
+        cipher.card.code = this.getValueOrDefault(value.cvv);
+        cipher.card.brand = this.getCardBrand(cipher.card.number);
+        if (value.expirationDate != null) {
+          if (value.expirationDate.month != null) {
+            cipher.card.expMonth = value.expirationDate.month + "";
+          }
+          if (value.expirationDate.year != null) {
+            cipher.card.expYear = value.expirationDate.year + "";
+          }
+        }
+        this.cleanupCipher(cipher);
+        result.ciphers.push(cipher);
+      });
+    }
+
+    result.success = true;
+    return Promise.resolve(result);
+  }
+}
--- a/libs/common/src/importers/aviraCsvImporter.ts
+++ b/libs/common/src/importers/aviraCsvImporter.ts
@@ -0,0 +1,41 @@
+import { ImportResult } from "../models/domain/importResult";
+
+import { BaseImporter } from "./baseImporter";
+import { Importer } from "./importer";
+
+export class AviraCsvImporter extends BaseImporter implements Importer {
+  parse(data: string): Promise<ImportResult> {
+    const result = new ImportResult();
+    const results = this.parseCsv(data, true);
+    if (results == null) {
+      result.success = false;
+      return Promise.resolve(result);
+    }
+
+    results.forEach((value) => {
+      const cipher = this.initLoginCipher();
+      cipher.name = this.getValueOrDefault(
+        value.name,
+        this.getValueOrDefault(this.nameFromUrl(value.website), "--")
+      );
+      cipher.login.uris = this.makeUriArray(value.website);
+      cipher.login.password = this.getValueOrDefault(value.password);
+
+      if (
+        this.isNullOrWhitespace(value.username) &&
+        !this.isNullOrWhitespace(value.secondary_username)
+      ) {
+        cipher.login.username = value.secondary_username;
+      } else {
+        cipher.login.username = this.getValueOrDefault(value.username);
+        cipher.notes = this.getValueOrDefault(value.secondary_username);
+      }
+
+      this.cleanupCipher(cipher);
+      result.ciphers.push(cipher);
+    });
+
+    result.success = true;
+    return Promise.resolve(result);
+  }
+}
--- a/libs/common/src/importers/baseImporter.ts
+++ b/libs/common/src/importers/baseImporter.ts
@@ -0,0 +1,466 @@
+import * as papa from "papaparse";
+
+import { LogService } from "../abstractions/log.service";
+import { CipherType } from "../enums/cipherType";
+import { FieldType } from "../enums/fieldType";
+import { SecureNoteType } from "../enums/secureNoteType";
+import { Utils } from "../misc/utils";
+import { ImportResult } from "../models/domain/importResult";
+import { CipherView } from "../models/view/cipherView";
+import { CollectionView } from "../models/view/collectionView";
+import { FieldView } from "../models/view/fieldView";
+import { FolderView } from "../models/view/folderView";
+import { LoginUriView } from "../models/view/loginUriView";
+import { LoginView } from "../models/view/loginView";
+import { SecureNoteView } from "../models/view/secureNoteView";
+import { ConsoleLogService } from "../services/consoleLog.service";
+
+export abstract class BaseImporter {
+  organizationId: string = null;
+
+  protected logService: LogService = new ConsoleLogService(false);
+
+  protected newLineRegex = /(?:\r\n|\r|\n)/;
+
+  protected passwordFieldNames = [
+    "password",
+    "pass word",
+    "passphrase",
+    "pass phrase",
+    "pass",
+    "code",
+    "code word",
+    "codeword",
+    "secret",
+    "secret word",
+    "personpwd",
+    "key",
+    "keyword",
+    "key word",
+    "keyphrase",
+    "key phrase",
+    "form_pw",
+    "wppassword",
+    "pin",
+    "pwd",
+    "pw",
+    "pword",
+    "passwd",
+    "p",
+    "serial",
+    "serial#",
+    "license key",
+    "reg #",
+
+    // Non-English names
+    "passwort",
+  ];
+
+  protected usernameFieldNames = [
+    "user",
+    "name",
+    "user name",
+    "username",
+    "login name",
+    "email",
+    "e-mail",
+    "id",
+    "userid",
+    "user id",
+    "login",
+    "form_loginname",
+    "wpname",
+    "mail",
+    "loginid",
+    "login id",
+    "log",
+    "personlogin",
+    "first name",
+    "last name",
+    "card#",
+    "account #",
+    "member",
+    "member #",
+
+    // Non-English names
+    "nom",
+    "benutzername",
+  ];
+
+  protected notesFieldNames = [
+    "note",
+    "notes",
+    "comment",
+    "comments",
+    "memo",
+    "description",
+    "free form",
+    "freeform",
+    "free text",
+    "freetext",
+    "free",
+
+    // Non-English names
+    "kommentar",
+  ];
+
+  protected uriFieldNames: string[] = [
+    "url",
+    "hyper link",
+    "hyperlink",
+    "link",
+    "host",
+    "hostname",
+    "host name",
+    "server",
+    "address",
+    "hyper ref",
+    "href",
+    "web",
+    "website",
+    "web site",
+    "site",
+    "web-site",
+    "uri",
+
+    // Non-English names
+    "ort",
+    "adresse",
+  ];
+
+  protected parseCsvOptions = {
+    encoding: "UTF-8",
+    skipEmptyLines: false,
+  };
+
+  protected get organization() {
+    return this.organizationId != null;
+  }
+
+  protected parseXml(data: string): Document {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(data, "application/xml");
+    return doc != null && doc.querySelector("parsererror") == null ? doc : null;
+  }
+
+  protected parseCsv(data: string, header: boolean, options: any = {}): any[] {
+    const parseOptions: papa.ParseConfig<string> = Object.assign(
+      { header: header },
+      this.parseCsvOptions,
+      options
+    );
+    data = this.splitNewLine(data).join("\n").trim();
+    const result = papa.parse(data, parseOptions);
+    if (result.errors != null && result.errors.length > 0) {
+      result.errors.forEach((e) => {
+        if (e.row != null) {
+          this.logService.warning("Error parsing row " + e.row + ": " + e.message);
+        }
+      });
+    }
+    return result.data && result.data.length > 0 ? result.data : null;
+  }
+
+  protected parseSingleRowCsv(rowData: string) {
+    if (this.isNullOrWhitespace(rowData)) {
+      return null;
+    }
+    const parsedRow = this.parseCsv(rowData, false);
+    if (parsedRow != null && parsedRow.length > 0 && parsedRow[0].length > 0) {
+      return parsedRow[0];
+    }
+    return null;
+  }
+
+  protected makeUriArray(uri: string | string[]): LoginUriView[] {
+    if (uri == null) {
+      return null;
+    }
+
+    if (typeof uri === "string") {
+      const loginUri = new LoginUriView();
+      loginUri.uri = this.fixUri(uri);
+      if (this.isNullOrWhitespace(loginUri.uri)) {
+        return null;
+      }
+      loginUri.match = null;
+      return [loginUri];
+    }
+
+    if (uri.length > 0) {
+      const returnArr: LoginUriView[] = [];
+      uri.forEach((u) => {
+        const loginUri = new LoginUriView();
+        loginUri.uri = this.fixUri(u);
+        if (this.isNullOrWhitespace(loginUri.uri)) {
+          return;
+        }
+        loginUri.match = null;
+        returnArr.push(loginUri);
+      });
+      return returnArr.length === 0 ? null : returnArr;
+    }
+
+    return null;
+  }
+
+  protected fixUri(uri: string) {
+    if (uri == null) {
+      return null;
+    }
+    uri = uri.trim();
+    if (uri.indexOf("://") === -1 && uri.indexOf(".") >= 0) {
+      uri = "http://" + uri;
+    }
+    if (uri.length > 1000) {
+      return uri.substring(0, 1000);
+    }
+    return uri;
+  }
+
+  protected nameFromUrl(url: string) {
+    const hostname = Utils.getHostname(url);
+    if (this.isNullOrWhitespace(hostname)) {
+      return null;
+    }
+    return hostname.startsWith("www.") ? hostname.replace("www.", "") : hostname;
+  }
+
+  protected isNullOrWhitespace(str: string): boolean {
+    return Utils.isNullOrWhitespace(str);
+  }
+
+  protected getValueOrDefault(str: string, defaultValue: string = null): string {
+    if (this.isNullOrWhitespace(str)) {
+      return defaultValue;
+    }
+    return str;
+  }
+
+  protected splitNewLine(str: string): string[] {
+    return str.split(this.newLineRegex);
+  }
+
+  // ref https://stackoverflow.com/a/5911300
+  protected getCardBrand(cardNum: string) {
+    if (this.isNullOrWhitespace(cardNum)) {
+      return null;
+    }
+
+    // Visa
+    let re = new RegExp("^4");
+    if (cardNum.match(re) != null) {
+      return "Visa";
+    }
+
+    // Mastercard
+    // Updated for Mastercard 2017 BINs expansion
+    if (
+      /^(5[1-5][0-9]{14}|2(22[1-9][0-9]{12}|2[3-9][0-9]{13}|[3-6][0-9]{14}|7[0-1][0-9]{13}|720[0-9]{12}))$/.test(
+        cardNum
+      )
+    ) {
+      return "Mastercard";
+    }
+
+    // AMEX
+    re = new RegExp("^3[47]");
+    if (cardNum.match(re) != null) {
+      return "Amex";
+    }
+
+    // Discover
+    re = new RegExp(
+      "^(6011|622(12[6-9]|1[3-9][0-9]|[2-8][0-9]{2}|9[0-1][0-9]|92[0-5]|64[4-9])|65)"
+    );
+    if (cardNum.match(re) != null) {
+      return "Discover";
+    }
+
+    // Diners
+    re = new RegExp("^36");
+    if (cardNum.match(re) != null) {
+      return "Diners Club";
+    }
+
+    // Diners - Carte Blanche
+    re = new RegExp("^30[0-5]");
+    if (cardNum.match(re) != null) {
+      return "Diners Club";
+    }
+
+    // JCB
+    re = new RegExp("^35(2[89]|[3-8][0-9])");
+    if (cardNum.match(re) != null) {
+      return "JCB";
+    }
+
+    // Visa Electron
+    re = new RegExp("^(4026|417500|4508|4844|491(3|7))");
+    if (cardNum.match(re) != null) {
+      return "Visa";
+    }
+
+    return null;
+  }
+
+  protected setCardExpiration(cipher: CipherView, expiration: string): boolean {
+    if (!this.isNullOrWhitespace(expiration)) {
+      expiration = expiration.replace(/\s/g, "");
+      const parts = expiration.split("/");
+      if (parts.length === 2) {
+        let month: string = null;
+        let year: string = null;
+        if (parts[0].length === 1 || parts[0].length === 2) {
+          month = parts[0];
+          if (month.length === 2 && month[0] === "0") {
+            month = month.substr(1, 1);
+          }
+        }
+        if (parts[1].length === 2 || parts[1].length === 4) {
+          year = month.length === 2 ? "20" + parts[1] : parts[1];
+        }
+        if (month != null && year != null) {
+          cipher.card.expMonth = month;
+          cipher.card.expYear = year;
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  protected moveFoldersToCollections(result: ImportResult) {
+    result.folderRelationships.forEach((r) => result.collectionRelationships.push(r));
+    result.collections = result.folders.map((f) => {
+      const collection = new CollectionView();
+      collection.name = f.name;
+      return collection;
+    });
+    result.folderRelationships = [];
+    result.folders = [];
+  }
+
+  protected querySelectorDirectChild(parentEl: Element, query: string) {
+    const els = this.querySelectorAllDirectChild(parentEl, query);
+    return els.length === 0 ? null : els[0];
+  }
+
+  protected querySelectorAllDirectChild(parentEl: Element, query: string) {
+    return Array.from(parentEl.querySelectorAll(query)).filter((el) => el.parentNode === parentEl);
+  }
+
+  protected initLoginCipher() {
+    const cipher = new CipherView();
+    cipher.favorite = false;
+    cipher.notes = "";
+    cipher.fields = [];
+    cipher.login = new LoginView();
+    cipher.type = CipherType.Login;
+    return cipher;
+  }
+
+  protected cleanupCipher(cipher: CipherView) {
+    if (cipher == null) {
+      return;
+    }
+    if (cipher.type !== CipherType.Login) {
+      cipher.login = null;
+    }
+    if (this.isNullOrWhitespace(cipher.name)) {
+      cipher.name = "--";
+    }
+    if (this.isNullOrWhitespace(cipher.notes)) {
+      cipher.notes = null;
+    } else {
+      cipher.notes = cipher.notes.trim();
+    }
+    if (cipher.fields != null && cipher.fields.length === 0) {
+      cipher.fields = null;
+    }
+  }
+
+  protected processKvp(
+    cipher: CipherView,
+    key: string,
+    value: string,
+    type: FieldType = FieldType.Text
+  ) {
+    if (this.isNullOrWhitespace(value)) {
+      return;
+    }
+    if (this.isNullOrWhitespace(key)) {
+      key = "";
+    }
+    if (value.length > 200 || value.trim().search(this.newLineRegex) > -1) {
+      if (cipher.notes == null) {
+        cipher.notes = "";
+      }
+      cipher.notes += key + ": " + this.splitNewLine(value).join("\n") + "\n";
+    } else {
+      if (cipher.fields == null) {
+        cipher.fields = [];
+      }
+      const field = new FieldView();
+      field.type = type;
+      field.name = key;
+      field.value = value;
+      cipher.fields.push(field);
+    }
+  }
+
+  protected processFolder(result: ImportResult, folderName: string) {
+    let folderIndex = result.folders.length;
+    const hasFolder = !this.isNullOrWhitespace(folderName);
+    let addFolder = hasFolder;
+
+    if (hasFolder) {
+      for (let i = 0; i < result.folders.length; i++) {
+        if (result.folders[i].name === folderName) {
+          addFolder = false;
+          folderIndex = i;
+          break;
+        }
+      }
+    }
+
+    if (addFolder) {
+      const f = new FolderView();
+      f.name = folderName;
+      result.folders.push(f);
+    }
+    if (hasFolder) {
+      result.folderRelationships.push([result.ciphers.length, folderIndex]);
+    }
+  }
+
+  protected convertToNoteIfNeeded(cipher: CipherView) {
+    if (
+      cipher.type === CipherType.Login &&
+      this.isNullOrWhitespace(cipher.login.username) &&
+      this.isNullOrWhitespace(cipher.login.password) &&
+      (cipher.login.uris == null || cipher.login.uris.length === 0)
+    ) {
+      cipher.type = CipherType.SecureNote;
+      cipher.secureNote = new SecureNoteView();
+      cipher.secureNote.type = SecureNoteType.Generic;
+    }
+  }
+
+  protected processFullName(cipher: CipherView, fullName: string) {
+    if (this.isNullOrWhitespace(fullName)) {
+      return;
+    }
+
+    const nameParts = fullName.split(" ");
+    if (nameParts.length > 0) {
+      cipher.identity.firstName = this.getValueOrDefault(nameParts[0]);
+    }
+    if (nameParts.length === 2) {
+      cipher.identity.lastName = this.getValueOrDefault(nameParts[1]);
+    } else if (nameParts.length >= 3) {
+      cipher.identity.middleName = this.getValueOrDefault(nameParts[1]);
+      cipher.identity.lastName = nameParts.slice(2, nameParts.length).join(" ");
+    }
+  }
+}
--- a/libs/common/src/importers/bitwardenCsvImporter.ts
+++ b/libs/common/src/importers/bitwardenCsvImporter.ts
@@ -0,0 +1,120 @@
+import { CipherRepromptType } from "../enums/cipherRepromptType";
+import { CipherType } from "../enums/cipherType";
+import { FieldType } from "../enums/fieldType";
+import { SecureNoteType } from "../enums/secureNoteType";
+import { ImportResult } from "../models/domain/importResult";
+import { CipherView } from "../models/view/cipherView";
+import { CollectionView } from "../models/view/collectionView";
+import { FieldView } from "../models/view/fieldView";
+import { LoginView } from "../models/view/loginView";
+import { SecureNoteView } from "../models/view/secureNoteView";
+
+import { BaseImporter } from "./baseImporter";
+import { Importer } from "./importer";
+
+export class BitwardenCsvImporter extends BaseImporter implements Importer {
+  parse(data: string): Promise<ImportResult> {
+    const result = new ImportResult();
+    const results = this.parseCsv(data, true);
+    if (results == null) {
+      result.success = false;
+      return Promise.resolve(result);
+    }
+
+    results.forEach((value) => {
+      if (this.organization && !this.isNullOrWhitespace(value.collections)) {
+        const collections = (value.collections as string).split(",");
+        collections.forEach((col) => {
+          let addCollection = true;
+          let collectionIndex = result.collections.length;
+
+          for (let i = 0; i < result.collections.length; i++) {
+            if (result.collections[i].name === col) {
+              addCollection = false;
+              collectionIndex = i;
+              break;
+            }
+          }
+
+          if (addCollection) {
+            const collection = new CollectionView();
+            collection.name = col;
+            result.collections.push(collection);
+          }
+
+          result.collectionRelationships.push([result.ciphers.length, collectionIndex]);
+        });
+      } else if (!this.organization) {
+        this.processFolder(result, value.folder);
+      }
+
+      const cipher = new CipherView();
+      cipher.favorite =
+        !this.organization && this.getValueOrDefault(value.favorite, "0") !== "0" ? true : false;
+      cipher.type = CipherType.Login;
+      cipher.notes = this.getValueOrDefault(value.notes);
+      cipher.name = this.getValueOrDefault(value.name, "--");
+      try {
+        cipher.reprompt = parseInt(
+          this.getValueOrDefault(value.reprompt, CipherRepromptType.None.toString()),
+          10
+        );
+      } catch (e) {
+        // eslint-disable-next-line
+        console.error("Unable to parse reprompt value", e);
+        cipher.reprompt = CipherRepromptType.None;
+      }
+
+      if (!this.isNullOrWhitespace(value.fields)) {
+        const fields = this.splitNewLine(value.fields);
+        for (let i = 0; i < fields.length; i++) {
+          if (this.isNullOrWhitespace(fields[i])) {
+            continue;
+          }
+
+          const delimPosition = fields[i].lastIndexOf(": ");
+          if (delimPosition === -1) {
+            continue;
+          }
+
+          if (cipher.fields == null) {
+            cipher.fields = [];
+          }
+
+          const field = new FieldView();
+          field.name = fields[i].substr(0, delimPosition);
+          field.value = null;
+          field.type = FieldType.Text;
+          if (fields[i].length > delimPosition + 2) {
+            field.value = fields[i].substr(delimPosition + 2);
+          }
+          cipher.fields.push(field);
+        }
+      }
+
+      const valueType = value.type != null ? value.type.toLowerCase() : null;
+      switch (valueType) {
+        case "note":
+          cipher.type = CipherType.SecureNote;
+          cipher.secureNote = new SecureNoteView();
+          cipher.secureNote.type = SecureNoteType.Generic;
+          break;
+        default: {
+          cipher.type = CipherType.Login;
+          cipher.login = new LoginView();
+          cipher.login.totp = this.getValueOrDefault(value.login_totp || value.totp);
+          cipher.login.username = this.getValueOrDefault(value.login_username || value.username);
+          cipher.login.password = this.getValueOrDefault(value.login_password || value.password);
+          const uris = this.parseSingleRowCsv(value.login_uri || value.uri);
+          cipher.login.uris = this.makeUriArray(uris);
+          break;
+        }
+      }
+
+      result.ciphers.push(cipher);
+    });
+
+    result.success = true;
+    return Promise.resolve(result);
+  }
+}
--- a/libs/common/src/importers/bitwardenJsonImporter.ts
+++ b/libs/common/src/importers/bitwardenJsonImporter.ts
@@ -0,0 +1,179 @@
+import { CryptoService } from "../abstractions/crypto.service";
+import { I18nService } from "../abstractions/i18n.service";
+import { EncString } from "../models/domain/encString";
+import { ImportResult } from "../models/domain/importResult";
+import { CipherWithIdExport } from "../models/export/cipherWithIdsExport";
+import { CollectionWithIdExport } from "../models/export/collectionWithIdExport";
+import { FolderWithIdExport } from "../models/export/folderWithIdExport";
+
+import { BaseImporter } from "./baseImporter";
+import { Importer } from "./importer";
+
+export class BitwardenJsonImporter extends BaseImporter implements Importer {
+  private results: any;
+  private result: ImportResult;
+
+  constructor(protected cryptoService: CryptoService, protected i18nService: I18nService) {
+    super();
+  }
+
+  async parse(data: string): Promise<ImportResult> {
+    this.result = new ImportResult();
+    this.results = JSON.parse(data);
+    if (this.results == null || this.results.items == null) {
+      if (this.results?.passwordProtected) {
+        this.result.success = false;
+        this.result.missingPassword = true;
+        this.result.errorMessage = this.i18nService.t("importPasswordRequired");
+        return this.result;
+      }
+
+      this.result.success = false;
+      return this.result;
+    }
+
+    if (this.results.encrypted) {
+      await this.parseEncrypted();
+    } else {
+      this.parseDecrypted();
+    }
+
+    return this.result;
+  }
+
+  private async parseEncrypted() {
+    if (this.results.encKeyValidation_DO_NOT_EDIT != null) {
+      const orgKey = await this.cryptoService.getOrgKey(this.organizationId);
+      const encKeyValidation = new EncString(this.results.encKeyValidation_DO_NOT_EDIT);
+      const encKeyValidationDecrypt = await this.cryptoService.decryptToUtf8(
+        encKeyValidation,
+        orgKey
+      );
+      if (encKeyValidationDecrypt === null) {
+        this.result.success = false;
+        this.result.errorMessage = this.i18nService.t("importEncKeyError");
+        return;
+      }
+    }
+
+    const groupingsMap = new Map<string, number>();
+
+    if (this.organization && this.results.collections != null) {
+      for (const c of this.results.collections as CollectionWithIdExport[]) {
+        const collection = CollectionWithIdExport.toDomain(c);
+        if (collection != null) {
+          collection.id = null;
+          collection.organizationId = this.organizationId;
+          const view = await collection.decrypt();
+          groupingsMap.set(c.id, this.result.collections.length);
+          this.result.collections.push(view);
+        }
+      }
+    } else if (!this.organization && this.results.folders != null) {
+      for (const f of this.results.folders as FolderWithIdExport[]) {
+        const folder = FolderWithIdExport.toDomain(f);
+        if (folder != null) {
+          folder.id = null;
+          const view = await folder.decrypt();
+          groupingsMap.set(f.id, this.result.folders.length);
+          this.result.folders.push(view);
+        }
+      }
+    }
+
+    for (const c of this.results.items as CipherWithIdExport[]) {
+      const cipher = CipherWithIdExport.toDomain(c);
+      // reset ids incase they were set for some reason
+      cipher.id = null;
+      cipher.folderId = null;
+      cipher.organizationId = this.organizationId;
+      cipher.collectionIds = null;
+
+      // make sure password history is limited
+      if (cipher.passwordHistory != null && cipher.passwordHistory.length > 5) {
+        cipher.passwordHistory = cipher.passwordHistory.slice(0, 5);
+      }
+
+      if (!this.organization && c.folderId != null && groupingsMap.has(c.folderId)) {
+        this.result.folderRelationships.push([
+          this.result.ciphers.length,
+          groupingsMap.get(c.folderId),
+        ]);
+      } else if (this.organization && c.collectionIds != null) {
+        c.collectionIds.forEach((cId) => {
+          if (groupingsMap.has(cId)) {
+            this.result.collectionRelationships.push([
+              this.result.ciphers.length,
+              groupingsMap.get(cId),
+            ]);
+          }
+        });
+      }
+
+      const view = await cipher.decrypt();
+      this.cleanupCipher(view);
+      this.result.ciphers.push(view);
+    }
+
+    this.result.success = true;
+  }
+
+  private parseDecrypted() {
+    const groupingsMap = new Map<string, number>();
+    if (this.organization && this.results.collections != null) {
+      this.results.collections.forEach((c: CollectionWithIdExport) => {
+        const collection = CollectionWithIdExport.toView(c);
+        if (collection != null) {
+          collection.id = null;
+          collection.organizationId = null;
+          groupingsMap.set(c.id, this.result.collections.length);
+          this.result.collections.push(collection);
+        }
+      });
+    } else if (!this.organization && this.results.folders != null) {
+      this.results.folders.forEach((f: FolderWithIdExport) => {
+        const folder = FolderWithIdExport.toView(f);
+        if (folder != null) {
+          folder.id = null;
+          groupingsMap.set(f.id, this.result.folders.length);
+          this.result.folders.push(folder);
+        }
+      });
+    }
+
+    this.results.items.forEach((c: CipherWithIdExport) => {
+      const cipher = CipherWithIdExport.toView(c);
+      // reset ids incase they were set for some reason
+      cipher.id = null;
+      cipher.folderId = null;
+      cipher.organizationId = null;
+      cipher.collectionIds = null;
+
+      // make sure password history is limited
+      if (cipher.passwordHistory != null && cipher.passwordHistory.length > 5) {
+        cipher.passwordHistory = cipher.passwordHistory.slice(0, 5);
+      }
+
+      if (!this.organization && c.folderId != null && groupingsMap.has(c.folderId)) {
+        this.result.folderRelationships.push([
+          this.result.ciphers.length,
+          groupingsMap.get(c.folderId),
+        ]);
+      } else if (this.organization && c.collectionIds != null) {
+        c.collectionIds.forEach((cId) => {
+          if (groupingsMap.has(cId)) {
+            this.result.collectionRelationships.push([
+              this.result.ciphers.length,
+              groupingsMap.get(cId),
+            ]);
+          }
+        });
+      }
+
+      this.cleanupCipher(cipher);
+      this.result.ciphers.push(cipher);
+    });
+
+    this.result.success = true;
+  }
+}
--- a/libs/common/src/importers/bitwardenPasswordProtectedImporter.ts
+++ b/libs/common/src/importers/bitwardenPasswordProtectedImporter.ts
@@ -0,0 +1,81 @@
+import { CryptoService } from "../abstractions/crypto.service";
+import { I18nService } from "../abstractions/i18n.service";
+import { KdfType } from "../enums/kdfType";
+import { EncString } from "../models/domain/encString";
+import { ImportResult } from "../models/domain/importResult";
+import { SymmetricCryptoKey } from "../models/domain/symmetricCryptoKey";
+
+import { BitwardenJsonImporter } from "./bitwardenJsonImporter";
+import { Importer } from "./importer";
+
+interface BitwardenPasswordProtectedFileFormat {
+  encrypted: boolean;
+  passwordProtected: boolean;
+  salt: string;
+  kdfIterations: number;
+  kdfType: number;
+  encKeyValidation_DO_NOT_EDIT: string;
+  data: string;
+}
+
+export class BitwardenPasswordProtectedImporter extends BitwardenJsonImporter implements Importer {
+  private key: SymmetricCryptoKey;
+
+  constructor(cryptoService: CryptoService, i18nService: I18nService, private password: string) {
+    super(cryptoService, i18nService);
+  }
+
+  async parse(data: string): Promise<ImportResult> {
+    const result = new ImportResult();
+    const parsedData = JSON.parse(data);
+    if (this.cannotParseFile(parsedData)) {
+      result.success = false;
+      return result;
+    }
+
+    if (!(await this.checkPassword(parsedData))) {
+      result.success = false;
+      result.errorMessage = this.i18nService.t("importEncKeyError");
+      return result;
+    }
+
+    const encData = new EncString(parsedData.data);
+    const clearTextData = await this.cryptoService.decryptToUtf8(encData, this.key);
+    return await super.parse(clearTextData);
+  }
+
+  private async checkPassword(jdoc: BitwardenPasswordProtectedFileFormat): Promise<boolean> {
+    this.key = await this.cryptoService.makePinKey(
+      this.password,
+      jdoc.salt,
+      KdfType.PBKDF2_SHA256,
+      jdoc.kdfIterations
+    );
+
+    const encKeyValidation = new EncString(jdoc.encKeyValidation_DO_NOT_EDIT);
+
+    const encKeyValidationDecrypt = await this.cryptoService.decryptToUtf8(
+      encKeyValidation,
+      this.key
+    );
+    if (encKeyValidationDecrypt === null) {
+      return false;
+    }
+    return true;
+  }
+
+  private cannotParseFile(jdoc: BitwardenPasswordProtectedFileFormat): boolean {
+    return (
+      !jdoc ||
+      !jdoc.encrypted ||
+      !jdoc.passwordProtected ||
+      !jdoc.salt ||
+      !jdoc.kdfIterations ||
+      typeof jdoc.kdfIterations !== "number" ||
+      jdoc.kdfType == null ||
+      KdfType[jdoc.kdfType] == null ||
+      !jdoc.encKeyValidation_DO_NOT_EDIT ||
+      !jdoc.data
+    );
+  }
+}
--- a/libs/common/src/importers/blackBerryCsvImporter.ts
+++ b/libs/common/src/importers/blackBerryCsvImporter.ts
@@ -0,0 +1,36 @@
+import { ImportResult } from "../models/domain/importResult";
+
+import { BaseImporter } from "./baseImporter";
+import { Importer } from "./importer";
+
+export class BlackBerryCsvImporter extends BaseImporter implements Importer {
+  parse(data: string): Promise<ImportResult> {
+    const result = new ImportResult();
+    const results = this.parseCsv(data, true);
+    if (results == null) {
+      result.success = false;
+      return Promise.resolve(result);
+    }
+
+    results.forEach((value) => {
+      if (value.grouping === "list") {
+        return;
+      }
+      const cipher = this.initLoginCipher();
+      cipher.favorite = value.fav === "1";
+      cipher.name = this.getValueOrDefault(value.name);
+      cipher.notes = this.getValueOrDefault(value.extra);
+      if (value.grouping !== "note") {
+        cipher.login.uris = this.makeUriArray(value.url);
+        cipher.login.password = this.getValueOrDefault(value.password);
+        cipher.login.username = this.getValueOrDefault(value.username);
+      }
+      this.convertToNoteIfNeeded(cipher);
+      this.cleanupCipher(cipher);
+      result.ciphers.push(cipher);
+    });
+
+    result.success = true;
+    return Promise.resolve(result);
+  }
+}
--- a/libs/common/src/importers/blurCsvImporter.ts
+++ b/libs/common/src/importers/blurCsvImporter.ts
@@ -0,0 +1,41 @@
+import { ImportResult } from "../models/domain/importResult";
+
+import { BaseImporter } from "./baseImporter";
+import { Importer } from "./importer";
+
+export class BlurCsvImporter extends BaseImporter implements Importer {
+  parse(data: string): Promise<ImportResult> {
+    const result = new ImportResult();
+    const results = this.parseCsv(data, true);
+    if (results == null) {
+      result.success = false;
+      return Promise.resolve(result);
+    }
+
+    results.forEach((value) => {
+      if (value.label === "null") {
+        value.label = null;
+      }
+      const cipher = this.initLoginCipher();
+      cipher.name = this.getValueOrDefault(
+        value.label,
+        this.getValueOrDefault(this.nameFromUrl(value.domain), "--")
+      );
+      cipher.login.uris = this.makeUriArray(value.domain);
+      cipher.login.password = this.getValueOrDefault(value.password);
+
+      if (this.isNullOrWhitespace(value.email) && !this.isNullOrWhitespace(value.username)) {
+        cipher.login.username = value.username;
+      } else {
+        cipher.login.username = this.getValueOrDefault(value.email);
+        cipher.notes = this.getValueOrDefault(value.username);
+      }
+
+      this.cleanupCipher(cipher);
+      result.ciphers.push(cipher);
+    });
+
+    result.success = true;
+    return Promise.resolve(result);
+  }
+}
--- a/libs/common/src/importers/buttercupCsvImporter.ts
+++ b/libs/common/src/importers/buttercupCsvImporter.ts
@@ -0,0 +1,50 @@
+import { ImportResult } from "../models/domain/importResult";
+
+import { BaseImporter } from "./baseImporter";
+import { Importer } from "./importer";
+
+const OfficialProps = ["!group_id", "!group_name", "title", "username", "password", "URL", "id"];
+
+export class ButtercupCsvImporter extends BaseImporter implements Importer {
+  parse(data: string): Promise<ImportResult> {
+    const result = new ImportResult();
+    const results = this.parseCsv(data, true);
+    if (results == null) {
+      result.success = false;
+      return Promise.resolve(result);
+    }
+
+    results.forEach((value) => {
+      this.processFolder(result, this.getValueOrDefault(value["!group_name"]));
+
+      const cipher = this.initLoginCipher();
+      cipher.name = this.getValueOrDefault(value.title, "--");
+      cipher.login.username = this.getValueOrDefault(value.username);
+      cipher.login.password = this.getValueOrDefault(value.password);
+      cipher.login.uris = this.makeUriArray(value.URL);
+
+      let processingCustomFields = false;
+      for (const prop in value) {
+        // eslint-disable-next-line
+        if (value.hasOwnProperty(prop)) {
+          if (!processingCustomFields && OfficialProps.indexOf(prop) === -1) {
+            processingCustomFields = true;
+          }
+          if (processingCustomFields) {
+            this.processKvp(cipher, prop, value[prop]);
+          }
+        }
+      }
+
+      this.cleanupCipher(cipher);
+      result.ciphers.push(cipher);
+    });
+
+    if (this.organization) {
+      this.moveFoldersToCollections(result);
+    }
+
+    result.success = true;
+    return Promise.resolve(result);
+  }
+}
--- a/libs/common/src/importers/chromeCsvImporter.ts
+++ b/libs/common/src/importers/chromeCsvImporter.ts
@@ -0,0 +1,28 @@
+import { ImportResult } from "../models/domain/importResult";
+
+import { BaseImporter } from "./baseImporter";
+import { Importer } from "./importer";
+
+export class ChromeCsvImporter extends BaseImporter implements Importer {
+  parse(data: string): Promise<ImportResult> {
+    const result = new ImportResult();
+    const results = this.parseCsv(data, true);
+    if (results == null) {
+      result.success = false;
+      return Promise.resolve(result);
+    }
+
+    results.forEach((value) => {
+      const cipher = this.initLoginCipher();
+      cipher.name = this.getValueOrDefault(value.name, "--");
+      cipher.login.username = this.getValueOrDefault(value.username);
+      cipher.login.password = this.getValueOrDefault(value.password);
+      cipher.login.uris = this.makeUriArray(value.url);
+      this.cleanupCipher(cipher);
+      result.ciphers.push(cipher);
+    });
+
+    result.success = true;
+    return Promise.resolve(result);
+  }
+}
--- a/libs/common/src/importers/clipperzHtmlImporter.ts
+++ b/libs/common/src/importers/clipperzHtmlImporter.ts
@@ -0,0 +1,88 @@
+import { ImportResult } from "../models/domain/importResult";
+
+import { BaseImporter } from "./baseImporter";
+import { Importer } from "./importer";
+
+export class ClipperzHtmlImporter extends BaseImporter implements Importer {
+  parse(data: string): Promise<ImportResult> {
+    const result = new ImportResult();
+    const doc = this.parseXml(data);
+    if (doc == null) {
+      result.success = false;
+      return Promise.resolve(result);
+    }
+
+    const textarea = doc.querySelector("textarea");
+    if (textarea == null || this.isNullOrWhitespace(textarea.textContent)) {
+      result.errorMessage = "Missing textarea.";
+      result.success = false;
+      return Promise.resolve(result);
+    }
+
+    const entries = JSON.parse(textarea.textContent);
+    entries.forEach((entry: any) => {
+      const cipher = this.initLoginCipher();
+      if (!this.isNullOrWhitespace(entry.label)) {
+        cipher.name = entry.label.split(" ")[0];
+      }
+      if (entry.data != null && !this.isNullOrWhitespace(entry.data.notes)) {
+        cipher.notes = entry.data.notes.split("\\n").join("\n");
+      }
+
+      if (entry.currentVersion != null && entry.currentVersion.fields != null) {
+        for (const property in entry.currentVersion.fields) {
+          // eslint-disable-next-line
+          if (!entry.currentVersion.fields.hasOwnProperty(property)) {
+            continue;
+          }
+
+          const field = entry.currentVersion.fields[property];
+          const actionType = field.actionType != null ? field.actionType.toLowerCase() : null;
+          switch (actionType) {
+            case "password":
+              cipher.login.password = this.getValueOrDefault(field.value);
+              break;
+            case "email":
+            case "username":
+            case "user":
+            case "name":
+              cipher.login.username = this.getValueOrDefault(field.value);
+              break;
+            case "url":
+              cipher.login.uris = this.makeUriArray(field.value);
+              break;
+            default: {
+              const labelLower = field.label != null ? field.label.toLowerCase() : null;
+              if (
+                cipher.login.password == null &&
+                this.passwordFieldNames.indexOf(labelLower) > -1
+              ) {
+                cipher.login.password = this.getValueOrDefault(field.value);
+              } else if (
+                cipher.login.username == null &&
+                this.usernameFieldNames.indexOf(labelLower) > -1
+              ) {
+                cipher.login.username = this.getValueOrDefault(field.value);
+              } else if (
+                (cipher.login.uris == null || cipher.login.uris.length === 0) &&
+                this.uriFieldNames.indexOf(labelLower) > -1
+              ) {
+                cipher.login.uris = this.makeUriArray(field.value);
+              } else {
+                this.processKvp(cipher, field.label, field.value);
+              }
+              break;
+            }
+          }
+        }
+      }
+
+      this.convertToNoteIfNeeded(cipher);
+      this.cleanupCipher(cipher);
+      result.ciphers.push(cipher);
+    });
+
+    result.success = true;
+    return Promise.resolve(result);
+  }
+}
--- a/libs/common/src/importers/codebookCsvImporter.ts
+++ b/libs/common/src/importers/codebookCsvImporter.ts
@@ -0,0 +1,47 @@
+import { ImportResult } from "../models/domain/importResult";
+
+import { BaseImporter } from "./baseImporter";
+import { Importer } from "./importer";
+
+export class CodebookCsvImporter extends BaseImporter implements Importer {
+  parse(data: string): Promise<ImportResult> {
+    const result = new ImportResult();
+    const results = this.parseCsv(data, true);
+    if (results == null) {
+      result.success = false;
+      return Promise.resolve(result);
+    }
+
+    results.forEach((value) => {
+      this.processFolder(result, this.getValueOrDefault(value.Category));
+
+      const cipher = this.initLoginCipher();
+      cipher.favorite = this.getValueOrDefault(value.Favorite) === "True";
+      cipher.name = this.getValueOrDefault(value.Entry, "--");
+      cipher.notes = this.getValueOrDefault(value.Note);
+      cipher.login.username = this.getValueOrDefault(value.Username, value.Email);
+      cipher.login.password = this.getValueOrDefault(value.Password);
+      cipher.login.totp = this.getValueOrDefault(value.TOTP);
+      cipher.login.uris = this.makeUriArray(value.Website);
+
+      if (!this.isNullOrWhitespace(value.Username)) {
+        this.processKvp(cipher, "Email", value.Email);
+      }
+      this.processKvp(cipher, "Phone", value.Phone);
+      this.processKvp(cipher, "PIN", value.PIN);
+      this.processKvp(cipher, "Account", value.Account);
+      this.processKvp(cipher, "Date", value.Date);
+
+      this.convertToNoteIfNeeded(cipher);
+      this.cleanupCipher(cipher);
+      result.ciphers.push(cipher);
+    });
+
+    if (this.organization) {
+      this.moveFoldersToCollections(result);
+    }
+
+    result.success = true;
+    return Promise.resolve(result);
+  }
+}
--- a/Show More
+++ b/Show More