@lifeready/core 1.0.10 → 1.0.12

package/lib/_common/utils.d.ts

@@ -1,3 +1,9 @@
 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>;
+/**
+ * Returns the defaultValue when value is undefined
+ * @param value The value to check
+ * @param defaultValue The value to return if value is undefined.
+ */
+export declare function undefinedDefault(value: any, defaultValue: any): any;

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

@@ -4,19 +4,28 @@ export declare class LockService extends LrService {
     private ngZone;
     private injector;
     constructor(ngZone: NgZone, injector: Injector);
-    updateLockMutation(resourceId: string, version: string): LrMutation<import("./lock.gql").UpdateLockMutationResult, {
+    updateLockMutation(options: {
+        resourceId?: string;
+        version: string;
+    }): LrMutation<import("./lock.gql").UpdateLockMutationResult, {
         input: {
             resourceId: string;
             version: string;
         };
     }>;
-    acquireLockMutation(resourceId: string, timeoutMs: number): LrMutation<import("./lock.gql").AcquireLockMutationResult, {
+    acquireLockMutation(options: {
+        resourceId?: string;
+        timeoutMs: number;
+    }): LrMutation<import("./lock.gql").AcquireLockMutationResult, {
         input: {
             resourceId: string;
             timeoutMs: number;
         };
     }>;
-    releaseLockMutation(resourceId: string, version: string): LrMutation<import("./lock.gql").ReleaseLockMutationResult, {
+    releaseLockMutation(options: {
+        resourceId: string;
+        version: string;
+    }): LrMutation<import("./lock.gql").ReleaseLockMutationResult, {
         input: {
             resourceId: string;
             version: string;

package/lib/api/lr-graphql/lr-merged-mutation.d.ts

@@ -8,6 +8,7 @@ export declare class LrMergedMutation<T> extends LrMutationBase<T> {
     static create<T1, T2, T3>(lrMutations: [LrMutationBase<T1> | LrMergedMutation<T1>, LrMutationBase<T2> | LrMergedMutation<T2>, LrMutationBase<T3> | LrMergedMutation<T3>]): LrMergedMutation<[T1, T2, T3]>;
     static create<T1, T2, T3, T4>(lrMutations: [LrMutationBase<T1> | LrMergedMutation<T1>, LrMutationBase<T2> | LrMergedMutation<T2>, LrMutationBase<T3> | LrMergedMutation<T3>, LrMutationBase<T4> | LrMergedMutation<T4>]): LrMergedMutation<[T1, T2, T3, T4]>;
     static create<T1, T2, T3, T4, T5>(lrMutations: [LrMutationBase<T1> | LrMergedMutation<T1>, LrMutationBase<T2> | LrMergedMutation<T2>, LrMutationBase<T3> | LrMergedMutation<T3>, LrMutationBase<T4> | LrMergedMutation<T4>, LrMutationBase<T5> | LrMergedMutation<T5>]): LrMergedMutation<[T1, T2, T3, T4, T5]>;
+    static create<T>(lrMutations: LrMutationBase<T>[]): LrMergedMutation<T[]>;
     static create(lrMutations: LrMutationBase<any>[]): LrMergedMutation<any[]>;
     private getDescendants;
     resolve(value: any): void;

package/lib/api/query-processor/query-processor.service.d.ts

@@ -9,10 +9,10 @@ export declare class QueryProcessorService {
     private tpprProcessor;
     readonly TYPENAME = "__typename";
     private processors;
-    constructor(ngZone: NgZone, keyService: KeyService, common: CommonProcessorsService, tpprProcessor: TpPasswordResetProcessorService);
     processQuery(fields: {
         [key: string]: any;
     }, options: ProcessorOptions): Promise<any>;
     private processField;
     private registerProcessor;
+    constructor(ngZone: NgZone, keyService: KeyService, common: CommonProcessorsService, tpprProcessor: TpPasswordResetProcessorService);
 }

package/lib/api/types/lr-graphql.types.d.ts

@@ -1,10 +1,9 @@
 import { Connection, DateTime, GenericScalar, ID, JSONString, LrEmail, Node, TimeStamped } from './graphql.types';
+export declare function mapEdges<T>(connection: Connection<T>): T[];
 export declare type UserStripeNode = any;
 export declare type UserPlanNode = any;
 export declare type UserDeleteNode = any;
 export declare type FeaturesNode = any;
-export declare type ScenarioNode = any;
-export declare type SharedScenarioNode = any;
 export declare type TpPasswordResetRequestNode = any;
 export interface PassKeyNode extends Node, TimeStamped {
     passKeyParams?: GenericScalar;
@@ -82,10 +81,12 @@ export interface FileNode extends Node, TimeStamped {
 export interface DirectoryLinkNode extends Node, TimeStamped {
     parentDirectory?: DirectoryNode;
     childDirectory?: DirectoryNode;
+    linkType?: LinkTypeField;
 }
 export interface FileLinkNode extends Node, TimeStamped {
     parentDirectory?: DirectoryNode;
     childFile?: FileNode;
+    linkType?: LinkTypeField;
 }
 export interface DirectoryLinkNodeLrNList {
     list?: DirectoryLinkNode[];
@@ -350,7 +351,9 @@ export interface TpSubAssemblyNode extends Node, TimeStamped {
 export interface TpAssemblyApproverNode extends Node, TimeStamped {
     sharedKey?: KeyNode;
     sharedCipherData?: string;
+    sharedCipherDataClearJson?: any;
     sharedCipherApprovalData?: string;
+    sharedCipherApprovalDataClearJson?: any;
     tp?: TpNode;
 }
 export interface SharedTpPasswordResetNode extends Node, TimeStamped {
@@ -377,7 +380,9 @@ export interface SharedTpClaimApproverNode extends Node, TimeStamped {
     state?: TpClaimApproverState;
     sharedKey?: KeyNode;
     sharedCipherApprovalData?: string;
+    sharedCipherApprovalDataClearJson?: any;
     sharedCipherPartialAssemblyKey?: string;
+    sharedCipherPartialAssemblyKeyClearJson?: any;
     receiverApprovals?: Connection<SharedTpClaimReceiverApprovalNode>;
 }
 export interface SharedTpClaimReceiverApprovalNode extends Node, TimeStamped {
@@ -387,6 +392,102 @@ export declare enum LockState {
     UNLOCKED = "UNLOCKED",
     MUTEX_LOCKED = "MUTEX_LOCKED"
 }
+export declare enum ScenarioState {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED",
+    CLAIMED = "CLAIMED",
+    APPROVED = "APPROVED"
+}
+export declare enum ClaimState {
+    CLAIMED = "CLAIMED",
+    EXPIRED = "EXPIRED",
+    APPROVED = "APPROVED",
+    REJECTED = "REJECTED",
+    CANCELLED = "CANCELLED",
+    RESET = "RESET"
+}
+export declare enum ClaimApproverState {
+    CLAIMED = "CLAIMED",
+    APPROVED = "APPROVED",
+    REJECTED = "REJECTED"
+}
+export declare type ScenarioClaimNode = any;
+export interface ScenarioNode extends Node, TimeStamped {
+    subject?: UserNode;
+    subjectKey?: KeyNode;
+    subjectCipherData?: string;
+    subjectCipherDataClearJson?: any;
+    assembly?: TpAssemblyNode;
+    state?: ScenarioState;
+    claimants?: Connection<ScenarioClaimantNode>;
+    receivers?: Connection<ScenarioReceiverNode>;
+    claims?: Connection<ScenarioClaimNode>;
+    claim?: ScenarioClaimNode;
+}
+export interface ScenarioReceiverNode extends Node, TimeStamped {
+    sharedKey?: KeyNode;
+    sharedCipherData?: string;
+    sharedCipherDataClearJson?: any;
+    pbk?: KeyNode;
+    receiverDirectories?: Connection<ScenarioReceiverDirectoryNode>;
+    receiverFiles?: Connection<ScenarioReceiverFileNode>;
+    tp?: TpNode;
+}
+export interface SharedScenarioReceiverNode extends Node, TimeStamped {
+    pbk?: KeyNode;
+}
+export declare type ReceiverDirectoryAccessRole = AccessRoleChoice;
+export interface ScenarioReceiverItemNode extends Node, TimeStamped {
+    receiver?: SharedScenarioReceiverNode;
+    sharedKey?: KeyNode;
+    sharedCipherData?: string;
+    sharedCipherDataClearJson?: any;
+    accessRole?: ReceiverDirectoryAccessRole;
+    wrappedItemKey?: string;
+    itemKey?: KeyNode;
+}
+export interface ScenarioReceiverDirectoryNode extends ScenarioReceiverItemNode {
+    directory?: DirectoryNode;
+}
+export interface ScenarioReceiverFileNode extends ScenarioReceiverItemNode {
+    file?: FileNode;
+}
+export interface ScenarioClaimantNode extends Node, TimeStamped {
+    tp?: TpNode;
+    sharedKey?: KeyNode;
+    sharedCipherData?: string;
+    sharedCipherDataClearJson?: any;
+}
+export interface SharedScenarioNode extends Node, TimeStamped {
+    subject?: UserNode;
+    state?: ScenarioState;
+    tp?: TpNode;
+    asClaimant?: ScenarioClaimantNode;
+    asReceiver?: ScenarioReceiverNode;
+    assembly?: SharedTpAssemblyNode;
+    sharedClaim?: SharedScenarioClaimNode;
+}
+export interface SharedScenarioClaimNode extends Node, TimeStamped {
+    state?: ClaimState;
+    sharedScenario?: SharedScenarioNode;
+    isClaimant?: boolean;
+    asClaimReceiver?: SharedScenarioClaimReceiverNode;
+    claim: SharedTpClaimNode;
+}
+export interface SharedScenarioClaimApproverNode extends Node, TimeStamped {
+    receivers?: Connection<SharedScenarioReceiverNode>;
+    state?: ClaimApproverState;
+    approver?: TpAssemblyApproverNode;
+}
+export interface SharedScenarioClaimReceiverNode extends Node, TimeStamped {
+    received?: DateTime;
+    approvals?: Connection<SharedScenarioClaimReceivedApprovalNode>;
+}
+export interface SharedScenarioClaimReceivedApprovalNode extends Node, TimeStamped {
+    receiverCipher?: string;
+    receiverCipherPartialAssemblyKey?: string;
+    pxk?: KeyNode;
+}
 export interface NotificationNode extends Node, TimeStamped {
     plainData?: JSONString;
     plainMeta?: JSONString;
@@ -395,3 +496,7 @@ export interface NotificationNode extends Node, TimeStamped {
 export interface NotificationManagementState extends Node, TimeStamped {
     lastViewed?: DateTime;
 }
+export declare enum LinkTypeField {
+    HARD = "HARD",
+    SOFT = "SOFT"
+}

package/lib/auth/life-ready-auth.service.d.ts

@@ -13,6 +13,7 @@ import { PersistService } from '../api/persist.service';
 import { LifeReadyConfig } from '../life-ready.config';
 import { EncryptionService } from '../cryptography/encryption.service';
 import { Slip39Service } from '../cryptography/slip39.service';
+import { TpPasswordResetAssemblyController } from '../trusted-parties/tp-password-reset.controller';
 export declare const initialiseAuth: (authService: LifeReadyAuthService) => () => Promise<void>;
 export interface LoginOptions {
     tpPasswordResetAutoComplete?: boolean;
@@ -31,10 +32,11 @@ export declare class LifeReadyAuthService {
     private persistService;
     private encryptionService;
     private slip39Service;
+    private assemblyController;
     private hubSubject;
     private currentUser;
     private currentResetUser;
-    constructor(config: LifeReadyConfig, auth: AuthClass, keyFactory: KeyFactoryService, keyService: KeyService, profileService: ProfileService, keyGraphService: KeyGraphService, passwordService: PasswordService, idleService: IdleService, lrGraphQL: LrGraphQLService, tpPasswordResetProcessorService: TpPasswordResetProcessorService, persistService: PersistService, encryptionService: EncryptionService, slip39Service: Slip39Service);
+    constructor(config: LifeReadyConfig, auth: AuthClass, keyFactory: KeyFactoryService, keyService: KeyService, profileService: ProfileService, keyGraphService: KeyGraphService, passwordService: PasswordService, idleService: IdleService, lrGraphQL: LrGraphQLService, tpPasswordResetProcessorService: TpPasswordResetProcessorService, persistService: PersistService, encryptionService: EncryptionService, slip39Service: Slip39Service, assemblyController: TpPasswordResetAssemblyController);
     initialise(): Promise<void>;
     private loginIdpImpl;
     private loginIdp;

package/lib/cryptography/key-graph.service.d.ts

@@ -2,6 +2,7 @@ import { JWK } from 'node-jose';
 import { CurrentUserKey } from '../users/profile.types';
 import { Edge, Key, KeyGraphResponse, PassKey } from './cryptography.types';
 import { DecryptOptions, EncryptionService } from './encryption.service';
+import { KeyFactoryService } from './key-factory.service';
 import { KeyService } from './key.service';
 export interface GraphKey extends Key {
     task?: Promise<any>;
@@ -9,8 +10,9 @@ export interface GraphKey extends Key {
 export declare class KeyGraphService {
     private encryptionService;
     private keyService;
+    private keyFactory;
     private graph;
-    constructor(encryptionService: EncryptionService, keyService: KeyService);
+    constructor(encryptionService: EncryptionService, keyService: KeyService, keyFactory: KeyFactoryService);
     purgeKeys(): void;
     populateKeys(userKey: CurrentUserKey): Promise<void>;
     hasKey(keyId: string): boolean;
@@ -30,4 +32,10 @@ export declare class KeyGraphService {
     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>;
+    encryptWithNewKey(wrappingKeyId: string, cipherClearJson: any): Promise<{
+        key: JWK.Key;
+        wrappingKeyId: string;
+        wrappedKey: string;
+        cipher: string;
+    }>;
 }

package/lib/{api → items2}/item2.gql.d.ts

@@ -1,4 +1,4 @@
-import { DateTime, ID } from './types';
+import { DateTime, ID } from '../api/types';
 export interface DirectoryKeyQuery {
     directory: {
         keyId: ID;
@@ -21,6 +21,7 @@ export interface CreateDirectoryMutation {
     createDirectory: {
         directory: {
             id: ID;
+            keyId: ID;
         };
     };
 }
@@ -94,3 +95,29 @@ export interface ChangeFileParentsMutationResult {
     };
 }
 export declare const ChangeFileParentsMutation: import("../_common/ast").TypedDocumentNode<ChangeFileParentsMutationResult>;
+export interface BeginDeleteChildItemLinksWindowMutationResult {
+    beginDeleteChildItemLinksWindow: {
+        begin: DateTime;
+        end: DateTime;
+        scheduled: DateTime;
+        windowMs: number;
+        directory: {
+            id: ID;
+        };
+    };
+}
+export declare const BeginDeleteChildItemLinksWindowMutation: import("../_common/ast").TypedDocumentNode<BeginDeleteChildItemLinksWindowMutationResult>;
+export interface TempDirectoryQueryResult {
+    rootDirectories: {
+        edges: {
+            node: {
+                id: ID;
+                keyId: ID;
+            };
+        }[];
+    };
+    lock: {
+        version: string;
+    };
+}
+export declare const TempDirectoryQuery: import("../_common/ast").TypedDocumentNode<TempDirectoryQueryResult>;

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

@@ -0,0 +1,203 @@
+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 } from './item2.types';
+import { LrMutation, LrService } from '../api/lr-graphql';
+import { DirectoryNode, ID, LrRelayIdInput } from '../api/types';
+import { LockService } from '../api/lock.service';
+export declare class Item2Service extends LrService {
+    private ngZone;
+    private injector;
+    private fileService;
+    private keyService;
+    private keyFactory;
+    private keyGraph;
+    private lockService;
+    constructor(ngZone: NgZone, injector: Injector, fileService: FileService, keyService: KeyService, keyFactory: KeyFactoryService, keyGraph: KeyGraphService, lockService: LockService);
+    static TEMP_DIRECTORY_PLAIN_META: {
+        kcType: string;
+    };
+    static TEMP_DIRECTORY_PLAIN_META_FILTER: string;
+    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, {
+        input: {
+            parentDirectories: ParentDirectoryInput[];
+            parentRootDirectory: ParentRootDirectoryInput;
+            plainMeta: string;
+            cipherMeta: string;
+        };
+    }>>;
+    createDirectoryMutation(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;
+        };
+    }>>;
+    deleteDirectoryExec(id: ID): Promise<DeleteDirectoryMutation>;
+    deleteDirectory(id: ID): LrMutation<DeleteDirectoryMutation, {
+        input: {
+            directoryId: string;
+        };
+    }>;
+    deleteDirectoryMutation(id: ID): LrMutation<DeleteDirectoryMutation, {
+        input: {
+            directoryId: string;
+        };
+    }>;
+    createFileExec(options: CreateFileOptions): Promise<CreateFileMutation>;
+    createFile(options: CreateFileOptions): Promise<LrMutation<CreateFileMutation, {
+        input: {
+            parentDirectories: FileParentDirectoryInput[];
+            wrappedStateKey: string;
+            contentResource: string;
+            plainMeta: string;
+            cipherMeta: string;
+        };
+    }>>;
+    createFileMutation(options: CreateFileOptions): Promise<LrMutation<CreateFileMutation, {
+        input: {
+            parentDirectories: FileParentDirectoryInput[];
+            wrappedStateKey: string;
+            contentResource: string;
+            plainMeta: string;
+            cipherMeta: string;
+        };
+    }>>;
+    updateFileExec(options: UpdateFileOptions): Promise<UpdateFileMutation>;
+    updateFile(options: UpdateFileOptions): Promise<LrMutation<UpdateFileMutation, {
+        input: {
+            fileId: string;
+            wrappedStateKey: string;
+            contentResource: string;
+            plainMeta: string;
+            cipherMeta: string;
+        };
+    }>>;
+    updateFileMutation(options: UpdateFileOptions): Promise<LrMutation<UpdateFileMutation, {
+        input: {
+            fileId: string;
+            wrappedStateKey: string;
+            contentResource: string;
+            plainMeta: string;
+            cipherMeta: string;
+        };
+    }>>;
+    deleteFileExec(id: ID): Promise<DeleteFileMutation>;
+    deleteFile(id: ID): LrMutation<DeleteFileMutation, {
+        input: {
+            fileId: string;
+        };
+    }>;
+    deleteFileMutation(id: ID): LrMutation<DeleteFileMutation, {
+        input: {
+            fileId: string;
+        };
+    }>;
+    archiveDirectoryExec(directoryId: string, recursive: boolean): Promise<ArchiveDirectoryMutation>;
+    archiveDirectory(directoryId: string, recursive: boolean): LrMutation<ArchiveDirectoryMutation, {
+        input: {
+            directoryId: string;
+            recursive: boolean;
+        };
+    }>;
+    archiveDirectoryMutation(directoryId: string, recursive: boolean): LrMutation<ArchiveDirectoryMutation, {
+        input: {
+            directoryId: string;
+            recursive: boolean;
+        };
+    }>;
+    unarchiveDirectoryExec(directoryId: string, recursive: boolean): Promise<UnarchiveDirectoryMutation>;
+    unarchiveDirectory(directoryId: string, recursive: boolean): LrMutation<UnarchiveDirectoryMutation, {
+        input: {
+            directoryId: string;
+            recursive: boolean;
+        };
+    }>;
+    unarchiveDirectoryMutation(directoryId: string, recursive: boolean): LrMutation<UnarchiveDirectoryMutation, {
+        input: {
+            directoryId: string;
+            recursive: boolean;
+        };
+    }>;
+    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[];
+        };
+    }>>;
+    beginDeleteChildItemLinksWindow(options: BeginDeleteChildItemLinksWindowOptions): Promise<import("./item2.gql").BeginDeleteChildItemLinksWindowMutationResult>;
+    beginDeleteChildItemLinksWindowMutation(options: BeginDeleteChildItemLinksWindowOptions): Promise<LrMutation<import("./item2.gql").BeginDeleteChildItemLinksWindowMutationResult, {
+        input: BeginDeleteChildItemLinksWindowOptions;
+    }>>;
+    /**
+     *
+     * This method may raise VERSION_MISMATCH exception if there is a race condition
+     * when multiple clients try to create the temp directory.
+     *
+     * TODO There is a retry mechanism in graphql with exponential back off but that's internal.
+     * But need to use an exponential back off lib if we want to retry here.
+     *
+     * @returns The ID of the temp directory
+     *
+     */
+    ensureTempDirectory(): Promise<Pick<DirectoryNode, 'id' | 'keyId'>>;
+    createDirectoryTree(options: CreateDirectoryTreeOptions): Promise<import("./item2.gql").ChangeDirectoryParentsMutationResult>;
+    /**
+     * You must run this mutation within the temp directory cleanup window on the
+     * server, otherwise the temp directory will get cleaned up.
+     *
+     */
+    createDirectoryTreeMutation(options: CreateDirectoryTreeOptions): Promise<LrMutation<import("./item2.gql").ChangeDirectoryParentsMutationResult, {
+        input: {
+            directoryId: string;
+            directoriesToRemove: string[];
+            directoriesToAdd: ParentDirectoryInput[];
+        };
+    }>>;
+    private prepareParentDirectory;
+    private getFileStateKeyId;
+    private prepareCreateFileState;
+    private prepareChangeItemParents;
+    private prepareItem;
+    private prepareCreateDirectory;
+    private prepareUpdateDirectory;
+    private prepareCreateFile;
+    private prepareUpdateFile;
+    private prepareChangeDirectoryParents;
+    private prepareChangeFileParents;
+}

package/lib/items2/item2.types.d.ts

@@ -0,0 +1,70 @@
+import { LinkTypeField, LrRelayIdInput } from '../api/types';
+export interface ParentDirectoryOptions {
+    directoryId: LrRelayIdInput;
+    wrappingKeyId?: LrRelayIdInput;
+    linkType?: LinkTypeField;
+}
+export interface ParentRootDirectoryInput {
+    wrappedKey: string;
+    wrappingKeyId: LrRelayIdInput;
+}
+export interface ParentDirectoryInputBase {
+    directoryId: LrRelayIdInput;
+    wrappingKeyId: LrRelayIdInput;
+    linkType?: LinkTypeField;
+}
+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;
+}
+export 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 interface BeginDeleteChildItemLinksWindowOptions {
+    directoryId: LrRelayIdInput;
+    requestWindowMs: number;
+}
+export interface CreateDirectoryTreeOptions extends Omit<CreateDirectoryOptions, 'asRootDirectory'> {
+    requestWindowMs: number;
+    createContent: (directoryId: string) => void | Promise<void>;
+}

package/lib/scenario/scenario.constants.d.ts

@@ -0,0 +1 @@
+export declare const SCENARIO_SLIP39_PASSPHRASE = "lifeready";

package/lib/scenario/scenario.controller.d.ts

@@ -0,0 +1,10 @@
+import { Injector, NgZone } from '@angular/core';
+import { TpNode } from '../api/types';
+import { TpAssemblyController } from '../trusted-parties/tp-assembly';
+export declare class ScenarioAssemblyController extends TpAssemblyController {
+    private ngZone;
+    private injector;
+    slip39Passphrase: string;
+    constructor(ngZone: NgZone, injector: Injector);
+    getTpWrappingKeyId(tp: TpNode): string;
+}