Split jslib into multiple modules (#363)

* Split jslib into multiple modules

common/src/abstractions/api.service.ts

@@ -0,0 +1,405 @@
+import { PolicyType } from '../enums/policyType';
+
+import { EnvironmentUrls } from '../models/domain/environmentUrls';
+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 { ImportCiphersRequest } from '../models/request/importCiphersRequest';
+import { ImportDirectoryRequest } from '../models/request/importDirectoryRequest';
+import { ImportOrganizationCiphersRequest } from '../models/request/importOrganizationCiphersRequest';
+import { KdfRequest } from '../models/request/kdfRequest';
+import { KeysRequest } from '../models/request/keysRequest';
+import { OrganizationCreateRequest } from '../models/request/organizationCreateRequest';
+import { OrganizationImportRequest } from '../models/request/organizationImportRequest';
+import { OrganizationKeysRequest } from '../models/request/organizationKeysRequest';
+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 { PasswordVerificationRequest } from '../models/request/passwordVerificationRequest';
+import { PaymentRequest } from '../models/request/paymentRequest';
+import { PolicyRequest } from '../models/request/policyRequest';
+import { PreloginRequest } from '../models/request/preloginRequest';
+import { RegisterRequest } from '../models/request/registerRequest';
+import { SeatRequest } from '../models/request/seatRequest';
+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 { TokenRequest } from '../models/request/tokenRequest';
+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 { 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 { IdentityTokenResponse } from '../models/response/identityTokenResponse';
+import { IdentityTwoFactorResponse } from '../models/response/identityTwoFactorResponse';
+import { ListResponse } from '../models/response/listResponse';
+import { OrganizationKeysResponse } from '../models/response/organizationKeysResponse';
+import { OrganizationResponse } from '../models/response/organizationResponse';
+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 { 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 {
+    urlsSet: boolean;
+    apiBaseUrl: string;
+    identityBaseUrl: string;
+    eventsBaseUrl: string;
+
+    setUrls: (urls: EnvironmentUrls) => void;
+    postIdentityToken: (request: TokenRequest) => Promise<IdentityTokenResponse | IdentityTwoFactorResponse>;
+    refreshIdentityToken: () => Promise<any>;
+
+    getProfile: () => Promise<ProfileResponse>;
+    getUserBilling: () => Promise<BillingResponse>;
+    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>;
+    postSecurityStamp: (request: PasswordVerificationRequest) => Promise<any>;
+    deleteAccount: (request: PasswordVerificationRequest) => 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: PasswordVerificationRequest) => Promise<any>;
+    postAccountRecoverDelete: (request: DeleteRecoverRequest) => Promise<any>;
+    postAccountRecoverDeleteToken: (request: VerifyDeleteRecoverRequest) => Promise<any>;
+    postAccountKdf: (request: KdfRequest) => Promise<any>;
+    getEnterprisePortalSignInToken: () => Promise<string>;
+    postUserApiKey: (id: string, request: PasswordVerificationRequest) => Promise<ApiKeyResponse>;
+    postUserRotateApiKey: (id: string, request: PasswordVerificationRequest) => Promise<ApiKeyResponse>;
+
+    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: PasswordVerificationRequest, 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>>;
+    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: PasswordVerificationRequest) => Promise<TwoFactorAuthenticatorResponse>;
+    getTwoFactorEmail: (request: PasswordVerificationRequest) => Promise<TwoFactorEmailResponse>;
+    getTwoFactorDuo: (request: PasswordVerificationRequest) => Promise<TwoFactorDuoResponse>;
+    getTwoFactorOrganizationDuo: (organizationId: string,
+        request: PasswordVerificationRequest) => Promise<TwoFactorDuoResponse>;
+    getTwoFactorYubiKey: (request: PasswordVerificationRequest) => Promise<TwoFactorYubiKeyResponse>;
+    getTwoFactorWebAuthn: (request: PasswordVerificationRequest) => Promise<TwoFactorWebAuthnResponse>;
+    getTwoFactorWebAuthnChallenge: (request: PasswordVerificationRequest) => Promise<ChallengeResponse>;
+    getTwoFactorRecover: (request: PasswordVerificationRequest) => 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>;
+    getOrganizationLicense: (id: string, installationId: string) => Promise<any>;
+    getOrganizationTaxInfo: (id: string) => Promise<TaxInfoResponse>;
+    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: PasswordVerificationRequest) => Promise<ApiKeyResponse>;
+    postOrganizationRotateApiKey: (id: string, request: PasswordVerificationRequest) => Promise<ApiKeyResponse>;
+    postOrganizationUpgrade: (id: string, request: OrganizationUpgradeRequest) => Promise<PaymentResponse>;
+    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: PasswordVerificationRequest) => Promise<any>;
+    getPlans: () => Promise<ListResponse<PlanResponse>>;
+    getTaxRates: () => Promise<ListResponse<TaxRateResponse>>;
+    getOrganizationKeys: (id: string) => Promise<OrganizationKeysResponse>;
+    postOrganizationKeys: (id: string, request: OrganizationKeysRequest) => Promise<OrganizationKeysResponse>;
+
+    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>>;
+    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<boolean>;
+}

common/src/abstractions/apiKey.service.ts

@@ -0,0 +1,7 @@
+export abstract class ApiKeyService {
+    setInformation: (clientId: string) => Promise<any>;
+    clear: () => Promise<any>;
+    getEntityType: () => Promise<string>;
+    getEntityId: () => Promise<string>;
+    isAuthenticated: () => Promise<boolean>;
+}

common/src/abstractions/appId.service.ts

@@ -0,0 +1,4 @@
+export abstract class AppIdService {
+    getAppId: () => Promise<string>;
+    getAnonymousAppId: () => Promise<string>;
+}

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[]>;
+}

common/src/abstractions/auth.service.ts

@@ -0,0 +1,35 @@
+import { TwoFactorProviderType } from '../enums/twoFactorProviderType';
+
+import { AuthResult } from '../models/domain/authResult';
+import { SymmetricCryptoKey } from '../models/domain/symmetricCryptoKey';
+
+export abstract class AuthService {
+    email: string;
+    masterPasswordHash: string;
+    code: string;
+    codeVerifier: string;
+    ssoRedirectUrl: string;
+    clientId: string;
+    clientSecret: string;
+    twoFactorProvidersData: Map<TwoFactorProviderType, { [key: string]: string; }>;
+    selectedTwoFactorProviderType: TwoFactorProviderType;
+
+    logIn: (email: string, masterPassword: string) => Promise<AuthResult>;
+    logInSso: (code: string, codeVerifier: string, redirectUrl: string) => Promise<AuthResult>;
+    logInApiKey: (clientId: string, clientSecret: string) => Promise<AuthResult>;
+    logInTwoFactor: (twoFactorProvider: TwoFactorProviderType, twoFactorToken: string,
+        remember?: boolean) => Promise<AuthResult>;
+    logInComplete: (email: string, masterPassword: string, twoFactorProvider: TwoFactorProviderType,
+        twoFactorToken: string, remember?: boolean) => Promise<AuthResult>;
+    logInSsoComplete: (code: string, codeVerifier: string, redirectUrl: string,
+        twoFactorProvider: TwoFactorProviderType, twoFactorToken: string, remember?: boolean) => Promise<AuthResult>;
+    logInApiKeyComplete: (clientId: string, clientSecret: string, twoFactorProvider: TwoFactorProviderType,
+        twoFactorToken: string, remember?: boolean) => Promise<AuthResult>;
+    logOut: (callback: Function) => void;
+    getSupportedTwoFactorProviders: (win: Window) => any[];
+    getDefaultTwoFactorProvider: (webAuthnSupported: boolean) => TwoFactorProviderType;
+    makePreloginKey: (masterPassword: string, email: string) => Promise<SymmetricCryptoKey>;
+    authingWithApiKey: () => boolean;
+    authingWithSso: () => boolean;
+    authingWithPassword: () => boolean;
+}

common/src/abstractions/biometric.main.ts

@@ -0,0 +1,6 @@
+export abstract class BiometricMain {
+    isError: boolean;
+    init: () => Promise<void>;
+    supportsBiometric: () => Promise<boolean>;
+    requestCreate: () => Promise<boolean>;
+}

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;
+}

common/src/abstractions/cipher.service.ts

@@ -0,0 +1,59 @@
+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 {
+    decryptedCipherCache: CipherView[];
+
+    clearCache: () => 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>;
+}

common/src/abstractions/collection.service.ts

@@ -0,0 +1,23 @@
+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 {
+    decryptedCollectionCache: CollectionView[];
+
+    clearCache: () => 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>;
+}

common/src/abstractions/crypto.service.ts

@@ -0,0 +1,52 @@
+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 { KdfType } from '../enums/kdfType';
+
+export abstract class CryptoService {
+    setKey: (key: SymmetricCryptoKey) => Promise<any>;
+    setKeyHash: (keyHash: string) => Promise<{}>;
+    setEncKey: (encKey: string) => Promise<{}>;
+    setEncPrivateKey: (encPrivateKey: string) => Promise<{}>;
+    setOrgKeys: (orgs: ProfileOrganizationResponse[]) => Promise<{}>;
+    getKey: () => Promise<SymmetricCryptoKey>;
+    getKeyHash: () => Promise<string>;
+    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>;
+    hasKey: () => Promise<boolean>;
+    hasEncKey: () => Promise<boolean>;
+    clearKey: () => Promise<any>;
+    clearKeyHash: () => Promise<any>;
+    clearEncKey: (memoryOnly?: boolean) => Promise<any>;
+    clearKeyPair: (memoryOnly?: boolean) => Promise<any>;
+    clearOrgKeys: (memoryOnly?: boolean) => Promise<any>;
+    clearPinProtectedKey: () => Promise<any>;
+    clearKeys: () => 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) => 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>;
+}

common/src/abstractions/cryptoFunction.service.ts

@@ -0,0 +1,27 @@
+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>;
+}

common/src/abstractions/environment.service.ts

@@ -0,0 +1,14 @@
+export abstract class EnvironmentService {
+    baseUrl: string;
+    webVaultUrl: string;
+    apiUrl: string;
+    identityUrl: string;
+    iconsUrl: string;
+    notificationsUrl: string;
+    eventsUrl: string;
+    enterpriseUrl: string;
+
+    getWebVaultUrl: () => string;
+    setUrlsFromStorage: () => Promise<void>;
+    setUrls: (urls: any) => Promise<any>;
+}

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: () => Promise<any>;
+    clearEvents: () => Promise<any>;
+}

common/src/abstractions/export.service.ts

@@ -0,0 +1,8 @@
+import { EventView } from '../models/view/eventView';
+
+export abstract class ExportService {
+    getExport: (format?: 'csv' | 'json' | 'encrypted_json') => Promise<string>;
+    getOrganizationExport: (organizationId: string, format?: 'csv' | 'json' | 'encrypted_json') => Promise<string>;
+    getEventExport: (events: EventView[]) => Promise<string>;
+    getFileName: (prefix?: string, extension?: string) => string;
+}

common/src/abstractions/fileUpload.service.ts

@@ -0,0 +1,11 @@
+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: string,
+        encryptedFileData: EncArrayBuffer) => Promise<any>;
+}

common/src/abstractions/folder.service.ts

@@ -0,0 +1,25 @@
+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 {
+    decryptedFolderCache: FolderView[];
+
+    clearCache: () => void;
+    encrypt: (model: FolderView, key?: SymmetricCryptoKey) => Promise<Folder>;
+    get: (id: string) => Promise<Folder>;
+    getAll: () => Promise<Folder[]>;
+    getAllDecrypted: () => Promise<FolderView[]>;
+    getAllNested: () => 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>;
+}

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;
+}

common/src/abstractions/import.service.ts

@@ -0,0 +1,13 @@
+import { Importer } from '../importers/importer';
+
+export interface ImportOption {
+    id: string;
+    name: string;
+}
+export abstract class ImportService {
+    featuredImportOptions: ImportOption[];
+    regularImportOptions: ImportOption[];
+    getImportOptions: () => ImportOption[];
+    import: (importer: Importer, fileContents: string, organizationId?: string) => Promise<Error>;
+    getImporter: (format: string, organizationId: string) => Importer;
+}

common/src/abstractions/index.ts

@@ -0,0 +1,24 @@
+// Using index.ts is deprecated, please do not extend
+export { ApiService } from './api.service';
+export { AppIdService } from './appId.service';
+export { AuditService } from './audit.service';
+export { AuthService } from './auth.service';
+export { CipherService } from './cipher.service';
+export { CollectionService } from './collection.service';
+export { CryptoService } from './crypto.service';
+export { EnvironmentService } from './environment.service';
+export { FolderService } from './folder.service';
+export { I18nService } from './i18n.service';
+export { LogService } from './log.service';
+export { MessagingService } from './messaging.service';
+export { PasswordGenerationService } from './passwordGeneration.service';
+export { PlatformUtilsService } from './platformUtils.service';
+export { SearchService } from './search.service';
+export { SettingsService } from './settings.service';
+export { StorageService } from './storage.service';
+export { StateService } from './state.service';
+export { SyncService } from './sync.service';
+export { TokenService } from './token.service';
+export { TotpService } from './totp.service';
+export { UserService } from './user.service';
+export { VaultTimeoutService } from './vaultTimeout.service';

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];
+}

common/src/abstractions/messaging.service.ts

@@ -0,0 +1,3 @@
+export abstract class MessagingService {
+    send: (subscriber: string, arg?: any) => void;
+}

common/src/abstractions/notifications.service.ts

@@ -0,0 +1,8 @@
+import { EnvironmentService } from './environment.service';
+
+export abstract class NotificationsService {
+    init: (environmentService: EnvironmentService) => Promise<void>;
+    updateConnection: (sync?: boolean) => Promise<void>;
+    reconnectFromActivity: () => Promise<void>;
+    disconnectFromInactivity: () => Promise<void>;
+}

common/src/abstractions/passwordGeneration.service.ts

@@ -0,0 +1,18 @@
+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: () => Promise<any>;
+    passwordStrength: (password: string, userInputs?: string[]) => zxcvbn.ZXCVBNResult;
+    normalizeOptions: (options: any, enforcedPolicyOptions: PasswordGeneratorPolicyOptions) => void;
+}

common/src/abstractions/passwordReprompt.service.ts

@@ -0,0 +1,4 @@
+export abstract class PasswordRepromptService {
+    protectedFields: () => string[];
+    showPasswordPrompt: () => Promise<boolean>;
+}

common/src/abstractions/platformUtils.service.ts

@@ -0,0 +1,39 @@
+import { DeviceType } from '../enums/deviceType';
+
+export abstract class PlatformUtilsService {
+    identityClientId: string;
+    getDevice: () => DeviceType;
+    getDeviceString: () => string;
+    isFirefox: () => boolean;
+    isChrome: () => boolean;
+    isEdge: () => boolean;
+    isOpera: () => boolean;
+    isVivaldi: () => boolean;
+    isSafari: () => boolean;
+    isIE: () => boolean;
+    isMacAppStore: () => boolean;
+    isViewOpen: () => Promise<boolean>;
+    /**
+     * @deprecated This only ever returns null. Pull from your platform's storage using ConstantsService.vaultTimeoutKey
+     */
+    lockTimeout: () => number;
+    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?: any) => void;
+    showDialog: (body: string, title?: string, confirmText?: string, cancelText?: string,
+        type?: string, bodyIsHtml?: boolean) => Promise<boolean>;
+    showPasswordDialog: (title: string, body: string, passwordValidation: (value: string) => Promise<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<'light' | 'dark'>;
+    onDefaultSystemThemeChange: (callback: ((theme: 'light' | 'dark') => unknown)) => unknown;
+    supportsSecureStorage: () => boolean;
+}

common/src/abstractions/policy.service.ts

@@ -0,0 +1,24 @@
+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 { PolicyType } from '../enums/policyType';
+
+import { ListResponse } from '../models/response/listResponse';
+import { PolicyResponse } from '../models/response/policyResponse';
+
+export abstract class PolicyService {
+    policyCache: Policy[];
+
+    clearCache: () => void;
+    getAll: (type?: PolicyType) => Promise<Policy[]>;
+    replace: (policies: { [id: string]: PolicyData; }) => Promise<any>;
+    clear: (userId: string) => Promise<any>;
+    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[];
+}

common/src/abstractions/search.service.ts

@@ -0,0 +1,14 @@
+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[];
+}

common/src/abstractions/send.service.ts

@@ -0,0 +1,24 @@
+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 {
+    decryptedSendCache: SendView[];
+
+    clearCache: () => 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>;
+}

common/src/abstractions/settings.service.ts

@@ -0,0 +1,6 @@
+export abstract class SettingsService {
+    clearCache: () => void;
+    getEquivalentDomains: () => Promise<any>;
+    setEquivalentDomains: (equivalentDomains: string[][]) => Promise<any>;
+    clear: (userId: string) => Promise<void>;
+}

common/src/abstractions/state.service.ts

@@ -0,0 +1,6 @@
+export abstract class StateService {
+    get: <T>(key: string) => Promise<T>;
+    save: (key: string, obj: any) => Promise<any>;
+    remove: (key: string) => Promise<any>;
+    purge: () => Promise<any>;
+}

common/src/abstractions/storage.service.ts

@@ -0,0 +1,5 @@
+export abstract class StorageService {
+    get: <T>(key: string) => Promise<T>;
+    save: (key: string, obj: any) => Promise<any>;
+    remove: (key: string) => Promise<any>;
+}

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) => 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>;
+}

common/src/abstractions/system.service.ts

@@ -0,0 +1,6 @@
+export abstract class SystemService {
+    startProcessReload: () => void;
+    cancelProcessReload: () => void;
+    clearClipboard: (clipboardValue: string, timeoutMs?: number) => void;
+    clearPendingClipboard: () => Promise<any>;
+}

common/src/abstractions/token.service.ts

@@ -0,0 +1,25 @@
+export abstract class TokenService {
+    token: string;
+    decodedToken: any;
+    refreshToken: string;
+    setTokens: (accessToken: string, refreshToken: string) => Promise<any>;
+    setToken: (token: string) => Promise<any>;
+    getToken: () => Promise<string>;
+    setRefreshToken: (refreshToken: string) => Promise<any>;
+    getRefreshToken: () => Promise<string>;
+    toggleTokens: () => Promise<any>;
+    setTwoFactorToken: (token: string, email: string) => Promise<any>;
+    getTwoFactorToken: (email: string) => Promise<string>;
+    clearTwoFactorToken: (email: string) => Promise<any>;
+    clearToken: () => Promise<any>;
+    decodeToken: () => any;
+    getTokenExpirationDate: () => Date;
+    tokenSecondsRemaining: (offsetSeconds?: number) => number;
+    tokenNeedsRefresh: (minutes?: number) => boolean;
+    getUserId: () => string;
+    getEmail: () => string;
+    getEmailVerified: () => boolean;
+    getName: () => string;
+    getPremium: () => boolean;
+    getIssuer: () => string;
+}

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>;
+}

common/src/abstractions/user.service.ts

@@ -0,0 +1,23 @@
+import { OrganizationData } from '../models/data/organizationData';
+import { Organization } from '../models/domain/organization';
+
+import { KdfType } from '../enums/kdfType';
+
+export abstract class UserService {
+    setInformation: (userId: string, email: string, kdf: KdfType, kdfIterations: number) => Promise<any>;
+    setEmailVerified: (emailVerified: boolean) => Promise<any>;
+    setSecurityStamp: (stamp: string) => Promise<any>;
+    getUserId: () => Promise<string>;
+    getEmail: () => Promise<string>;
+    getSecurityStamp: () => Promise<string>;
+    getKdf: () => Promise<KdfType>;
+    getKdfIterations: () => Promise<number>;
+    getEmailVerified: () => Promise<boolean>;
+    clear: () => Promise<any>;
+    isAuthenticated: () => Promise<boolean>;
+    canAccessPremium: () => Promise<boolean>;
+    getOrganization: (id: string) => Promise<Organization>;
+    getAllOrganizations: () => Promise<Organization[]>;
+    replaceOrganizations: (organizations: { [id: string]: OrganizationData; }) => Promise<any>;
+    clearOrganizations: (userId: string) => Promise<any>;
+}

common/src/abstractions/vaultTimeout.service.ts

@@ -0,0 +1,14 @@
+import { EncString } from '../models/domain/encString';
+
+export abstract class VaultTimeoutService {
+    biometricLocked: boolean;
+    pinProtectedKey: EncString;
+    isLocked: () => Promise<boolean>;
+    checkVaultTimeout: () => Promise<void>;
+    lock: (allowSoftLock?: boolean) => Promise<void>;
+    logOut: () => Promise<void>;
+    setVaultTimeoutOptions: (vaultTimeout: number, vaultTimeoutAction: string) => Promise<void>;
+    isPinLockSet: () => Promise<[boolean, boolean]>;
+    isBiometricLockSet: () => Promise<boolean>;
+    clear: () => Promise<any>;
+}