@lifeready/core 7.0.4 → 7.1.2

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

@@ -72,6 +72,10 @@ export interface UserNode extends Node {
 export interface UserFeatureState extends TimeStamped {
     notificationsLastViewed?: DateTime;
 }
+export interface PublicProfile {
+    userId?: ID;
+    email?: string;
+}
 export interface ServerTime {
     timestamp?: string;
 }
@@ -96,6 +100,7 @@ export interface AccessControlledResource {
     accessRole?: AccessRoleChoice;
     permissions?: PermissionChoice[];
     tpAccessRoles?: AccessRole[];
+    allAccessRoles?: AllAccessRole[];
     confidentiality?: ConfidentialResource;
 }
 export interface DirectoryNode extends Node, TimeStamped, AccessControlledResource {
@@ -146,26 +151,31 @@ export interface DirectoryLinkNodeLrNList {
 export interface FileLinkNodeLrNList {
     list?: FileLinkNode[];
 }
-export interface TpSharedDirectoryNode extends Node, TimeStamped {
-    item?: DirectoryNode;
-    tp?: TpNode;
-    role?: AccessRoleChoice;
-    issuer?: UserNode;
-    isIssuer?: boolean;
+export declare enum TpShareTypeChoice {
+    TP = "TP",
+    DETACHED = "DETACHED"
 }
-export interface TpSharedDirectoryNodeLrNList {
-    list?: TpSharedDirectoryNode[];
+export declare enum TpDetachedShareStateChoice {
+    IN_PROGRESS = "IN_PROGRESS",
+    COMPLETED = "COMPLETED"
 }
-export interface TpSharedFileNode extends Node, TimeStamped {
-    item?: FileNode;
+export interface TpSharedItem<ItemType> extends Node, TimeStamped {
+    item?: ItemType;
     tp?: TpNode;
     role?: AccessRoleChoice;
     issuer?: UserNode;
     isIssuer?: boolean;
+    subject?: PublicProfile;
+    shareType?: TpShareTypeChoice;
+    detachedShareState?: TpDetachedShareStateChoice;
 }
-export interface TpSharedFileNodeLrNList {
-    list?: TpSharedFileNode[];
+export interface TpSharedItemLrNList<SharedItemType> {
+    list?: SharedItemType[];
 }
+export declare type TpSharedDirectoryNode = TpSharedItem<DirectoryNode>;
+export declare type TpSharedFileNode = TpSharedItem<FileNode>;
+export declare type TpSharedDirectoryNodeLrNList = TpSharedItemLrNList<TpSharedDirectoryNode>;
+export declare type TpSharedFileNodeLrNList = TpSharedItemLrNList<TpSharedFileNode>;
 export interface Descendants {
     directories?: Connection<DirectoryNode>;
     files?: Connection<FileNode>;
@@ -176,9 +186,19 @@ export declare enum AccessRoleChoice {
     READER = "READER",
     WRITER = "WRITER",
     ADMIN = "ADMIN",
+    CUSTODIAN = "CUSTODIAN",
     DENY = "DENY",
     OWNER = "OWNER"
 }
+export declare enum AccessRoleChoiceOrder {
+    READER = 0,
+    WRITER = 1,
+    ADMIN = 2,
+    CUSTODIAN = 3,
+    DENY = 4,
+    CONFIDENTIAL = 5,
+    OWNER = 6
+}
 export declare enum AccessRoleMethodChoice {
     INHERITED = "INHERITED",
     DIRECT = "DIRECT"
@@ -202,15 +222,21 @@ export interface InheritedRole {
     role?: AccessRoleChoice;
     source?: DirectoryNode;
 }
-export interface AccessRole {
-    issuer?: UserNode;
-    subject?: UserNode;
+export interface AccessRoleBase {
     role?: AccessRoleChoice;
     method?: AccessRoleMethodChoice;
     inheritedRole?: InheritedRole;
-    tp?: TpNode;
     isIssuer?: boolean;
 }
+export interface AccessRole extends AccessRoleBase {
+    issuer?: UserNode;
+    subject?: UserNode;
+    tp?: TpNode;
+}
+export interface AllAccessRole extends AccessRoleBase {
+    issuer?: PublicProfile;
+    subject?: PublicProfile;
+}
 export declare enum FileOperationField {
     CREATE = "CREATE",
     READ = "READ",

package/lib/item/item.gql.private.d.ts

@@ -11,6 +11,22 @@ export interface FileKeyQueryResult {
     };
 }
 export declare const FileKeyQuery: import("../_common/ast").TypedDocumentNode<FileKeyQueryResult>;
+export interface DirectoryKeyFromSharedDirectoryQueryResult {
+    tpSharedDirectory: {
+        item: {
+            keyId: ID;
+        };
+    };
+}
+export declare const DirectoryKeyFromSharedDirectoryQuery: import("../_common/ast").TypedDocumentNode<DirectoryKeyFromSharedDirectoryQueryResult>;
+export interface FileKeyFromSharedFileQueryResult {
+    tpSharedFile: {
+        item: {
+            keyId: ID;
+        };
+    };
+}
+export declare const FileKeyFromSharedFileQuery: import("../_common/ast").TypedDocumentNode<FileKeyFromSharedFileQueryResult>;
 export interface FileStateKeyQueryResult {
     fileState: {
         keyId: ID;

package/lib/item/item.service.d.ts

@@ -26,6 +26,8 @@ export declare class ItemService extends LrService {
     downloadFileContent(options: DownloadFileContentOptions): Promise<Uint8Array>;
     getDirectoryKeyId(directoryId: LrRelayIdInput): Promise<string>;
     getFileKeyId(fileId: LrRelayIdInput): Promise<string>;
+    getDirectoryKeyIdFromSharedDirectory(sharedDirectoryId: LrRelayIdInput): Promise<string>;
+    getFileKeyIdFromSharedFile(sharedFileId: LrRelayIdInput): Promise<string>;
     getDirectoryKey(directoryId: LrRelayIdInput, directoryKeyId?: LrRelayIdInput): Promise<import("../key/key.types").Key>;
     getFileKey(fileId: LrRelayIdInput, fileKeyId?: LrRelayIdInput): Promise<import("../key/key.types").Key>;
     createDirectory(options: CreateDirectoryOptions): Promise<import("./item.gql").CreateDirectoryMutationResult>;

package/lib/trusted-party/trusted-party.gql.d.ts

@@ -37,6 +37,66 @@ export interface UnshareFileMutation {
     };
 }
 export declare const UnshareFileMutation: import("../_common/ast").TypedDocumentNode<UnshareFileMutation>;
+export interface CreateSharedDirectoryMutationResult {
+    createSharedDirectory: {
+        tpSharedDirectory: {
+            id: ID;
+        };
+    };
+}
+export declare const CreateSharedDirectoryMutation: import("../_common/ast").TypedDocumentNode<CreateSharedDirectoryMutationResult>;
+export interface CreateSharedFileMutationResult {
+    createSharedFile: {
+        tpSharedFile: {
+            id: ID;
+        };
+    };
+}
+export declare const CreateSharedFileMutation: import("../_common/ast").TypedDocumentNode<CreateSharedFileMutationResult>;
+export interface UpdateSharedDirectoryMutationResult {
+    updateSharedDirectory: {
+        tpSharedDirectory: {
+            id: ID;
+        };
+    };
+}
+export declare const UpdateSharedDirectoryMutation: import("../_common/ast").TypedDocumentNode<UpdateSharedDirectoryMutationResult>;
+export interface UpdateSharedFileMutationResult {
+    updateSharedFile: {
+        tpSharedFile: {
+            id: ID;
+        };
+    };
+}
+export declare const UpdateSharedFileMutation: import("../_common/ast").TypedDocumentNode<UpdateSharedFileMutationResult>;
+export interface DeleteSharedDirectoryMutationResult {
+    deleteSharedDirectory: {
+        id: ID;
+    };
+}
+export declare const DeleteSharedDirectoryMutation: import("../_common/ast").TypedDocumentNode<DeleteSharedDirectoryMutationResult>;
+export interface DeleteSharedFileMutationResult {
+    deleteSharedFile: {
+        id: ID;
+    };
+}
+export declare const DeleteSharedFileMutation: import("../_common/ast").TypedDocumentNode<DeleteSharedFileMutationResult>;
+export interface CompleteDetachedSharedDirectoryMutationResult {
+    completeDetachedSharedDirectory: {
+        tpSharedDirectory: {
+            id: ID;
+        };
+    };
+}
+export declare const CompleteDetachedSharedDirectoryMutation: import("../_common/ast").TypedDocumentNode<CompleteDetachedSharedDirectoryMutationResult>;
+export interface CompleteDetachedSharedFileMutationResult {
+    completeDetachedSharedDirectory: {
+        tpSharedDirectory: {
+            id: ID;
+        };
+    };
+}
+export declare const CompleteDetachedSharedFileMutation: import("../_common/ast").TypedDocumentNode<CompleteDetachedSharedFileMutationResult>;
 export interface RequestTpMkReshareMutation {
     requestTpMkReshare: {
         id: ID;

package/lib/trusted-party/trusted-party.service.d.ts

@@ -6,8 +6,8 @@ import { ItemService } from '../item/item.service';
 import { KeyFactoryService } from '../key/key-factory.service';
 import { KeyGraphService } from '../key/key-graph.service';
 import { KeyService } from '../key/key.service';
-import { CompleteTpMkReshareMutation, DeleteTpMutation, RequestTpMkReshareMutation, RespondTpMkReshareMutation, ShareDirectoryMutation, UnshareDirectoryMutation } from './trusted-party.gql';
-import { ShareItemOptions, UnshareItemOptions } from './trusted-party.types';
+import { CompleteTpMkReshareMutation, DeleteTpMutation, RequestTpMkReshareMutation, RespondTpMkReshareMutation, ShareDirectoryMutation, ShareFileMutation, UnshareDirectoryMutation } from './trusted-party.gql';
+import { CompleteDetachedSharedItemOptions, CreateSharedItemOptions, ShareItemOptions, UnshareItemOptions, UpdateSharedItemOptions } from './trusted-party.types';
 export declare class TrustedPartyService extends LrService {
     private ngZone;
     private injector;
@@ -34,8 +34,8 @@ export declare class TrustedPartyService extends LrService {
             wrappedKey: string;
         };
     }>>;
-    shareFile(options: ShareItemOptions): Promise<ShareDirectoryMutation>;
-    shareFileMutation(options: ShareItemOptions): Promise<LrMutation<ShareDirectoryMutation, {
+    shareFile(options: ShareItemOptions): Promise<ShareFileMutation>;
+    shareFileMutation(options: ShareItemOptions): Promise<LrMutation<ShareFileMutation, {
         input: {
             id: string;
             tpId: string;
@@ -45,7 +45,7 @@ export declare class TrustedPartyService extends LrService {
             wrappedKey: string;
         };
     }>>;
-    private shareItemMutation;
+    private prepareShareItemMutation;
     unshareDirectory(options: UnshareItemOptions): Promise<UnshareDirectoryMutation>;
     unshareDirectoryMutation(options: UnshareItemOptions): Promise<LrMutation<UnshareDirectoryMutation, {
         input: {
@@ -61,6 +61,71 @@ export declare class TrustedPartyService extends LrService {
         };
     }>>;
     private unshareItemMutation;
+    createSharedDirectory(options: CreateSharedItemOptions): Promise<import("./trusted-party.gql").CreateSharedDirectoryMutationResult>;
+    createSharedDirectoryMutation(options: CreateSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").CreateSharedDirectoryMutationResult, {
+        input: {
+            id: string;
+            tpId: string;
+            accessRole: import("../api/types").AccessRoleChoice;
+            keyId: string;
+            wrappingKeyId: string;
+            wrappedKey: string;
+            shareType: import("../api/types").TpShareTypeChoice;
+        };
+    }>>;
+    createSharedFile(options: CreateSharedItemOptions): Promise<import("./trusted-party.gql").CreateSharedFileMutationResult>;
+    createSharedFileMutation(options: CreateSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").CreateSharedFileMutationResult, {
+        input: {
+            id: string;
+            tpId: string;
+            accessRole: import("../api/types").AccessRoleChoice;
+            keyId: string;
+            wrappingKeyId: string;
+            wrappedKey: string;
+            shareType: import("../api/types").TpShareTypeChoice;
+        };
+    }>>;
+    private prepareCreateSharedItemMutation;
+    updateSharedDirectory(options: UpdateSharedItemOptions): Promise<import("./trusted-party.gql").UpdateSharedDirectoryMutationResult>;
+    updateSharedDirectoryMutation(options: UpdateSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").UpdateSharedDirectoryMutationResult, {
+        input: {
+            id: string;
+            accessRole: import("../api/types").AccessRoleChoice;
+        };
+    }>>;
+    updateSharedFile(options: UpdateSharedItemOptions): Promise<import("./trusted-party.gql").UpdateSharedFileMutationResult>;
+    updateSharedFileMutation(options: UpdateSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").UpdateSharedFileMutationResult, {
+        input: {
+            id: string;
+            accessRole: import("../api/types").AccessRoleChoice;
+        };
+    }>>;
+    private prepareUpdateSharedItemMutation;
+    deleteSharedDirectory(id: string): Promise<import("./trusted-party.gql").DeleteSharedDirectoryMutationResult>;
+    deleteSharedDirectoryMutation(id: string): Promise<LrMutation<import("./trusted-party.gql").DeleteSharedDirectoryMutationResult, {
+        input: {
+            id: string;
+        };
+    }>>;
+    completeDetachedSharedDirectory(options: CompleteDetachedSharedItemOptions): Promise<import("./trusted-party.gql").CompleteDetachedSharedDirectoryMutationResult>;
+    completeDetachedSharedDirectoryMutation(options: CompleteDetachedSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").CompleteDetachedSharedDirectoryMutationResult, {
+        input: {
+            id: string;
+            keyId: string;
+            wrappingKeyId: string;
+            wrappedKey: string;
+        };
+    }>>;
+    completeDetachedSharedFile(options: CompleteDetachedSharedItemOptions): Promise<import("./trusted-party.gql").CompleteDetachedSharedFileMutationResult>;
+    completeDetachedSharedFileMutation(options: CompleteDetachedSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").CompleteDetachedSharedFileMutationResult, {
+        input: {
+            id: string;
+            keyId: string;
+            wrappingKeyId: string;
+            wrappedKey: string;
+        };
+    }>>;
+    private prepareCompleteDetachedSharedItemMutation;
     requestMkReshareMutation(tpId: LrRelayIdInput): Promise<LrMutation<RequestTpMkReshareMutation, {
         input: {
             tpId: string;

package/lib/trusted-party/trusted-party.types.d.ts

@@ -1,4 +1,4 @@
-import { AccessRoleChoice, LrRelayIdInput } from '../api/types';
+import { AccessRoleChoice, LrRelayIdInput, TpShareTypeChoice } from '../api/types';
 export interface ShareItemOptions {
     itemId: LrRelayIdInput;
     itemKeyId?: LrRelayIdInput;
@@ -10,3 +10,19 @@ export interface UnshareItemOptions {
     itemId: string;
     tpId: string;
 }
+export interface CreateSharedItemOptions {
+    itemId: LrRelayIdInput;
+    itemKeyId?: LrRelayIdInput;
+    tpId: LrRelayIdInput;
+    tpSharedKeyId?: LrRelayIdInput;
+    accessRole: AccessRoleChoice;
+    shareType: TpShareTypeChoice;
+}
+export interface UpdateSharedItemOptions {
+    sharedItemId: LrRelayIdInput;
+    accessRole: AccessRoleChoice;
+}
+export interface CompleteDetachedSharedItemOptions {
+    sharedItemId: LrRelayIdInput;
+    itemKeyId?: LrRelayIdInput;
+}