@lifeready/core 1.0.21 → 1.0.23

package/lib/{items2 → item2}/item2.service.d.ts

@@ -1,22 +1,21 @@
 import { Injector, NgZone } from '@angular/core';
-import { KeyFactoryService } from '../cryptography/key-factory.service';
-import { KeyGraphService } from '../cryptography/key-graph.service';
-import { KeyService } from '../cryptography/key.service';
-import { FileService } from '../api/file.service';
-import { CreateDirectoryMutation, DeleteDirectoryMutation, CreateFileMutation, DeleteFileMutation, UpdateFileMutation, UpdateDirectoryMutation, ArchiveDirectoryMutation, UnarchiveDirectoryMutation } from './item2.gql';
-import { ChangeFileParentsOptions, ChangeDirectoryParentsOptions, CreateDirectoryOptions, CreateFileOptions, DownloadFileContentOptions, FileParentDirectoryInput, ParentDirectoryInput, ParentRootDirectoryInput, UpdateDirectoryOptions, UpdateFileOptions, BeginDeleteChildItemLinksWindowOptions, CreateDirectoryTreeOptions, RevertFileOptions } from './item2.types';
 import { LrMutation, LrService } from '../api/lr-graphql';
 import { DirectoryNode, ID, LrRelayIdInput } from '../api/types';
-import { LockService } from '../api/lock.service';
+import { FileUploadService } from '../file-upload/file-upload.service';
+import { KeyFactoryService } from '../key/key-factory.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { KeyService } from '../key/key.service';
+import { LockService } from '../lock/lock.service';
+import { BeginDeleteChildItemLinksWindowOptions, ChangeDirectoryParentsOptions, ChangeFileParentsOptions, CreateDirectoryOptions, CreateDirectoryTreeOptions, CreateFileOptions, DownloadFileContentOptions, FileParentDirectoryInput, ParentDirectoryInput, ParentRootDirectoryInput, RevertFileOptions, UpdateDirectoryOptions, UpdateFileOptions } from './item2.types';
 export declare class Item2Service extends LrService {
     private ngZone;
     private injector;
-    private fileService;
+    private fileUploadService;
     private keyService;
     private keyFactory;
     private keyGraph;
     private lockService;
-    constructor(ngZone: NgZone, injector: Injector, fileService: FileService, keyService: KeyService, keyFactory: KeyFactoryService, keyGraph: KeyGraphService, lockService: LockService);
+    constructor(ngZone: NgZone, injector: Injector, fileUploadService: FileUploadService, keyService: KeyService, keyFactory: KeyFactoryService, keyGraph: KeyGraphService, lockService: LockService);
     static TEMP_DIRECTORY_PLAIN_META: {
         kcType: string;
     };
@@ -24,10 +23,10 @@ export declare class Item2Service extends LrService {
     downloadFileContent(options: DownloadFileContentOptions): Promise<ArrayBuffer>;
     getDirectoryKeyId(directoryId: LrRelayIdInput): Promise<string>;
     getFileKeyId(fileId: LrRelayIdInput): Promise<string>;
-    getDirectoryKey(directoryId: LrRelayIdInput, directoryKeyId?: LrRelayIdInput): Promise<import("../cryptography/cryptography.types").Key>;
-    getFileKey(fileId: LrRelayIdInput, fileKeyId?: LrRelayIdInput): Promise<import("../cryptography/cryptography.types").Key>;
-    createDirectoryExec(options: CreateDirectoryOptions): Promise<CreateDirectoryMutation>;
-    createDirectory(options: CreateDirectoryOptions): Promise<LrMutation<CreateDirectoryMutation, {
+    getDirectoryKey(directoryId: LrRelayIdInput, directoryKeyId?: LrRelayIdInput): Promise<import("../key/key.types").Key>;
+    getFileKey(fileId: LrRelayIdInput, fileKeyId?: LrRelayIdInput): Promise<import("../key/key.types").Key>;
+    createDirectoryExec(options: CreateDirectoryOptions): Promise<import("./item2.gql").CreateDirectoryMutationResult>;
+    createDirectory(options: CreateDirectoryOptions): Promise<LrMutation<import("./item2.gql").CreateDirectoryMutationResult, {
         input: {
             parentDirectories: ParentDirectoryInput[];
             parentRootDirectory: ParentRootDirectoryInput;
@@ -35,7 +34,7 @@ export declare class Item2Service extends LrService {
             cipherMeta: string;
         };
     }>>;
-    createDirectoryMutation(options: CreateDirectoryOptions): Promise<LrMutation<CreateDirectoryMutation, {
+    createDirectoryMutation(options: CreateDirectoryOptions): Promise<LrMutation<import("./item2.gql").CreateDirectoryMutationResult, {
         input: {
             parentDirectories: ParentDirectoryInput[];
             parentRootDirectory: ParentRootDirectoryInput;
@@ -43,34 +42,34 @@ export declare class Item2Service extends LrService {
             cipherMeta: string;
         };
     }>>;
-    updateDirectoryExec(options: UpdateDirectoryOptions): Promise<UpdateDirectoryMutation>;
-    updateDirectory(options: UpdateDirectoryOptions): Promise<LrMutation<UpdateDirectoryMutation, {
+    updateDirectoryExec(options: UpdateDirectoryOptions): Promise<import("./item2.gql").UpdateDirectoryMutationResult>;
+    updateDirectory(options: UpdateDirectoryOptions): Promise<LrMutation<import("./item2.gql").UpdateDirectoryMutationResult, {
         input: {
             directoryId: string;
             plainMeta: string;
             cipherMeta: string;
         };
     }>>;
-    updateDirectoryMutation(options: UpdateDirectoryOptions): Promise<LrMutation<UpdateDirectoryMutation, {
+    updateDirectoryMutation(options: UpdateDirectoryOptions): Promise<LrMutation<import("./item2.gql").UpdateDirectoryMutationResult, {
         input: {
             directoryId: string;
             plainMeta: string;
             cipherMeta: string;
         };
     }>>;
-    deleteDirectoryExec(id: ID): Promise<DeleteDirectoryMutation>;
-    deleteDirectory(id: ID): LrMutation<DeleteDirectoryMutation, {
+    deleteDirectoryExec(id: ID): Promise<import("./item2.gql").DeleteDirectoryMutationResult>;
+    deleteDirectory(id: ID): LrMutation<import("./item2.gql").DeleteDirectoryMutationResult, {
         input: {
             directoryId: string;
         };
     }>;
-    deleteDirectoryMutation(id: ID): LrMutation<DeleteDirectoryMutation, {
+    deleteDirectoryMutation(id: ID): LrMutation<import("./item2.gql").DeleteDirectoryMutationResult, {
         input: {
             directoryId: string;
         };
     }>;
-    createFileExec(options: CreateFileOptions): Promise<CreateFileMutation>;
-    createFile(options: CreateFileOptions): Promise<LrMutation<CreateFileMutation, {
+    createFileExec(options: CreateFileOptions): Promise<import("./item2.gql").CreateFileMutationResult>;
+    createFile(options: CreateFileOptions): Promise<LrMutation<import("./item2.gql").CreateFileMutationResult, {
         input: {
             parentDirectories: FileParentDirectoryInput[];
             wrappedStateKey: string;
@@ -79,7 +78,7 @@ export declare class Item2Service extends LrService {
             cipherMeta: string;
         };
     }>>;
-    createFileMutation(options: CreateFileOptions): Promise<LrMutation<CreateFileMutation, {
+    createFileMutation(options: CreateFileOptions): Promise<LrMutation<import("./item2.gql").CreateFileMutationResult, {
         input: {
             parentDirectories: FileParentDirectoryInput[];
             wrappedStateKey: string;
@@ -88,8 +87,8 @@ export declare class Item2Service extends LrService {
             cipherMeta: string;
         };
     }>>;
-    updateFileExec(options: UpdateFileOptions): Promise<UpdateFileMutation>;
-    updateFile(options: UpdateFileOptions): Promise<LrMutation<UpdateFileMutation, {
+    updateFileExec(options: UpdateFileOptions): Promise<import("./item2.gql").UpdateFileMutationResult>;
+    updateFile(options: UpdateFileOptions): Promise<LrMutation<import("./item2.gql").UpdateFileMutationResult, {
         input: {
             fileId: string;
             wrappedStateKey: string;
@@ -98,7 +97,7 @@ export declare class Item2Service extends LrService {
             cipherMeta: string;
         };
     }>>;
-    updateFileMutation(options: UpdateFileOptions): Promise<LrMutation<UpdateFileMutation, {
+    updateFileMutation(options: UpdateFileOptions): Promise<LrMutation<import("./item2.gql").UpdateFileMutationResult, {
         input: {
             fileId: string;
             wrappedStateKey: string;
@@ -114,38 +113,38 @@ export declare class Item2Service extends LrService {
     revertFileMutation(options: RevertFileOptions): Promise<LrMutation<import("./item2.gql").RevertFileMutationResult, {
         input: RevertFileOptions;
     }>>;
-    deleteFileExec(id: ID): Promise<DeleteFileMutation>;
-    deleteFile(id: ID): LrMutation<DeleteFileMutation, {
+    deleteFileExec(id: ID): Promise<import("./item2.gql").DeleteFileMutationResult>;
+    deleteFile(id: ID): LrMutation<import("./item2.gql").DeleteFileMutationResult, {
         input: {
             fileId: string;
         };
     }>;
-    deleteFileMutation(id: ID): LrMutation<DeleteFileMutation, {
+    deleteFileMutation(id: ID): LrMutation<import("./item2.gql").DeleteFileMutationResult, {
         input: {
             fileId: string;
         };
     }>;
-    archiveDirectoryExec(directoryId: string, recursive: boolean): Promise<ArchiveDirectoryMutation>;
-    archiveDirectory(directoryId: string, recursive: boolean): LrMutation<ArchiveDirectoryMutation, {
+    archiveDirectoryExec(directoryId: string, recursive: boolean): Promise<import("./item2.gql").ArchiveDirectoryMutationResult>;
+    archiveDirectory(directoryId: string, recursive: boolean): LrMutation<import("./item2.gql").ArchiveDirectoryMutationResult, {
         input: {
             directoryId: string;
             recursive: boolean;
         };
     }>;
-    archiveDirectoryMutation(directoryId: string, recursive: boolean): LrMutation<ArchiveDirectoryMutation, {
+    archiveDirectoryMutation(directoryId: string, recursive: boolean): LrMutation<import("./item2.gql").ArchiveDirectoryMutationResult, {
         input: {
             directoryId: string;
             recursive: boolean;
         };
     }>;
-    unarchiveDirectoryExec(directoryId: string, recursive: boolean): Promise<UnarchiveDirectoryMutation>;
-    unarchiveDirectory(directoryId: string, recursive: boolean): LrMutation<UnarchiveDirectoryMutation, {
+    unarchiveDirectoryExec(directoryId: string, recursive: boolean): Promise<import("./item2.gql").UnarchiveDirectoryMutationResult>;
+    unarchiveDirectory(directoryId: string, recursive: boolean): LrMutation<import("./item2.gql").UnarchiveDirectoryMutationResult, {
         input: {
             directoryId: string;
             recursive: boolean;
         };
     }>;
-    unarchiveDirectoryMutation(directoryId: string, recursive: boolean): LrMutation<UnarchiveDirectoryMutation, {
+    unarchiveDirectoryMutation(directoryId: string, recursive: boolean): LrMutation<import("./item2.gql").UnarchiveDirectoryMutationResult, {
         input: {
             directoryId: string;
             recursive: boolean;

package/lib/{cryptography → key}/key-factory.service.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="node" />
 import { JWK } from 'node-jose';
-import { LbopKeyParams, PassIdpParams, PassKeyParams, DeriveKeyResult, DerivePassIdpParams, DerivePassKeyParams, DeriveLbopKeyParams } from './cryptography.types';
-import { WebCryptoService } from './web-crypto.service';
+import { JSONObject } from '../api/types';
+import { WebCryptoService } from '../web-crypto/web-crypto.service';
+import { DeriveKeyResult, DeriveLbopKeyParams, DerivePassIdpParams, DerivePassKeyParams, LbopKeyParams, PassIdpParams, PassKeyParams } from './key.types';
 export declare function sha256(message: any): Promise<string>;
 export declare class KeyFactoryService {
     private webCryptoService;
@@ -13,7 +14,7 @@ export declare class KeyFactoryService {
     readonly DEFAULT_PASS_IDP_PBKDF_ITER = 100000;
     readonly DEFAULT_PASS_KEY_PBKDF_ITER = 100000;
     readonly DEFAULT_LBOP_KEY_PBKDF_ITER = 100000;
-    static asKey(key: string | Buffer | object | JWK.RawKey, form?: 'json' | 'private' | 'pkcs8' | 'public' | 'spki' | 'pkix' | 'x509' | 'pem', extras?: Record<string, unknown>): Promise<JWK.Key>;
+    static asKey(key: string | Buffer | Record<string, JSONObject> | JWK.RawKey, form?: 'json' | 'private' | 'pkcs8' | 'public' | 'spki' | 'pkix' | 'x509' | 'pem', extras?: Record<string, unknown>): Promise<JWK.Key>;
     randomString(digits: number): string;
     randomDigitsNoZeros(digits: number): string;
     randomChoices<T>(array: T[], chooseN: number): T[];

package/lib/{cryptography → key}/key-graph.service.d.ts

@@ -1,10 +1,10 @@
 import { JWK } from 'node-jose';
 import { JSONObject } from '../api/types';
-import { CurrentUserKey } from '../users/profile.types';
-import { Edge, Key, KeyGraphResponse, PassKey } from './cryptography.types';
-import { DecryptOptions, EncryptionService } from './encryption.service';
+import { DecryptOptions, EncryptionService } from '../encryption/encryption.service';
+import { CurrentUserKey } from '../profile/profile.types';
 import { KeyFactoryService } from './key-factory.service';
 import { KeyService } from './key.service';
+import { Key, KeyGraphEdge, KeyGraphResponse, PassKey } from './key.types';
 export interface GraphKey extends Key {
     task?: Promise<any>;
 }
@@ -21,8 +21,8 @@ export declare class KeyGraphService {
     key(id: any): GraphKey;
     passKey(id: any): PassKey;
     addKeys(src: KeyGraphResponse): void;
-    tracePath(distances: any, keyId: string): Edge[];
-    getPath(knownKeyId: string, keyId: string): Edge[];
+    tracePath(distances: any, keyId: string): KeyGraphEdge[];
+    getPath(knownKeyId: string, keyId: string): KeyGraphEdge[];
     getJwkKey(keyOrId: string | Key, getKeyIdCallback?: () => Promise<string> | string): Promise<JWK.Key>;
     getKey(keyOrId: string | Key, getKeyIdCallback?: () => Promise<string> | string): Promise<Key>;
     private _unwrapLink;
@@ -32,7 +32,7 @@ export declare class KeyGraphService {
     decryptFromString<T>(keyOrId: string | Key, cipherData: string, options?: DecryptOptions): Promise<T>;
     decryptFile(keyId: string, file: any): Promise<any>;
     encryptToString(key: string | Key | JWK.Key, content: any): Promise<string>;
-    wrapKey<T>(wrappingKey: string | Key | JWK.Key, key: JWK.Key): Promise<string>;
+    wrapKey(wrappingKey: string | Key | JWK.Key, key: JWK.Key): Promise<string>;
     encryptWithNewKey(wrappingKeyId: string, cipherClearJson: JSONObject): Promise<{
         key: JWK.Key;
         wrappingKeyId: string;

package/lib/{cryptography → key}/key-meta.service.d.ts

@@ -1,6 +1,6 @@
 import { JWK } from 'node-jose';
 import { LrApolloService } from '../api/lr-apollo.service';
-import { EncryptionService } from './encryption.service';
+import { EncryptionService } from '../encryption/encryption.service';
 import { KeyFactoryService } from './key-factory.service';
 import { KeyGraphService } from './key-graph.service';
 import { KeyService } from './key.service';

package/lib/{cryptography → key}/key.service.d.ts

@@ -1,6 +1,6 @@
-import { Key, PassKey } from './cryptography.types';
-import { PersistService } from '../api/persist.service';
 import { LifeReadyConfig } from '../life-ready.config';
+import { PersistService } from '../persist/persist.service';
+import { Key, PassKey } from './key.types';
 export declare class UserKeys {
     passKey: PassKey;
     masterKey: Key;

package/lib/{cryptography/cryptography.types.d.ts → key/key.types.d.ts}

@@ -1,4 +1,6 @@
 import { JWK } from 'node-jose';
+import { JSONObject, PassKeyNode } from '../api/types';
+import { SomeRequired } from '../_common/types';
 export interface Key {
     id: string;
     pbk?: string;
@@ -19,20 +21,14 @@ export interface LbopKeyParams {
     iterations: number;
 }
 export interface PassIdpVerifier {
-    wrappedPrK: object;
-    pbk: object;
+    wrappedPrK: Record<string, JSONObject>;
+    pbk: Record<string, JSONObject>;
 }
 export interface LbopKeyVerifier {
-    wrappedKey: object;
-    key: object;
-}
-export interface PassKey {
-    id: string;
-    passKeyParams?: PassKeyParams;
-    passIdpParams?: PassIdpParams;
-    wrappedPassIdpVerifierPrk?: object;
-    created?: string;
+    wrappedKey: Record<string, JSONObject>;
+    key: Record<string, JSONObject>;
 }
+export declare type PassKey = SomeRequired<PassKeyNode, 'id'>;
 export interface KeyLink {
     keyId: string;
     wrappingKeyId: string;
@@ -43,20 +39,20 @@ export interface PassKeyLink {
     passKeyId: string;
     wrappedKey: string;
 }
-export declare enum NodeType {
+export declare enum KeyGraphNodeType {
     Key = "key",
     PassKey = "passKey"
 }
-export interface Node {
-    type: NodeType;
+export interface KeyGraphNode {
+    type: KeyGraphNodeType;
     data: Key | PassKey;
 }
-export declare enum EdgeType {
+export declare enum KeyGraphEdgeType {
     KeyLink = "keyLink",
     PassKeyLink = "passKeyLink"
 }
-export interface Edge {
-    type: EdgeType;
+export interface KeyGraphEdge {
+    type: KeyGraphEdgeType;
     data: KeyLink | PassKeyLink;
 }
 export interface KeyGraphResponse {

package/lib/{api → key-exchange}/key-exchange.service.d.ts

@@ -1,10 +1,10 @@
+import { LrApolloService } from '../api/lr-apollo.service';
 import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
-import { EncryptionService } from '../cryptography/encryption.service';
-import { KeyService } from '../cryptography/key.service';
-import { UserService } from './../users/user.service';
+import { EncryptionService } from '../encryption/encryption.service';
+import { KeyFactoryService as KFS } from '../key/key-factory.service';
+import { KeyService } from '../key/key.service';
+import { UserService } from '../user/user.service';
 import { CompleteOtk, DecryptedKeyExchange, GetKeyExchangeListOptions, GetKeyExchangeOptions, InitiateOtkInput, KeyExchange, RespondOtk, RespondOtkInput, UserSharedKey } from './key-exchange.types';
-import { LrApolloService } from './lr-apollo.service';
-import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
 export declare class KeyExchangeService {
     private keyFactory;
     private keyService;

package/lib/{api → key-exchange}/key-exchange.types.d.ts

@@ -1,8 +1,8 @@
-import { Key } from '../cryptography/cryptography.types';
-import { AccessLevel } from '../category/category.types';
 import { JWK } from 'node-jose';
-import { ContactCardName, TrustedPartyDetails } from '../users/profile.types';
-import { JSONObject, KeyExchangeMode, KeyExchangeState } from './types';
+import { JSONObject, KeyExchangeMode, KeyExchangeState } from '../api/types';
+import { AccessLevel } from '../category/category.types';
+import { Key } from '../key/key.types';
+import { ContactCardName, TrustedPartyDetails } from '../profile/profile.types';
 export interface PlainInitiatorRootKeyCipher {
     nonce: string;
     oneTimePrk: object;

package/lib/{api → key-exchange}/key-exchange2.gql.d.ts

@@ -1,5 +1,5 @@
 import { JWK } from 'node-jose';
-import { Connection, DateTime, ID, JSONObject, LrEmail, OtKeyCipherClearJson2 } from './types';
+import { Connection, DateTime, ID, JSONObject, LrEmail, OtKeyCipherClearJson2 } from '../api/types';
 export declare type KeyExchangeState2 = 'IN_PROGRESS' | 'COMPLETED' | 'DECLINED' | 'CANCELLED' | 'DELETED';
 export interface KeyExchangeFragment {
     id: ID;

package/lib/{api → key-exchange}/key-exchange2.service.d.ts

@@ -1,14 +1,13 @@
-import { NgZone } from '@angular/core';
+import { Injector, NgZone } from '@angular/core';
 import { JWK } from 'node-jose';
-import { EncryptionService } from '../cryptography/encryption.service';
-import { KeyFactoryService } from '../cryptography/key-factory.service';
-import { KeyGraphService } from '../cryptography/key-graph.service';
-import { KeyService } from '../cryptography/key.service';
-import { UserService } from './../users/user.service';
-import { OwnerPlainDataJson } from './contact-card2.service';
+import { LrMutation, LrService } from '../api/lr-graphql';
+import { ContactCardSharedCipherData, JSONObject, OtKeyCipherClearJson2 } from '../api/types';
+import { OwnerPlainDataJson } from '../contact-card/contact-card2.service';
+import { EncryptionService } from '../encryption/encryption.service';
+import { KeyFactoryService } from '../key/key-factory.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { KeyService } from '../key/key.service';
 import { CancelKeyExchangeMutation, CompleteKeyExchangeOtkMutation, CurrentUserSharedKeyQuery2, DeclineKeyExchangeMutation, InitiateKeyExchangeOtkMutation, KeyExchangeFragment, KeyExchangeState2, RespondKeyExchangeOtkMutation } from './key-exchange2.gql';
-import { LrGraphQLService, LrMutation } from './lr-graphql';
-import { ContactCardSharedCipherData, JSONObject, OtKeyCipherClearJson2 } from './types';
 /**
  * The decrypted content of the one-time key cipher;
  * When user supplies this information the lib doesn't need to do another API call
@@ -35,7 +34,7 @@ export interface ContactCardOwnerCipherData {
 export declare type SendContactCardInput = ContactCardOwnerPlainData & ContactCardOwnerCipherData & ContactCardSharedCipherData;
 export interface InitiateOtkInput2 {
     email?: string;
-    message?: any;
+    message?: JSONObject;
     contactCard?: SendContactCardInput;
     upgrade?: boolean;
 }
@@ -43,7 +42,7 @@ export interface RespondOtkInput2 {
     keyExchangeId: string;
     token: string;
     decryptedOtk: DecryptedOtk2;
-    message?: any;
+    message?: JSONObject;
     initiatorContactCard?: ContactCardReceiverCipherData;
     responderContactCard?: SendContactCardInput;
 }
@@ -56,24 +55,24 @@ export interface CompleteOtkInput2 {
 }
 export interface InitiatorRootKeyCipherClearJson2 {
     nonce: string;
-    oneTimePrk: object;
-    otKey: object;
+    oneTimePrk: Record<string, JSONObject>;
+    otKey: Record<string, JSONObject>;
     initiatorContactCard?: ContactCardOwnerCipherData & ContactCardSharedCipherData;
     initiator: {
-        message?: any;
+        message?: JSONObject;
         contactCard?: ContactCardSharedCipherData;
     };
 }
 export interface InitiatorOneTimePbkCipherClearJson {
     nonce: string;
-    sharedKey: object;
-    mkSharedKey: object;
+    sharedKey: Record<string, JSONObject>;
+    mkSharedKey: Record<string, JSONObject>;
     responder: {
-        pbk: object;
-        sigPbk: object;
-        message?: any;
+        pbk: Record<string, JSONObject>;
+        sigPbk: Record<string, JSONObject>;
+        message?: JSONObject;
         contactCard?: ContactCardSharedCipherData & {
-            sharedCipherKey: object;
+            sharedCipherKey: Record<string, JSONObject>;
         };
     };
 }
@@ -81,16 +80,15 @@ export interface GetKeyExchangeOptions2 {
     otKeyK?: string;
     token?: string;
 }
-export declare class KeyExchange2Service {
+export declare class KeyExchange2Service extends LrService {
     private ngZone;
+    private injector;
     private keyFactory;
     private keyService;
     private encryptionService;
-    private userService;
     private keyGraph;
-    private lrGraphQL;
     private readonly CLIENT_NONCE_LENGTH;
-    constructor(ngZone: NgZone, keyFactory: KeyFactoryService, keyService: KeyService, encryptionService: EncryptionService, userService: UserService, keyGraph: KeyGraphService, lrGraphQL: LrGraphQLService);
+    constructor(ngZone: NgZone, injector: Injector, keyFactory: KeyFactoryService, keyService: KeyService, encryptionService: EncryptionService, keyGraph: KeyGraphService);
     private getOtKey;
     private decryptOtk;
     private decryptResponseCipher;
@@ -121,19 +119,21 @@ export declare class KeyExchange2Service {
             id: string;
         };
     }>;
-    declineKeyExchange(id: string, token: string): Promise<LrMutation<DeclineKeyExchangeMutation, {
+    declineKeyExchangeExec(id: string, token: string): Promise<DeclineKeyExchangeMutation>;
+    declineKeyExchange(id: string, token: string): LrMutation<DeclineKeyExchangeMutation, {
         input: {
             id: string;
             token: string;
         };
-    }>>;
+    }>;
     declineKeyExchangeMutation(id: string, token: string): LrMutation<DeclineKeyExchangeMutation, {
         input: {
             id: string;
             token: string;
         };
     }>;
-    initiateOtk({ message, email, contactCard, upgrade, }?: InitiateOtkInput2): Promise<{
+    initiateOtkExec(input?: InitiateOtkInput2): Promise<InitiateKeyExchangeOtkMutation>;
+    initiateOtk(input?: InitiateOtkInput2): Promise<{
         lrMutation: LrMutation<InitiateKeyExchangeOtkMutation, {
             input: {
                 initiatorRootKeyCipher: string;
@@ -152,7 +152,44 @@ export declare class KeyExchange2Service {
         }>;
         otKeyK: string;
     }>;
-    respondOtk({ keyExchangeId, token, decryptedOtk, message, initiatorContactCard, responderContactCard, }: RespondOtkInput2): Promise<LrMutation<RespondKeyExchangeOtkMutation, {
+    initiateOtkMutation({ message, email, contactCard, upgrade, }?: InitiateOtkInput2): Promise<{
+        lrMutation: LrMutation<InitiateKeyExchangeOtkMutation, {
+            input: {
+                initiatorRootKeyCipher: string;
+                initiatorPxkId: string;
+                initiatorSigPxkId: string;
+                otKeyParams: string;
+                otKeyCipher: string;
+                sendEmail: {
+                    email: string;
+                    rawOtKey: string;
+                };
+                createTp: boolean;
+                initiatorPlainDataSig: string;
+                upgrade: boolean;
+            };
+        }>;
+        otKeyK: string;
+    }>;
+    respondOtkExec(input: RespondOtkInput2): Promise<RespondKeyExchangeOtkMutation>;
+    respondOtk(input: RespondOtkInput2): Promise<LrMutation<RespondKeyExchangeOtkMutation, {
+        input: {
+            keyExchangeId: string;
+            keyExchangeToken: string;
+            rootKeyId: string;
+            masterKeyId: string;
+            responderPxkId: string;
+            responderSigPxkId: string;
+            signedInitiatorPbk: string;
+            signedInitiatorSigPbk: string;
+            rkWrappedSharedKey: string;
+            mkWrappedMkSharedKey: string;
+            initiatorOneTimePbkCipher: string;
+            initiatorContactCard: any;
+            responderContactCard: any;
+        };
+    }>>;
+    respondOtkMutation({ keyExchangeId, token, decryptedOtk, message, initiatorContactCard, responderContactCard, }: RespondOtkInput2): Promise<LrMutation<RespondKeyExchangeOtkMutation, {
         input: {
             keyExchangeId: string;
             keyExchangeToken: string;
@@ -169,7 +206,23 @@ export declare class KeyExchange2Service {
             responderContactCard: any;
         };
     }>>;
-    completeOtk({ keyExchangeId, initiatorRootKeyCipher, initiatorOneTimePbkCipher, responderContactCard, initiatorContactCard, }: CompleteOtkInput2): Promise<LrMutation<CompleteKeyExchangeOtkMutation, {
+    completeOtkExec(input: CompleteOtkInput2): Promise<CompleteKeyExchangeOtkMutation>;
+    completeOtk(input: CompleteOtkInput2): Promise<LrMutation<CompleteKeyExchangeOtkMutation, {
+        input: {
+            keyExchangeId: string;
+            rootKeyId: string;
+            masterKeyId: string;
+            initiatorSigPxkId: string;
+            signedResponderPbk: string;
+            signedResponderSigPbk: string;
+            rkWrappedSharedKey: string;
+            mkWrappedMkSharedKey: string;
+            responderContactCardCipher: any;
+            initiatorContactCardCipher: any;
+            initiatorContactCardSharedCipher: any;
+        };
+    }>>;
+    completeOtkMutation({ keyExchangeId, initiatorRootKeyCipher, initiatorOneTimePbkCipher, responderContactCard, initiatorContactCard, }: CompleteOtkInput2): Promise<LrMutation<CompleteKeyExchangeOtkMutation, {
         input: {
             keyExchangeId: string;
             rootKeyId: string;

package/lib/{auth → lbop}/lbop.service.d.ts

@@ -1,14 +1,14 @@
-import { LrApolloService } from '../api/lr-apollo.service';
 import { HttpClient } from '@angular/common/http';
 import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
 import { JWK } from 'node-jose';
-import { EncryptionService } from '../cryptography/encryption.service';
-import { KeyGraphService } from '../cryptography/key-graph.service';
-import { KeyService } from '../cryptography/key.service';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { EncryptionService } from '../encryption/encryption.service';
+import { KeyFactoryService as KFS } from '../key/key-factory.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { KeyService } from '../key/key.service';
 import { LifeReadyConfig } from '../life-ready.config';
-import { LifeReadyAuthService } from './life-ready-auth.service';
-import { PasswordService } from './password.service';
-import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
+import { PasswordService } from '../password/password.service';
 export interface SetPasswordParams {
     lbopId: string;
     newPassword: string;

package/lib/life-ready.config.d.ts

@@ -1,6 +1,6 @@
 import { InjectionToken } from '@angular/core';
-import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
 import { ApolloClientOptions } from '@apollo/client/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
 export declare const LR_CONFIG: InjectionToken<LifeReadyConfig>;
 export interface LifeReadyConfig {
     authUrl: string;

package/lib/{api → lock}/lock.gql.d.ts

@@ -1,4 +1,4 @@
-import { DateTime, LockState, UUID } from './types';
+import { DateTime, LockState, UUID } from '../api/types';
 export interface LockFragmentResult {
     created: DateTime;
     modified: DateTime;

package/lib/{api → lock}/lock.service.d.ts

@@ -1,5 +1,5 @@
 import { Injector, NgZone } from '@angular/core';
-import { LrMutation, LrService } from './lr-graphql';
+import { LrMutation, LrService } from '../api/lr-graphql';
 export declare class LockService extends LrService {
     private ngZone;
     private injector;

package/lib/message/message.gql.d.ts

@@ -0,0 +1,13 @@
+import { ID, MessageNode } from '../api/types';
+export interface SendMessageMutationResult {
+    sendMessage: {
+        message: {
+            id: ID;
+        };
+    };
+}
+export declare const SendMessageMutation: import("../_common/ast").TypedDocumentNode<SendMessageMutationResult>;
+export interface MessageQueryResult {
+    message: MessageNode;
+}
+export declare const MessageQuery: import("../_common/ast").TypedDocumentNode<MessageQueryResult>;

package/lib/message/message.service.d.ts

@@ -0,0 +1,36 @@
+import { Injector, NgZone } from '@angular/core';
+import { JWK } from 'node-jose';
+import { LrMutation, LrService } from '../api/lr-graphql';
+import { MessageNode } from '../api/types';
+import { EncryptionService } from '../encryption/encryption.service';
+import { KeyExchangeService } from '../key-exchange/key-exchange.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { SendMessageInput } from './message.types';
+export declare class MessageService extends LrService {
+    private ngZone;
+    private injector;
+    private keyGraph;
+    private encryptionService;
+    private keyExchangeService;
+    private readonly encrypt;
+    private readonly decrypt;
+    private readonly sign;
+    private readonly verify;
+    constructor(ngZone: NgZone, injector: Injector, keyGraph: KeyGraphService, encryptionService: EncryptionService, keyExchangeService: KeyExchangeService);
+    sendMessage(input: SendMessageInput): Promise<import("./message.gql").SendMessageMutationResult>;
+    sendMessageMutation({ username, userId, plainMessageJson, plainCipherMessageJson, }: SendMessageInput): Promise<LrMutation<import("./message.gql").SendMessageMutationResult, {
+        input: {
+            receiverUsername: string;
+            receiverId: string;
+            sharedKeyId: string;
+            senderSigPbkId: string;
+            signedCipherMessage: string;
+            plainMessage: string;
+        };
+    }>>;
+    decryptMessage(message: MessageNode, options: {
+        sharedKey: JWK.Key;
+        senderSigPbk: JWK.Key;
+    }): Promise<void>;
+    getMessage(id: string): Promise<MessageNode>;
+}