@lifeready/core 8.0.1 → 8.0.3

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

@@ -1,10 +1,4 @@
 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/api/types/lr-graphql.types.d.ts

@@ -119,8 +119,8 @@ export interface DirectoryNode extends Node, TimeStamped, AccessControlledResour
     descendants?: Descendants;
     lock?: LockField;
     lockVersion?: string;
-    tpShared?: Connection<TpSharedDirectoryNode>;
-    nTpShared?: TpSharedDirectoryNodeLrNList;
+    shares?: Connection<DirectoryShareNode>;
+    nShares?: DirectoryShareNodeLrNList;
     reminder?: ReminderNode;
 }
 export interface FileNode extends Node, TimeStamped, AccessControlledResource {
@@ -132,8 +132,8 @@ export interface FileNode extends Node, TimeStamped, AccessControlledResource {
     nParentDirectoryLinks?: FileLinkNodeLrNList;
     lock?: LockField;
     lockVersion?: string;
-    tpShared?: Connection<TpSharedFileNode>;
-    nTpShared?: TpSharedFileNodeLrNList;
+    shares?: Connection<FileShareNode>;
+    nShares?: FileShareNodeLrNList;
 }
 export interface DirectoryLinkNode extends Node, TimeStamped {
     parentDirectory?: DirectoryNode;
@@ -151,31 +151,31 @@ export interface DirectoryLinkNodeLrNList {
 export interface FileLinkNodeLrNList {
     list?: FileLinkNode[];
 }
-export declare enum TpShareTypeChoice {
+export declare enum ShareTypeChoice {
     TP = "TP",
     DETACHED = "DETACHED"
 }
-export declare enum TpDetachedShareStateChoice {
+export declare enum DetachedShareStateChoice {
     IN_PROGRESS = "IN_PROGRESS",
     COMPLETED = "COMPLETED"
 }
-export interface TpSharedItem<ItemType> extends Node, TimeStamped {
+export interface ItemShare<ItemType> extends Node, TimeStamped {
     item?: ItemType;
     tp?: TpNode;
     role?: AccessRoleChoice;
     issuer?: PublicProfile;
     isIssuer?: boolean;
     subject?: PublicProfile;
-    shareType?: TpShareTypeChoice;
-    detachedShareState?: TpDetachedShareStateChoice;
+    shareType?: ShareTypeChoice;
+    detachedShareState?: DetachedShareStateChoice;
 }
-export interface TpSharedItemLrNList<SharedItemType> {
+export interface ItemShareLrNList<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 declare type DirectoryShareNode = ItemShare<DirectoryNode>;
+export declare type FileShareNode = ItemShare<FileNode>;
+export declare type DirectoryShareNodeLrNList = ItemShareLrNList<DirectoryShareNode>;
+export declare type FileShareNodeLrNList = ItemShareLrNList<FileShareNode>;
 export interface Descendants {
     directories?: Connection<DirectoryNode>;
     files?: Connection<FileNode>;
@@ -493,6 +493,7 @@ export interface SharedTpAssemblyNode extends Node, TimeStamped {
 export interface TpAssemblyAsApproverNode extends Node, TimeStamped {
     sharedKey?: KeyNode;
     sharedCipherData?: string;
+    sharedCipherDataClearJson?: JSONObject;
 }
 export interface SharedTpPasswordResetRequestNode extends Node, TimeStamped {
     claim?: SharedTpClaimNode;
@@ -582,18 +583,20 @@ export interface ScenarioSubAssemblyState {
 export interface ScenarioAssemblyApproverState {
     state?: TpClaimApproverState;
 }
-export interface ScenarioReceiverNode extends Node, TimeStamped {
+export interface ReceiverItems {
+    receiverDirectories?: Connection<ScenarioReceiverDirectoryNode>;
+    receiverFiles?: Connection<ScenarioReceiverFileNode>;
+}
+export interface ScenarioReceiverNodeBase extends Node, TimeStamped {
     sharedKey?: KeyNode;
     sharedCipherData?: string;
     sharedCipherDataClearJson?: JSONObject;
     pbk?: KeyNode;
-    receiverDirectories?: Connection<ScenarioReceiverDirectoryNode>;
-    receiverFiles?: Connection<ScenarioReceiverFileNode>;
     tp?: TpNode;
+    receiverItems?: ReceiverItems;
 }
-export interface SharedScenarioReceiverNode extends Node, TimeStamped {
-    pbk?: KeyNode;
-}
+export declare type ScenarioReceiverNode = ScenarioReceiverNodeBase;
+export declare type SharedScenarioReceiverNode = ScenarioReceiverNodeBase;
 export declare type ReceiverDirectoryAccessRole = AccessRoleChoice;
 export interface ScenarioReceiverItemNode extends Node, TimeStamped {
     receiver?: SharedScenarioReceiverNode;
@@ -641,6 +644,7 @@ export interface SharedScenarioClaimApproverNode extends Node, TimeStamped {
 }
 export interface SharedScenarioClaimReceiverNode extends Node, TimeStamped {
     received?: DateTime;
+    assemblyKeyId?: ID;
     approvals?: Connection<SharedScenarioClaimReceivedApprovalNode>;
 }
 export interface SharedScenarioClaimReceivedApprovalNode extends Node, TimeStamped {

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

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

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

@@ -26,8 +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>;
+    getDirectoryKeyIdFromDirectoryShare(directoryShareId: LrRelayIdInput): Promise<string>;
+    getFileKeyIdFromFileShare(fileShareId: 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/key/key.types.d.ts

@@ -32,6 +32,7 @@ export declare type PassKey = SomeRequired<PassKeyNode, 'id'>;
 export interface KeyLink {
     keyId: string;
     wrappingKeyId: string;
+    nestedWrappingKeyIds: string[];
     wrappedKey: string;
 }
 export interface PassKeyLink {

package/lib/scenario/scenario.gql.d.ts

@@ -53,7 +53,7 @@ export interface ApproveScenarioClaimMutationResult {
 }
 export declare const ApproveScenarioClaimMutation: import("../_common/ast").TypedDocumentNode<ApproveScenarioClaimMutationResult>;
 export interface ReceiveScenarioClaimMutationResult {
-    receiveScenarioClaim: {
+    receiveScenarioClaim2: {
         sharedClaim: {
             id: string;
         };

package/lib/scenario/scenario.service.d.ts

@@ -1,5 +1,6 @@
 import { Injector, NgZone } from '@angular/core';
 import { LrMergedMutation, LrMutation, LrService } from '../api/lr-graphql';
+import { AccessRoleChoice } from '../api/types';
 import { EncryptionService } from '../encryption/encryption.service';
 import { ItemService } from '../item/item.service';
 import { KeyGraphService } from '../key/key-graph.service';
@@ -49,12 +50,17 @@ export declare class ScenarioService extends LrService {
                 wrappedAssemblyKeyVerifierPrk: string;
             };
             createReceivers: {
-                addDirectories: {
+                addDirectories: ({
                     directoryId: string;
+                    accessRole: AccessRoleChoice.DENY;
+                    wrappedItemKey: any;
+                    sharedCipherData: any;
+                } | {
+                    directoryId: string;
+                    accessRole: AccessRoleChoice.READER | AccessRoleChoice.WRITER | AccessRoleChoice.ADMIN | AccessRoleChoice.CUSTODIAN | AccessRoleChoice.OWNER;
                     wrappedItemKey: string;
-                    accessRole: import("../api/types").AccessRoleChoice;
                     sharedCipherData: string;
-                }[];
+                })[];
                 tpId: string;
                 tpSharedKeyId: string;
                 tpSharedKeyWrappedSharedKey: string;
@@ -125,30 +131,45 @@ export declare class ScenarioService extends LrService {
                 wrappedAssemblyKeyVerifierPrk: string;
             };
             createReceivers: {
-                addDirectories: {
+                addDirectories: ({
+                    directoryId: string;
+                    accessRole: AccessRoleChoice.DENY;
+                    wrappedItemKey: any;
+                    sharedCipherData: any;
+                } | {
                     directoryId: string;
+                    accessRole: AccessRoleChoice.READER | AccessRoleChoice.WRITER | AccessRoleChoice.ADMIN | AccessRoleChoice.CUSTODIAN | AccessRoleChoice.OWNER;
                     wrappedItemKey: string;
-                    accessRole: import("../api/types").AccessRoleChoice;
                     sharedCipherData: string;
-                }[];
+                })[];
                 tpId: string;
                 tpSharedKeyId: string;
                 tpSharedKeyWrappedSharedKey: string;
                 sharedCipherData: string;
             }[];
             updateReceivers: {
-                addDirectories: {
+                addDirectories: ({
+                    directoryId: string;
+                    accessRole: AccessRoleChoice.DENY;
+                    wrappedItemKey: any;
+                    sharedCipherData: any;
+                } | {
                     directoryId: string;
+                    accessRole: AccessRoleChoice.READER | AccessRoleChoice.WRITER | AccessRoleChoice.ADMIN | AccessRoleChoice.CUSTODIAN | AccessRoleChoice.OWNER;
                     wrappedItemKey: string;
-                    accessRole: import("../api/types").AccessRoleChoice;
                     sharedCipherData: string;
-                }[];
-                updateDirectories: {
+                })[];
+                updateDirectories: ({
+                    directoryId: string;
+                    accessRole: AccessRoleChoice.DENY;
+                    wrappedItemKey: any;
+                    sharedCipherData: any;
+                } | {
                     directoryId: string;
+                    accessRole: AccessRoleChoice.READER | AccessRoleChoice.WRITER | AccessRoleChoice.ADMIN | AccessRoleChoice.CUSTODIAN | AccessRoleChoice.OWNER;
                     wrappedItemKey: string;
-                    accessRole: import("../api/types").AccessRoleChoice;
                     sharedCipherData: string;
-                }[];
+                })[];
                 deleteDirectories: string[];
                 tpId: string;
                 sharedKeyId: string;
@@ -226,30 +247,45 @@ export declare class ScenarioService extends LrService {
                 wrappedAssemblyKeyVerifierPrk: string;
             };
             createReceivers: {
-                addDirectories: {
+                addDirectories: ({
+                    directoryId: string;
+                    accessRole: AccessRoleChoice.DENY;
+                    wrappedItemKey: any;
+                    sharedCipherData: any;
+                } | {
                     directoryId: string;
+                    accessRole: AccessRoleChoice.READER | AccessRoleChoice.WRITER | AccessRoleChoice.ADMIN | AccessRoleChoice.CUSTODIAN | AccessRoleChoice.OWNER;
                     wrappedItemKey: string;
-                    accessRole: import("../api/types").AccessRoleChoice;
                     sharedCipherData: string;
-                }[];
+                })[];
                 tpId: string;
                 tpSharedKeyId: string;
                 tpSharedKeyWrappedSharedKey: string;
                 sharedCipherData: string;
             }[];
             updateReceivers: {
-                addDirectories: {
+                addDirectories: ({
+                    directoryId: string;
+                    accessRole: AccessRoleChoice.DENY;
+                    wrappedItemKey: any;
+                    sharedCipherData: any;
+                } | {
                     directoryId: string;
+                    accessRole: AccessRoleChoice.READER | AccessRoleChoice.WRITER | AccessRoleChoice.ADMIN | AccessRoleChoice.CUSTODIAN | AccessRoleChoice.OWNER;
                     wrappedItemKey: string;
-                    accessRole: import("../api/types").AccessRoleChoice;
                     sharedCipherData: string;
-                }[];
-                updateDirectories: {
+                })[];
+                updateDirectories: ({
+                    directoryId: string;
+                    accessRole: AccessRoleChoice.DENY;
+                    wrappedItemKey: any;
+                    sharedCipherData: any;
+                } | {
                     directoryId: string;
+                    accessRole: AccessRoleChoice.READER | AccessRoleChoice.WRITER | AccessRoleChoice.ADMIN | AccessRoleChoice.CUSTODIAN | AccessRoleChoice.OWNER;
                     wrappedItemKey: string;
-                    accessRole: import("../api/types").AccessRoleChoice;
                     sharedCipherData: string;
-                }[];
+                })[];
                 deleteDirectories: string[];
                 tpId: string;
                 sharedKeyId: string;
@@ -293,13 +329,12 @@ export declare class ScenarioService extends LrService {
     approveClaim(sharedScenarioId: string, sharedClaimId: string): Promise<any>;
     approveClaimMutation(sharedScenarioId: string, sharedClaimId: string): Promise<LrMergedMutation<import("./scenario.gql").ApproveScenarioClaimMutationResult[]>>;
     receiveClaim(scenarioId: string, sharedClaimId: string): Promise<import("./scenario.gql").ReceiveScenarioClaimMutationResult>;
-    receiveClaimMutation(scenarioId: string, sharedClaimId: string): Promise<LrMutation<import("./scenario.gql").ReceiveScenarioClaimMutationResult, {
+    receiveClaim2Mutation(scenarioId: string, sharedClaimId: string): Promise<LrMutation<import("./scenario.gql").ReceiveScenarioClaimMutationResult, {
         input: {
             scenarioClaimId: string;
-            receiverDirectories: {
-                receiverDirectoryId: string;
-                receiverSharedKeyWrappedItemKey: any;
-            }[];
+            sharedKeyWrappedAssemblyKey: string;
+            sharedKeyId: string;
+            assemblyKeyId: string;
         };
     }>>;
     debugExpireClaim(scenarioId: string): Promise<import("./scenario.gql").DebugExpireScenarioClaimMutationResult>;
@@ -323,7 +358,13 @@ export declare class ScenarioService extends LrService {
     private prepareUpdateParticipant;
     private prepareCreateClaimant;
     private prepareUpdateClaimant;
-    prepareClaim(scenarioId: string, sharedClaimId: string): Promise<{
+    prepareReceiveClaim2(scenarioId: string, sharedClaimId: string): Promise<{
+        scenarioClaimId: string;
+        sharedKeyWrappedAssemblyKey: string;
+        sharedKeyId: string;
+        assemblyKeyId: string;
+    }>;
+    prepareReceiveClaim(scenarioId: string, sharedClaimId: string): Promise<{
         scenarioClaimId: string;
         receiverDirectories: {
             receiverDirectoryId: string;

package/lib/scenario/scenario.types.d.ts

@@ -13,7 +13,7 @@ export interface ReceiverDirectoryOptions {
     directoryId: string;
     directoryKeyId?: string;
     accessRole: AccessRoleChoice;
-    sharedCipherDataClearJson: JSONObject;
+    sharedCipherDataClearJson?: JSONObject;
 }
 export declare type CreateReceiverDirectoryOptions = ReceiverDirectoryOptions;
 export declare type UpdateReceiverDirectoryOptions = ReceiverDirectoryOptions;

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

@@ -7,7 +7,7 @@ export interface DeleteTpMutation {
 export declare const DeleteTpMutation: import("../_common/ast").TypedDocumentNode<DeleteTpMutation>;
 export interface ShareDirectoryMutation {
     shareDirectory: {
-        tpSharedDirectory: {
+        directoryShare: {
             id: ID;
         };
     };
@@ -15,7 +15,7 @@ export interface ShareDirectoryMutation {
 export declare const ShareDirectoryMutation: import("../_common/ast").TypedDocumentNode<ShareDirectoryMutation>;
 export interface UnshareDirectoryMutation {
     unshareDirectory: {
-        tpSharedDirectory: {
+        directoryShare: {
             id: ID;
         };
     };
@@ -23,7 +23,7 @@ export interface UnshareDirectoryMutation {
 export declare const UnshareDirectoryMutation: import("../_common/ast").TypedDocumentNode<UnshareDirectoryMutation>;
 export interface ShareFileMutation {
     shareFile: {
-        tpSharedFile: {
+        fileShare: {
             id: ID;
         };
     };
@@ -31,72 +31,72 @@ export interface ShareFileMutation {
 export declare const ShareFileMutation: import("../_common/ast").TypedDocumentNode<ShareFileMutation>;
 export interface UnshareFileMutation {
     unshareFile: {
-        tpSharedFile: {
+        fileShare: {
             id: ID;
         };
     };
 }
 export declare const UnshareFileMutation: import("../_common/ast").TypedDocumentNode<UnshareFileMutation>;
-export interface CreateSharedDirectoryMutationResult {
-    createSharedDirectory: {
-        tpSharedDirectory: {
+export interface CreateDirectoryShareMutationResult {
+    createDirectoryShare: {
+        directoryShare: {
             id: ID;
         };
     };
 }
-export declare const CreateSharedDirectoryMutation: import("../_common/ast").TypedDocumentNode<CreateSharedDirectoryMutationResult>;
-export interface CreateSharedFileMutationResult {
-    createSharedFile: {
-        tpSharedFile: {
+export declare const CreateDirectoryShareMutation: import("../_common/ast").TypedDocumentNode<CreateDirectoryShareMutationResult>;
+export interface CreateFileShareMutationResult {
+    createFileShare: {
+        fileShare: {
             id: ID;
         };
     };
 }
-export declare const CreateSharedFileMutation: import("../_common/ast").TypedDocumentNode<CreateSharedFileMutationResult>;
-export interface UpdateSharedDirectoryMutationResult {
-    updateSharedDirectory: {
-        tpSharedDirectory: {
+export declare const CreateFileShareMutation: import("../_common/ast").TypedDocumentNode<CreateFileShareMutationResult>;
+export interface UpdateDirectoryShareMutationResult {
+    updateDirectoryShare: {
+        directoryShare: {
             id: ID;
         };
     };
 }
-export declare const UpdateSharedDirectoryMutation: import("../_common/ast").TypedDocumentNode<UpdateSharedDirectoryMutationResult>;
-export interface UpdateSharedFileMutationResult {
-    updateSharedFile: {
-        tpSharedFile: {
+export declare const UpdateDirectoryShareMutation: import("../_common/ast").TypedDocumentNode<UpdateDirectoryShareMutationResult>;
+export interface UpdateFileShareMutationResult {
+    updateFileShare: {
+        fileShare: {
             id: ID;
         };
     };
 }
-export declare const UpdateSharedFileMutation: import("../_common/ast").TypedDocumentNode<UpdateSharedFileMutationResult>;
-export interface DeleteSharedDirectoryMutationResult {
-    deleteSharedDirectory: {
+export declare const UpdateFileShareMutation: import("../_common/ast").TypedDocumentNode<UpdateFileShareMutationResult>;
+export interface DeleteDirectoryShareMutationResult {
+    deleteDirectoryShare: {
         id: ID;
     };
 }
-export declare const DeleteSharedDirectoryMutation: import("../_common/ast").TypedDocumentNode<DeleteSharedDirectoryMutationResult>;
-export interface DeleteSharedFileMutationResult {
-    deleteSharedFile: {
+export declare const DeleteDirectoryShareMutation: import("../_common/ast").TypedDocumentNode<DeleteDirectoryShareMutationResult>;
+export interface DeleteFileShareMutationResult {
+    deleteFileShare: {
         id: ID;
     };
 }
-export declare const DeleteSharedFileMutation: import("../_common/ast").TypedDocumentNode<DeleteSharedFileMutationResult>;
-export interface CompleteDetachedSharedDirectoryMutationResult {
-    completeDetachedSharedDirectory: {
-        tpSharedDirectory: {
+export declare const DeleteFileShareMutation: import("../_common/ast").TypedDocumentNode<DeleteFileShareMutationResult>;
+export interface CompleteDetachedDirectoryShareMutationResult {
+    completeDetachedDirectoryShare: {
+        directoryShare: {
             id: ID;
         };
     };
 }
-export declare const CompleteDetachedSharedDirectoryMutation: import("../_common/ast").TypedDocumentNode<CompleteDetachedSharedDirectoryMutationResult>;
-export interface CompleteDetachedSharedFileMutationResult {
-    completeDetachedSharedDirectory: {
-        tpSharedDirectory: {
+export declare const CompleteDetachedDirectoryShareMutation: import("../_common/ast").TypedDocumentNode<CompleteDetachedDirectoryShareMutationResult>;
+export interface CompleteDetachedFileShareMutationResult {
+    completeDetachedDirectoryShare: {
+        directoryShare: {
             id: ID;
         };
     };
 }
-export declare const CompleteDetachedSharedFileMutation: import("../_common/ast").TypedDocumentNode<CompleteDetachedSharedFileMutationResult>;
+export declare const CompleteDetachedFileShareMutation: import("../_common/ast").TypedDocumentNode<CompleteDetachedFileShareMutationResult>;
 export interface RequestTpMkReshareMutation {
     requestTpMkReshare: {
         id: ID;

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

@@ -61,8 +61,8 @@ 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, {
+    createDirectoryShare(options: CreateSharedItemOptions): Promise<import("./trusted-party.gql").CreateDirectoryShareMutationResult>;
+    createDirectoryShareMutation(options: CreateSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").CreateDirectoryShareMutationResult, {
         input: {
             id: string;
             tpId: string;
@@ -70,11 +70,11 @@ export declare class TrustedPartyService extends LrService {
             keyId: string;
             wrappingKeyId: string;
             wrappedKey: string;
-            shareType: import("../api/types").TpShareTypeChoice;
+            shareType: import("../api/types").ShareTypeChoice;
         };
     }>>;
-    createSharedFile(options: CreateSharedItemOptions): Promise<import("./trusted-party.gql").CreateSharedFileMutationResult>;
-    createSharedFileMutation(options: CreateSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").CreateSharedFileMutationResult, {
+    createFileShare(options: CreateSharedItemOptions): Promise<import("./trusted-party.gql").CreateFileShareMutationResult>;
+    createFileShareMutation(options: CreateSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").CreateFileShareMutationResult, {
         input: {
             id: string;
             tpId: string;
@@ -82,33 +82,33 @@ export declare class TrustedPartyService extends LrService {
             keyId: string;
             wrappingKeyId: string;
             wrappedKey: string;
-            shareType: import("../api/types").TpShareTypeChoice;
+            shareType: import("../api/types").ShareTypeChoice;
         };
     }>>;
     private prepareCreateSharedItemMutation;
-    updateSharedDirectory(options: UpdateSharedItemOptions): Promise<import("./trusted-party.gql").UpdateSharedDirectoryMutationResult>;
-    updateSharedDirectoryMutation(options: UpdateSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").UpdateSharedDirectoryMutationResult, {
+    updateDirectoryShare(options: UpdateSharedItemOptions): Promise<import("./trusted-party.gql").UpdateDirectoryShareMutationResult>;
+    updateDirectoryShareMutation(options: UpdateSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").UpdateDirectoryShareMutationResult, {
         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, {
+    updateFileShare(options: UpdateSharedItemOptions): Promise<import("./trusted-party.gql").UpdateFileShareMutationResult>;
+    updateFileShareMutation(options: UpdateSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").UpdateFileShareMutationResult, {
         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, {
+    deleteDirectoryShare(id: string): Promise<import("./trusted-party.gql").DeleteDirectoryShareMutationResult>;
+    deleteDirectoryShareMutation(id: string): Promise<LrMutation<import("./trusted-party.gql").DeleteDirectoryShareMutationResult, {
         input: {
             id: string;
         };
     }>>;
-    completeDetachedSharedDirectory(options: CompleteDetachedSharedItemOptions): Promise<import("./trusted-party.gql").CompleteDetachedSharedDirectoryMutationResult>;
-    completeDetachedSharedDirectoryMutation(options: CompleteDetachedSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").CompleteDetachedSharedDirectoryMutationResult, {
+    completeDetachedDirectoryShare(options: CompleteDetachedSharedItemOptions): Promise<import("./trusted-party.gql").CompleteDetachedDirectoryShareMutationResult>;
+    completeDetachedDirectoryShareMutation(options: CompleteDetachedSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").CompleteDetachedDirectoryShareMutationResult, {
         input: {
             id: string;
             keyId: string;
@@ -116,8 +116,8 @@ export declare class TrustedPartyService extends LrService {
             wrappedKey: string;
         };
     }>>;
-    completeDetachedSharedFile(options: CompleteDetachedSharedItemOptions): Promise<import("./trusted-party.gql").CompleteDetachedSharedFileMutationResult>;
-    completeDetachedSharedFileMutation(options: CompleteDetachedSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").CompleteDetachedSharedFileMutationResult, {
+    completeDetachedFileShare(options: CompleteDetachedSharedItemOptions): Promise<import("./trusted-party.gql").CompleteDetachedFileShareMutationResult>;
+    completeDetachedFileShareMutation(options: CompleteDetachedSharedItemOptions): Promise<LrMutation<import("./trusted-party.gql").CompleteDetachedFileShareMutationResult, {
         input: {
             id: string;
             keyId: string;

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

@@ -1,4 +1,4 @@
-import { AccessRoleChoice, LrRelayIdInput, TpShareTypeChoice } from '../api/types';
+import { AccessRoleChoice, LrRelayIdInput, ShareTypeChoice } from '../api/types';
 export interface ShareItemOptions {
     itemId: LrRelayIdInput;
     itemKeyId?: LrRelayIdInput;
@@ -16,7 +16,7 @@ export interface CreateSharedItemOptions {
     tpId: LrRelayIdInput;
     tpSharedKeyId?: LrRelayIdInput;
     accessRole: AccessRoleChoice;
-    shareType: TpShareTypeChoice;
+    shareType: ShareTypeChoice;
 }
 export interface UpdateSharedItemOptions {
     sharedItemId: LrRelayIdInput;