@lifeready/core 0.6.0-beta.1

package/lib/_common/ast.d.ts

@@ -0,0 +1,11 @@
+import { DocumentNode, FieldNode, FragmentDefinitionNode, NameNode, OperationDefinitionNode, OperationTypeNode } from 'graphql';
+export declare function getAstOperation(astDocument: any, operation: OperationTypeNode): OperationDefinitionNode;
+export declare function getQuery(doc: DocumentNode): OperationDefinitionNode;
+export declare function getMutation(doc: DocumentNode): OperationDefinitionNode;
+export declare function getFragments(doc: DocumentNode): FragmentDefinitionNode[];
+export declare function getFragment(astDocument: DocumentNode): FragmentDefinitionNode;
+export declare function name(value: string): NameNode;
+export declare function getAliasOrName(field: FieldNode): string;
+export interface TypedDocumentNode<T> extends DocumentNode {
+}
+export declare function gqlTyped<T = any>(literals: ReadonlyArray<string> | Readonly<string>, ...placeholders: any[]): TypedDocumentNode<T>;

package/lib/_common/deferred-promise.d.ts

@@ -0,0 +1,12 @@
+export declare type ResolvePromise<T> = (value?: T | PromiseLike<T>) => void;
+export declare type RejectPromise = (reason?: any) => void;
+export declare class DeferredPromise<T> {
+    readonly promise: Promise<T>;
+    private _resolve;
+    private _reject;
+    private _fulfilled;
+    constructor();
+    get resolve(): ResolvePromise<T>;
+    get reject(): RejectPromise;
+    get fulfilled(): boolean;
+}

package/lib/_common/exceptions.d.ts

@@ -0,0 +1,109 @@
+import { GraphQLError } from 'graphql';
+export declare function handleApolloError(errors: ReadonlyArray<GraphQLError>): void;
+export declare class LrError {
+    code?: string;
+    source?: string;
+    message: string;
+    debug?: {
+        locations: {
+            line: number;
+            column: number;
+        }[];
+        path: string[];
+    };
+}
+export declare class LrException {
+    errors: LrError[];
+    constructor(...errors: LrError[]);
+    toString(): string[];
+}
+export declare enum LrApiErrorCode {
+    ARCHIVED_RESOURCE = "ARCHIVED_RESOURCE",
+    BAD_ARGUMENT = "BAD_ARGUMENT",
+    BAD_SIGNATURE = "BAD_SIGNATURE",
+    BAD_STATE = "BAD_STATE",
+    CHANGED_PERMISSIONS = "CHANGED_PERMISSIONS",
+    CONCURRENT_ACCESS = "CONCURRENT_ACCESS",
+    CONFIG_ERROR = "CONFIG_ERROR",
+    CYCLE_DETECTED = "CYCLE_DETECTED",
+    EXPIRED = "EXPIRED",
+    INVALID_TOKEN = "INVALID_TOKEN",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    JSON_DECODE_ERROR = "JSON_DECODE_ERROR",
+    KEY_MISMATCH = "KEY_MISMATCH",
+    LIMIT_REACHED = "LIMIT_REACHED",
+    LOCKED = "LOCKED",
+    LOGIC_ERROR = "LOGIC_ERROR",
+    LR_DEBUG_ONLY = "LR_DEBUG_ONLY",
+    MIN_DELAY = "MIN_DELAY",
+    MISSING_FIELD = "MISSING_FIELD",
+    MISSING_FIELD_VALUE = "MISSING_FIELD_VALUE",
+    MISSING_QUERY_PARAM = "MISSING_QUERY_PARAM",
+    NOT_IMPLEMENTED = "NOT_IMPLEMENTED",
+    OBJECT_DOES_NOT_EXIST = "OBJECT_DOES_NOT_EXIST",
+    OBJECT_EXISTS = "OBJECT_EXISTS",
+    RANGE_ERROR = "RANGE_ERROR",
+    TRUSTED_PARTY_NOT_FOUND = "TRUSTED_PARTY_NOT_FOUND",
+    UNAUTHENTICATED_USER = "UNAUTHENTICATED_USER",
+    USER_NOT_FOUND = "USER_NOT_FOUND",
+    VERSION_MISMATCH = "VERSION_MISMATCH",
+    WRONG_PERMISSIONS = "WRONG_PERMISSIONS"
+}
+export declare enum LrErrorCode {
+    BadTimeSync = "LrBadTimeSync",
+    ReceiveClaimMismatch = "LrReceiveClaimMismatch",
+    BadState = "LrBadState",
+    BadSignature = "LrBadSignature",
+    Auth = "LrAuth",
+    BadArgument = "LrBadArgument",
+    SuspiciousException = "LrSuspiciousException",
+    NotFound = "LrNotFound",
+    BadLogic = "LrBadLogicException",
+    CodeMismatch = "LrCodeMismatchException",
+    ConcurrentAccess = "LrConcurrentAccessException",
+    BadRequest = "LrBadRequestException",
+    Encryption = "LrEncryptionGoBad",
+    Locked = "LrLockedException"
+}
+export declare class LrBadArgumentException extends LrException {
+    constructor(message: any);
+}
+export declare class LrSuspiciousException extends LrException {
+    constructor(message: any);
+}
+export declare class LrNotFoundException extends LrException {
+    constructor(message: any);
+}
+export declare class LrBadLogicException extends LrException {
+    constructor(message: any);
+}
+export declare class LrCodeMismatchException extends LrException {
+    constructor(message: any);
+}
+export declare class LrConcurrentAccessException extends LrException {
+    constructor(message: any);
+}
+export declare class LrLockedException extends LrException {
+    constructor(message: any);
+}
+export declare class LrBadRequestException extends LrException {
+    constructor(message: any);
+}
+export declare class LrAuthException extends LrException {
+    constructor(message: any);
+}
+export declare class LrEncryptionException extends LrException {
+    constructor(message: any);
+}
+export declare class LrUnsupportedException extends LrException {
+    constructor(message: any);
+}
+export declare class LrExpiredCodeException extends LrException {
+    constructor(message: any);
+}
+export declare class LrExpiredException extends LrException {
+    constructor(message: any);
+}
+export declare class LrBadStateException extends LrException {
+    constructor(message: any);
+}

package/lib/_common/queries.gql.d.ts

@@ -0,0 +1,10 @@
+export declare const KeyGraphFragment: import("graphql").DocumentNode;
+export declare const KeyGraphField: string;
+export declare const FetchKeyGraphField: string;
+export declare const FileQuery: import("graphql").DocumentNode;
+export declare const DirectoryQuery: import("graphql").DocumentNode;
+export declare const CreateFileQuery: import("graphql").DocumentNode;
+export declare const UpdateFileQuery: import("graphql").DocumentNode;
+export declare const RevertFileQuery: import("graphql").DocumentNode;
+export declare const MoveFileQuery: import("graphql").DocumentNode;
+export declare const MoveDirectoryQuery: import("graphql").DocumentNode;

package/lib/_common/run-outside-angular.d.ts

@@ -0,0 +1,14 @@
+export interface RunOutsideAngularConfig {
+    ngZoneName: string;
+    exceptLastPromise?: boolean;
+    excludeMethods?: string[];
+    patchSetters?: boolean;
+}
+/**
+ * If you wish to change the behaviour of those, you'll need to create a derived
+ * class and override the methods.
+ * However, can't figure out a way to call the super() in the derived class ctor, error says
+ * the super call can't be in tested function.
+ */
+export declare const EXCLUDE_METHODS: string[];
+export declare function RunOutsideAngular({ ngZoneName, exceptLastPromise, excludeMethods, patchSetters, }: RunOutsideAngularConfig): (target: any) => any;

package/lib/_common/types.d.ts

@@ -0,0 +1,10 @@
+import { HasKeyGraph } from '../cryptography/cryptography.types';
+export interface Edge<T> {
+    node: T;
+}
+export interface HasEdges<T> {
+    edges: Edge<T>[];
+}
+export interface HasKeyGraphEdges<T> extends HasKeyGraph {
+    list: HasEdges<T>;
+}

package/lib/_common/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function promiseAllMayAsync(values: any[]): Promise<any> | any;
+export declare function mapValuesMayAsync(obj: object, callback: (value: any, key: string, obj: object) => any | Promise<any>): Promise<any> | any;
+export declare function mapValuesAsync(obj: object, callback?: (value: any, key: string, obj: object) => any | Promise<any>): Promise<any>;

package/lib/api/contact-card.gql.d.ts

@@ -0,0 +1,7 @@
+export declare const ContactCardFields = "\nid\npublicData\npublicSearchable\ncipherData\nkey {\n  id\n}\n";
+export declare const ContactCardQuery: import("graphql").DocumentNode;
+export declare const SearchContactCardQuery: import("graphql").DocumentNode;
+export declare const ContactCardListQuery: import("graphql").DocumentNode;
+export declare const CreateContactCardMutation: import("graphql").DocumentNode;
+export declare const UpdateContactCardMutation: import("graphql").DocumentNode;
+export declare const DeleteContactCardMutation: import("graphql").DocumentNode;

package/lib/api/contact-card.service.d.ts

@@ -0,0 +1,52 @@
+import { Key } from '../cryptography/cryptography.types';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyService } from '../cryptography/key.service';
+import { HasEdges } from '../_common/types';
+import { LrApolloService } from './lr-apollo.service';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { MainContactCardPlainFields } from '../users/profile.types';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+export declare class ContactCard {
+    id: string;
+    key: Key;
+    sigPxk: Key;
+    publicData: string;
+    publicDataSig: string;
+    publicSearchable: string;
+    publicSearchableSig: string;
+    plainData: string;
+    plainDataSig: string;
+    cipherData: string;
+    publicDataJson: any;
+    publicSearchableJson: any;
+    plainCipherDataJson: any;
+    plainDataJson: any;
+}
+export interface CreateContactCardInput {
+    publicDataJson: any;
+    publicSearchableJson: any;
+    plainCipherDataJson: any;
+    plainDataJson: MainContactCardPlainFields;
+}
+export interface UpdateContactCardInput extends CreateContactCardInput {
+    id: string;
+}
+export declare class ContactCardService {
+    private keyFactory;
+    private keyService;
+    private lrApollo;
+    private keyGraph;
+    private encryptionService;
+    private keyMetaService;
+    constructor(keyFactory: KeyFactoryService, keyService: KeyService, lrApollo: LrApolloService, keyGraph: KeyGraphService, encryptionService: EncryptionService, keyMetaService: KeyMetaService);
+    decryptContactCard(cc: ContactCard): Promise<ContactCard>;
+    decryptContactCardEdges(hasEdges: HasEdges<ContactCard>): Promise<ContactCard[]>;
+    searchContactCard(publicSearchable: object): Promise<ContactCard[]>;
+    getContactCardList(): Promise<ContactCard[]>;
+    getContactCard(id: string): Promise<ContactCard>;
+    private prepareContactCardInput;
+    createContactCard(input: CreateContactCardInput): Promise<ContactCard>;
+    updateContactCard(input: UpdateContactCardInput): Promise<ContactCard>;
+    deleteContactCard(id: string): Promise<string>;
+}

package/lib/api/contact-card2.gql.d.ts

@@ -0,0 +1,34 @@
+import { Connection, ContactCardNode, ID } from './types';
+export declare const ContactCardFragment: import("../_common/ast").TypedDocumentNode<ContactCardNode>;
+export interface CreateContactCardMutation {
+    createContactCard: {
+        contactCard: {
+            id: ID;
+        };
+    };
+}
+export declare const CreateContactCardMutation: import("../_common/ast").TypedDocumentNode<CreateContactCardMutation>;
+export interface UpdateContactCardMutation {
+    updateContactCard: {
+        contactCard: {
+            id: ID;
+        };
+    };
+}
+export declare const UpdateContactCardMutation: import("../_common/ast").TypedDocumentNode<UpdateContactCardMutation>;
+export interface DeleteContactCardMutation {
+    deleteContactCard: {
+        deleteContactCard: {
+            id: ID;
+        };
+    };
+}
+export declare const DeleteContactCardMutation: import("../_common/ast").TypedDocumentNode<DeleteContactCardMutation>;
+export interface ContactCardsQuery {
+    contactCards: Connection<ContactCardNode>;
+}
+export declare const ContactCardsQuery: import("../_common/ast").TypedDocumentNode<ContactCardsQuery>;
+export interface ContactCardQuery {
+    contactCard: ContactCardNode;
+}
+export declare const ContactCardQuery: import("../_common/ast").TypedDocumentNode<ContactCardQuery>;

package/lib/api/contact-card2.service.d.ts

@@ -0,0 +1,49 @@
+import { NgZone } from '@angular/core';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { KeyService } from '../cryptography/key.service';
+import { MainContactCardPlainFields } from '../users/profile.types';
+import { CreateContactCardMutation, DeleteContactCardMutation, UpdateContactCardMutation } from './contact-card2.gql';
+import { LrMutation } from './lr-graphql';
+export interface CreateContactCardInput2 {
+    publicDataJson: any;
+    publicSearchableJson: any;
+    plainCipherDataJson: any;
+    plainDataJson: MainContactCardPlainFields;
+}
+export interface ContactCardName2 {
+    name: string;
+    title?: string;
+    firstName?: string;
+    lastName?: string;
+}
+export declare class OwnerPlainDataJson {
+    name: ContactCardName2;
+}
+export interface UpdateContactCardInput2 extends CreateContactCardInput2 {
+    id: string;
+    keyId: string;
+}
+export declare class ContactCard2Service {
+    private keyFactory;
+    private keyService;
+    private encryptionService;
+    private keyGraph;
+    private keyMetaService;
+    private ngZone;
+    constructor(keyFactory: KeyFactoryService, keyService: KeyService, encryptionService: EncryptionService, keyGraph: KeyGraphService, keyMetaService: KeyMetaService, ngZone: NgZone);
+    createContactCard(input: CreateContactCardInput2): Promise<LrMutation<CreateContactCardMutation, {
+        input: any;
+    }>>;
+    updateContactCard(input: UpdateContactCardInput2): Promise<LrMutation<UpdateContactCardMutation, {
+        input: any;
+    }>>;
+    deleteContactCard(id: string): LrMutation<DeleteContactCardMutation, {
+        input: {
+            id: string;
+        };
+    }>;
+    private prepareContactCardInput;
+}

package/lib/api/file.service.d.ts

@@ -0,0 +1,18 @@
+import { HttpClient } from '@angular/common/http';
+import { LifeReadyConfig } from '../life-ready.config';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+export declare type FileContentContext = 'FILE_STATE';
+export interface UploadEncryptedFileOptions {
+    encryptedContent: string;
+    fileName?: string;
+}
+export declare class FileService {
+    private config;
+    private http;
+    private lrAuth;
+    constructor(config: LifeReadyConfig, http: HttpClient, lrAuth: LifeReadyAuthService);
+    downloadEncryptedFile(fileStateNodeId: string): Promise<any>;
+    downloadEncryptedFile2(fileStateNodeId: string): Promise<string>;
+    loadFile(file: File): Promise<ArrayBuffer>;
+    uploadEncryptedFile(options: UploadEncryptedFileOptions): Promise<string>;
+}

package/lib/api/item2.gql.d.ts

@@ -0,0 +1,96 @@
+import { DateTime, ID } from './types';
+export interface DirectoryKeyQuery {
+    directory: {
+        keyId: ID;
+    };
+}
+export declare const DirectoryKeyQuery: import("../_common/ast").TypedDocumentNode<DirectoryKeyQuery>;
+export interface FileKeyQuery {
+    file: {
+        keyId: ID;
+    };
+}
+export declare const FileKeyQuery: import("../_common/ast").TypedDocumentNode<FileKeyQuery>;
+export interface FileStateKeyQuery {
+    fileState: {
+        keyId: ID;
+    };
+}
+export declare const FileStateKeyQuery: import("../_common/ast").TypedDocumentNode<FileStateKeyQuery>;
+export interface CreateDirectoryMutation {
+    createDirectory: {
+        directory: {
+            id: ID;
+        };
+    };
+}
+export declare const CreateDirectoryMutation: import("../_common/ast").TypedDocumentNode<CreateDirectoryMutation>;
+export interface UpdateDirectoryMutation {
+    updateDirectory: {
+        directory: {
+            id: ID;
+            modified: DateTime;
+        };
+    };
+}
+export declare const UpdateDirectoryMutation: import("../_common/ast").TypedDocumentNode<UpdateDirectoryMutation>;
+export interface DeleteDirectoryMutation {
+    deleteDirectory: {
+        id: ID;
+    };
+}
+export declare const DeleteDirectoryMutation: import("../_common/ast").TypedDocumentNode<DeleteDirectoryMutation>;
+export interface CreateFileMutation {
+    createFile: {
+        file: {
+            id: ID;
+        };
+    };
+}
+export declare const CreateFileMutation: import("../_common/ast").TypedDocumentNode<CreateFileMutation>;
+export interface UpdateFileMutation {
+    updateFile: {
+        file: {
+            id: ID;
+        };
+    };
+}
+export declare const UpdateFileMutation: import("../_common/ast").TypedDocumentNode<UpdateFileMutation>;
+export interface DeleteFileMutation {
+    deleteFile: {
+        id: ID;
+    };
+}
+export declare const DeleteFileMutation: import("../_common/ast").TypedDocumentNode<DeleteFileMutation>;
+export interface ArchiveDirectoryMutation {
+    archiveDirectory: {
+        directory: {
+            id: ID;
+        };
+    };
+}
+export declare const ArchiveDirectoryMutation: import("../_common/ast").TypedDocumentNode<ArchiveDirectoryMutation>;
+export interface UnarchiveDirectoryMutation {
+    unarchiveDirectory: {
+        directory: {
+            id: ID;
+        };
+    };
+}
+export declare const UnarchiveDirectoryMutation: import("../_common/ast").TypedDocumentNode<UnarchiveDirectoryMutation>;
+export interface ChangeDirectoryParentsMutationResult {
+    unarchiveDirectory: {
+        directory: {
+            id: ID;
+        };
+    };
+}
+export declare const ChangeDirectoryParentsMutation: import("../_common/ast").TypedDocumentNode<ChangeDirectoryParentsMutationResult>;
+export interface ChangeFileParentsMutationResult {
+    unarchiveDirectory: {
+        directory: {
+            id: ID;
+        };
+    };
+}
+export declare const ChangeFileParentsMutation: import("../_common/ast").TypedDocumentNode<ChangeFileParentsMutationResult>;

package/lib/api/item2.service.d.ts

@@ -0,0 +1,177 @@
+import { Injector, NgZone } from '@angular/core';
+import { JWK } from 'node-jose';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { KeyService } from '../cryptography/key.service';
+import { FileService } from './file.service';
+import { LrMutation, LrService } from './lr-graphql';
+import { CreateDirectoryMutation, DeleteDirectoryMutation, CreateFileMutation, DeleteFileMutation, UpdateFileMutation, UpdateDirectoryMutation, ArchiveDirectoryMutation, UnarchiveDirectoryMutation } from './item2.gql';
+import { ID, LrRelayIdInput } from './types';
+export declare enum DirectoryLinkType {
+    HARD = "HARD"
+}
+export interface ParentDirectoryOptions {
+    directoryId: LrRelayIdInput;
+    wrappingKeyId?: LrRelayIdInput;
+    linkType?: DirectoryLinkType.HARD;
+}
+export interface ParentRootDirectoryInput {
+    wrappedKey: string;
+    wrappingKeyId: LrRelayIdInput;
+}
+export interface ParentDirectoryInputBase {
+    directoryId: LrRelayIdInput;
+    wrappingKeyId: LrRelayIdInput;
+    linkType?: DirectoryLinkType.HARD;
+}
+export interface ParentDirectoryInput extends ParentDirectoryInputBase {
+    wrappedKey: string;
+}
+export interface FileParentDirectoryInput extends ParentDirectoryInputBase {
+    wrappedFileKey: string;
+}
+export interface DownloadFileContentOptions {
+    fileStateNodeId: LrRelayIdInput;
+    fileStateKeyId?: LrRelayIdInput;
+}
+export interface CommonDirectoryOptions {
+    plainMetaJson?: any;
+    cipherMetaClearJson?: any;
+}
+export interface CreateDirectoryOptions extends CommonDirectoryOptions {
+    asRootDirectory?: boolean;
+    parentDirectories?: ParentDirectoryOptions[];
+}
+export interface UpdateDirectoryOptions extends CommonDirectoryOptions {
+    directoryId: LrRelayIdInput;
+    directoryKeyId?: LrRelayIdInput;
+}
+export interface CommonFileOptions {
+    plainMetaJson?: any;
+    cipherMetaClearJson?: any;
+    file?: File;
+    upload?: (cipherFileContent: string) => Promise<string>;
+}
+export interface CreateFileOptions extends CommonFileOptions {
+    parentDirectories: ParentDirectoryOptions[];
+}
+export interface UpdateFileOptions extends CommonFileOptions {
+    fileId: LrRelayIdInput;
+    fileKeyId?: LrRelayIdInput;
+}
+interface ChangeItemParentsOptions {
+    parentsToRemove: LrRelayIdInput[];
+    parentsToAdd: ParentDirectoryOptions[];
+}
+export interface ChangeDirectoryParentsOptions extends ChangeItemParentsOptions {
+    directoryId: LrRelayIdInput;
+    directoryKeyId?: LrRelayIdInput;
+}
+export interface ChangeFileParentsOptions extends ChangeItemParentsOptions {
+    fileId: LrRelayIdInput;
+    fileKeyId?: LrRelayIdInput;
+}
+export declare class Item2Service extends LrService {
+    private ngZone;
+    private injector;
+    private fileService;
+    private keyService;
+    private keyMeta;
+    private keyFactory;
+    private keyGraph;
+    constructor(ngZone: NgZone, injector: Injector, fileService: FileService, keyService: KeyService, keyMeta: KeyMetaService, keyFactory: KeyFactoryService, keyGraph: KeyGraphService);
+    downloadFileContent(options: DownloadFileContentOptions): Promise<ArrayBuffer>;
+    createDirectory(options: CreateDirectoryOptions): Promise<LrMutation<CreateDirectoryMutation, {
+        input: {
+            parentDirectories: ParentDirectoryInput[];
+            parentRootDirectory: ParentRootDirectoryInput;
+            plainMeta: string;
+            cipherMeta: string;
+        };
+    }>>;
+    updateDirectoryExec(options: UpdateDirectoryOptions): Promise<UpdateDirectoryMutation>;
+    updateDirectory(options: UpdateDirectoryOptions): Promise<LrMutation<UpdateDirectoryMutation, {
+        input: {
+            directoryId: string;
+            plainMeta: string;
+            cipherMeta: string;
+        };
+    }>>;
+    updateDirectoryMutation(options: UpdateDirectoryOptions): Promise<LrMutation<UpdateDirectoryMutation, {
+        input: {
+            directoryId: string;
+            plainMeta: string;
+            cipherMeta: string;
+        };
+    }>>;
+    deleteDirectory(id: ID): LrMutation<DeleteDirectoryMutation, {
+        input: {
+            directoryId: string;
+        };
+    }>;
+    createFile(options: CreateFileOptions): Promise<LrMutation<CreateFileMutation, {
+        input: {
+            parentDirectories: FileParentDirectoryInput[];
+            wrappedStateKey: string;
+            contentResource: string;
+            plainMeta: string;
+            cipherMeta: string;
+        };
+    }>>;
+    updateFile(options: UpdateFileOptions): Promise<LrMutation<UpdateFileMutation, {
+        input: {
+            fileId: string;
+            wrappedStateKey: string;
+            contentResource: string;
+            plainMeta: string;
+            cipherMeta: string;
+        };
+    }>>;
+    deleteFile(id: ID): LrMutation<DeleteFileMutation, {
+        input: {
+            fileId: string;
+        };
+    }>;
+    private getParentDirectoryInput;
+    getFileStateKeyId(fileStateNodeId: LrRelayIdInput): Promise<string>;
+    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>;
+    private getInput;
+    private createFileState;
+    archiveDirectory(directoryId: string, recursive: boolean): LrMutation<ArchiveDirectoryMutation, {
+        input: {
+            directoryId: string;
+            recursive: boolean;
+        };
+    }>;
+    unarchiveDirectory(directoryId: string, recursive: boolean): LrMutation<UnarchiveDirectoryMutation, {
+        input: {
+            directoryId: string;
+            recursive: boolean;
+        };
+    }>;
+    protected getChangeItemParentsInput(options: ChangeItemParentsOptions, itemKey: JWK.Key): Promise<{
+        directoriesToRemove: string[];
+        directoriesToAdd: ParentDirectoryInput[];
+    }>;
+    changeDirectoryParents(options: ChangeDirectoryParentsOptions): Promise<import("./item2.gql").ChangeDirectoryParentsMutationResult>;
+    changeDirectoryParentsMutation(options: ChangeDirectoryParentsOptions): Promise<LrMutation<import("./item2.gql").ChangeDirectoryParentsMutationResult, {
+        input: {
+            directoryId: string;
+            directoriesToRemove: string[];
+            directoriesToAdd: ParentDirectoryInput[];
+        };
+    }>>;
+    changeFileParents(options: ChangeFileParentsOptions): Promise<import("./item2.gql").ChangeFileParentsMutationResult>;
+    changeFileParentsMutation(options: ChangeFileParentsOptions): Promise<LrMutation<import("./item2.gql").ChangeFileParentsMutationResult, {
+        input: {
+            fileId: string;
+            directoriesToRemove: string[];
+            directoriesToAdd: ParentDirectoryInput[];
+        };
+    }>>;
+}
+export {};

package/lib/api/key-exchange.gql.d.ts

@@ -0,0 +1,9 @@
+export declare const KeyExchangeFields = "\n  id\n  token\n  state\n  mode\n  isInitiator\n  initiator {\n    id\n    username\n  }\n  responder {\n    id\n    username\n  }\n  created\n  modified\n  tokenExpiryTime\n  isExpired\n  initiatorRootKeyCipher\n  initiatorActionRequired\n  responderActionRequired\n  responderEmailAddress\n  otk {\n    state\n    otKeyParams\n    otKeyCipher\n    sharedKey {\n      id\n    }\n    mkSharedKey {\n      id\n    }\n    initiatorSigPxk {\n      id\n    }\n    responderSigPxk {\n      id\n    }\n    initiatorOneTimePbkCipher\n    responderPbkCipher\n}";
+export declare const UserSharedKeyFields = "\n  userSigPrk {\n    id\n  }\n  otherSigPbk {\n    id\n  }\n  sharedKey {\n    id\n  }\n  mkSharedKey {\n    id\n  }\n  mkPxk {\n    id\n    pbk\n  }\n  mkReshareRequestCipher\n  mkReshareResponseCipher\n  mkReshareRequestSent\n  mkReshareResponseSent\n";
+export declare const CurrentUserSharedKeyQuery: import("graphql").DocumentNode;
+export declare const KeyExchangesQuery: import("graphql").DocumentNode;
+export declare const KeyExchangeQuery: import("graphql").DocumentNode;
+export declare const KeyExchangeTokenQuery: import("graphql").DocumentNode;
+export declare const InitiateOtkMutation: import("graphql").DocumentNode;
+export declare const RespondOtkMutation: import("graphql").DocumentNode;
+export declare const CompleteOtkMutation: import("graphql").DocumentNode;

package/lib/api/key-exchange.service.d.ts

@@ -0,0 +1,39 @@
+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 { 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;
+    private lrApollo;
+    private encryptionService;
+    private authService;
+    private userService;
+    private readonly CLIENT_NONCE_LENGTH;
+    constructor(keyFactory: KFS, keyService: KeyService, lrApollo: LrApolloService, encryptionService: EncryptionService, authService: LifeReadyAuthService, userService: UserService);
+    getKeyExchangeList(input?: GetKeyExchangeListOptions): Promise<any>;
+    /**
+     * @param id If the current user can responder the key exchange if they are either the initiator or the receiver.
+     * @param token If not signed in, or not the initiator or responder, 'token' must be given.
+     * @param otKeyK Is the raw one-time key (string). If the responder is explicitly specified at time of initiation, then
+     *   it's possible to have the otKey wrapped by the public key of the responder. In which case, the otKeyK is not needed.
+     */
+    getKeyExchange(id: string, { otKeyK, token }?: GetKeyExchangeOptions): Promise<DecryptedKeyExchange>;
+    private decryptResponseCipher;
+    decryptKeyExchange(keyExchange: KeyExchange, otKeyK?: string): Promise<DecryptedKeyExchange>;
+    private decryptOtk;
+    private getOtKey;
+    initiateOtk({ message, email, contactCard, upgrade, }: InitiateOtkInput): Promise<{
+        keyExchange: KeyExchange;
+        otKeyK: string;
+    }>;
+    respondOtk({ id, token, decryptedOtk, message, initiatorContactCard, responderContactCard: sentContactCard, }: RespondOtkInput): Promise<RespondOtk>;
+    completeOtk(keyExchangeId: string, initiatorRootKeyCipher: string, initiatorOneTimePbkCipher: string, responderContactCard?: string): Promise<CompleteOtk>;
+    currentUserSharedKey(input: {
+        username?: string;
+        userId?: string;
+    }): Promise<UserSharedKey>;
+}