@lifeready/core 6.1.3 → 6.1.4

package/fesm2015/lifeready-core.js

@@ -3580,13 +3580,6 @@ class MainContactCardFields {
 }
 class MainContactCardPlainFields {
 }
-var PasswordChangeStatus;
-(function (PasswordChangeStatus) {
-    PasswordChangeStatus["InProgress"] = "IN_PROGRESS";
-    PasswordChangeStatus["Recovery"] = "RECOVERY";
-})(PasswordChangeStatus || (PasswordChangeStatus = {}));
-class PassIdpApiResult {
-}
 class TrustedPartyDetails {
 }
 class SharedTrustedPartyDetails extends TrustedPartyDetails {
@@ -3884,13 +3877,6 @@ class ProfileService {
         this.keyGraph = keyGraph;
         this.encryptionService = encryptionService;
     }
-    getPassIdpParams(emailOrPhone) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.http
-                .get(`${this.config.authUrl}users/pass-idp-params/?login_name=${encodeURIComponent(emailOrPhone)}`)
-                .toPromise();
-        });
-    }
     getCurrentUser() {
         return __awaiter(this, void 0, void 0, function* () {
             const { currentUser, contactCards } = yield this.lrApollo.query({
@@ -5098,11 +5084,11 @@ var RecoveryStatus;
 })(RecoveryStatus || (RecoveryStatus = {}));
 // TODO restrict this type
 // export type AuthResetUser = TpPasswordResetUserNode;
-var PasswordChangeStatus$1;
+var PasswordChangeStatus;
 (function (PasswordChangeStatus) {
     PasswordChangeStatus["IN_PROGRESS"] = "IN_PROGRESS";
     PasswordChangeStatus["RECOVERY"] = "RECOVERY";
-})(PasswordChangeStatus$1 || (PasswordChangeStatus$1 = {}));
+})(PasswordChangeStatus || (PasswordChangeStatus = {}));
 var CognitoChallengeName;
 (function (CognitoChallengeName) {
     CognitoChallengeName["NEW_PASSWORD_REQUIRED"] = "NEW_PASSWORD_REQUIRED";
@@ -5111,15 +5097,8 @@ var CognitoChallengeName;
     CognitoChallengeName["MFA_SETUP"] = "MFA_SETUP";
 })(CognitoChallengeName || (CognitoChallengeName = {}));
 
-var auth2_types = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get RecoveryStatus () { return RecoveryStatus; },
-    get PasswordChangeStatus () { return PasswordChangeStatus$1; },
-    get CognitoChallengeName () { return CognitoChallengeName; }
-});
-
-var Auth2Service_1;
-let Auth2Service = Auth2Service_1 = class Auth2Service extends LrService {
+var AuthService_1;
+let AuthService = AuthService_1 = class AuthService extends LrService {
     constructor(ngZone, injector, http, cognito, api, keyService, keyGraphService, keyFactoryService, passwordService, idleService, persistService, encryptionService, assemblyController, kcConfig) {
         super(injector);
         this.ngZone = ngZone;
@@ -5177,7 +5156,7 @@ let Auth2Service = Auth2Service_1 = class Auth2Service extends LrService {
             let loginResult = yield this.loginImpl(emailOrPhone, password);
             // Save the password for use after meeting challenge.
             if (loginResult.challenge) {
-                this.password = new KeyContainer(password, Auth2Service_1.CHALLENGE_TIMEOUT);
+                this.password = new KeyContainer(password, AuthService_1.CHALLENGE_TIMEOUT);
                 return loginResult;
             }
             if (tpPasswordResetAutoComplete &&
@@ -5314,10 +5293,10 @@ let Auth2Service = Auth2Service_1 = class Auth2Service extends LrService {
         return __awaiter(this, void 0, void 0, function* () {
             // Download the salt needed to derive the PassIdp
             const passIdpApiResult = yield this.fetchPassIdpParams(emailOrPhone);
-            if (passIdpApiResult.passwordChangeStatus === PasswordChangeStatus$1.IN_PROGRESS) {
+            if (passIdpApiResult.passwordChangeStatus === PasswordChangeStatus.IN_PROGRESS) {
                 throw new KcConcurrentAccessException('A password change is in progress');
             }
-            if (passIdpApiResult.passwordChangeStatus === PasswordChangeStatus$1.RECOVERY) {
+            if (passIdpApiResult.passwordChangeStatus === PasswordChangeStatus.RECOVERY) {
                 console.log('In recovery mode.');
                 // Let's say we don't know if the password is the new one or the old one. We just have to try both.
                 try {
@@ -5653,14 +5632,14 @@ let Auth2Service = Auth2Service_1 = class Auth2Service extends LrService {
         });
     }
 };
-Auth2Service.CHALLENGE_TIMEOUT = 1000 * 60 * 5;
-Auth2Service.ɵprov = ɵɵdefineInjectable({ factory: function Auth2Service_Factory() { return new Auth2Service(ɵɵinject(NgZone), ɵɵinject(INJECTOR), ɵɵinject(HttpClient), ɵɵinject(AuthClass), ɵɵinject(LrGraphQLService), ɵɵinject(KeyService), ɵɵinject(KeyGraphService), ɵɵinject(KeyFactoryService), ɵɵinject(PasswordService), ɵɵinject(IdleService), ɵɵinject(PersistService), ɵɵinject(EncryptionService), ɵɵinject(TpPasswordResetAssemblyController), ɵɵinject(KC_CONFIG)); }, token: Auth2Service, providedIn: "root" });
-Auth2Service.decorators = [
+AuthService.CHALLENGE_TIMEOUT = 1000 * 60 * 5;
+AuthService.ɵprov = ɵɵdefineInjectable({ factory: function AuthService_Factory() { return new AuthService(ɵɵinject(NgZone), ɵɵinject(INJECTOR), ɵɵinject(HttpClient), ɵɵinject(AuthClass), ɵɵinject(LrGraphQLService), ɵɵinject(KeyService), ɵɵinject(KeyGraphService), ɵɵinject(KeyFactoryService), ɵɵinject(PasswordService), ɵɵinject(IdleService), ɵɵinject(PersistService), ɵɵinject(EncryptionService), ɵɵinject(TpPasswordResetAssemblyController), ɵɵinject(KC_CONFIG)); }, token: AuthService, providedIn: "root" });
+AuthService.decorators = [
     { type: Injectable, args: [{
                 providedIn: 'root',
             },] }
 ];
-Auth2Service.ctorParameters = () => [
+AuthService.ctorParameters = () => [
     { type: NgZone },
     { type: Injector },
     { type: HttpClient },
@@ -5676,11 +5655,11 @@ Auth2Service.ctorParameters = () => [
     { type: TpPasswordResetAssemblyController },
     { type: undefined, decorators: [{ type: Inject, args: [KC_CONFIG,] }] }
 ];
-Auth2Service = Auth2Service_1 = __decorate([
+AuthService = AuthService_1 = __decorate([
     RunOutsideAngular({
         ngZoneName: 'ngZone',
     })
-], Auth2Service);
+], AuthService);
 
 const CreateContactCardMutation$2 = gqlTyped `
 mutation CreateContactCardMutation(
@@ -5857,102 +5836,6 @@ FileUploadService.ctorParameters = () => [
     { type: AuthClass }
 ];
 
-const LockFragment = gqlTyped `
-fragment LockFragment on LockField {
-  created
-  modified
-  version
-  expiryTime
-  state
-}`;
-const UpdateLockMutation = gqlTyped `
-mutation UpdateLockMutation($input: UpdateLockInput!) {
-  updateLock(input: $input) {
-    lock {
-      ...LockFragment
-    }
-  }
-}
-${LockFragment}
-`;
-const AcquireLockMutation = gqlTyped `
-mutation AcquireLockMutation($input: AcquireLockInput!) {
-  acquireLock(input: $input) {
-    lock {
-      ...LockFragment
-    }
-  }
-}
-${LockFragment}
-`;
-const ReleaseLockMutation = gqlTyped `
-mutation ReleaseLockMutation($input: ReleaseLockInput!) {
-  releaseLock(input: $input) {
-    lock {
-      ...LockFragment
-    }
-  }
-}
-${LockFragment}
-`;
-
-let LockService = class LockService extends LrService {
-    constructor(ngZone, injector) {
-        super(injector);
-        this.ngZone = ngZone;
-        this.injector = injector;
-    }
-    // Updating the lock version is always to be down along with another mutation.
-    updateLockMutation(options) {
-        return new LrMutation({
-            mutation: UpdateLockMutation,
-            variables: {
-                input: {
-                    resourceId: options.resourceId,
-                    version: options.version,
-                },
-            },
-        });
-    }
-    acquireLockMutation(options) {
-        return new LrMutation({
-            mutation: AcquireLockMutation,
-            variables: {
-                input: {
-                    resourceId: options.resourceId,
-                    timeoutMs: options.timeoutMs,
-                },
-            },
-        });
-    }
-    releaseLockMutation(options) {
-        return new LrMutation({
-            mutation: ReleaseLockMutation,
-            variables: {
-                input: {
-                    resourceId: options.resourceId,
-                    version: options.version,
-                },
-            },
-        });
-    }
-};
-LockService.ɵprov = ɵɵdefineInjectable({ factory: function LockService_Factory() { return new LockService(ɵɵinject(NgZone), ɵɵinject(INJECTOR)); }, token: LockService, providedIn: "root" });
-LockService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-LockService.ctorParameters = () => [
-    { type: NgZone },
-    { type: Injector }
-];
-LockService = __decorate([
-    RunOutsideAngular({
-        ngZoneName: 'ngZone',
-    })
-], LockService);
-
 const CreateDirectoryMutation = gqlTyped `
 mutation CreateDirectoryMutation($input: CreateDirectoryInput!) {
   createDirectory(input: $input) {
@@ -6116,6 +5999,102 @@ mutation SetDirectoryConfidentialMutation($input: SetDirectoryConfidentialInput!
 }
 `;
 
+const LockFragment = gqlTyped `
+fragment LockFragment on LockField {
+  created
+  modified
+  version
+  expiryTime
+  state
+}`;
+const UpdateLockMutation = gqlTyped `
+mutation UpdateLockMutation($input: UpdateLockInput!) {
+  updateLock(input: $input) {
+    lock {
+      ...LockFragment
+    }
+  }
+}
+${LockFragment}
+`;
+const AcquireLockMutation = gqlTyped `
+mutation AcquireLockMutation($input: AcquireLockInput!) {
+  acquireLock(input: $input) {
+    lock {
+      ...LockFragment
+    }
+  }
+}
+${LockFragment}
+`;
+const ReleaseLockMutation = gqlTyped `
+mutation ReleaseLockMutation($input: ReleaseLockInput!) {
+  releaseLock(input: $input) {
+    lock {
+      ...LockFragment
+    }
+  }
+}
+${LockFragment}
+`;
+
+let LockService = class LockService extends LrService {
+    constructor(ngZone, injector) {
+        super(injector);
+        this.ngZone = ngZone;
+        this.injector = injector;
+    }
+    // Updating the lock version is always to be down along with another mutation.
+    updateLockMutation(options) {
+        return new LrMutation({
+            mutation: UpdateLockMutation,
+            variables: {
+                input: {
+                    resourceId: options.resourceId,
+                    version: options.version,
+                },
+            },
+        });
+    }
+    acquireLockMutation(options) {
+        return new LrMutation({
+            mutation: AcquireLockMutation,
+            variables: {
+                input: {
+                    resourceId: options.resourceId,
+                    timeoutMs: options.timeoutMs,
+                },
+            },
+        });
+    }
+    releaseLockMutation(options) {
+        return new LrMutation({
+            mutation: ReleaseLockMutation,
+            variables: {
+                input: {
+                    resourceId: options.resourceId,
+                    version: options.version,
+                },
+            },
+        });
+    }
+};
+LockService.ɵprov = ɵɵdefineInjectable({ factory: function LockService_Factory() { return new LockService(ɵɵinject(NgZone), ɵɵinject(INJECTOR)); }, token: LockService, providedIn: "root" });
+LockService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+LockService.ctorParameters = () => [
+    { type: NgZone },
+    { type: Injector }
+];
+LockService = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], LockService);
+
 const DirectoryKeyQuery$1 = gqlTyped `
 query DirectoryKeyQuery($id: LrRelayIdInput!) {
   directory(id: $id) {
@@ -6138,9 +6117,9 @@ query FileStateKeyQuery($id: LrRelayIdInput!) {
 }
 `;
 
-var Item2Service_1;
-let Item2Service = Item2Service_1 = class Item2Service extends LrService {
-    constructor(ngZone, injector, fileUploadService, keyService, keyFactory, keyGraph, lockService, auth2Service) {
+var ItemService_1;
+let ItemService = ItemService_1 = class ItemService extends LrService {
+    constructor(ngZone, injector, fileUploadService, keyService, keyFactory, keyGraph, lockService, authService) {
         super(injector);
         this.ngZone = ngZone;
         this.injector = injector;
@@ -6149,10 +6128,10 @@ let Item2Service = Item2Service_1 = class Item2Service extends LrService {
         this.keyFactory = keyFactory;
         this.keyGraph = keyGraph;
         this.lockService = lockService;
-        this.auth2Service = auth2Service;
+        this.authService = authService;
         // Caching the temp directory.
         this.tempDirectory = null;
-        this.auth2Service.addLogoutListener(() => this.onLogout());
+        this.authService.addLogoutListener(() => this.onLogout());
     }
     downloadFileContent(options) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -6409,17 +6388,17 @@ let Item2Service = Item2Service_1 = class Item2Service extends LrService {
             const existing = yield this.query({
                 query: TempDirectoryQuery,
                 variables: {
-                    plainMeta: Item2Service_1.TEMP_DIRECTORY_PLAIN_META_FILTER,
+                    plainMeta: ItemService_1.TEMP_DIRECTORY_PLAIN_META_FILTER,
                 },
             });
             if (existing.rootDirectories.edges.length > 1) {
-                console.error(`There is more than 1 temp directory (plainMeta filter: ${Item2Service_1.TEMP_DIRECTORY_PLAIN_META_FILTER})`);
+                console.error(`There is more than 1 temp directory (plainMeta filter: ${ItemService_1.TEMP_DIRECTORY_PLAIN_META_FILTER})`);
             }
             if (existing.rootDirectories.edges.length === 0) {
                 // Doesn't exist yet, create it
                 const createDirectory = yield this.createDirectoryMutation({
                     asRootDirectory: true,
-                    plainMetaJson: Item2Service_1.TEMP_DIRECTORY_PLAIN_META,
+                    plainMetaJson: ItemService_1.TEMP_DIRECTORY_PLAIN_META,
                 });
                 // Optimistic lock on the current user.
                 const updateLock = this.lockService.updateLockMutation({
@@ -6678,21 +6657,21 @@ let Item2Service = Item2Service_1 = class Item2Service extends LrService {
         this.tempDirectory = null;
     }
 };
-Item2Service.TEMP_DIRECTORY_PLAIN_META = { kcType: 'temp' };
-Item2Service.TEMP_DIRECTORY_PLAIN_META_FILTER = JSON.stringify({
+ItemService.TEMP_DIRECTORY_PLAIN_META = { kcType: 'temp' };
+ItemService.TEMP_DIRECTORY_PLAIN_META_FILTER = JSON.stringify({
     filter: [
         {
-            contains: Item2Service_1.TEMP_DIRECTORY_PLAIN_META,
+            contains: ItemService_1.TEMP_DIRECTORY_PLAIN_META,
         },
     ],
 });
-Item2Service.ɵprov = ɵɵdefineInjectable({ factory: function Item2Service_Factory() { return new Item2Service(ɵɵinject(NgZone), ɵɵinject(INJECTOR), ɵɵinject(FileUploadService), ɵɵinject(KeyService), ɵɵinject(KeyFactoryService), ɵɵinject(KeyGraphService), ɵɵinject(LockService), ɵɵinject(Auth2Service)); }, token: Item2Service, providedIn: "root" });
-Item2Service.decorators = [
+ItemService.ɵprov = ɵɵdefineInjectable({ factory: function ItemService_Factory() { return new ItemService(ɵɵinject(NgZone), ɵɵinject(INJECTOR), ɵɵinject(FileUploadService), ɵɵinject(KeyService), ɵɵinject(KeyFactoryService), ɵɵinject(KeyGraphService), ɵɵinject(LockService), ɵɵinject(AuthService)); }, token: ItemService, providedIn: "root" });
+ItemService.decorators = [
     { type: Injectable, args: [{
                 providedIn: 'root',
             },] }
 ];
-Item2Service.ctorParameters = () => [
+ItemService.ctorParameters = () => [
     { type: NgZone },
     { type: Injector },
     { type: FileUploadService },
@@ -6700,15 +6679,15 @@ Item2Service.ctorParameters = () => [
     { type: KeyFactoryService },
     { type: KeyGraphService },
     { type: LockService },
-    { type: Auth2Service }
+    { type: AuthService }
 ];
-Item2Service = Item2Service_1 = __decorate([
+ItemService = ItemService_1 = __decorate([
     RunOutsideAngular({
         ngZoneName: 'ngZone',
     })
-], Item2Service);
+], ItemService);
 
-let KeyExchange2Service = class KeyExchange2Service extends LrService {
+let KeyExchangeService = class KeyExchangeService extends LrService {
     constructor(ngZone, injector, keyFactory, keyService, encryptionService, keyGraph) {
         super(injector);
         this.ngZone = ngZone;
@@ -7152,13 +7131,13 @@ let KeyExchange2Service = class KeyExchange2Service extends LrService {
         });
     }
 };
-KeyExchange2Service.ɵprov = ɵɵdefineInjectable({ factory: function KeyExchange2Service_Factory() { return new KeyExchange2Service(ɵɵinject(NgZone), ɵɵinject(INJECTOR), ɵɵinject(KeyFactoryService), ɵɵinject(KeyService), ɵɵinject(EncryptionService), ɵɵinject(KeyGraphService)); }, token: KeyExchange2Service, providedIn: "root" });
-KeyExchange2Service.decorators = [
+KeyExchangeService.ɵprov = ɵɵdefineInjectable({ factory: function KeyExchangeService_Factory() { return new KeyExchangeService(ɵɵinject(NgZone), ɵɵinject(INJECTOR), ɵɵinject(KeyFactoryService), ɵɵinject(KeyService), ɵɵinject(EncryptionService), ɵɵinject(KeyGraphService)); }, token: KeyExchangeService, providedIn: "root" });
+KeyExchangeService.decorators = [
     { type: Injectable, args: [{
                 providedIn: 'root',
             },] }
 ];
-KeyExchange2Service.ctorParameters = () => [
+KeyExchangeService.ctorParameters = () => [
     { type: NgZone },
     { type: Injector },
     { type: KeyFactoryService },
@@ -7166,11 +7145,11 @@ KeyExchange2Service.ctorParameters = () => [
     { type: EncryptionService },
     { type: KeyGraphService }
 ];
-KeyExchange2Service = __decorate([
+KeyExchangeService = __decorate([
     RunOutsideAngular({
         ngZoneName: 'ngZone',
     })
-], KeyExchange2Service);
+], KeyExchangeService);
 
 const ERROR_SOURCE = 'LBOP';
 var KcLbopErrorCode;
@@ -7223,16 +7202,14 @@ const LbopsQuery = gql `
   }
 `;
 class LbopService {
-    constructor(config, http, lrApollo, auth, auth2Service, keyFactory, keyService, encryptionService, keyGraph, passwordService) {
+    constructor(config, http, lrApollo, auth, keyFactory, keyService, encryptionService, passwordService) {
         this.config = config;
         this.http = http;
         this.lrApollo = lrApollo;
         this.auth = auth;
-        this.auth2Service = auth2Service;
         this.keyFactory = keyFactory;
         this.keyService = keyService;
         this.encryptionService = encryptionService;
-        this.keyGraph = keyGraph;
         this.passwordService = passwordService;
         this.CLIENT_NONCE_LENGTH = 32;
         // There are 1024 words (10 bits), so 25 words should give ~256 bits of entropy.
@@ -7485,7 +7462,7 @@ class LbopService {
         });
     }
 }
-LbopService.ɵprov = ɵɵdefineInjectable({ factory: function LbopService_Factory() { return new LbopService(ɵɵinject(KC_CONFIG), ɵɵinject(HttpClient), ɵɵinject(LrApolloService), ɵɵinject(AuthClass), ɵɵinject(Auth2Service), ɵɵinject(KeyFactoryService), ɵɵinject(KeyService), ɵɵinject(EncryptionService), ɵɵinject(KeyGraphService), ɵɵinject(PasswordService)); }, token: LbopService, providedIn: "root" });
+LbopService.ɵprov = ɵɵdefineInjectable({ factory: function LbopService_Factory() { return new LbopService(ɵɵinject(KC_CONFIG), ɵɵinject(HttpClient), ɵɵinject(LrApolloService), ɵɵinject(AuthClass), ɵɵinject(KeyFactoryService), ɵɵinject(KeyService), ɵɵinject(EncryptionService), ɵɵinject(PasswordService)); }, token: LbopService, providedIn: "root" });
 LbopService.decorators = [
     { type: Injectable, args: [{
                 providedIn: 'root',
@@ -7496,11 +7473,9 @@ LbopService.ctorParameters = () => [
     { type: HttpClient },
     { type: LrApolloService },
     { type: AuthClass },
-    { type: Auth2Service },
     { type: KeyFactoryService },
     { type: KeyService },
     { type: EncryptionService },
-    { type: KeyGraphService },
     { type: PasswordService }
 ];
 
@@ -7781,7 +7756,7 @@ mutation ReactivatePlanMutation($input: ReactivatePlanInput!) {
 }
 `;
 
-let Plan2Service = class Plan2Service extends LrService {
+let PlanService = class PlanService extends LrService {
     constructor(ngZone, injector) {
         super(injector);
         this.ngZone = ngZone;
@@ -7949,21 +7924,21 @@ let Plan2Service = class Plan2Service extends LrService {
         });
     }
 };
-Plan2Service.ɵprov = ɵɵdefineInjectable({ factory: function Plan2Service_Factory() { return new Plan2Service(ɵɵinject(NgZone), ɵɵinject(INJECTOR)); }, token: Plan2Service, providedIn: "root" });
-Plan2Service.decorators = [
+PlanService.ɵprov = ɵɵdefineInjectable({ factory: function PlanService_Factory() { return new PlanService(ɵɵinject(NgZone), ɵɵinject(INJECTOR)); }, token: PlanService, providedIn: "root" });
+PlanService.decorators = [
     { type: Injectable, args: [{
                 providedIn: 'root',
             },] }
 ];
-Plan2Service.ctorParameters = () => [
+PlanService.ctorParameters = () => [
     { type: NgZone },
     { type: Injector }
 ];
-Plan2Service = __decorate([
+PlanService = __decorate([
     RunOutsideAngular({
         ngZoneName: 'ngZone',
     })
-], Plan2Service);
+], PlanService);
 
 var ContactFields;
 (function (ContactFields) {
@@ -8370,6 +8345,9 @@ RegisterService.ctorParameters = () => [
     { type: PasswordService }
 ];
 
+class RegisterResult {
+}
+
 const CreateReminderMutation = gqlTyped `
 mutation CreateReminderMutation($input: CreateReminderInput!) {
   createReminder(input: $input) {
@@ -8474,35 +8452,6 @@ ReminderService = __decorate([
     })
 ], ReminderService);
 
-const SCENARIO_SLIP39_PASSPHRASE = 'lifeready';
-
-let ScenarioAssemblyController = class ScenarioAssemblyController extends TpAssemblyController {
-    constructor(ngZone, injector) {
-        super(injector);
-        this.ngZone = ngZone;
-        this.injector = injector;
-        this.slip39Passphrase = SCENARIO_SLIP39_PASSPHRASE;
-    }
-    getTpWrappingKeyId(tp) {
-        return tp.currentUserSharedKey.userSharedKey.sharedKey.id;
-    }
-};
-ScenarioAssemblyController.ɵprov = ɵɵdefineInjectable({ factory: function ScenarioAssemblyController_Factory() { return new ScenarioAssemblyController(ɵɵinject(NgZone), ɵɵinject(INJECTOR)); }, token: ScenarioAssemblyController, providedIn: "root" });
-ScenarioAssemblyController.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-ScenarioAssemblyController.ctorParameters = () => [
-    { type: NgZone },
-    { type: Injector }
-];
-ScenarioAssemblyController = __decorate([
-    RunOutsideAngular({
-        ngZoneName: 'ngZone',
-    })
-], ScenarioAssemblyController);
-
 const CreateScenarioMutation = gqlTyped `
 mutation CreateScenarioMutation($input: CreateScenarioInput!) {
   createScenario(input: $input) {
@@ -8592,6 +8541,35 @@ mutation DebugExpireTpPasswordResetRequestMutation($input: DebugExpireTpPassword
 }
 `;
 
+const SCENARIO_SLIP39_PASSPHRASE = 'lifeready';
+
+let ScenarioAssemblyController = class ScenarioAssemblyController extends TpAssemblyController {
+    constructor(ngZone, injector) {
+        super(injector);
+        this.ngZone = ngZone;
+        this.injector = injector;
+        this.slip39Passphrase = SCENARIO_SLIP39_PASSPHRASE;
+    }
+    getTpWrappingKeyId(tp) {
+        return tp.currentUserSharedKey.userSharedKey.sharedKey.id;
+    }
+};
+ScenarioAssemblyController.ɵprov = ɵɵdefineInjectable({ factory: function ScenarioAssemblyController_Factory() { return new ScenarioAssemblyController(ɵɵinject(NgZone), ɵɵinject(INJECTOR)); }, token: ScenarioAssemblyController, providedIn: "root" });
+ScenarioAssemblyController.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+ScenarioAssemblyController.ctorParameters = () => [
+    { type: NgZone },
+    { type: Injector }
+];
+ScenarioAssemblyController = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], ScenarioAssemblyController);
+
 const ScenarioQuery = gqlTyped `
 query ScenarioQuery(
   $scenarioId: LrRelayIdInput!
@@ -8796,12 +8774,12 @@ function throwClaimNotApproved() {
     throw new KcBadStateException('Scenario claim has not been approved');
 }
 let ScenarioService = class ScenarioService extends LrService {
-    constructor(ngZone, injector, keyGraph, item2Service, assemblyController, encryptionService) {
+    constructor(ngZone, injector, keyGraph, itemService, assemblyController, encryptionService) {
         super(injector);
         this.ngZone = ngZone;
         this.injector = injector;
         this.keyGraph = keyGraph;
-        this.item2Service = item2Service;
+        this.itemService = itemService;
         this.assemblyController = assemblyController;
         this.encryptionService = encryptionService;
         this.prepareAddReceiverDirectory = this.prepareReceiverDirectory;
@@ -9101,7 +9079,7 @@ let ScenarioService = class ScenarioService extends LrService {
     prepareReceiverDirectory(options, receiverSharedKey, assemblyKey) {
         return __awaiter(this, void 0, void 0, function* () {
             // TODO this should be batched
-            const directoryKey = yield this.item2Service.getDirectoryKey(options.directoryId, options.directoryKeyId);
+            const directoryKey = yield this.itemService.getDirectoryKey(options.directoryId, options.directoryKeyId);
             const sharedCipherData = yield this.keyGraph.encryptToString(receiverSharedKey, options.sharedCipherDataClearJson || '');
             let wrappedItemKey = yield this.keyGraph.encryptToString(receiverSharedKey, directoryKey.jwk.toJSON(true));
             // TODO fetch assemblyKeyId. We are changing it such that there is always an assembly
@@ -9303,7 +9281,7 @@ let ScenarioService = class ScenarioService extends LrService {
     }
 };
 ScenarioService.SLIP39_PASSPHRASE = 'lifeready';
-ScenarioService.ɵprov = ɵɵdefineInjectable({ factory: function ScenarioService_Factory() { return new ScenarioService(ɵɵinject(NgZone), ɵɵinject(INJECTOR), ɵɵinject(KeyGraphService), ɵɵinject(Item2Service), ɵɵinject(ScenarioAssemblyController), ɵɵinject(EncryptionService)); }, token: ScenarioService, providedIn: "root" });
+ScenarioService.ɵprov = ɵɵdefineInjectable({ factory: function ScenarioService_Factory() { return new ScenarioService(ɵɵinject(NgZone), ɵɵinject(INJECTOR), ɵɵinject(KeyGraphService), ɵɵinject(ItemService), ɵɵinject(ScenarioAssemblyController), ɵɵinject(EncryptionService)); }, token: ScenarioService, providedIn: "root" });
 ScenarioService.decorators = [
     { type: Injectable, args: [{
                 providedIn: 'root',
@@ -9313,7 +9291,7 @@ ScenarioService.ctorParameters = () => [
     { type: NgZone },
     { type: Injector },
     { type: KeyGraphService },
-    { type: Item2Service },
+    { type: ItemService },
     { type: ScenarioAssemblyController },
     { type: EncryptionService }
 ];
@@ -10117,13 +10095,13 @@ query TpCurrentUserSharedKeyQuery($id: LrRelayIdInput!) {
 }
 `;
 
-let TrustedParty2Service = class TrustedParty2Service extends LrService {
-    constructor(ngZone, injector, keyGraph, item2Service, keyService, keyFactory, encryptionService) {
+let TrustedPartyService = class TrustedPartyService extends LrService {
+    constructor(ngZone, injector, keyGraph, itemService, keyService, keyFactory, encryptionService) {
         super(injector);
         this.ngZone = ngZone;
         this.injector = injector;
         this.keyGraph = keyGraph;
-        this.item2Service = item2Service;
+        this.itemService = itemService;
         this.keyService = keyService;
         this.keyFactory = keyFactory;
         this.encryptionService = encryptionService;
@@ -10164,8 +10142,8 @@ let TrustedParty2Service = class TrustedParty2Service extends LrService {
     shareItemMutation({ itemId, itemKeyId, tpId, tpSharedKeyId, accessRole, isDirectory, }) {
         return __awaiter(this, void 0, void 0, function* () {
             const itemKey = yield this.keyGraph.getKey(itemKeyId, () => isDirectory
-                ? this.item2Service.getDirectoryKeyId(itemId)
-                : this.item2Service.getFileKeyId(itemId));
+                ? this.itemService.getDirectoryKeyId(itemId)
+                : this.itemService.getFileKeyId(itemId));
             const wrappingKey = yield this.keyGraph.getKey(tpSharedKeyId, () => this.getTpCurrentUserSharedKey(tpId).then((res) => res.sharedKey.id));
             const wrappedKey = yield this.keyGraph.wrapKey(wrappingKey, itemKey.jwk);
             return new LrMutation({
@@ -10316,26 +10294,26 @@ let TrustedParty2Service = class TrustedParty2Service extends LrService {
         });
     }
 };
-TrustedParty2Service.ɵprov = ɵɵdefineInjectable({ factory: function TrustedParty2Service_Factory() { return new TrustedParty2Service(ɵɵinject(NgZone), ɵɵinject(INJECTOR), ɵɵinject(KeyGraphService), ɵɵinject(Item2Service), ɵɵinject(KeyService), ɵɵinject(KeyFactoryService), ɵɵinject(EncryptionService)); }, token: TrustedParty2Service, providedIn: "root" });
-TrustedParty2Service.decorators = [
+TrustedPartyService.ɵprov = ɵɵdefineInjectable({ factory: function TrustedPartyService_Factory() { return new TrustedPartyService(ɵɵinject(NgZone), ɵɵinject(INJECTOR), ɵɵinject(KeyGraphService), ɵɵinject(ItemService), ɵɵinject(KeyService), ɵɵinject(KeyFactoryService), ɵɵinject(EncryptionService)); }, token: TrustedPartyService, providedIn: "root" });
+TrustedPartyService.decorators = [
     { type: Injectable, args: [{
                 providedIn: 'root',
             },] }
 ];
-TrustedParty2Service.ctorParameters = () => [
+TrustedPartyService.ctorParameters = () => [
     { type: NgZone },
     { type: Injector },
     { type: KeyGraphService },
-    { type: Item2Service },
+    { type: ItemService },
     { type: KeyService },
     { type: KeyFactoryService },
     { type: EncryptionService }
 ];
-TrustedParty2Service = __decorate([
+TrustedPartyService = __decorate([
     RunOutsideAngular({
         ngZoneName: 'ngZone',
     })
-], TrustedParty2Service);
+], TrustedPartyService);
 
 class TwoFactorService {
     constructor(auth) {
@@ -10495,5 +10473,5 @@ UserService.ctorParameters = () => [
  * Generated bundle index. Do not edit.
  */
 
-export { AccessRoleChoice, AccessRoleMethodChoice, ApiContactCard, ApiCurrentUser, Auth2Service, auth2_types as AuthTypes, CancelKeyExchangeMutation, CancelUserDeleteMutation, ClaimApproverState, ClaimState, CommonProcessorsService, CompleteKeyExchangeOtkMutation, Config, ContactCard2Service, ContactCardAddress, ContactCardName, ContactCardsQuery, CreateContactCardMutation$1 as CreateContactCardMutation, CreateFileQuery, CreateLbopQuery, CurrentUserKey, CurrentUserQuery, CurrentUserSharedKeyQuery2, DeclineKeyExchangeMutation, DefaultProcessorOptions, DeleteLbopQuery, DirectoryQuery, ERROR_SOURCE, FeatureAction, Features, FetchKeyGraphField, FileOperationField, FileQuery, FileUploadService, IdleService, InitiateKeyExchangeOtkMutation, Item2Service, KC_CONFIG, KcAuthException, KcBadArgumentException, KcBadLogicException, KcBadRequestException, KcBadSignatureException, KcBadStateException, KcBadTimeSyncException, KcCodeMismatchException, KcConcurrentAccessException, KcEncryptionException, KcError, KcErrorCode, KcException, KcInternalErrorException, KcLbopErrorCode, KcLockedException, KcNotFoundException, KcSuspiciousOperationException, KcUnsupportedException, KeyExchange2Service, KeyExchangeFields, KeyExchangeMode, KeyExchangeOtkState, KeyExchangeQuery2, KeyExchangeState, KeyExchangeTokenQuery2, KeyExchangesQuery2, KeyGraphField, KeyGraphFragment, LbopQuery, LbopService, LbopsQuery, LifeReadyModule, LinkTypeField, LockService, LockState, LoginHistoryQuery, LrApolloService, LrGraphQLService, LrMergedMutation, LrMutation, LrMutationBase, LrService, MainContactCardFields, MainContactCardPlainFields, MainContactCardProperty, MoveDirectoryQuery, MoveFileQuery, NotificationService, OwnerPlainDataJson, PassIdpApiResult, PasswordChangeStatus, PasswordCheck, PasswordService, PermissionChoice, PersistService, Plan2Service, PlanState, PlanStateField, ProfileDetailsService, ProfileService, QueryProcessorService, RegisterService, ReminderService, RequestUserDeleteMutation, RespondKeyExchangeOtkMutation, RevertFileQuery, ScenarioLastClaimState, ScenarioService, ScenarioState, ServerConfigService, ServerTimeQuery, SharedContactCard2Service, SharedTrustedPartyDetails, SharedVaultFeature, TPFeatures, TimeService, TpAssemblyState, TpClaimApproverState, TpClaimState, TpPasswordResetRequestService, TpPasswordResetService, TpPasswordResetUserService, TrustedPartiesQuery, TrustedParty, TrustedParty2Service, TrustedPartyDetails, TrustedPartyProperties, TrustedPartyType, TwoFactorService, UpdateContactCardMutation$1 as UpdateContactCardMutation, UpdateFileQuery, UpdateLbopQuery, UserDeleteState, UserService, UserSharedKeyFields, WebCryptoService, awsFetch, configureAmplifyAuth, configureApollo, fragmentSpreadAstSelection, gqlTyped, handleApolloError, handleCognitoCallback, httpOptions, mapEdges, processConnection, throwClaimIdMismatch, throwClaimNotApproved, KeyGraphService as ɵa, EncryptionService as ɵb, KeyService as ɵc, KeyFactoryService as ɵd, LrService as ɵe, RunOutsideAngular as ɵf, LrGraphQLService as ɵg, KeyMetaService as ɵh, TpPasswordResetAssemblyController as ɵi, TpAssemblyController as ɵj, SharedContactCardFields as ɵk, SharedContactCardService as ɵl, ScenarioAssemblyController as ɵm, TpPasswordResetPrivateService as ɵn };
+export { AccessRoleChoice, AccessRoleMethodChoice, ApiContactCard, ApiCurrentUser, ApproveScenarioClaimMutation, ApproveTpPasswordResetRequestMutation, ArchiveDirectoryMutation, ArchiveFileMutation, AuthService, BeginDeleteChildItemLinksWindowMutation, CancelKeyExchangeMutation, CancelScenarioClaimMutation, CancelTpPasswordResetRequestMutation, CancelUserDeleteMutation, ChangeDirectoryParentsMutation, ChangeFileParentsMutation, ClaimApproverState, ClaimState, CognitoChallengeName, CommonProcessorsService, CompleteKeyExchangeOtkMutation, CompleteTpPasswordResetRequestMutation, Config, ContactCard2Service, ContactCardAddress, ContactCardName, ContactCardsQuery, CreateContactCardMutation$1 as CreateContactCardMutation, CreateDirectoryMutation, CreateFileMutation, CreateFileQuery, CreateLbopQuery, CreateScenarioClaimMutation, CreateScenarioMutation, CreateTpAssemblyKeyChallengeMutation, CreateTpPasswordResetMutation, CurrentUserKey, CurrentUserQuery, CurrentUserSharedKeyQuery2, DebugExpireScenarioClaimMutation, DebugExpireTpPasswordResetRequestMutation, DeclineKeyExchangeMutation, DefaultProcessorOptions, DeleteDirectoryMutation, DeleteFileMutation, DeleteLbopQuery, DeleteScenarioMutation, DeleteTpPasswordResetMutation, DirectoryQuery, ERROR_SOURCE, FeatureAction, Features, FetchKeyGraphField, FileOperationField, FileQuery, FileUploadService, GetOwnedContactCardKeyIdsQuery, GetReceivedContactCardKeyIdQuery, IdleService, InitiateKeyExchangeOtkMutation, ItemService, KC_CONFIG, KcAuthException, KcBadArgumentException, KcBadLogicException, KcBadRequestException, KcBadSignatureException, KcBadStateException, KcBadTimeSyncException, KcCodeMismatchException, KcConcurrentAccessException, KcEncryptionException, KcError, KcErrorCode, KcException, KcInternalErrorException, KcLbopErrorCode, KcLockedException, KcNotFoundException, KcSuspiciousOperationException, KcUnsupportedException, KeyExchangeFields, KeyExchangeMode, KeyExchangeOtkState, KeyExchangeQuery2, KeyExchangeService, KeyExchangeState, KeyExchangeTokenQuery2, KeyExchangesQuery2, KeyGraphField, KeyGraphFragment, LbopQuery, LbopService, LbopsQuery, LifeReadyModule, LinkTypeField, LockService, LockState, LoginHistoryQuery, LrApolloService, LrGraphQLService, LrMergedMutation, LrMutation, LrMutationBase, LrService, MainContactCardFields, MainContactCardPlainFields, MainContactCardProperty, MoveDirectoryQuery, MoveFileQuery, NotificationService, OwnerPlainDataJson, PasswordChangeStatus, PasswordCheck, PasswordService, PermissionChoice, PersistService, PlanService, PlanState, PlanStateField, PreCompleteTpPasswordResetRequestMutation, ProfileDetailsService, ProfileService, QueryProcessorService, ReceiveScenarioClaimMutation, RecoveryStatus, RegisterResult, RegisterService, RejectScenarioClaimMutation, RejectTpPasswordResetRequestMutation, ReminderService, RequestUserDeleteMutation, RespondKeyExchangeOtkMutation, RevertFileMutation, RevertFileQuery, ScenarioLastClaimState, ScenarioService, ScenarioState, ServerConfigService, ServerTimeQuery, SetDirectoryConfidentialMutation, SetFileConfidentialMutation, SharedContactCard2Service, SharedTrustedPartyDetails, SharedVaultFeature, TPFeatures, TempDirectoryQuery, TimeService, TpAssemblyState, TpClaimApproverState, TpClaimState, TpPasswordResetRequestService, TpPasswordResetService, TpPasswordResetUserService, TrustedPartiesQuery, TrustedParty, TrustedPartyDetails, TrustedPartyProperties, TrustedPartyService, TrustedPartyType, TwoFactorService, UnarchiveDirectoryMutation, UnarchiveFileMutation, UpdateContactCardMutation$1 as UpdateContactCardMutation, UpdateDirectoryMutation, UpdateFileMutation, UpdateFileQuery, UpdateLbopQuery, UpdateOwnedContactCardMutation, UpdateReceivedContactCardMutation, UpdateScenarioMutation, UpdateTpPasswordResetMutation, UserDeleteState, UserService, UserSharedKeyFields, WebCryptoService, awsFetch, configureAmplifyAuth, configureApollo, fragmentSpreadAstSelection, gqlTyped, handleApolloError, handleCognitoCallback, httpOptions, mapEdges, processConnection, throwClaimIdMismatch, throwClaimNotApproved, KeyGraphService as ɵa, EncryptionService as ɵb, KeyService as ɵc, KeyFactoryService as ɵd, LrService as ɵe, RunOutsideAngular as ɵf, LrGraphQLService as ɵg, KeyMetaService as ɵh, TpPasswordResetAssemblyController as ɵi, TpAssemblyController as ɵj, SharedContactCardFields as ɵk, SharedContactCardService as ɵl, ScenarioAssemblyController as ɵm, TpPasswordResetPrivateService as ɵn };
 //# sourceMappingURL=lifeready-core.js.map