Delete FileUploadService

Delete PolicyService
Delete VaultTimeoutService
2025-12-05 23:53:21 +00:00 · 2024-07-10 17:00:33 -04:00 · 2024-07-10 16:58:00 -04:00 · 2024-07-10 16:06:51 -04:00 · 2024-07-10 15:50:54 -04:00 · 2024-07-10 15:48:37 -04:00
40 changed files with 6 additions and 4168 deletions
--- a/jslib/angular/src/services/auth-guard.service.ts
+++ b/jslib/angular/src/services/auth-guard.service.ts
@@ -4,12 +4,10 @@ import { ActivatedRouteSnapshot, Router, RouterStateSnapshot } from "@angular/ro
 import { KeyConnectorService } from "@/jslib/common/src/abstractions/keyConnector.service";
 import { MessagingService } from "@/jslib/common/src/abstractions/messaging.service";
 import { StateService } from "@/jslib/common/src/abstractions/state.service";
-import { VaultTimeoutService } from "@/jslib/common/src/abstractions/vaultTimeout.service";

@Injectable()
 export class AuthGuardService  {
  constructor(
-    private vaultTimeoutService: VaultTimeoutService,
    private router: Router,
    private messagingService: MessagingService,
    private keyConnectorService: KeyConnectorService,
@@ -23,15 +21,6 @@ export class AuthGuardService  {
      return false;
    }

-    const locked = await this.vaultTimeoutService.isLocked();
-    if (locked) {
-      if (routerState != null) {
-        this.messagingService.send("lockedUrl", { url: routerState.url });
-      }
-      this.router.navigate(["lock"], { queryParams: { promptBiometric: true } });
-      return false;
-    }
-
    if (
      !routerState.url.includes("remove-password") &&
      (await this.keyConnectorService.getConvertAccountRequired())
--- a/jslib/angular/src/services/jslib-services.module.ts
+++ b/jslib/angular/src/services/jslib-services.module.ts
@@ -1,18 +1,13 @@
-import { Injector, LOCALE_ID, NgModule } from "@angular/core";
+import { LOCALE_ID, NgModule } from "@angular/core";

 import { ApiService as ApiServiceAbstraction } from "@/jslib/common/src/abstractions/api.service";
 import { AppIdService as AppIdServiceAbstraction } from "@/jslib/common/src/abstractions/appId.service";
-import { AuditService as AuditServiceAbstraction } from "@/jslib/common/src/abstractions/audit.service";
 import { AuthService as AuthServiceAbstraction } from "@/jslib/common/src/abstractions/auth.service";
 import { BroadcasterService as BroadcasterServiceAbstraction } from "@/jslib/common/src/abstractions/broadcaster.service";
-import { CipherService as CipherServiceAbstraction } from "@/jslib/common/src/abstractions/cipher.service";
-import { CollectionService as CollectionServiceAbstraction } from "@/jslib/common/src/abstractions/collection.service";
 import { CryptoService as CryptoServiceAbstraction } from "@/jslib/common/src/abstractions/crypto.service";
 import { CryptoFunctionService as CryptoFunctionServiceAbstraction } from "@/jslib/common/src/abstractions/cryptoFunction.service";
 import { EnvironmentService as EnvironmentServiceAbstraction } from "@/jslib/common/src/abstractions/environment.service";
 import { EventService as EventServiceAbstraction } from "@/jslib/common/src/abstractions/event.service";
-import { FileUploadService as FileUploadServiceAbstraction } from "@/jslib/common/src/abstractions/fileUpload.service";
-import { FolderService as FolderServiceAbstraction } from "@/jslib/common/src/abstractions/folder.service";
 import { I18nService as I18nServiceAbstraction } from "@/jslib/common/src/abstractions/i18n.service";
 import { KeyConnectorService as KeyConnectorServiceAbstraction } from "@/jslib/common/src/abstractions/keyConnector.service";
 import { LogService } from "@/jslib/common/src/abstractions/log.service";
@@ -22,54 +17,37 @@ import { OrganizationService as OrganizationServiceAbstraction } from "@/jslib/c
 import { PasswordGenerationService as PasswordGenerationServiceAbstraction } from "@/jslib/common/src/abstractions/passwordGeneration.service";
 import { PasswordRepromptService as PasswordRepromptServiceAbstraction } from "@/jslib/common/src/abstractions/passwordReprompt.service";
 import { PlatformUtilsService as PlatformUtilsServiceAbstraction } from "@/jslib/common/src/abstractions/platformUtils.service";
-import { PolicyService as PolicyServiceAbstraction } from "@/jslib/common/src/abstractions/policy.service";
-import { ProviderService as ProviderServiceAbstraction } from "@/jslib/common/src/abstractions/provider.service";
 import { SearchService as SearchServiceAbstraction } from "@/jslib/common/src/abstractions/search.service";
-import { SendService as SendServiceAbstraction } from "@/jslib/common/src/abstractions/send.service";
 import { SettingsService as SettingsServiceAbstraction } from "@/jslib/common/src/abstractions/settings.service";
 import { StateService as StateServiceAbstraction } from "@/jslib/common/src/abstractions/state.service";
 import { StateMigrationService as StateMigrationServiceAbstraction } from "@/jslib/common/src/abstractions/stateMigration.service";
 import { StorageService as StorageServiceAbstraction } from "@/jslib/common/src/abstractions/storage.service";
 import { SyncService as SyncServiceAbstraction } from "@/jslib/common/src/abstractions/sync.service";
 import { TokenService as TokenServiceAbstraction } from "@/jslib/common/src/abstractions/token.service";
-import { TotpService as TotpServiceAbstraction } from "@/jslib/common/src/abstractions/totp.service";
 import { TwoFactorService as TwoFactorServiceAbstraction } from "@/jslib/common/src/abstractions/twoFactor.service";
 import { UserVerificationService as UserVerificationServiceAbstraction } from "@/jslib/common/src/abstractions/userVerification.service";
-import { UsernameGenerationService as UsernameGenerationServiceAbstraction } from "@/jslib/common/src/abstractions/usernameGeneration.service";
-import { VaultTimeoutService as VaultTimeoutServiceAbstraction } from "@/jslib/common/src/abstractions/vaultTimeout.service";
 import { StateFactory } from "@/jslib/common/src/factories/stateFactory";
 import { Account } from "@/jslib/common/src/models/domain/account";
 import { GlobalState } from "@/jslib/common/src/models/domain/globalState";
 import { ApiService } from "@/jslib/common/src/services/api.service";
 import { AppIdService } from "@/jslib/common/src/services/appId.service";
-import { AuditService } from "@/jslib/common/src/services/audit.service";
 import { AuthService } from "@/jslib/common/src/services/auth.service";
-import { CipherService } from "@/jslib/common/src/services/cipher.service";
-import { CollectionService } from "@/jslib/common/src/services/collection.service";
 import { ConsoleLogService } from "@/jslib/common/src/services/consoleLog.service";
 import { CryptoService } from "@/jslib/common/src/services/crypto.service";
 import { EnvironmentService } from "@/jslib/common/src/services/environment.service";
 import { EventService } from "@/jslib/common/src/services/event.service";
-import { FileUploadService } from "@/jslib/common/src/services/fileUpload.service";
-import { FolderService } from "@/jslib/common/src/services/folder.service";
 import { KeyConnectorService } from "@/jslib/common/src/services/keyConnector.service";
 import { NotificationsService } from "@/jslib/common/src/services/notifications.service";
 import { OrganizationService } from "@/jslib/common/src/services/organization.service";
 import { PasswordGenerationService } from "@/jslib/common/src/services/passwordGeneration.service";
-import { PolicyService } from "@/jslib/common/src/services/policy.service";
-import { ProviderService } from "@/jslib/common/src/services/provider.service";
 import { SearchService } from "@/jslib/common/src/services/search.service";
-import { SendService } from "@/jslib/common/src/services/send.service";
 import { SettingsService } from "@/jslib/common/src/services/settings.service";
 import { StateService } from "@/jslib/common/src/services/state.service";
 import { StateMigrationService } from "@/jslib/common/src/services/stateMigration.service";
 import { SyncService } from "@/jslib/common/src/services/sync.service";
 import { TokenService } from "@/jslib/common/src/services/token.service";
-import { TotpService } from "@/jslib/common/src/services/totp.service";
 import { TwoFactorService } from "@/jslib/common/src/services/twoFactor.service";
 import { UserVerificationService } from "@/jslib/common/src/services/userVerification.service";
-import { UsernameGenerationService } from "@/jslib/common/src/services/usernameGeneration.service";
-import { VaultTimeoutService } from "@/jslib/common/src/services/vaultTimeout.service";

 import { AuthGuardService } from "./auth-guard.service";
 import { BroadcasterService } from "./broadcaster.service";
@@ -98,11 +76,6 @@ import { ValidationService } from "./validation.service";
      useClass: AppIdService,
      deps: [StorageServiceAbstraction],
    },
-    {
-      provide: AuditServiceAbstraction,
-      useClass: AuditService,
-      deps: [CryptoFunctionServiceAbstraction, ApiServiceAbstraction],
-    },
    {
      provide: AuthServiceAbstraction,
      useClass: AuthService,
@@ -121,66 +94,12 @@ import { ValidationService } from "./validation.service";
        I18nServiceAbstraction,
      ],
    },
-    {
-      provide: CipherServiceAbstraction,
-      useFactory: (
-        cryptoService: CryptoServiceAbstraction,
-        settingsService: SettingsServiceAbstraction,
-        apiService: ApiServiceAbstraction,
-        fileUploadService: FileUploadServiceAbstraction,
-        i18nService: I18nServiceAbstraction,
-        injector: Injector,
-        logService: LogService,
-        stateService: StateServiceAbstraction,
-      ) =>
-        new CipherService(
-          cryptoService,
-          settingsService,
-          apiService,
-          fileUploadService,
-          i18nService,
-          () => injector.get(SearchServiceAbstraction),
-          logService,
-          stateService,
-        ),
-      deps: [
-        CryptoServiceAbstraction,
-        SettingsServiceAbstraction,
-        ApiServiceAbstraction,
-        FileUploadServiceAbstraction,
-        I18nServiceAbstraction,
-        Injector, // TODO: Get rid of this circular dependency!
-        LogService,
-        StateServiceAbstraction,
-      ],
-    },
-    {
-      provide: FolderServiceAbstraction,
-      useClass: FolderService,
-      deps: [
-        CryptoServiceAbstraction,
-        ApiServiceAbstraction,
-        I18nServiceAbstraction,
-        CipherServiceAbstraction,
-        StateServiceAbstraction,
-      ],
-    },
    { provide: LogService, useFactory: () => new ConsoleLogService(false) },
-    {
-      provide: CollectionServiceAbstraction,
-      useClass: CollectionService,
-      deps: [CryptoServiceAbstraction, I18nServiceAbstraction, StateServiceAbstraction],
-    },
    {
      provide: EnvironmentServiceAbstraction,
      useClass: EnvironmentService,
      deps: [StateServiceAbstraction],
    },
-    {
-      provide: TotpServiceAbstraction,
-      useClass: TotpService,
-      deps: [CryptoFunctionServiceAbstraction, LogService, StateServiceAbstraction],
-    },
    { provide: TokenServiceAbstraction, useClass: TokenService, deps: [StateServiceAbstraction] },
    {
      provide: CryptoServiceAbstraction,
@@ -195,11 +114,6 @@ import { ValidationService } from "./validation.service";
    {
      provide: PasswordGenerationServiceAbstraction,
      useClass: PasswordGenerationService,
-      deps: [CryptoServiceAbstraction, PolicyServiceAbstraction, StateServiceAbstraction],
-    },
-    {
-      provide: UsernameGenerationServiceAbstraction,
-      useClass: UsernameGenerationService,
      deps: [CryptoServiceAbstraction, StateServiceAbstraction],
    },
    {
@@ -226,61 +140,38 @@ import { ValidationService } from "./validation.service";
        AppIdServiceAbstraction,
      ],
    },
-    {
-      provide: FileUploadServiceAbstraction,
-      useClass: FileUploadService,
-      deps: [LogService, ApiServiceAbstraction],
-    },
    {
      provide: SyncServiceAbstraction,
      useFactory: (
        apiService: ApiServiceAbstraction,
        settingsService: SettingsServiceAbstraction,
-        folderService: FolderServiceAbstraction,
-        cipherService: CipherServiceAbstraction,
        cryptoService: CryptoServiceAbstraction,
-        collectionService: CollectionServiceAbstraction,
        messagingService: MessagingServiceAbstraction,
-        policyService: PolicyServiceAbstraction,
-        sendService: SendServiceAbstraction,
        logService: LogService,
        keyConnectorService: KeyConnectorServiceAbstraction,
        stateService: StateServiceAbstraction,
        organizationService: OrganizationServiceAbstraction,
-        providerService: ProviderServiceAbstraction,
      ) =>
        new SyncService(
          apiService,
          settingsService,
-          folderService,
-          cipherService,
          cryptoService,
-          collectionService,
          messagingService,
-          policyService,
-          sendService,
          logService,
          keyConnectorService,
          stateService,
          organizationService,
-          providerService,
          async (expired: boolean) => messagingService.send("logout", { expired: expired }),
        ),
      deps: [
        ApiServiceAbstraction,
        SettingsServiceAbstraction,
-        FolderServiceAbstraction,
-        CipherServiceAbstraction,
        CryptoServiceAbstraction,
-        CollectionServiceAbstraction,
        MessagingServiceAbstraction,
-        PolicyServiceAbstraction,
-        SendServiceAbstraction,
        LogService,
        KeyConnectorServiceAbstraction,
        StateServiceAbstraction,
        OrganizationServiceAbstraction,
-        ProviderServiceAbstraction,
      ],
    },
    { provide: BroadcasterServiceAbstraction, useClass: BroadcasterService },
@@ -289,51 +180,6 @@ import { ValidationService } from "./validation.service";
      useClass: SettingsService,
      deps: [StateServiceAbstraction],
    },
-    {
-      provide: VaultTimeoutServiceAbstraction,
-      useFactory: (
-        cipherService: CipherServiceAbstraction,
-        folderService: FolderServiceAbstraction,
-        collectionService: CollectionServiceAbstraction,
-        cryptoService: CryptoServiceAbstraction,
-        platformUtilsService: PlatformUtilsServiceAbstraction,
-        messagingService: MessagingServiceAbstraction,
-        searchService: SearchServiceAbstraction,
-        tokenService: TokenServiceAbstraction,
-        policyService: PolicyServiceAbstraction,
-        keyConnectorService: KeyConnectorServiceAbstraction,
-        stateService: StateServiceAbstraction,
-      ) =>
-        new VaultTimeoutService(
-          cipherService,
-          folderService,
-          collectionService,
-          cryptoService,
-          platformUtilsService,
-          messagingService,
-          searchService,
-          tokenService,
-          policyService,
-          keyConnectorService,
-          stateService,
-          null,
-          async (userId?: string) =>
-            messagingService.send("logout", { expired: false, userId: userId }),
-        ),
-      deps: [
-        CipherServiceAbstraction,
-        FolderServiceAbstraction,
-        CollectionServiceAbstraction,
-        CryptoServiceAbstraction,
-        PlatformUtilsServiceAbstraction,
-        MessagingServiceAbstraction,
-        SearchServiceAbstraction,
-        TokenServiceAbstraction,
-        PolicyServiceAbstraction,
-        KeyConnectorServiceAbstraction,
-        StateServiceAbstraction,
-      ],
-    },
    {
      provide: StateServiceAbstraction,
      useFactory: (
@@ -372,7 +218,7 @@ import { ValidationService } from "./validation.service";
    {
      provide: SearchServiceAbstraction,
      useClass: SearchService,
-      deps: [CipherServiceAbstraction, LogService, I18nServiceAbstraction],
+      deps: [LogService, I18nServiceAbstraction],
    },
    {
      provide: NotificationsServiceAbstraction,
@@ -380,7 +226,6 @@ import { ValidationService } from "./validation.service";
        syncService: SyncServiceAbstraction,
        appIdService: AppIdServiceAbstraction,
        apiService: ApiServiceAbstraction,
-        vaultTimeoutService: VaultTimeoutServiceAbstraction,
        environmentService: EnvironmentServiceAbstraction,
        messagingService: MessagingServiceAbstraction,
        logService: LogService,
@@ -390,7 +235,6 @@ import { ValidationService } from "./validation.service";
          syncService,
          appIdService,
          apiService,
-          vaultTimeoutService,
          environmentService,
          async () => messagingService.send("logout", { expired: true }),
          logService,
@@ -400,7 +244,6 @@ import { ValidationService } from "./validation.service";
        SyncServiceAbstraction,
        AppIdServiceAbstraction,
        ApiServiceAbstraction,
-        VaultTimeoutServiceAbstraction,
        EnvironmentServiceAbstraction,
        MessagingServiceAbstraction,
        LogService,
@@ -412,29 +255,11 @@ import { ValidationService } from "./validation.service";
      useClass: EventService,
      deps: [
        ApiServiceAbstraction,
-        CipherServiceAbstraction,
        StateServiceAbstraction,
        LogService,
        OrganizationServiceAbstraction,
      ],
    },
-    {
-      provide: PolicyServiceAbstraction,
-      useClass: PolicyService,
-      deps: [StateServiceAbstraction, OrganizationServiceAbstraction, ApiServiceAbstraction],
-    },
-    {
-      provide: SendServiceAbstraction,
-      useClass: SendService,
-      deps: [
-        CryptoServiceAbstraction,
-        ApiServiceAbstraction,
-        FileUploadServiceAbstraction,
-        I18nServiceAbstraction,
-        CryptoFunctionServiceAbstraction,
-        StateServiceAbstraction,
-      ],
-    },
    {
      provide: KeyConnectorServiceAbstraction,
      useClass: KeyConnectorService,
@@ -459,11 +284,6 @@ import { ValidationService } from "./validation.service";
      useClass: OrganizationService,
      deps: [StateServiceAbstraction],
    },
-    {
-      provide: ProviderServiceAbstraction,
-      useClass: ProviderService,
-      deps: [StateServiceAbstraction],
-    },
    {
      provide: TwoFactorServiceAbstraction,
      useClass: TwoFactorService,
--- a/jslib/angular/src/services/lock-guard.service.ts
+++ b/jslib/angular/src/services/lock-guard.service.ts
@@ -2,23 +2,17 @@ import { Injectable } from "@angular/core";
 import { Router } from "@angular/router";

 import { StateService } from "@/jslib/common/src/abstractions/state.service";
-import { VaultTimeoutService } from "@/jslib/common/src/abstractions/vaultTimeout.service";

@Injectable()
 export class LockGuardService  {
  protected homepage = "vault";
  protected loginpage = "login";
  constructor(
-    private vaultTimeoutService: VaultTimeoutService,
    private router: Router,
    private stateService: StateService,
  ) {}

  async canActivate() {
-    if (await this.vaultTimeoutService.isLocked()) {
-      return true;
-    }
-
    const redirectUrl = (await this.stateService.getIsAuthenticated())
      ? [this.homepage]
      : [this.loginpage];
--- a/jslib/angular/src/services/unauth-guard.service.ts
+++ b/jslib/angular/src/services/unauth-guard.service.ts
@@ -2,13 +2,11 @@ import { Injectable } from "@angular/core";
 import { Router } from "@angular/router";

 import { StateService } from "@/jslib/common/src/abstractions/state.service";
-import { VaultTimeoutService } from "@/jslib/common/src/abstractions/vaultTimeout.service";

@Injectable()
 export class UnauthGuardService  {
  protected homepage = "vault";
  constructor(
-    private vaultTimeoutService: VaultTimeoutService,
    private router: Router,
    private stateService: StateService,
  ) {}
@@ -16,12 +14,7 @@ export class UnauthGuardService  {
  async canActivate() {
    const isAuthed = await this.stateService.getIsAuthenticated();
    if (isAuthed) {
-      const locked = await this.vaultTimeoutService.isLocked();
-      if (locked) {
-        this.router.navigate(["lock"]);
-      } else {
-        this.router.navigate([this.homepage]);
-      }
+      this.router.navigate([this.homepage]);
      return false;
    }
    return true;
--- a/jslib/common/spec/services/cipher.service.spec.ts
+++ b/jslib/common/spec/services/cipher.service.spec.ts
@@ -1,69 +0,0 @@
-import { Arg, Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
-
-import { ApiService } from "@/jslib/common/src/abstractions/api.service";
-import { CryptoService } from "@/jslib/common/src/abstractions/crypto.service";
-import { FileUploadService } from "@/jslib/common/src/abstractions/fileUpload.service";
-import { I18nService } from "@/jslib/common/src/abstractions/i18n.service";
-import { LogService } from "@/jslib/common/src/abstractions/log.service";
-import { SearchService } from "@/jslib/common/src/abstractions/search.service";
-import { SettingsService } from "@/jslib/common/src/abstractions/settings.service";
-import { StateService } from "@/jslib/common/src/abstractions/state.service";
-import { Utils } from "@/jslib/common/src/misc/utils";
-import { Cipher } from "@/jslib/common/src/models/domain/cipher";
-import { EncArrayBuffer } from "@/jslib/common/src/models/domain/encArrayBuffer";
-import { EncString } from "@/jslib/common/src/models/domain/encString";
-import { SymmetricCryptoKey } from "@/jslib/common/src/models/domain/symmetricCryptoKey";
-import { CipherService } from "@/jslib/common/src/services/cipher.service";
-
-const ENCRYPTED_TEXT = "This data has been encrypted";
-const ENCRYPTED_BYTES = new EncArrayBuffer(Utils.fromUtf8ToArray(ENCRYPTED_TEXT).buffer);
-
-describe("Cipher Service", () => {
-  let cryptoService: SubstituteOf<CryptoService>;
-  let stateService: SubstituteOf<StateService>;
-  let settingsService: SubstituteOf<SettingsService>;
-  let apiService: SubstituteOf<ApiService>;
-  let fileUploadService: SubstituteOf<FileUploadService>;
-  let i18nService: SubstituteOf<I18nService>;
-  let searchService: SubstituteOf<SearchService>;
-  let logService: SubstituteOf<LogService>;
-
-  let cipherService: CipherService;
-
-  beforeEach(() => {
-    cryptoService = Substitute.for<CryptoService>();
-    stateService = Substitute.for<StateService>();
-    settingsService = Substitute.for<SettingsService>();
-    apiService = Substitute.for<ApiService>();
-    fileUploadService = Substitute.for<FileUploadService>();
-    i18nService = Substitute.for<I18nService>();
-    searchService = Substitute.for<SearchService>();
-    logService = Substitute.for<LogService>();
-
-    cryptoService.encryptToBytes(Arg.any(), Arg.any()).resolves(ENCRYPTED_BYTES);
-    cryptoService.encrypt(Arg.any(), Arg.any()).resolves(new EncString(ENCRYPTED_TEXT));
-
-    cipherService = new CipherService(
-      cryptoService,
-      settingsService,
-      apiService,
-      fileUploadService,
-      i18nService,
-      () => searchService,
-      logService,
-      stateService,
-    );
-  });
-
-  it("attachments upload encrypted file contents", async () => {
-    const fileName = "filename";
-    const fileData = new Uint8Array(10).buffer;
-    cryptoService.getOrgKey(Arg.any()).resolves(new SymmetricCryptoKey(new Uint8Array(32).buffer));
-
-    await cipherService.saveAttachmentRawWithServer(new Cipher(), fileName, fileData);
-
-    fileUploadService
-      .received(1)
-      .uploadCipherAttachment(Arg.any(), Arg.any(), new EncString(ENCRYPTED_TEXT), ENCRYPTED_BYTES);
-  });
-});
--- a/jslib/common/src/abstractions/audit.service.ts
+++ b/jslib/common/src/abstractions/audit.service.ts
@@ -1,6 +0,0 @@
-import { BreachAccountResponse } from "../models/response/breachAccountResponse";
-
-export abstract class AuditService {
-  passwordLeaked: (password: string) => Promise<number>;
-  breachedAccounts: (username: string) => Promise<BreachAccountResponse[]>;
-}
--- a/jslib/common/src/abstractions/cipher.service.ts
+++ b/jslib/common/src/abstractions/cipher.service.ts
@@ -1,79 +0,0 @@
-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/jslib/common/src/abstractions/collection.service.ts
+++ b/jslib/common/src/abstractions/collection.service.ts
@@ -1,19 +0,0 @@
-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/jslib/common/src/abstractions/fileUpload.service.ts
+++ b/jslib/common/src/abstractions/fileUpload.service.ts
@@ -1,18 +0,0 @@
-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/jslib/common/src/abstractions/folder.service.ts
+++ b/jslib/common/src/abstractions/folder.service.ts
@@ -1,21 +0,0 @@
-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: () => 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/jslib/common/src/abstractions/passwordGeneration.service.ts
+++ b/jslib/common/src/abstractions/passwordGeneration.service.ts
@@ -10,7 +10,6 @@ export abstract class PasswordGenerationService {
  enforcePasswordGeneratorPoliciesOnOptions: (
    options: any,
  ) => Promise<[any, PasswordGeneratorPolicyOptions]>;
-  getPasswordGeneratorPolicyOptions: () => Promise<PasswordGeneratorPolicyOptions>;
  saveOptions: (options: any) => Promise<any>;
  getHistory: () => Promise<GeneratedPasswordHistory[]>;
  addHistory: (password: string) => Promise<any>;
--- a/jslib/common/src/abstractions/policy.service.ts
+++ b/jslib/common/src/abstractions/policy.service.ts
@@ -1,32 +0,0 @@
-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/jslib/common/src/abstractions/provider.service.ts
+++ b/jslib/common/src/abstractions/provider.service.ts
@@ -1,8 +0,0 @@
-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/jslib/common/src/abstractions/send.service.ts
+++ b/jslib/common/src/abstractions/send.service.ts
@@ -1,25 +0,0 @@
-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/jslib/common/src/abstractions/sync.service.ts
+++ b/jslib/common/src/abstractions/sync.service.ts
@@ -1,7 +1,4 @@
 import {
-  SyncCipherNotification,
-  SyncFolderNotification,
-  SyncSendNotification,
 } from "../models/response/notificationResponse";

 export abstract class SyncService {
@@ -10,10 +7,4 @@ export abstract class SyncService {
  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/jslib/common/src/abstractions/totp.service.ts
+++ b/jslib/common/src/abstractions/totp.service.ts
@@ -1,5 +0,0 @@
-export abstract class TotpService {
-  getCode: (key: string) => Promise<string>;
-  getTimeInterval: (key: string) => number;
-  isAutoCopyEnabled: () => Promise<boolean>;
-}
--- a/jslib/common/src/abstractions/usernameGeneration.service.ts
+++ b/jslib/common/src/abstractions/usernameGeneration.service.ts
@@ -1,8 +0,0 @@
-export abstract class UsernameGenerationService {
-  generateUsername: (options: any) => Promise<string>;
-  generateWord: (options: any) => Promise<string>;
-  generateSubaddress: (options: any) => Promise<string>;
-  generateCatchall: (options: any) => Promise<string>;
-  getOptions: () => Promise<any>;
-  saveOptions: (options: any) => Promise<void>;
-}
--- a/jslib/common/src/abstractions/vaultTimeout.service.ts
+++ b/jslib/common/src/abstractions/vaultTimeout.service.ts
@@ -1,11 +0,0 @@
-export abstract class VaultTimeoutService {
-  isLocked: (userId?: string) => Promise<boolean>;
-  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/jslib/common/src/services/audit.service.ts
+++ b/jslib/common/src/services/audit.service.ts
@@ -1,44 +0,0 @@
-import { ApiService } from "../abstractions/api.service";
-import { AuditService as AuditServiceAbstraction } from "../abstractions/audit.service";
-import { CryptoFunctionService } from "../abstractions/cryptoFunction.service";
-import { throttle } from "../misc/throttle";
-import { Utils } from "../misc/utils";
-import { BreachAccountResponse } from "../models/response/breachAccountResponse";
-import { ErrorResponse } from "../models/response/errorResponse";
-
-const PwnedPasswordsApi = "https://api.pwnedpasswords.com/range/";
-
-export class AuditService implements AuditServiceAbstraction {
-  constructor(
-    private cryptoFunctionService: CryptoFunctionService,
-    private apiService: ApiService,
-  ) {}
-
-  @throttle(100, () => "passwordLeaked")
-  async passwordLeaked(password: string): Promise<number> {
-    const hashBytes = await this.cryptoFunctionService.hash(password, "sha1");
-    const hash = Utils.fromBufferToHex(hashBytes).toUpperCase();
-    const hashStart = hash.substr(0, 5);
-    const hashEnding = hash.substr(5);
-
-    const response = await this.apiService.nativeFetch(new Request(PwnedPasswordsApi + hashStart));
-    const leakedHashes = await response.text();
-    const match = leakedHashes.split(/\r?\n/).find((v) => {
-      return v.split(":")[0] === hashEnding;
-    });
-
-    return match != null ? parseInt(match.split(":")[1], 10) : 0;
-  }
-
-  async breachedAccounts(username: string): Promise<BreachAccountResponse[]> {
-    try {
-      return await this.apiService.getHibpBreach(username);
-    } catch (e) {
-      const error = e as ErrorResponse;
-      if (error.statusCode === 404) {
-        return [];
-      }
-      throw new Error();
-    }
-  }
-}
--- a/jslib/common/src/services/azureFileUpload.service.ts
+++ b/jslib/common/src/services/azureFileUpload.service.ts
@@ -1,214 +0,0 @@
-import { LogService } from "../abstractions/log.service";
-import { Utils } from "../misc/utils";
-import { EncArrayBuffer } from "../models/domain/encArrayBuffer";
-
-const MAX_SINGLE_BLOB_UPLOAD_SIZE = 256 * 1024 * 1024; // 256 MiB
-const MAX_BLOCKS_PER_BLOB = 50000;
-
-export class AzureFileUploadService {
-  constructor(private logService: LogService) {}
-
-  async upload(url: string, data: EncArrayBuffer, renewalCallback: () => Promise<string>) {
-    if (data.buffer.byteLength <= MAX_SINGLE_BLOB_UPLOAD_SIZE) {
-      return await this.azureUploadBlob(url, data);
-    } else {
-      return await this.azureUploadBlocks(url, data, renewalCallback);
-    }
-  }
-  private async azureUploadBlob(url: string, data: EncArrayBuffer) {
-    const urlObject = Utils.getUrl(url);
-    const headers = new Headers({
-      "x-ms-date": new Date().toUTCString(),
-      "x-ms-version": urlObject.searchParams.get("sv"),
-      "Content-Length": data.buffer.byteLength.toString(),
-      "x-ms-blob-type": "BlockBlob",
-    });
-
-    const request = new Request(url, {
-      body: data.buffer,
-      cache: "no-store",
-      method: "PUT",
-      headers: headers,
-    });
-
-    const blobResponse = await fetch(request);
-
-    if (blobResponse.status !== 201) {
-      throw new Error(`Failed to create Azure blob: ${blobResponse.status}`);
-    }
-  }
-  private async azureUploadBlocks(
-    url: string,
-    data: EncArrayBuffer,
-    renewalCallback: () => Promise<string>,
-  ) {
-    const baseUrl = Utils.getUrl(url);
-    const blockSize = this.getMaxBlockSize(baseUrl.searchParams.get("sv"));
-    let blockIndex = 0;
-    const numBlocks = Math.ceil(data.buffer.byteLength / blockSize);
-    const blocksStaged: string[] = [];
-
-    if (numBlocks > MAX_BLOCKS_PER_BLOB) {
-      throw new Error(
-        `Cannot upload file, exceeds maximum size of ${blockSize * MAX_BLOCKS_PER_BLOB}`,
-      );
-    }
-
-    // eslint-disable-next-line
-    try {
-      while (blockIndex < numBlocks) {
-        url = await this.renewUrlIfNecessary(url, renewalCallback);
-        const blockUrl = Utils.getUrl(url);
-        const blockId = this.encodedBlockId(blockIndex);
-        blockUrl.searchParams.append("comp", "block");
-        blockUrl.searchParams.append("blockid", blockId);
-        const start = blockIndex * blockSize;
-        const blockData = data.buffer.slice(start, start + blockSize);
-        const blockHeaders = new Headers({
-          "x-ms-date": new Date().toUTCString(),
-          "x-ms-version": blockUrl.searchParams.get("sv"),
-          "Content-Length": blockData.byteLength.toString(),
-        });
-
-        const blockRequest = new Request(blockUrl.toString(), {
-          body: blockData,
-          cache: "no-store",
-          method: "PUT",
-          headers: blockHeaders,
-        });
-
-        const blockResponse = await fetch(blockRequest);
-
-        if (blockResponse.status !== 201) {
-          const message = `Unsuccessful block PUT. Received status ${blockResponse.status}`;
-          this.logService.error(message + "\n" + (await blockResponse.json()));
-          throw new Error(message);
-        }
-
-        blocksStaged.push(blockId);
-        blockIndex++;
-      }
-
-      url = await this.renewUrlIfNecessary(url, renewalCallback);
-      const blockListUrl = Utils.getUrl(url);
-      const blockListXml = this.blockListXml(blocksStaged);
-      blockListUrl.searchParams.append("comp", "blocklist");
-      const headers = new Headers({
-        "x-ms-date": new Date().toUTCString(),
-        "x-ms-version": blockListUrl.searchParams.get("sv"),
-        "Content-Length": blockListXml.length.toString(),
-      });
-
-      const request = new Request(blockListUrl.toString(), {
-        body: blockListXml,
-        cache: "no-store",
-        method: "PUT",
-        headers: headers,
-      });
-
-      const response = await fetch(request);
-
-      if (response.status !== 201) {
-        const message = `Unsuccessful block list PUT. Received status ${response.status}`;
-        this.logService.error(message + "\n" + (await response.json()));
-        throw new Error(message);
-      }
-    } catch (e) {
-      throw e;
-    }
-  }
-
-  private async renewUrlIfNecessary(
-    url: string,
-    renewalCallback: () => Promise<string>,
-  ): Promise<string> {
-    const urlObject = Utils.getUrl(url);
-    const expiry = new Date(urlObject.searchParams.get("se") ?? "");
-
-    if (isNaN(expiry.getTime())) {
-      expiry.setTime(Date.now() + 3600000);
-    }
-
-    if (expiry.getTime() < Date.now() + 1000) {
-      return await renewalCallback();
-    }
-    return url;
-  }
-
-  private encodedBlockId(blockIndex: number) {
-    // Encoded blockId max size is 64, so pre-encoding max size is 48
-    const utfBlockId = (
-      "000000000000000000000000000000000000000000000000" + blockIndex.toString()
-    ).slice(-48);
-    return Utils.fromUtf8ToB64(utfBlockId);
-  }
-
-  private blockListXml(blockIdList: string[]) {
-    let xml = '<?xml version="1.0" encoding="utf-8"?><BlockList>';
-    blockIdList.forEach((blockId) => {
-      xml += `<Latest>${blockId}</Latest>`;
-    });
-    xml += "</BlockList>";
-    return xml;
-  }
-
-  private getMaxBlockSize(version: string) {
-    if (Version.compare(version, "2019-12-12") >= 0) {
-      return 4000 * 1024 * 1024; // 4000 MiB
-    } else if (Version.compare(version, "2016-05-31") >= 0) {
-      return 100 * 1024 * 1024; // 100 MiB
-    } else {
-      return 4 * 1024 * 1024; // 4 MiB
-    }
-  }
-}
-
-class Version {
-  /**
-   * Compares two Azure Versions against each other
-   * @param a Version to compare
-   * @param b Version to compare
-   * @returns a number less than zero if b is newer than a, 0 if equal,
-   * and greater than zero if a is newer than b
-   */
-  static compare(a: Required<Version> | string, b: Required<Version> | string) {
-    if (typeof a === "string") {
-      a = new Version(a);
-    }
-
-    if (typeof b === "string") {
-      b = new Version(b);
-    }
-
-    return a.year !== b.year
-      ? a.year - b.year
-      : a.month !== b.month
-        ? a.month - b.month
-        : a.day !== b.day
-          ? a.day - b.day
-          : 0;
-  }
-  year = 0;
-  month = 0;
-  day = 0;
-
-  constructor(version: string) {
-    try {
-      const parts = version.split("-").map((v) => Number.parseInt(v, 10));
-      this.year = parts[0];
-      this.month = parts[1];
-      this.day = parts[2];
-    } catch {
-      // Ignore error
-    }
-  }
-  /**
-   * Compares two Azure Versions against each other
-   * @param compareTo Version to compare against
-   * @returns a number less than zero if compareTo is newer, 0 if equal,
-   * and greater than zero if this is greater than compareTo
-   */
-  compare(compareTo: Required<Version> | string) {
-    return Version.compare(this, compareTo);
-  }
-}
--- a/jslib/common/src/services/bitwardenFileUpload.service.ts
+++ b/jslib/common/src/services/bitwardenFileUpload.service.ts
@@ -1,34 +0,0 @@
-import { ApiService } from "../abstractions/api.service";
-import { Utils } from "../misc/utils";
-import { EncArrayBuffer } from "../models/domain/encArrayBuffer";
-
-export class BitwardenFileUploadService {
-  constructor(private apiService: ApiService) {}
-
-  async upload(
-    encryptedFileName: string,
-    encryptedFileData: EncArrayBuffer,
-    apiCall: (fd: FormData) => Promise<any>,
-  ) {
-    const fd = new FormData();
-    try {
-      const blob = new Blob([encryptedFileData.buffer], { type: "application/octet-stream" });
-      fd.append("data", blob, encryptedFileName);
-    } catch (e) {
-      if (Utils.isNode && !Utils.isBrowser) {
-        fd.append(
-          "data",
-          Buffer.from(encryptedFileData.buffer) as any,
-          {
-            filepath: encryptedFileName,
-            contentType: "application/octet-stream",
-          } as any,
-        );
-      } else {
-        throw e;
-      }
-    }
-
-    await apiCall(fd);
-  }
-}
--- a/jslib/common/src/services/cipher.service.ts
+++ b/jslib/common/src/services/cipher.service.ts
--- a/jslib/common/src/services/collection.service.ts
+++ b/jslib/common/src/services/collection.service.ts
@@ -1,157 +0,0 @@
-import { CollectionService as CollectionServiceAbstraction } from "../abstractions/collection.service";
-import { CryptoService } from "../abstractions/crypto.service";
-import { I18nService } from "../abstractions/i18n.service";
-import { StateService } from "../abstractions/state.service";
-import { ServiceUtils } from "../misc/serviceUtils";
-import { Utils } from "../misc/utils";
-import { CollectionData } from "../models/data/collectionData";
-import { Collection } from "../models/domain/collection";
-import { TreeNode } from "../models/domain/treeNode";
-import { CollectionView } from "../models/view/collectionView";
-
-const NestingDelimiter = "/";
-
-export class CollectionService implements CollectionServiceAbstraction {
-  constructor(
-    private cryptoService: CryptoService,
-    private i18nService: I18nService,
-    private stateService: StateService,
-  ) {}
-
-  async clearCache(userId?: string): Promise<void> {
-    await this.stateService.setDecryptedCollections(null, { userId: userId });
-  }
-
-  async encrypt(model: CollectionView): Promise<Collection> {
-    if (model.organizationId == null) {
-      throw new Error("Collection has no organization id.");
-    }
-    const key = await this.cryptoService.getOrgKey(model.organizationId);
-    if (key == null) {
-      throw new Error("No key for this collection's organization.");
-    }
-    const collection = new Collection();
-    collection.id = model.id;
-    collection.organizationId = model.organizationId;
-    collection.readOnly = model.readOnly;
-    collection.name = await this.cryptoService.encrypt(model.name, key);
-    return collection;
-  }
-
-  async decryptMany(collections: Collection[]): Promise<CollectionView[]> {
-    if (collections == null) {
-      return [];
-    }
-    const decCollections: CollectionView[] = [];
-    const promises: Promise<any>[] = [];
-    collections.forEach((collection) => {
-      promises.push(collection.decrypt().then((c) => decCollections.push(c)));
-    });
-    await Promise.all(promises);
-    return decCollections.sort(Utils.getSortFunction(this.i18nService, "name"));
-  }
-
-  async get(id: string): Promise<Collection> {
-    const collections = await this.stateService.getEncryptedCollections();
-    // eslint-disable-next-line
-    if (collections == null || !collections.hasOwnProperty(id)) {
-      return null;
-    }
-
-    return new Collection(collections[id]);
-  }
-
-  async getAll(): Promise<Collection[]> {
-    const collections = await this.stateService.getEncryptedCollections();
-    const response: Collection[] = [];
-    for (const id in collections) {
-      // eslint-disable-next-line
-      if (collections.hasOwnProperty(id)) {
-        response.push(new Collection(collections[id]));
-      }
-    }
-    return response;
-  }
-
-  async getAllDecrypted(): Promise<CollectionView[]> {
-    let decryptedCollections = await this.stateService.getDecryptedCollections();
-    if (decryptedCollections != null) {
-      return decryptedCollections;
-    }
-
-    const hasKey = await this.cryptoService.hasKey();
-    if (!hasKey) {
-      throw new Error("No key.");
-    }
-
-    const collections = await this.getAll();
-    decryptedCollections = await this.decryptMany(collections);
-    await this.stateService.setDecryptedCollections(decryptedCollections);
-    return decryptedCollections;
-  }
-
-  async getAllNested(collections: CollectionView[] = null): Promise<TreeNode<CollectionView>[]> {
-    if (collections == null) {
-      collections = await this.getAllDecrypted();
-    }
-    const nodes: TreeNode<CollectionView>[] = [];
-    collections.forEach((c) => {
-      const collectionCopy = new CollectionView();
-      collectionCopy.id = c.id;
-      collectionCopy.organizationId = c.organizationId;
-      const parts = c.name != null ? c.name.replace(/^\/+|\/+$/g, "").split(NestingDelimiter) : [];
-      ServiceUtils.nestedTraverse(nodes, 0, parts, collectionCopy, null, NestingDelimiter);
-    });
-    return nodes;
-  }
-
-  async getNested(id: string): Promise<TreeNode<CollectionView>> {
-    const collections = await this.getAllNested();
-    return ServiceUtils.getTreeNodeObject(collections, id) as TreeNode<CollectionView>;
-  }
-
-  async upsert(collection: CollectionData | CollectionData[]): Promise<any> {
-    let collections = await this.stateService.getEncryptedCollections();
-    if (collections == null) {
-      collections = {};
-    }
-
-    if (collection instanceof CollectionData) {
-      const c = collection as CollectionData;
-      collections[c.id] = c;
-    } else {
-      (collection as CollectionData[]).forEach((c) => {
-        collections[c.id] = c;
-      });
-    }
-
-    await this.replace(collections);
-  }
-
-  async replace(collections: { [id: string]: CollectionData }): Promise<any> {
-    await this.clearCache();
-    await this.stateService.setEncryptedCollections(collections);
-  }
-
-  async clear(userId?: string): Promise<any> {
-    await this.clearCache(userId);
-    await this.stateService.setEncryptedCollections(null, { userId: userId });
-  }
-
-  async delete(id: string | string[]): Promise<any> {
-    const collections = await this.stateService.getEncryptedCollections();
-    if (collections == null) {
-      return;
-    }
-
-    if (typeof id === "string") {
-      delete collections[id];
-    } else {
-      (id as string[]).forEach((i) => {
-        delete collections[i];
-      });
-    }
-
-    await this.replace(collections);
-  }
-}
--- a/jslib/common/src/services/event.service.ts
+++ b/jslib/common/src/services/event.service.ts
@@ -1,5 +1,4 @@
 import { ApiService } from "../abstractions/api.service";
-import { CipherService } from "../abstractions/cipher.service";
 import { EventService as EventServiceAbstraction } from "../abstractions/event.service";
 import { LogService } from "../abstractions/log.service";
 import { OrganizationService } from "../abstractions/organization.service";
@@ -13,7 +12,6 @@ export class EventService implements EventServiceAbstraction {

  constructor(
    private apiService: ApiService,
-    private cipherService: CipherService,
    private stateService: StateService,
    private logService: LogService,
    private organizationService: OrganizationService,
@@ -48,12 +46,6 @@ export class EventService implements EventServiceAbstraction {
    if (orgIds.size === 0) {
      return;
    }
-    if (cipherId != null) {
-      const cipher = await this.cipherService.get(cipherId);
-      if (cipher == null || cipher.organizationId == null || !orgIds.has(cipher.organizationId)) {
-        return;
-      }
-    }
    let eventCollection = await this.stateService.getEventCollection();
    if (eventCollection == null) {
      eventCollection = [];
--- a/jslib/common/src/services/fileUpload.service.ts
+++ b/jslib/common/src/services/fileUpload.service.ts
@@ -1,111 +0,0 @@
-import { ApiService } from "../abstractions/api.service";
-import { FileUploadService as FileUploadServiceAbstraction } from "../abstractions/fileUpload.service";
-import { LogService } from "../abstractions/log.service";
-import { FileUploadType } from "../enums/fileUploadType";
-import { EncArrayBuffer } from "../models/domain/encArrayBuffer";
-import { EncString } from "../models/domain/encString";
-import { AttachmentUploadDataResponse } from "../models/response/attachmentUploadDataResponse";
-import { SendFileUploadDataResponse } from "../models/response/sendFileUploadDataResponse";
-
-import { AzureFileUploadService } from "./azureFileUpload.service";
-import { BitwardenFileUploadService } from "./bitwardenFileUpload.service";
-
-export class FileUploadService implements FileUploadServiceAbstraction {
-  private azureFileUploadService: AzureFileUploadService;
-  private bitwardenFileUploadService: BitwardenFileUploadService;
-
-  constructor(
-    private logService: LogService,
-    private apiService: ApiService,
-  ) {
-    this.azureFileUploadService = new AzureFileUploadService(logService);
-    this.bitwardenFileUploadService = new BitwardenFileUploadService(apiService);
-  }
-
-  async uploadSendFile(
-    uploadData: SendFileUploadDataResponse,
-    fileName: EncString,
-    encryptedFileData: EncArrayBuffer,
-  ) {
-    try {
-      switch (uploadData.fileUploadType) {
-        case FileUploadType.Direct:
-          await this.bitwardenFileUploadService.upload(
-            fileName.encryptedString,
-            encryptedFileData,
-            (fd) =>
-              this.apiService.postSendFile(
-                uploadData.sendResponse.id,
-                uploadData.sendResponse.file.id,
-                fd,
-              ),
-          );
-          break;
-        case FileUploadType.Azure: {
-          const renewalCallback = async () => {
-            const renewalResponse = await this.apiService.renewSendFileUploadUrl(
-              uploadData.sendResponse.id,
-              uploadData.sendResponse.file.id,
-            );
-            return renewalResponse.url;
-          };
-          await this.azureFileUploadService.upload(
-            uploadData.url,
-            encryptedFileData,
-            renewalCallback,
-          );
-          break;
-        }
-        default:
-          throw new Error("Unknown file upload type");
-      }
-    } catch (e) {
-      await this.apiService.deleteSend(uploadData.sendResponse.id);
-      throw e;
-    }
-  }
-
-  async uploadCipherAttachment(
-    admin: boolean,
-    uploadData: AttachmentUploadDataResponse,
-    encryptedFileName: EncString,
-    encryptedFileData: EncArrayBuffer,
-  ) {
-    const response = admin ? uploadData.cipherMiniResponse : uploadData.cipherResponse;
-    try {
-      switch (uploadData.fileUploadType) {
-        case FileUploadType.Direct:
-          await this.bitwardenFileUploadService.upload(
-            encryptedFileName.encryptedString,
-            encryptedFileData,
-            (fd) => this.apiService.postAttachmentFile(response.id, uploadData.attachmentId, fd),
-          );
-          break;
-        case FileUploadType.Azure: {
-          const renewalCallback = async () => {
-            const renewalResponse = await this.apiService.renewAttachmentUploadUrl(
-              response.id,
-              uploadData.attachmentId,
-            );
-            return renewalResponse.url;
-          };
-          await this.azureFileUploadService.upload(
-            uploadData.url,
-            encryptedFileData,
-            renewalCallback,
-          );
-          break;
-        }
-        default:
-          throw new Error("Unknown file upload type.");
-      }
-    } catch (e) {
-      if (admin) {
-        await this.apiService.deleteCipherAttachmentAdmin(response.id, uploadData.attachmentId);
-      } else {
-        await this.apiService.deleteCipherAttachment(response.id, uploadData.attachmentId);
-      }
-      throw e;
-    }
-  }
-}
--- a/jslib/common/src/services/folder.service.ts
+++ b/jslib/common/src/services/folder.service.ts
@@ -1,194 +0,0 @@
-import { ApiService } from "../abstractions/api.service";
-import { CipherService } from "../abstractions/cipher.service";
-import { CryptoService } from "../abstractions/crypto.service";
-import { FolderService as FolderServiceAbstraction } from "../abstractions/folder.service";
-import { I18nService } from "../abstractions/i18n.service";
-import { StateService } from "../abstractions/state.service";
-import { ServiceUtils } from "../misc/serviceUtils";
-import { Utils } from "../misc/utils";
-import { CipherData } from "../models/data/cipherData";
-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 { FolderRequest } from "../models/request/folderRequest";
-import { FolderResponse } from "../models/response/folderResponse";
-import { FolderView } from "../models/view/folderView";
-
-const NestingDelimiter = "/";
-
-export class FolderService implements FolderServiceAbstraction {
-  constructor(
-    private cryptoService: CryptoService,
-    private apiService: ApiService,
-    private i18nService: I18nService,
-    private cipherService: CipherService,
-    private stateService: StateService,
-  ) {}
-
-  async clearCache(userId?: string): Promise<void> {
-    await this.stateService.setDecryptedFolders(null, { userId: userId });
-  }
-
-  async encrypt(model: FolderView, key?: SymmetricCryptoKey): Promise<Folder> {
-    const folder = new Folder();
-    folder.id = model.id;
-    folder.name = await this.cryptoService.encrypt(model.name, key);
-    return folder;
-  }
-
-  async get(id: string): Promise<Folder> {
-    const folders = await this.stateService.getEncryptedFolders();
-    // eslint-disable-next-line
-    if (folders == null || !folders.hasOwnProperty(id)) {
-      return null;
-    }
-
-    return new Folder(folders[id]);
-  }
-
-  async getAll(): Promise<Folder[]> {
-    const folders = await this.stateService.getEncryptedFolders();
-    const response: Folder[] = [];
-    for (const id in folders) {
-      // eslint-disable-next-line
-      if (folders.hasOwnProperty(id)) {
-        response.push(new Folder(folders[id]));
-      }
-    }
-    return response;
-  }
-
-  async getAllDecrypted(): Promise<FolderView[]> {
-    const decryptedFolders = await this.stateService.getDecryptedFolders();
-    if (decryptedFolders != null) {
-      return decryptedFolders;
-    }
-
-    const hasKey = await this.cryptoService.hasKey();
-    if (!hasKey) {
-      throw new Error("No key.");
-    }
-
-    const decFolders: FolderView[] = [];
-    const promises: Promise<any>[] = [];
-    const folders = await this.getAll();
-    folders.forEach((folder) => {
-      promises.push(folder.decrypt().then((f) => decFolders.push(f)));
-    });
-
-    await Promise.all(promises);
-    decFolders.sort(Utils.getSortFunction(this.i18nService, "name"));
-
-    const noneFolder = new FolderView();
-    noneFolder.name = this.i18nService.t("noneFolder");
-    decFolders.push(noneFolder);
-
-    await this.stateService.setDecryptedFolders(decFolders);
-    return decFolders;
-  }
-
-  async getAllNested(): Promise<TreeNode<FolderView>[]> {
-    const folders = await this.getAllDecrypted();
-    const nodes: TreeNode<FolderView>[] = [];
-    folders.forEach((f) => {
-      const folderCopy = new FolderView();
-      folderCopy.id = f.id;
-      folderCopy.revisionDate = f.revisionDate;
-      const parts = f.name != null ? f.name.replace(/^\/+|\/+$/g, "").split(NestingDelimiter) : [];
-      ServiceUtils.nestedTraverse(nodes, 0, parts, folderCopy, null, NestingDelimiter);
-    });
-    return nodes;
-  }
-
-  async getNested(id: string): Promise<TreeNode<FolderView>> {
-    const folders = await this.getAllNested();
-    return ServiceUtils.getTreeNodeObject(folders, id) as TreeNode<FolderView>;
-  }
-
-  async saveWithServer(folder: Folder): Promise<any> {
-    const request = new FolderRequest(folder);
-
-    let response: FolderResponse;
-    if (folder.id == null) {
-      response = await this.apiService.postFolder(request);
-      folder.id = response.id;
-    } else {
-      response = await this.apiService.putFolder(folder.id, request);
-    }
-
-    const userId = await this.stateService.getUserId();
-    const data = new FolderData(response, userId);
-    await this.upsert(data);
-  }
-
-  async upsert(folder: FolderData | FolderData[]): Promise<any> {
-    let folders = await this.stateService.getEncryptedFolders();
-    if (folders == null) {
-      folders = {};
-    }
-
-    if (folder instanceof FolderData) {
-      const f = folder as FolderData;
-      folders[f.id] = f;
-    } else {
-      (folder as FolderData[]).forEach((f) => {
-        folders[f.id] = f;
-      });
-    }
-
-    await this.stateService.setDecryptedFolders(null);
-    await this.stateService.setEncryptedFolders(folders);
-  }
-
-  async replace(folders: { [id: string]: FolderData }): Promise<any> {
-    await this.stateService.setDecryptedFolders(null);
-    await this.stateService.setEncryptedFolders(folders);
-  }
-
-  async clear(userId?: string): Promise<any> {
-    await this.stateService.setDecryptedFolders(null, { userId: userId });
-    await this.stateService.setEncryptedFolders(null, { userId: userId });
-  }
-
-  async delete(id: string | string[]): Promise<any> {
-    const folders = await this.stateService.getEncryptedFolders();
-    if (folders == null) {
-      return;
-    }
-
-    if (typeof id === "string") {
-      if (folders[id] == null) {
-        return;
-      }
-      delete folders[id];
-    } else {
-      (id as string[]).forEach((i) => {
-        delete folders[i];
-      });
-    }
-
-    await this.stateService.setDecryptedFolders(null);
-    await this.stateService.setEncryptedFolders(folders);
-
-    // Items in a deleted folder are re-assigned to "No Folder"
-    const ciphers = await this.stateService.getEncryptedCiphers();
-    if (ciphers != null) {
-      const updates: CipherData[] = [];
-      for (const cId in ciphers) {
-        if (ciphers[cId].folderId === id) {
-          ciphers[cId].folderId = null;
-          updates.push(ciphers[cId]);
-        }
-      }
-      if (updates.length > 0) {
-        this.cipherService.upsert(updates);
-      }
-    }
-  }
-
-  async deleteWithServer(id: string): Promise<any> {
-    await this.apiService.deleteFolder(id);
-    await this.delete(id);
-  }
-}
--- a/jslib/common/src/services/notifications.service.ts
+++ b/jslib/common/src/services/notifications.service.ts
@@ -8,13 +8,9 @@ import { LogService } from "../abstractions/log.service";
 import { NotificationsService as NotificationsServiceAbstraction } from "../abstractions/notifications.service";
 import { StateService } from "../abstractions/state.service";
 import { SyncService } from "../abstractions/sync.service";
-import { VaultTimeoutService } from "../abstractions/vaultTimeout.service";
 import { NotificationType } from "../enums/notificationType";
 import {
  NotificationResponse,
-  SyncCipherNotification,
-  SyncFolderNotification,
-  SyncSendNotification,
 } from "../models/response/notificationResponse";

 export class NotificationsService implements NotificationsServiceAbstraction {
@@ -29,7 +25,6 @@ export class NotificationsService implements NotificationsServiceAbstraction {
    private syncService: SyncService,
    private appIdService: AppIdService,
    private apiService: ApiService,
-    private vaultTimeoutService: VaultTimeoutService,
    private environmentService: EnvironmentService,
    private logoutCallback: () => Promise<void>,
    private logService: LogService,
@@ -132,27 +127,6 @@ export class NotificationsService implements NotificationsServiceAbstraction {
    }

    switch (notification.type) {
-      case NotificationType.SyncCipherCreate:
-      case NotificationType.SyncCipherUpdate:
-        await this.syncService.syncUpsertCipher(
-          notification.payload as SyncCipherNotification,
-          notification.type === NotificationType.SyncCipherUpdate,
-        );
-        break;
-      case NotificationType.SyncCipherDelete:
-      case NotificationType.SyncLoginDelete:
-        await this.syncService.syncDeleteCipher(notification.payload as SyncCipherNotification);
-        break;
-      case NotificationType.SyncFolderCreate:
-      case NotificationType.SyncFolderUpdate:
-        await this.syncService.syncUpsertFolder(
-          notification.payload as SyncFolderNotification,
-          notification.type === NotificationType.SyncFolderUpdate,
-        );
-        break;
-      case NotificationType.SyncFolderDelete:
-        await this.syncService.syncDeleteFolder(notification.payload as SyncFolderNotification);
-        break;
      case NotificationType.SyncVault:
      case NotificationType.SyncCiphers:
      case NotificationType.SyncSettings:
@@ -172,16 +146,6 @@ export class NotificationsService implements NotificationsServiceAbstraction {
          this.logoutCallback();
        }
        break;
-      case NotificationType.SyncSendCreate:
-      case NotificationType.SyncSendUpdate:
-        await this.syncService.syncUpsertSend(
-          notification.payload as SyncSendNotification,
-          notification.type === NotificationType.SyncSendUpdate,
-        );
-        break;
-      case NotificationType.SyncSendDelete:
-        await this.syncService.syncDeleteSend(notification.payload as SyncSendNotification);
-        break;
      default:
        break;
    }
@@ -216,11 +180,7 @@ export class NotificationsService implements NotificationsServiceAbstraction {
  }

  private async isAuthedAndUnlocked() {
-    if (await this.stateService.getIsAuthenticated()) {
-      const locked = await this.vaultTimeoutService.isLocked();
-      return !locked;
-    }
-    return false;
+    return await this.stateService.getIsAuthenticated()
  }

  private random(min: number, max: number) {
--- a/jslib/common/src/services/passwordGeneration.service.ts
+++ b/jslib/common/src/services/passwordGeneration.service.ts
@@ -2,14 +2,11 @@ import * as zxcvbn from "zxcvbn";

 import { CryptoService } from "../abstractions/crypto.service";
 import { PasswordGenerationService as PasswordGenerationServiceAbstraction } from "../abstractions/passwordGeneration.service";
-import { PolicyService } from "../abstractions/policy.service";
 import { StateService } from "../abstractions/state.service";
-import { PolicyType } from "../enums/policyType";
 import { EEFLongWordList } from "../misc/wordlist";
 import { EncString } from "../models/domain/encString";
 import { GeneratedPasswordHistory } from "../models/domain/generatedPasswordHistory";
 import { PasswordGeneratorPolicyOptions } from "../models/domain/passwordGeneratorPolicyOptions";
-import { Policy } from "../models/domain/policy";

 const DefaultOptions = {
  length: 14,
@@ -34,7 +31,6 @@ const MaxPasswordsInHistory = 100;
 export class PasswordGenerationService implements PasswordGenerationServiceAbstraction {
  constructor(
    private cryptoService: CryptoService,
-    private policyService: PolicyService,
    private stateService: StateService,
  ) {}

@@ -193,146 +189,7 @@ export class PasswordGenerationService implements PasswordGenerationServiceAbstr
  async enforcePasswordGeneratorPoliciesOnOptions(
    options: any,
  ): Promise<[any, PasswordGeneratorPolicyOptions]> {
-    let enforcedPolicyOptions = await this.getPasswordGeneratorPolicyOptions();
-    if (enforcedPolicyOptions != null) {
-      if (options.length < enforcedPolicyOptions.minLength) {
-        options.length = enforcedPolicyOptions.minLength;
-      }
-
-      if (enforcedPolicyOptions.useUppercase) {
-        options.uppercase = true;
-      }
-
-      if (enforcedPolicyOptions.useLowercase) {
-        options.lowercase = true;
-      }
-
-      if (enforcedPolicyOptions.useNumbers) {
-        options.number = true;
-      }
-
-      if (options.minNumber < enforcedPolicyOptions.numberCount) {
-        options.minNumber = enforcedPolicyOptions.numberCount;
-      }
-
-      if (enforcedPolicyOptions.useSpecial) {
-        options.special = true;
-      }
-
-      if (options.minSpecial < enforcedPolicyOptions.specialCount) {
-        options.minSpecial = enforcedPolicyOptions.specialCount;
-      }
-
-      // Must normalize these fields because the receiving call expects all options to pass the current rules
-      if (options.minSpecial + options.minNumber > options.length) {
-        options.minSpecial = options.length - options.minNumber;
-      }
-
-      if (options.numWords < enforcedPolicyOptions.minNumberWords) {
-        options.numWords = enforcedPolicyOptions.minNumberWords;
-      }
-
-      if (enforcedPolicyOptions.capitalize) {
-        options.capitalize = true;
-      }
-
-      if (enforcedPolicyOptions.includeNumber) {
-        options.includeNumber = true;
-      }
-
-      // Force default type if password/passphrase selected via policy
-      if (
-        enforcedPolicyOptions.defaultType === "password" ||
-        enforcedPolicyOptions.defaultType === "passphrase"
-      ) {
-        options.type = enforcedPolicyOptions.defaultType;
-      }
-    } else {
-      // UI layer expects an instantiated object to prevent more explicit null checks
-      enforcedPolicyOptions = new PasswordGeneratorPolicyOptions();
-    }
-    return [options, enforcedPolicyOptions];
-  }
-
-  async getPasswordGeneratorPolicyOptions(): Promise<PasswordGeneratorPolicyOptions> {
-    const policies: Policy[] =
-      this.policyService == null
-        ? null
-        : await this.policyService.getAll(PolicyType.PasswordGenerator);
-    let enforcedOptions: PasswordGeneratorPolicyOptions = null;
-
-    if (policies == null || policies.length === 0) {
-      return enforcedOptions;
-    }
-
-    policies.forEach((currentPolicy) => {
-      if (!currentPolicy.enabled || currentPolicy.data == null) {
-        return;
-      }
-
-      if (enforcedOptions == null) {
-        enforcedOptions = new PasswordGeneratorPolicyOptions();
-      }
-
-      // Password wins in multi-org collisions
-      if (currentPolicy.data.defaultType != null && enforcedOptions.defaultType !== "password") {
-        enforcedOptions.defaultType = currentPolicy.data.defaultType;
-      }
-
-      if (
-        currentPolicy.data.minLength != null &&
-        currentPolicy.data.minLength > enforcedOptions.minLength
-      ) {
-        enforcedOptions.minLength = currentPolicy.data.minLength;
-      }
-
-      if (currentPolicy.data.useUpper) {
-        enforcedOptions.useUppercase = true;
-      }
-
-      if (currentPolicy.data.useLower) {
-        enforcedOptions.useLowercase = true;
-      }
-
-      if (currentPolicy.data.useNumbers) {
-        enforcedOptions.useNumbers = true;
-      }
-
-      if (
-        currentPolicy.data.minNumbers != null &&
-        currentPolicy.data.minNumbers > enforcedOptions.numberCount
-      ) {
-        enforcedOptions.numberCount = currentPolicy.data.minNumbers;
-      }
-
-      if (currentPolicy.data.useSpecial) {
-        enforcedOptions.useSpecial = true;
-      }
-
-      if (
-        currentPolicy.data.minSpecial != null &&
-        currentPolicy.data.minSpecial > enforcedOptions.specialCount
-      ) {
-        enforcedOptions.specialCount = currentPolicy.data.minSpecial;
-      }
-
-      if (
-        currentPolicy.data.minNumberWords != null &&
-        currentPolicy.data.minNumberWords > enforcedOptions.minNumberWords
-      ) {
-        enforcedOptions.minNumberWords = currentPolicy.data.minNumberWords;
-      }
-
-      if (currentPolicy.data.capitalize) {
-        enforcedOptions.capitalize = true;
-      }
-
-      if (currentPolicy.data.includeNumber) {
-        enforcedOptions.includeNumber = true;
-      }
-    });
-
-    return enforcedOptions;
+    return [options, new PasswordGeneratorPolicyOptions()];
  }

  async saveOptions(options: any) {
--- a/jslib/common/src/services/policy.service.ts
+++ b/jslib/common/src/services/policy.service.ts
@@ -1,247 +0,0 @@
-import { ApiService } from "../abstractions/api.service";
-import { OrganizationService } from "../abstractions/organization.service";
-import { PolicyService as PolicyServiceAbstraction } from "../abstractions/policy.service";
-import { StateService } from "../abstractions/state.service";
-import { OrganizationUserStatusType } from "../enums/organizationUserStatusType";
-import { OrganizationUserType } from "../enums/organizationUserType";
-import { PolicyType } from "../enums/policyType";
-import { PolicyData } from "../models/data/policyData";
-import { MasterPasswordPolicyOptions } from "../models/domain/masterPasswordPolicyOptions";
-import { Organization } from "../models/domain/organization";
-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 class PolicyService implements PolicyServiceAbstraction {
-  policyCache: Policy[];
-
-  constructor(
-    private stateService: StateService,
-    private organizationService: OrganizationService,
-    private apiService: ApiService,
-  ) {}
-
-  async clearCache(): Promise<void> {
-    await this.stateService.setDecryptedPolicies(null);
-  }
-
-  async getAll(type?: PolicyType, userId?: string): Promise<Policy[]> {
-    let response: Policy[] = [];
-    const decryptedPolicies = await this.stateService.getDecryptedPolicies({ userId: userId });
-    if (decryptedPolicies != null) {
-      response = decryptedPolicies;
-    } else {
-      const diskPolicies = await this.stateService.getEncryptedPolicies({ userId: userId });
-      for (const id in diskPolicies) {
-        // eslint-disable-next-line
-        if (diskPolicies.hasOwnProperty(id)) {
-          response.push(new Policy(diskPolicies[id]));
-        }
-      }
-      await this.stateService.setDecryptedPolicies(response, { userId: userId });
-    }
-    if (type != null) {
-      return response.filter((policy) => policy.type === type);
-    } else {
-      return response;
-    }
-  }
-
-  async getPolicyForOrganization(policyType: PolicyType, organizationId: string): Promise<Policy> {
-    const org = await this.organizationService.get(organizationId);
-    if (org?.isProviderUser) {
-      const orgPolicies = await this.apiService.getPolicies(organizationId);
-      const policy = orgPolicies.data.find((p) => p.organizationId === organizationId);
-
-      if (policy == null) {
-        return null;
-      }
-
-      return new Policy(new PolicyData(policy));
-    }
-
-    const policies = await this.getAll(policyType);
-    return policies.find((p) => p.organizationId === organizationId);
-  }
-
-  async replace(policies: { [id: string]: PolicyData }): Promise<any> {
-    await this.stateService.setDecryptedPolicies(null);
-    await this.stateService.setEncryptedPolicies(policies);
-  }
-
-  async clear(userId?: string): Promise<any> {
-    await this.stateService.setDecryptedPolicies(null, { userId: userId });
-    await this.stateService.setEncryptedPolicies(null, { userId: userId });
-  }
-
-  async getMasterPasswordPoliciesForInvitedUsers(
-    orgId: string,
-  ): Promise<MasterPasswordPolicyOptions> {
-    const userId = await this.stateService.getUserId();
-    const response = await this.apiService.getPoliciesByInvitedUser(orgId, userId);
-    const policies = await this.mapPoliciesFromToken(response);
-    return this.getMasterPasswordPolicyOptions(policies);
-  }
-
-  async getMasterPasswordPolicyOptions(policies?: Policy[]): Promise<MasterPasswordPolicyOptions> {
-    let enforcedOptions: MasterPasswordPolicyOptions = null;
-
-    if (policies == null) {
-      policies = await this.getAll(PolicyType.MasterPassword);
-    } else {
-      policies = policies.filter((p) => p.type === PolicyType.MasterPassword);
-    }
-
-    if (policies == null || policies.length === 0) {
-      return enforcedOptions;
-    }
-
-    policies.forEach((currentPolicy) => {
-      if (!currentPolicy.enabled || currentPolicy.data == null) {
-        return;
-      }
-
-      if (enforcedOptions == null) {
-        enforcedOptions = new MasterPasswordPolicyOptions();
-      }
-
-      if (
-        currentPolicy.data.minComplexity != null &&
-        currentPolicy.data.minComplexity > enforcedOptions.minComplexity
-      ) {
-        enforcedOptions.minComplexity = currentPolicy.data.minComplexity;
-      }
-
-      if (
-        currentPolicy.data.minLength != null &&
-        currentPolicy.data.minLength > enforcedOptions.minLength
-      ) {
-        enforcedOptions.minLength = currentPolicy.data.minLength;
-      }
-
-      if (currentPolicy.data.requireUpper) {
-        enforcedOptions.requireUpper = true;
-      }
-
-      if (currentPolicy.data.requireLower) {
-        enforcedOptions.requireLower = true;
-      }
-
-      if (currentPolicy.data.requireNumbers) {
-        enforcedOptions.requireNumbers = true;
-      }
-
-      if (currentPolicy.data.requireSpecial) {
-        enforcedOptions.requireSpecial = true;
-      }
-    });
-
-    return enforcedOptions;
-  }
-
-  evaluateMasterPassword(
-    passwordStrength: number,
-    newPassword: string,
-    enforcedPolicyOptions: MasterPasswordPolicyOptions,
-  ): boolean {
-    if (enforcedPolicyOptions == null) {
-      return true;
-    }
-
-    if (
-      enforcedPolicyOptions.minComplexity > 0 &&
-      enforcedPolicyOptions.minComplexity > passwordStrength
-    ) {
-      return false;
-    }
-
-    if (
-      enforcedPolicyOptions.minLength > 0 &&
-      enforcedPolicyOptions.minLength > newPassword.length
-    ) {
-      return false;
-    }
-
-    if (enforcedPolicyOptions.requireUpper && newPassword.toLocaleLowerCase() === newPassword) {
-      return false;
-    }
-
-    if (enforcedPolicyOptions.requireLower && newPassword.toLocaleUpperCase() === newPassword) {
-      return false;
-    }
-
-    if (enforcedPolicyOptions.requireNumbers && !/[0-9]/.test(newPassword)) {
-      return false;
-    }
-
-    // eslint-disable-next-line
-    if (enforcedPolicyOptions.requireSpecial && !/[!@#$%\^&*]/g.test(newPassword)) {
-      return false;
-    }
-
-    return true;
-  }
-
-  getResetPasswordPolicyOptions(
-    policies: Policy[],
-    orgId: string,
-  ): [ResetPasswordPolicyOptions, boolean] {
-    const resetPasswordPolicyOptions = new ResetPasswordPolicyOptions();
-
-    if (policies == null || orgId == null) {
-      return [resetPasswordPolicyOptions, false];
-    }
-
-    const policy = policies.find(
-      (p) => p.organizationId === orgId && p.type === PolicyType.ResetPassword && p.enabled,
-    );
-    resetPasswordPolicyOptions.autoEnrollEnabled = policy?.data?.autoEnrollEnabled ?? false;
-
-    return [resetPasswordPolicyOptions, policy?.enabled ?? false];
-  }
-
-  mapPoliciesFromToken(policiesResponse: ListResponse<PolicyResponse>): Policy[] {
-    if (policiesResponse == null || policiesResponse.data == null) {
-      return null;
-    }
-
-    const policiesData = policiesResponse.data.map((p) => new PolicyData(p));
-    return policiesData.map((p) => new Policy(p));
-  }
-
-  async policyAppliesToUser(
-    policyType: PolicyType,
-    policyFilter?: (policy: Policy) => boolean,
-    userId?: string,
-  ) {
-    const policies = await this.getAll(policyType, userId);
-    const organizations = await this.organizationService.getAll(userId);
-    let filteredPolicies;
-
-    if (policyFilter != null) {
-      filteredPolicies = policies.filter((p) => p.enabled && policyFilter(p));
-    } else {
-      filteredPolicies = policies.filter((p) => p.enabled);
-    }
-
-    const policySet = new Set(filteredPolicies.map((p) => p.organizationId));
-
-    return organizations.some(
-      (o) =>
-        o.enabled &&
-        o.status >= OrganizationUserStatusType.Accepted &&
-        o.usePolicies &&
-        !this.isExcemptFromPolicies(o, policyType) &&
-        policySet.has(o.id),
-    );
-  }
-
-  private isExcemptFromPolicies(organization: Organization, policyType: PolicyType) {
-    if (policyType === PolicyType.MaximumVaultTimeout) {
-      return organization.type === OrganizationUserType.Owner;
-    }
-
-    return organization.isExemptFromPolicies;
-  }
-}
--- a/jslib/common/src/services/provider.service.ts
+++ b/jslib/common/src/services/provider.service.ts
@@ -1,34 +0,0 @@
-import { ProviderService as ProviderServiceAbstraction } from "../abstractions/provider.service";
-import { StateService } from "../abstractions/state.service";
-import { ProviderData } from "../models/data/providerData";
-import { Provider } from "../models/domain/provider";
-
-export class ProviderService implements ProviderServiceAbstraction {
-  constructor(private stateService: StateService) {}
-
-  async get(id: string): Promise<Provider> {
-    const providers = await this.stateService.getProviders();
-    // eslint-disable-next-line
-    if (providers == null || !providers.hasOwnProperty(id)) {
-      return null;
-    }
-
-    return new Provider(providers[id]);
-  }
-
-  async getAll(): Promise<Provider[]> {
-    const providers = await this.stateService.getProviders();
-    const response: Provider[] = [];
-    for (const id in providers) {
-      // eslint-disable-next-line
-      if (providers.hasOwnProperty(id)) {
-        response.push(new Provider(providers[id]));
-      }
-    }
-    return response;
-  }
-
-  async save(providers: { [id: string]: ProviderData }) {
-    await this.stateService.setProviders(providers);
-  }
-}
--- a/jslib/common/src/services/search.service.ts
+++ b/jslib/common/src/services/search.service.ts
@@ -1,6 +1,5 @@
 import * as lunr from "lunr";

-import { CipherService } from "../abstractions/cipher.service";
 import { I18nService } from "../abstractions/i18n.service";
 import { LogService } from "../abstractions/log.service";
 import { SearchService as SearchServiceAbstraction } from "../abstractions/search.service";
@@ -17,7 +16,6 @@ export class SearchService implements SearchServiceAbstraction {
  private searchableMinLength = 2;

  constructor(
-    private cipherService: CipherService,
    private logService: LogService,
    private i18nService: I18nService,
  ) {
@@ -76,7 +74,6 @@ export class SearchService implements SearchServiceAbstraction {
      extractor: (c: CipherView) => this.attachmentExtractor(c, true),
    });
    builder.field("organizationid", { extractor: (c: CipherView) => c.organizationId });
-    ciphers = ciphers || (await this.cipherService.getAllDecrypted());
    ciphers.forEach((c) => builder.add(c));
    this.index = builder.build();

@@ -97,11 +94,6 @@ export class SearchService implements SearchServiceAbstraction {
    if (query === "") {
      query = null;
    }
-
-    if (ciphers == null) {
-      ciphers = await this.cipherService.getAllDecrypted();
-    }
-
    if (filter != null && Array.isArray(filter) && filter.length > 0) {
      ciphers = ciphers.filter((c) => filter.every((f) => f == null || f(c)));
    } else if (filter != null) {
--- a/jslib/common/src/services/send.service.ts
+++ b/jslib/common/src/services/send.service.ts
@@ -1,297 +0,0 @@
-import { ApiService } from "../abstractions/api.service";
-import { CryptoService } from "../abstractions/crypto.service";
-import { CryptoFunctionService } from "../abstractions/cryptoFunction.service";
-import { FileUploadService } from "../abstractions/fileUpload.service";
-import { I18nService } from "../abstractions/i18n.service";
-import { SendService as SendServiceAbstraction } from "../abstractions/send.service";
-import { StateService } from "../abstractions/state.service";
-import { SEND_KDF_ITERATIONS } from "../enums/kdfType";
-import { SendType } from "../enums/sendType";
-import { Utils } from "../misc/utils";
-import { SendData } from "../models/data/sendData";
-import { EncArrayBuffer } from "../models/domain/encArrayBuffer";
-import { EncString } from "../models/domain/encString";
-import { Send } from "../models/domain/send";
-import { SendFile } from "../models/domain/sendFile";
-import { SendText } from "../models/domain/sendText";
-import { SymmetricCryptoKey } from "../models/domain/symmetricCryptoKey";
-import { SendRequest } from "../models/request/sendRequest";
-import { ErrorResponse } from "../models/response/errorResponse";
-import { SendResponse } from "../models/response/sendResponse";
-import { SendView } from "../models/view/sendView";
-
-export class SendService implements SendServiceAbstraction {
-  constructor(
-    private cryptoService: CryptoService,
-    private apiService: ApiService,
-    private fileUploadService: FileUploadService,
-    private i18nService: I18nService,
-    private cryptoFunctionService: CryptoFunctionService,
-    private stateService: StateService,
-  ) {}
-
-  async clearCache(): Promise<void> {
-    await this.stateService.setDecryptedSends(null);
-  }
-
-  async encrypt(
-    model: SendView,
-    file: File | ArrayBuffer,
-    password: string,
-    key?: SymmetricCryptoKey,
-  ): Promise<[Send, EncArrayBuffer]> {
-    let fileData: EncArrayBuffer = null;
-    const send = new Send();
-    send.id = model.id;
-    send.type = model.type;
-    send.disabled = model.disabled;
-    send.hideEmail = model.hideEmail;
-    send.maxAccessCount = model.maxAccessCount;
-    if (model.key == null) {
-      model.key = await this.cryptoFunctionService.randomBytes(16);
-      model.cryptoKey = await this.cryptoService.makeSendKey(model.key);
-    }
-    if (password != null) {
-      const passwordHash = await this.cryptoFunctionService.pbkdf2(
-        password,
-        model.key,
-        "sha256",
-        SEND_KDF_ITERATIONS,
-      );
-      send.password = Utils.fromBufferToB64(passwordHash);
-    }
-    send.key = await this.cryptoService.encrypt(model.key, key);
-    send.name = await this.cryptoService.encrypt(model.name, model.cryptoKey);
-    send.notes = await this.cryptoService.encrypt(model.notes, model.cryptoKey);
-    if (send.type === SendType.Text) {
-      send.text = new SendText();
-      send.text.text = await this.cryptoService.encrypt(model.text.text, model.cryptoKey);
-      send.text.hidden = model.text.hidden;
-    } else if (send.type === SendType.File) {
-      send.file = new SendFile();
-      if (file != null) {
-        if (file instanceof ArrayBuffer) {
-          const [name, data] = await this.encryptFileData(
-            model.file.fileName,
-            file,
-            model.cryptoKey,
-          );
-          send.file.fileName = name;
-          fileData = data;
-        } else {
-          fileData = await this.parseFile(send, file, model.cryptoKey);
-        }
-      }
-    }
-
-    return [send, fileData];
-  }
-
-  async get(id: string): Promise<Send> {
-    const sends = await this.stateService.getEncryptedSends();
-    // eslint-disable-next-line
-    if (sends == null || !sends.hasOwnProperty(id)) {
-      return null;
-    }
-
-    return new Send(sends[id]);
-  }
-
-  async getAll(): Promise<Send[]> {
-    const sends = await this.stateService.getEncryptedSends();
-    const response: Send[] = [];
-    for (const id in sends) {
-      // eslint-disable-next-line
-      if (sends.hasOwnProperty(id)) {
-        response.push(new Send(sends[id]));
-      }
-    }
-    return response;
-  }
-
-  async getAllDecrypted(): Promise<SendView[]> {
-    let decSends = await this.stateService.getDecryptedSends();
-    if (decSends != null) {
-      return decSends;
-    }
-
-    decSends = [];
-    const hasKey = await this.cryptoService.hasKey();
-    if (!hasKey) {
-      throw new Error("No key.");
-    }
-
-    const promises: Promise<any>[] = [];
-    const sends = await this.getAll();
-    sends.forEach((send) => {
-      promises.push(send.decrypt().then((f) => decSends.push(f)));
-    });
-
-    await Promise.all(promises);
-    decSends.sort(Utils.getSortFunction(this.i18nService, "name"));
-
-    await this.stateService.setDecryptedSends(decSends);
-    return decSends;
-  }
-
-  async saveWithServer(sendData: [Send, EncArrayBuffer]): Promise<any> {
-    const request = new SendRequest(sendData[0], sendData[1]?.buffer.byteLength);
-    let response: SendResponse;
-    if (sendData[0].id == null) {
-      if (sendData[0].type === SendType.Text) {
-        response = await this.apiService.postSend(request);
-      } else {
-        try {
-          const uploadDataResponse = await this.apiService.postFileTypeSend(request);
-          response = uploadDataResponse.sendResponse;
-
-          await this.fileUploadService.uploadSendFile(
-            uploadDataResponse,
-            sendData[0].file.fileName,
-            sendData[1],
-          );
-        } catch (e) {
-          if (e instanceof ErrorResponse && (e as ErrorResponse).statusCode === 404) {
-            response = await this.legacyServerSendFileUpload(sendData, request);
-          } else if (e instanceof ErrorResponse) {
-            throw new Error((e as ErrorResponse).getSingleMessage());
-          } else {
-            throw e;
-          }
-        }
-      }
-      sendData[0].id = response.id;
-      sendData[0].accessId = response.accessId;
-    } else {
-      response = await this.apiService.putSend(sendData[0].id, request);
-    }
-
-    const userId = await this.stateService.getUserId();
-    const data = new SendData(response, userId);
-    await this.upsert(data);
-  }
-
-  /**
-   * @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.
-   */
-  async legacyServerSendFileUpload(
-    sendData: [Send, EncArrayBuffer],
-    request: SendRequest,
-  ): Promise<SendResponse> {
-    const fd = new FormData();
-    try {
-      const blob = new Blob([sendData[1].buffer], { type: "application/octet-stream" });
-      fd.append("model", JSON.stringify(request));
-      fd.append("data", blob, sendData[0].file.fileName.encryptedString);
-    } catch (e) {
-      if (Utils.isNode && !Utils.isBrowser) {
-        fd.append("model", JSON.stringify(request));
-        fd.append(
-          "data",
-          Buffer.from(sendData[1].buffer) as any,
-          {
-            filepath: sendData[0].file.fileName.encryptedString,
-            contentType: "application/octet-stream",
-          } as any,
-        );
-      } else {
-        throw e;
-      }
-    }
-    return await this.apiService.postSendFileLegacy(fd);
-  }
-
-  async upsert(send: SendData | SendData[]): Promise<any> {
-    let sends = await this.stateService.getEncryptedSends();
-    if (sends == null) {
-      sends = {};
-    }
-
-    if (send instanceof SendData) {
-      const s = send as SendData;
-      sends[s.id] = s;
-    } else {
-      (send as SendData[]).forEach((s) => {
-        sends[s.id] = s;
-      });
-    }
-
-    await this.replace(sends);
-  }
-
-  async replace(sends: { [id: string]: SendData }): Promise<any> {
-    await this.stateService.setDecryptedSends(null);
-    await this.stateService.setEncryptedSends(sends);
-  }
-
-  async clear(): Promise<any> {
-    await this.stateService.setDecryptedSends(null);
-    await this.stateService.setEncryptedSends(null);
-  }
-
-  async delete(id: string | string[]): Promise<any> {
-    const sends = await this.stateService.getEncryptedSends();
-    if (sends == null) {
-      return;
-    }
-
-    if (typeof id === "string") {
-      if (sends[id] == null) {
-        return;
-      }
-      delete sends[id];
-    } else {
-      (id as string[]).forEach((i) => {
-        delete sends[i];
-      });
-    }
-
-    await this.replace(sends);
-  }
-
-  async deleteWithServer(id: string): Promise<any> {
-    await this.apiService.deleteSend(id);
-    await this.delete(id);
-  }
-
-  async removePasswordWithServer(id: string): Promise<any> {
-    const response = await this.apiService.putSendRemovePassword(id);
-    const userId = await this.stateService.getUserId();
-    const data = new SendData(response, userId);
-    await this.upsert(data);
-  }
-
-  private parseFile(send: Send, file: File, key: SymmetricCryptoKey): Promise<EncArrayBuffer> {
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader();
-      reader.readAsArrayBuffer(file);
-      reader.onload = async (evt) => {
-        try {
-          const [name, data] = await this.encryptFileData(
-            file.name,
-            evt.target.result as ArrayBuffer,
-            key,
-          );
-          send.file.fileName = name;
-          resolve(data);
-        } catch (e) {
-          reject(e);
-        }
-      };
-      reader.onerror = () => {
-        reject("Error reading file.");
-      };
-    });
-  }
-
-  private async encryptFileData(
-    fileName: string,
-    data: ArrayBuffer,
-    key: SymmetricCryptoKey,
-  ): Promise<[EncString, EncArrayBuffer]> {
-    const encFileName = await this.cryptoService.encrypt(fileName, key);
-    const encFileData = await this.cryptoService.encryptToBytes(data, key);
-    return [encFileName, encFileData];
-  }
-}
--- a/jslib/common/src/services/sync.service.ts
+++ b/jslib/common/src/services/sync.service.ts
@@ -1,38 +1,16 @@
 import { ApiService } from "../abstractions/api.service";
-import { CipherService } from "../abstractions/cipher.service";
-import { CollectionService } from "../abstractions/collection.service";
 import { CryptoService } from "../abstractions/crypto.service";
-import { FolderService } from "../abstractions/folder.service";
 import { KeyConnectorService } from "../abstractions/keyConnector.service";
 import { LogService } from "../abstractions/log.service";
 import { MessagingService } from "../abstractions/messaging.service";
 import { OrganizationService } from "../abstractions/organization.service";
-import { PolicyService } from "../abstractions/policy.service";
-import { ProviderService } from "../abstractions/provider.service";
-import { SendService } from "../abstractions/send.service";
 import { SettingsService } from "../abstractions/settings.service";
 import { StateService } from "../abstractions/state.service";
 import { SyncService as SyncServiceAbstraction } from "../abstractions/sync.service";
 import { sequentialize } from "../misc/sequentialize";
-import { CipherData } from "../models/data/cipherData";
-import { CollectionData } from "../models/data/collectionData";
-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 { CipherResponse } from "../models/response/cipherResponse";
-import { CollectionDetailsResponse } from "../models/response/collectionResponse";
 import { DomainsResponse } from "../models/response/domainsResponse";
-import { FolderResponse } from "../models/response/folderResponse";
-import {
-  SyncCipherNotification,
-  SyncFolderNotification,
-  SyncSendNotification,
-} from "../models/response/notificationResponse";
-import { PolicyResponse } from "../models/response/policyResponse";
 import { ProfileResponse } from "../models/response/profileResponse";
-import { SendResponse } from "../models/response/sendResponse";

 export class SyncService implements SyncServiceAbstraction {
  syncInProgress = false;
@@ -40,18 +18,12 @@ export class SyncService implements SyncServiceAbstraction {
  constructor(
    private apiService: ApiService,
    private settingsService: SettingsService,
-    private folderService: FolderService,
-    private cipherService: CipherService,
    private cryptoService: CryptoService,
-    private collectionService: CollectionService,
    private messagingService: MessagingService,
-    private policyService: PolicyService,
-    private sendService: SendService,
    private logService: LogService,
    private keyConnectorService: KeyConnectorService,
    private stateService: StateService,
    private organizationService: OrganizationService,
-    private providerService: ProviderService,
    private logoutCallback: (expired: boolean) => Promise<void>,
  ) {}

@@ -95,18 +67,12 @@ export class SyncService implements SyncServiceAbstraction {
      return this.syncCompleted(false);
    }

-    const userId = await this.stateService.getUserId();
    try {
      await this.apiService.refreshIdentityToken();
      const response = await this.apiService.getSync();

      await this.syncProfile(response.profile);
-      await this.syncFolders(userId, response.folders);
-      await this.syncCollections(response.collections);
-      await this.syncCiphers(userId, response.ciphers);
-      await this.syncSends(userId, response.sends);
      await this.syncSettings(response.domains);
-      await this.syncPolicies(response.policies);

      await this.setLastSync(now);
      return this.syncCompleted(true);
@@ -119,149 +85,6 @@ export class SyncService implements SyncServiceAbstraction {
    }
  }

-  async syncUpsertFolder(notification: SyncFolderNotification, isEdit: boolean): Promise<boolean> {
-    this.syncStarted();
-    if (await this.stateService.getIsAuthenticated()) {
-      try {
-        const localFolder = await this.folderService.get(notification.id);
-        if (
-          (!isEdit && localFolder == null) ||
-          (isEdit && localFolder != null && localFolder.revisionDate < notification.revisionDate)
-        ) {
-          const remoteFolder = await this.apiService.getFolder(notification.id);
-          if (remoteFolder != null) {
-            const userId = await this.stateService.getUserId();
-            await this.folderService.upsert(new FolderData(remoteFolder, userId));
-            this.messagingService.send("syncedUpsertedFolder", { folderId: notification.id });
-            return this.syncCompleted(true);
-          }
-        }
-      } catch (e) {
-        this.logService.error(e);
-      }
-    }
-    return this.syncCompleted(false);
-  }
-
-  async syncDeleteFolder(notification: SyncFolderNotification): Promise<boolean> {
-    this.syncStarted();
-    if (await this.stateService.getIsAuthenticated()) {
-      await this.folderService.delete(notification.id);
-      this.messagingService.send("syncedDeletedFolder", { folderId: notification.id });
-      this.syncCompleted(true);
-      return true;
-    }
-    return this.syncCompleted(false);
-  }
-
-  async syncUpsertCipher(notification: SyncCipherNotification, isEdit: boolean): Promise<boolean> {
-    this.syncStarted();
-    if (await this.stateService.getIsAuthenticated()) {
-      try {
-        let shouldUpdate = true;
-        const localCipher = await this.cipherService.get(notification.id);
-        if (localCipher != null && localCipher.revisionDate >= notification.revisionDate) {
-          shouldUpdate = false;
-        }
-
-        let checkCollections = false;
-        if (shouldUpdate) {
-          if (isEdit) {
-            shouldUpdate = localCipher != null;
-            checkCollections = true;
-          } else {
-            if (notification.collectionIds == null || notification.organizationId == null) {
-              shouldUpdate = localCipher == null;
-            } else {
-              shouldUpdate = false;
-              checkCollections = true;
-            }
-          }
-        }
-
-        if (
-          !shouldUpdate &&
-          checkCollections &&
-          notification.organizationId != null &&
-          notification.collectionIds != null &&
-          notification.collectionIds.length > 0
-        ) {
-          const collections = await this.collectionService.getAll();
-          if (collections != null) {
-            for (let i = 0; i < collections.length; i++) {
-              if (notification.collectionIds.indexOf(collections[i].id) > -1) {
-                shouldUpdate = true;
-                break;
-              }
-            }
-          }
-        }
-
-        if (shouldUpdate) {
-          const remoteCipher = await this.apiService.getCipher(notification.id);
-          if (remoteCipher != null) {
-            const userId = await this.stateService.getUserId();
-            await this.cipherService.upsert(new CipherData(remoteCipher, userId));
-            this.messagingService.send("syncedUpsertedCipher", { cipherId: notification.id });
-            return this.syncCompleted(true);
-          }
-        }
-      } catch (e) {
-        if (e != null && e.statusCode === 404 && isEdit) {
-          await this.cipherService.delete(notification.id);
-          this.messagingService.send("syncedDeletedCipher", { cipherId: notification.id });
-          return this.syncCompleted(true);
-        }
-      }
-    }
-    return this.syncCompleted(false);
-  }
-
-  async syncDeleteCipher(notification: SyncCipherNotification): Promise<boolean> {
-    this.syncStarted();
-    if (await this.stateService.getIsAuthenticated()) {
-      await this.cipherService.delete(notification.id);
-      this.messagingService.send("syncedDeletedCipher", { cipherId: notification.id });
-      return this.syncCompleted(true);
-    }
-    return this.syncCompleted(false);
-  }
-
-  async syncUpsertSend(notification: SyncSendNotification, isEdit: boolean): Promise<boolean> {
-    this.syncStarted();
-    if (await this.stateService.getIsAuthenticated()) {
-      try {
-        const localSend = await this.sendService.get(notification.id);
-        if (
-          (!isEdit && localSend == null) ||
-          (isEdit && localSend != null && localSend.revisionDate < notification.revisionDate)
-        ) {
-          const remoteSend = await this.apiService.getSend(notification.id);
-          if (remoteSend != null) {
-            const userId = await this.stateService.getUserId();
-            await this.sendService.upsert(new SendData(remoteSend, userId));
-            this.messagingService.send("syncedUpsertedSend", { sendId: notification.id });
-            return this.syncCompleted(true);
-          }
-        }
-      } catch (e) {
-        this.logService.error(e);
-      }
-    }
-    return this.syncCompleted(false);
-  }
-
-  async syncDeleteSend(notification: SyncSendNotification): Promise<boolean> {
-    this.syncStarted();
-    if (await this.stateService.getIsAuthenticated()) {
-      await this.sendService.delete(notification.id);
-      this.messagingService.send("syncedDeletedSend", { sendId: notification.id });
-      this.syncCompleted(true);
-      return true;
-    }
-    return this.syncCompleted(false);
-  }
-
  // Helpers

  private syncStarted() {
@@ -304,7 +127,6 @@ export class SyncService implements SyncServiceAbstraction {

    await this.cryptoService.setEncKey(response.key);
    await this.cryptoService.setEncPrivateKey(response.privateKey);
-    await this.cryptoService.setProviderKeys(response.providers);
    await this.cryptoService.setOrgKeys(response.organizations, response.providerOrganizations);
    await this.stateService.setSecurityStamp(response.securityStamp);
    await this.stateService.setEmailVerified(response.emailVerified);
@@ -316,11 +138,6 @@ export class SyncService implements SyncServiceAbstraction {
      organizations[o.id] = new OrganizationData(o);
    });

-    const providers: { [id: string]: ProviderData } = {};
-    response.providers.forEach((p) => {
-      providers[p.id] = new ProviderData(p);
-    });
-
    response.providerOrganizations.forEach((o) => {
      if (organizations[o.id] == null) {
        organizations[o.id] = new OrganizationData(o);
@@ -329,7 +146,6 @@ export class SyncService implements SyncServiceAbstraction {
    });

    await this.organizationService.save(organizations);
-    await this.providerService.save(providers);

    if (await this.keyConnectorService.userNeedsMigration()) {
      await this.keyConnectorService.setConvertAccountRequired(true);
@@ -339,38 +155,6 @@ export class SyncService implements SyncServiceAbstraction {
    }
  }

-  private async syncFolders(userId: string, response: FolderResponse[]) {
-    const folders: { [id: string]: FolderData } = {};
-    response.forEach((f) => {
-      folders[f.id] = new FolderData(f, userId);
-    });
-    return await this.folderService.replace(folders);
-  }
-
-  private async syncCollections(response: CollectionDetailsResponse[]) {
-    const collections: { [id: string]: CollectionData } = {};
-    response.forEach((c) => {
-      collections[c.id] = new CollectionData(c);
-    });
-    return await this.collectionService.replace(collections);
-  }
-
-  private async syncCiphers(userId: string, response: CipherResponse[]) {
-    const ciphers: { [id: string]: CipherData } = {};
-    response.forEach((c) => {
-      ciphers[c.id] = new CipherData(c, userId);
-    });
-    return await this.cipherService.replace(ciphers);
-  }
-
-  private async syncSends(userId: string, response: SendResponse[]) {
-    const sends: { [id: string]: SendData } = {};
-    response.forEach((s) => {
-      sends[s.id] = new SendData(s, userId);
-    });
-    return await this.sendService.replace(sends);
-  }
-
  private async syncSettings(response: DomainsResponse) {
    let eqDomains: string[][] = [];
    if (response != null && response.equivalentDomains != null) {
@@ -387,14 +171,4 @@ export class SyncService implements SyncServiceAbstraction {

    return this.settingsService.setEquivalentDomains(eqDomains);
  }
-
-  private async syncPolicies(response: PolicyResponse[]) {
-    const policies: { [id: string]: PolicyData } = {};
-    if (response != null) {
-      response.forEach((p) => {
-        policies[p.id] = new PolicyData(p);
-      });
-    }
-    return await this.policyService.replace(policies);
-  }
 }
--- a/jslib/common/src/services/totp.service.ts
+++ b/jslib/common/src/services/totp.service.ts
@@ -1,174 +0,0 @@
-import { CryptoFunctionService } from "../abstractions/cryptoFunction.service";
-import { LogService } from "../abstractions/log.service";
-import { StateService } from "../abstractions/state.service";
-import { TotpService as TotpServiceAbstraction } from "../abstractions/totp.service";
-import { Utils } from "../misc/utils";
-
-const B32Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-const SteamChars = "23456789BCDFGHJKMNPQRTVWXY";
-
-export class TotpService implements TotpServiceAbstraction {
-  constructor(
-    private cryptoFunctionService: CryptoFunctionService,
-    private logService: LogService,
-    private stateService: StateService,
-  ) {}
-
-  async getCode(key: string): Promise<string> {
-    if (key == null) {
-      return null;
-    }
-    let period = 30;
-    let alg: "sha1" | "sha256" | "sha512" = "sha1";
-    let digits = 6;
-    let keyB32 = key;
-    const isOtpAuth = key.toLowerCase().indexOf("otpauth://") === 0;
-    const isSteamAuth = !isOtpAuth && key.toLowerCase().indexOf("steam://") === 0;
-    if (isOtpAuth) {
-      const params = Utils.getQueryParams(key);
-      if (params.has("digits") && params.get("digits") != null) {
-        try {
-          const digitParams = parseInt(params.get("digits").trim(), null);
-          if (digitParams > 10) {
-            digits = 10;
-          } else if (digitParams > 0) {
-            digits = digitParams;
-          }
-        } catch {
-          this.logService.error("Invalid digits param.");
-        }
-      }
-      if (params.has("period") && params.get("period") != null) {
-        try {
-          const periodParam = parseInt(params.get("period").trim(), null);
-          if (periodParam > 0) {
-            period = periodParam;
-          }
-        } catch {
-          this.logService.error("Invalid period param.");
-        }
-      }
-      if (params.has("secret") && params.get("secret") != null) {
-        keyB32 = params.get("secret");
-      }
-      if (params.has("algorithm") && params.get("algorithm") != null) {
-        const algParam = params.get("algorithm").toLowerCase();
-        if (algParam === "sha1" || algParam === "sha256" || algParam === "sha512") {
-          alg = algParam;
-        }
-      }
-    } else if (isSteamAuth) {
-      keyB32 = key.substr("steam://".length);
-      digits = 5;
-    }
-
-    const epoch = Math.round(new Date().getTime() / 1000.0);
-    const timeHex = this.leftPad(this.decToHex(Math.floor(epoch / period)), 16, "0");
-    const timeBytes = Utils.fromHexToArray(timeHex);
-    const keyBytes = this.b32ToBytes(keyB32);
-
-    if (!keyBytes.length || !timeBytes.length) {
-      return null;
-    }
-
-    const hash = await this.sign(keyBytes, timeBytes, alg);
-    if (hash.length === 0) {
-      return null;
-    }
-
-    const offset = hash[hash.length - 1] & 0xf;
-    const binary =
-      ((hash[offset] & 0x7f) << 24) |
-      ((hash[offset + 1] & 0xff) << 16) |
-      ((hash[offset + 2] & 0xff) << 8) |
-      (hash[offset + 3] & 0xff);
-
-    let otp = "";
-    if (isSteamAuth) {
-      let fullCode = binary & 0x7fffffff;
-      for (let i = 0; i < digits; i++) {
-        otp += SteamChars[fullCode % SteamChars.length];
-        fullCode = Math.trunc(fullCode / SteamChars.length);
-      }
-    } else {
-      otp = (binary % Math.pow(10, digits)).toString();
-      otp = this.leftPad(otp, digits, "0");
-    }
-
-    return otp;
-  }
-
-  getTimeInterval(key: string): number {
-    let period = 30;
-    if (key != null && key.toLowerCase().indexOf("otpauth://") === 0) {
-      const params = Utils.getQueryParams(key);
-      if (params.has("period") && params.get("period") != null) {
-        try {
-          period = parseInt(params.get("period").trim(), null);
-        } catch {
-          this.logService.error("Invalid period param.");
-        }
-      }
-    }
-    return period;
-  }
-
-  async isAutoCopyEnabled(): Promise<boolean> {
-    return !(await this.stateService.getDisableAutoTotpCopy());
-  }
-
-  // Helpers
-
-  private leftPad(s: string, l: number, p: string): string {
-    if (l + 1 >= s.length) {
-      s = Array(l + 1 - s.length).join(p) + s;
-    }
-    return s;
-  }
-
-  private decToHex(d: number): string {
-    return (d < 15.5 ? "0" : "") + Math.round(d).toString(16);
-  }
-
-  private b32ToHex(s: string): string {
-    s = s.toUpperCase();
-    let cleanedInput = "";
-
-    for (let i = 0; i < s.length; i++) {
-      if (B32Chars.indexOf(s[i]) < 0) {
-        continue;
-      }
-
-      cleanedInput += s[i];
-    }
-    s = cleanedInput;
-
-    let bits = "";
-    let hex = "";
-    for (let i = 0; i < s.length; i++) {
-      const byteIndex = B32Chars.indexOf(s.charAt(i));
-      if (byteIndex < 0) {
-        continue;
-      }
-      bits += this.leftPad(byteIndex.toString(2), 5, "0");
-    }
-    for (let i = 0; i + 4 <= bits.length; i += 4) {
-      const chunk = bits.substr(i, 4);
-      hex = hex + parseInt(chunk, 2).toString(16);
-    }
-    return hex;
-  }
-
-  private b32ToBytes(s: string): Uint8Array {
-    return Utils.fromHexToArray(this.b32ToHex(s));
-  }
-
-  private async sign(
-    keyBytes: Uint8Array,
-    timeBytes: Uint8Array,
-    alg: "sha1" | "sha256" | "sha512",
-  ) {
-    const signature = await this.cryptoFunctionService.hmac(timeBytes.buffer, keyBytes.buffer, alg);
-    return new Uint8Array(signature);
-  }
-}
--- a/jslib/common/src/services/usernameGeneration.service.ts
+++ b/jslib/common/src/services/usernameGeneration.service.ts
@@ -1,131 +0,0 @@
-import { CryptoService } from "../abstractions/crypto.service";
-import { StateService } from "../abstractions/state.service";
-import { UsernameGenerationService as BaseUsernameGenerationService } from "../abstractions/usernameGeneration.service";
-import { EEFLongWordList } from "../misc/wordlist";
-
-const DefaultOptions = {
-  type: "word",
-  wordCapitalize: true,
-  wordIncludeNumber: true,
-  subaddressType: "random",
-  catchallType: "random",
-};
-
-export class UsernameGenerationService implements BaseUsernameGenerationService {
-  constructor(
-    private cryptoService: CryptoService,
-    private stateService: StateService,
-  ) {}
-
-  generateUsername(options: any): Promise<string> {
-    if (options.type === "catchall") {
-      return this.generateCatchall(options);
-    } else if (options.type === "subaddress") {
-      return this.generateSubaddress(options);
-    } else if (options.type === "forwarded") {
-      return this.generateSubaddress(options);
-    } else {
-      return this.generateWord(options);
-    }
-  }
-
-  async generateWord(options: any): Promise<string> {
-    const o = Object.assign({}, DefaultOptions, options);
-
-    if (o.wordCapitalize == null) {
-      o.wordCapitalize = true;
-    }
-    if (o.wordIncludeNumber == null) {
-      o.wordIncludeNumber = true;
-    }
-
-    const wordIndex = await this.cryptoService.randomNumber(0, EEFLongWordList.length - 1);
-    let word = EEFLongWordList[wordIndex];
-    if (o.wordCapitalize) {
-      word = word.charAt(0).toUpperCase() + word.slice(1);
-    }
-    if (o.wordIncludeNumber) {
-      const num = await this.cryptoService.randomNumber(1, 9999);
-      word = word + this.zeroPad(num.toString(), 4);
-    }
-    return word;
-  }
-
-  async generateSubaddress(options: any): Promise<string> {
-    const o = Object.assign({}, DefaultOptions, options);
-
-    const subaddressEmail = o.subaddressEmail;
-    if (subaddressEmail == null || subaddressEmail.length < 3) {
-      return o.subaddressEmail;
-    }
-    const atIndex = subaddressEmail.indexOf("@");
-    if (atIndex < 1 || atIndex >= subaddressEmail.length - 1) {
-      return subaddressEmail;
-    }
-    if (o.subaddressType == null) {
-      o.subaddressType = "random";
-    }
-
-    const emailBeginning = subaddressEmail.substr(0, atIndex);
-    const emailEnding = subaddressEmail.substr(atIndex + 1, subaddressEmail.length);
-
-    let subaddressString = "";
-    if (o.subaddressType === "random") {
-      subaddressString = await this.randomString(8);
-    } else if (o.subaddressType === "website-name") {
-      subaddressString = o.website;
-    }
-    return emailBeginning + "+" + subaddressString + "@" + emailEnding;
-  }
-
-  async generateCatchall(options: any): Promise<string> {
-    const o = Object.assign({}, DefaultOptions, options);
-
-    if (o.catchallDomain == null || o.catchallDomain === "") {
-      return null;
-    }
-    if (o.catchallType == null) {
-      o.catchallType = "random";
-    }
-
-    let startString = "";
-    if (o.catchallType === "random") {
-      startString = await this.randomString(8);
-    } else if (o.catchallType === "website-name") {
-      startString = o.website;
-    }
-    return startString + "@" + o.catchallDomain;
-  }
-
-  async getOptions(): Promise<any> {
-    let options = await this.stateService.getUsernameGenerationOptions();
-    if (options == null) {
-      options = Object.assign({}, DefaultOptions);
-    } else {
-      options = Object.assign({}, DefaultOptions, options);
-    }
-    await this.stateService.setUsernameGenerationOptions(options);
-    return options;
-  }
-
-  async saveOptions(options: any) {
-    await this.stateService.setUsernameGenerationOptions(options);
-  }
-
-  private async randomString(length: number) {
-    let str = "";
-    const charSet = "abcdefghijklmnopqrstuvwxyz1234567890";
-    for (let i = 0; i < length; i++) {
-      const randomCharIndex = await this.cryptoService.randomNumber(0, charSet.length - 1);
-      str += charSet.charAt(randomCharIndex);
-    }
-    return str;
-  }
-
-  // ref: https://stackoverflow.com/a/10073788
-  private zeroPad(number: string, width: number) {
-    return number.length >= width
-      ? number
-      : new Array(width - number.length + 1).join("0") + number;
-  }
-}
--- a/jslib/common/src/services/vaultTimeout.service.ts
+++ b/jslib/common/src/services/vaultTimeout.service.ts
@@ -1,225 +0,0 @@
-import { firstValueFrom } from "rxjs";
-
-import { CipherService } from "../abstractions/cipher.service";
-import { CollectionService } from "../abstractions/collection.service";
-import { CryptoService } from "../abstractions/crypto.service";
-import { FolderService } from "../abstractions/folder.service";
-import { KeyConnectorService } from "../abstractions/keyConnector.service";
-import { MessagingService } from "../abstractions/messaging.service";
-import { PlatformUtilsService } from "../abstractions/platformUtils.service";
-import { PolicyService } from "../abstractions/policy.service";
-import { SearchService } from "../abstractions/search.service";
-import { StateService } from "../abstractions/state.service";
-import { TokenService } from "../abstractions/token.service";
-import { VaultTimeoutService as VaultTimeoutServiceAbstraction } from "../abstractions/vaultTimeout.service";
-import { KeySuffixOptions } from "../enums/keySuffixOptions";
-import { PolicyType } from "../enums/policyType";
-
-export class VaultTimeoutService implements VaultTimeoutServiceAbstraction {
-  private inited = false;
-
-  constructor(
-    private cipherService: CipherService,
-    private folderService: FolderService,
-    private collectionService: CollectionService,
-    private cryptoService: CryptoService,
-    protected platformUtilsService: PlatformUtilsService,
-    private messagingService: MessagingService,
-    private searchService: SearchService,
-    private tokenService: TokenService,
-    private policyService: PolicyService,
-    private keyConnectorService: KeyConnectorService,
-    private stateService: StateService,
-    private lockedCallback: (userId?: string) => Promise<void> = null,
-    private loggedOutCallback: (userId?: string) => Promise<void> = null,
-  ) {}
-
-  init(checkOnInterval: boolean) {
-    if (this.inited) {
-      return;
-    }
-
-    this.inited = true;
-    if (checkOnInterval) {
-      this.startCheck();
-    }
-  }
-
-  startCheck() {
-    this.checkVaultTimeout();
-    setInterval(() => this.checkVaultTimeout(), 10 * 1000); // check every 10 seconds
-  }
-
-  // Keys aren't stored for a device that is locked or logged out.
-  async isLocked(userId?: string): Promise<boolean> {
-    const neverLock =
-      (await this.cryptoService.hasKeyStored(KeySuffixOptions.Auto, userId)) &&
-      !(await this.stateService.getEverBeenUnlocked({ userId: userId }));
-    if (neverLock) {
-      // TODO: This also _sets_ the key so when we check memory in the next line it finds a key.
-      // We should refactor here.
-      await this.cryptoService.getKey(KeySuffixOptions.Auto, userId);
-    }
-
-    return !(await this.cryptoService.hasKeyInMemory(userId));
-  }
-
-  async checkVaultTimeout(): Promise<void> {
-    if (await this.platformUtilsService.isViewOpen()) {
-      return;
-    }
-
-    const accounts = await firstValueFrom(this.stateService.accounts$);
-    for (const userId in accounts) {
-      if (userId != null && (await this.shouldLock(userId))) {
-        await this.executeTimeoutAction(userId);
-      }
-    }
-  }
-
-  async lock(allowSoftLock = false, userId?: string): Promise<void> {
-    const authed = await this.stateService.getIsAuthenticated({ userId: userId });
-    if (!authed) {
-      return;
-    }
-
-    if (await this.keyConnectorService.getUsesKeyConnector()) {
-      const pinSet = await this.isPinLockSet();
-      const pinLock =
-        (pinSet[0] && (await this.stateService.getDecryptedPinProtected()) != null) || pinSet[1];
-
-      if (!pinLock && !(await this.isBiometricLockSet())) {
-        await this.logOut(userId);
-      }
-    }
-
-    if (userId == null || userId === (await this.stateService.getUserId())) {
-      this.searchService.clearIndex();
-    }
-
-    await this.stateService.setEverBeenUnlocked(true, { userId: userId });
-    await this.stateService.setBiometricLocked(true, { userId: userId });
-    await this.stateService.setCryptoMasterKeyAuto(null, { userId: userId });
-
-    await this.cryptoService.clearKey(false, userId);
-    await this.cryptoService.clearOrgKeys(true, userId);
-    await this.cryptoService.clearKeyPair(true, userId);
-    await this.cryptoService.clearEncKey(true, userId);
-
-    await this.folderService.clearCache(userId);
-    await this.cipherService.clearCache(userId);
-    await this.collectionService.clearCache(userId);
-
-    this.messagingService.send("locked", { userId: userId });
-
-    if (this.lockedCallback != null) {
-      await this.lockedCallback(userId);
-    }
-  }
-
-  async logOut(userId?: string): Promise<void> {
-    if (this.loggedOutCallback != null) {
-      await this.loggedOutCallback(userId);
-    }
-  }
-
-  async setVaultTimeoutOptions(timeout: number, action: string): Promise<void> {
-    await this.stateService.setVaultTimeout(timeout);
-
-    // We swap these tokens from being on disk for lock actions, and in memory for logout actions
-    // Get them here to set them to their new location after changing the timeout action and clearing if needed
-    const token = await this.tokenService.getToken();
-    const refreshToken = await this.tokenService.getRefreshToken();
-    const clientId = await this.tokenService.getClientId();
-    const clientSecret = await this.tokenService.getClientSecret();
-
-    const currentAction = await this.stateService.getVaultTimeoutAction();
-    if ((timeout != null || timeout === 0) && action === "logOut" && action !== currentAction) {
-      // if we have a vault timeout and the action is log out, reset tokens
-      await this.tokenService.clearToken();
-    }
-
-    await this.stateService.setVaultTimeoutAction(action);
-
-    await this.tokenService.setToken(token);
-    await this.tokenService.setRefreshToken(refreshToken);
-    await this.tokenService.setClientId(clientId);
-    await this.tokenService.setClientSecret(clientSecret);
-
-    await this.cryptoService.toggleKey();
-  }
-
-  async isPinLockSet(): Promise<[boolean, boolean]> {
-    const protectedPin = await this.stateService.getProtectedPin();
-    const pinProtectedKey = await this.stateService.getEncryptedPinProtected();
-    return [protectedPin != null, pinProtectedKey != null];
-  }
-
-  async isBiometricLockSet(): Promise<boolean> {
-    return await this.stateService.getBiometricUnlock();
-  }
-
-  async getVaultTimeout(userId?: string): Promise<number> {
-    const vaultTimeout = await this.stateService.getVaultTimeout({ userId: userId });
-
-    if (
-      await this.policyService.policyAppliesToUser(PolicyType.MaximumVaultTimeout, null, userId)
-    ) {
-      const policy = await this.policyService.getAll(PolicyType.MaximumVaultTimeout, userId);
-      // Remove negative values, and ensure it's smaller than maximum allowed value according to policy
-      let timeout = Math.min(vaultTimeout, policy[0].data.minutes);
-
-      if (vaultTimeout == null || timeout < 0) {
-        timeout = policy[0].data.minutes;
-      }
-
-      // We really shouldn't need to set the value here, but multiple services relies on this value being correct.
-      if (vaultTimeout !== timeout) {
-        await this.stateService.setVaultTimeout(timeout, { userId: userId });
-      }
-
-      return timeout;
-    }
-
-    return vaultTimeout;
-  }
-
-  async clear(userId?: string): Promise<void> {
-    await this.stateService.setEverBeenUnlocked(false, { userId: userId });
-    await this.stateService.setDecryptedPinProtected(null, { userId: userId });
-    await this.stateService.setProtectedPin(null, { userId: userId });
-  }
-
-  private async isLoggedOut(userId?: string): Promise<boolean> {
-    return !(await this.stateService.getIsAuthenticated({ userId: userId }));
-  }
-
-  private async shouldLock(userId: string): Promise<boolean> {
-    if (await this.isLoggedOut(userId)) {
-      return false;
-    }
-
-    if (await this.isLocked(userId)) {
-      return false;
-    }
-
-    const vaultTimeout = await this.getVaultTimeout(userId);
-    if (vaultTimeout == null || vaultTimeout < 0) {
-      return false;
-    }
-
-    const lastActive = await this.stateService.getLastActive({ userId: userId });
-    if (lastActive == null) {
-      return false;
-    }
-
-    const vaultTimeoutSeconds = vaultTimeout * 60;
-    const diffSeconds = (new Date().getTime() - lastActive) / 1000;
-    return diffSeconds >= vaultTimeoutSeconds;
-  }
-
-  private async executeTimeoutAction(userId: string): Promise<void> {
-    const timeoutAction = await this.stateService.getVaultTimeoutAction({ userId: userId });
-    timeoutAction === "logOut" ? await this.logOut(userId) : await this.lock(true, userId);
-  }
-}
--- a/jslib/node/src/cli/commands/login.command.ts
+++ b/jslib/node/src/cli/commands/login.command.ts
@@ -12,7 +12,6 @@ import { EnvironmentService } from "@/jslib/common/src/abstractions/environment.
 import { I18nService } from "@/jslib/common/src/abstractions/i18n.service";
 import { PasswordGenerationService } from "@/jslib/common/src/abstractions/passwordGeneration.service";
 import { PlatformUtilsService } from "@/jslib/common/src/abstractions/platformUtils.service";
-import { PolicyService } from "@/jslib/common/src/abstractions/policy.service";
 import { StateService } from "@/jslib/common/src/abstractions/state.service";
 import { TwoFactorService } from "@/jslib/common/src/abstractions/twoFactor.service";
 import { TwoFactorProviderType } from "@/jslib/common/src/enums/twoFactorProviderType";
@@ -53,7 +52,6 @@ export class LoginCommand {
    protected platformUtilsService: PlatformUtilsService,
    protected stateService: StateService,
    protected cryptoService: CryptoService,
-    protected policyService: PolicyService,
    protected twoFactorService: TwoFactorService,
    clientId: string,
  ) {
@@ -372,23 +370,9 @@ export class LoginCommand {
    const masterPasswordHint = hint.input;

    // Retrieve details for key generation
-    const enforcedPolicyOptions = await this.policyService.getMasterPasswordPolicyOptions();
    const kdf = await this.stateService.getKdfType();
    const kdfIterations = await this.stateService.getKdfIterations();

-    if (
-      enforcedPolicyOptions != null &&
-      !this.policyService.evaluateMasterPassword(
-        strengthResult.score,
-        masterPassword,
-        enforcedPolicyOptions,
-      )
-    ) {
-      return this.updateTempPassword(
-        "Your new master password does not meet the policy requirements.\n",
-      );
-    }
-
    try {
      // Create new key and hash new password
      const newKey = await this.cryptoService.makeKey(
--- a/src/app/services/services.module.ts
+++ b/src/app/services/services.module.ts
@@ -9,7 +9,6 @@ import { CryptoService as CryptoServiceAbstraction } from "@/jslib/common/src/ab
 import { CryptoFunctionService as CryptoFunctionServiceAbstraction } from "@/jslib/common/src/abstractions/cryptoFunction.service";
 import { EnvironmentService as EnvironmentServiceAbstraction } from "@/jslib/common/src/abstractions/environment.service";
 import { I18nService as I18nServiceAbstraction } from "@/jslib/common/src/abstractions/i18n.service";
-import { KeyConnectorService as KeyConnectorServiceAbstraction } from "@/jslib/common/src/abstractions/keyConnector.service";
 import { LogService as LogServiceAbstraction } from "@/jslib/common/src/abstractions/log.service";
 import { MessagingService as MessagingServiceAbstraction } from "@/jslib/common/src/abstractions/messaging.service";
 import { PlatformUtilsService as PlatformUtilsServiceAbstraction } from "@/jslib/common/src/abstractions/platformUtils.service";
@@ -153,7 +152,6 @@ export function initFactory(
        PlatformUtilsServiceAbstraction,
        MessagingServiceAbstraction,
        LogServiceAbstraction,
-        KeyConnectorServiceAbstraction,
        EnvironmentServiceAbstraction,
        StateServiceAbstraction,
        TwoFactorServiceAbstraction,
--- a/src/bwdc.ts
+++ b/src/bwdc.ts
@@ -8,21 +8,14 @@ import { LogLevelType } from "@/jslib/common/src/enums/logLevelType";
 import { StateFactory } from "@/jslib/common/src/factories/stateFactory";
 import { GlobalState } from "@/jslib/common/src/models/domain/globalState";
 import { AppIdService } from "@/jslib/common/src/services/appId.service";
-import { CipherService } from "@/jslib/common/src/services/cipher.service";
-import { CollectionService } from "@/jslib/common/src/services/collection.service";
 import { ContainerService } from "@/jslib/common/src/services/container.service";
 import { CryptoService } from "@/jslib/common/src/services/crypto.service";
 import { EnvironmentService } from "@/jslib/common/src/services/environment.service";
-import { FileUploadService } from "@/jslib/common/src/services/fileUpload.service";
-import { FolderService } from "@/jslib/common/src/services/folder.service";
 import { KeyConnectorService } from "@/jslib/common/src/services/keyConnector.service";
 import { NoopMessagingService } from "@/jslib/common/src/services/noopMessaging.service";
 import { OrganizationService } from "@/jslib/common/src/services/organization.service";
 import { PasswordGenerationService } from "@/jslib/common/src/services/passwordGeneration.service";
-import { PolicyService } from "@/jslib/common/src/services/policy.service";
-import { ProviderService } from "@/jslib/common/src/services/provider.service";
 import { SearchService } from "@/jslib/common/src/services/search.service";
-import { SendService } from "@/jslib/common/src/services/send.service";
 import { SettingsService } from "@/jslib/common/src/services/settings.service";
 import { TokenService } from "@/jslib/common/src/services/token.service";
 import { CliPlatformUtilsService } from "@/jslib/node/src/cli/services/cliPlatformUtils.service";
@@ -61,22 +54,15 @@ export class Main {
  containerService: ContainerService;
  cryptoFunctionService: NodeCryptoFunctionService;
  authService: AuthService;
-  collectionService: CollectionService;
-  cipherService: CipherService;
-  fileUploadService: FileUploadService;
-  folderService: FolderService;
  searchService: SearchService;
-  sendService: SendService;
  settingsService: SettingsService;
  syncService: SyncService;
  passwordGenerationService: PasswordGenerationService;
-  policyService: PolicyService;
  keyConnectorService: KeyConnectorService;
  program: Program;
  stateService: StateService;
  stateMigrationService: StateMigrationService;
  organizationService: OrganizationService;
-  providerService: ProviderService;
  twoFactorService: TwoFactorServiceAbstraction;

  constructor() {
@@ -204,59 +190,14 @@ export class Main {
      this.stateService,
    );

-    this.policyService = new PolicyService(
-      this.stateService,
-      this.organizationService,
-      this.apiService,
-    );
-
    this.passwordGenerationService = new PasswordGenerationService(
      this.cryptoService,
-      this.policyService,
      this.stateService,
    );

    this.settingsService = new SettingsService(this.stateService);

-    this.fileUploadService = new FileUploadService(this.logService, this.apiService);
-
-    this.cipherService = new CipherService(
-      this.cryptoService,
-      this.settingsService,
-      this.apiService,
-      this.fileUploadService,
-      this.i18nService,
-      () => searchService,
-      this.logService,
-      this.stateService,
-    );
-
-    this.searchService = new SearchService(this.cipherService, this.logService, this.i18nService);
-
-    this.folderService = new FolderService(
-      this.cryptoService,
-      this.apiService,
-      this.i18nService,
-      this.cipherService,
-      this.stateService,
-    );
-
-    this.collectionService = new CollectionService(
-      this.cryptoService,
-      this.i18nService,
-      this.stateService,
-    );
-
-    this.sendService = new SendService(
-      this.cryptoService,
-      this.apiService,
-      this.fileUploadService,
-      this.i18nService,
-      this.cryptoFunctionService,
-      this.stateService,
-    );
-
-    this.providerService = new ProviderService(this.stateService);
+    this.searchService = new SearchService(this.logService, this.i18nService);

    this.program = new Program(this);
  }
--- a/src/program.ts
+++ b/src/program.ts
@@ -102,7 +102,6 @@ export class Program extends BaseProgram {
          this.main.platformUtilsService,
          this.main.stateService,
          this.main.cryptoService,
-          this.main.policyService,
          this.main.twoFactorService,
          "connector",
        );
Author	SHA1	Message	Date
Addison Beck	ab52feec41	Delete `FileUploadService`	2024-07-10 17:00:33 -04:00
Addison Beck	ecce1be094	Delete `PolicyService`	2024-07-10 16:58:00 -04:00
Addison Beck	1d6e70d897	Delete `VaultTimeoutService`	2024-07-10 16:06:51 -04:00
Addison Beck	d2739b78e0	Delete `ProviderService`	2024-07-10 15:50:54 -04:00
Addison Beck	a9118683df	Delete `CollectionService`	2024-07-10 15:48:37 -04:00
Addison Beck	f6e6902416	Delete `FolderService`	2024-07-10 15:45:57 -04:00
Addison Beck	b123ca785e	Delete `CipherService`	2024-07-10 15:41:05 -04:00
Addison Beck	707cbb8ad6	Delete `SendService`	2024-07-10 15:28:59 -04:00
Addison Beck	ec45092188	Delete `TotpService`	2024-07-10 14:52:59 -04:00
Addison Beck	20ddfce0a8	Delete `UsernameGenerationService`	2024-07-10 14:47:54 -04:00
Addison Beck	1c42050c3e	Delete `AuditService`	2024-07-10 14:36:35 -04:00