@lifeready/core 7.2.3 → 8.0.2

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/query-processor/tp-password-reset-processor.service.d.ts

@@ -1,12 +1,12 @@
 import { NgZone } from '@angular/core';
 import { KeyGraphService } from '../../key/key-graph.service';
-import { TpPasswordResetNode, TpPasswordResetUserNode } from '../types';
+import { TpPasswordResetNode, TpPasswordResetUser } from '../types';
 import { ProcessorCallbackParams } from './common-processors.service';
 export declare class TpPasswordResetProcessorService {
     private ngZone;
     private keyGraph;
     constructor(ngZone: NgZone, keyGraph: KeyGraphService);
-    processTpPasswordResetUserNode(node: TpPasswordResetUserNode): Promise<TpPasswordResetUserNode>;
+    processTpPasswordResetUser(node: TpPasswordResetUser): Promise<TpPasswordResetUser>;
     private processTpPasswordResetUserApprovalNode;
     makeTpPasswordResetNodeProcessor(): ({ field, }: ProcessorCallbackParams) => Promise<TpPasswordResetNode>;
     private processTpAssemblyNode;

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?: UserNode;
+    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>;
@@ -432,7 +432,7 @@ export interface TpPasswordResetUserAssembly {
     quorum?: number;
     subAssemblies?: TpPasswordResetUserSubAssembly[];
 }
-export interface TpPasswordResetUserNode {
+export interface TpPasswordResetUser {
     username?: string;
     resetUsername?: string;
     state?: TpClaimState;
@@ -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 {
@@ -681,7 +685,6 @@ export interface ServerConfig {
     relayConnectionMaxLimit?: number;
 }
 export interface AvailablePlanField {
-    planName?: string;
     issuerUid?: string;
     planUid?: string;
     name?: string;
@@ -691,19 +694,13 @@ export interface AvailablePlanField {
 }
 export interface PriceOptionField {
     priceId?: string;
-    planName?: string;
     name?: string;
-    billingPeriod?: BillingPeriodField;
     description?: string;
     amount?: number;
     currency?: string;
     intervalUnit?: string;
     intervalCount?: number;
 }
-export declare enum BillingPeriodField {
-    MONTHLY = "MONTHLY",
-    ANNUAL = "ANNUAL"
-}
 export interface TrialPeriodField {
     years?: number;
     months?: number;

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

@@ -1,13 +1,13 @@
-import { TpPasswordResetUserApprovalNode, TpPasswordResetUserApprover, TpPasswordResetUserAssembly, TpPasswordResetUserNode, TpPasswordResetUserSubAssembly, UserNode } from '../api/types';
+import { TpPasswordResetUser, TpPasswordResetUserApprovalNode, TpPasswordResetUserApprover, TpPasswordResetUserAssembly, TpPasswordResetUserSubAssembly, UserNode } from '../api/types';
 import { UserKeys } from '../key/key.service';
 export interface CurrentUserQueryResult {
-    currentUser: Pick<Required<UserNode>, 'username' | 'sessionEncryptionKey'> & {
+    currentUser: Pick<Required<UserNode>, 'id' | 'username' | 'sessionEncryptionKey'> & {
         currentUserKey: UserKeys;
     };
 }
 export declare const CurrentUserQuery: import("../_common/ast").TypedDocumentNode<CurrentUserQueryResult>;
 export interface ResetUserQueryResult {
-    tpPasswordResetUser: Pick<Required<TpPasswordResetUserNode>, 'username' | 'sessionEncryptionKey' | 'state' | 'passKey' | 'masterKey' | 'pxk' | 'approvals' | 'assemblyCipherData' | 'wrappedAssemblyKeyVerifierPrk'> & {
+    tpPasswordResetUser: Pick<Required<TpPasswordResetUser>, 'username' | 'sessionEncryptionKey' | 'state' | 'passKey' | 'masterKey' | 'pxk' | 'approvals' | 'assemblyCipherData' | 'wrappedAssemblyKeyVerifierPrk'> & {
         assembly: Pick<Required<TpPasswordResetUserAssembly>, 'singleReject' | 'quorum'> & {
             subAssemblies: (Pick<Required<TpPasswordResetUserSubAssembly>, 'singleReject' | 'quorum'> & {
                 approvers: Pick<Required<TpPasswordResetUserApprover>, 'name' | 'email' | 'state'>[];

package/lib/auth/auth.types.d.ts

@@ -1,9 +1,10 @@
 import { CognitoUser } from '@aws-amplify/auth';
 import { CognitoUserAttribute } from 'amazon-cognito-identity-js';
 import { JWK } from 'node-jose';
-import { JSONObject, TpClaimState, TpPasswordResetUserApprovalNode, TpPasswordResetUserApprover, TpPasswordResetUserAssembly, TpPasswordResetUserNode, TpPasswordResetUserSubAssembly, UserNode } from '../api/types';
+import { ID, JSONObject, TpClaimState, TpPasswordResetUser, TpPasswordResetUserApprovalNode, TpPasswordResetUserApprover, TpPasswordResetUserAssembly, TpPasswordResetUserSubAssembly, UserNode } from '../api/types';
 import { PassIdpParams, PassKeyParams } from '../key/key.types';
 export declare type AuthUser = Pick<Required<UserNode>, 'username'> & {
+    id?: ID;
     sub: string;
     loginEmail: string;
     resetUser: null | {
@@ -59,7 +60,7 @@ export interface PassKeyBundle {
     passIdpVerifier: JWK.Key;
     wrappedPassIdpVerifierPrk: Record<string, JSONObject>;
 }
-export declare type ResetUser = Pick<Required<TpPasswordResetUserNode>, 'username' | 'state' | 'approvals'> & {
+export declare type ResetUser = Pick<Required<TpPasswordResetUser>, 'username' | 'state' | 'approvals'> & {
     assembly: Pick<Required<TpPasswordResetUserAssembly>, 'singleReject' | 'quorum'> & {
         subAssemblies: (Pick<Required<TpPasswordResetUserSubAssembly>, 'singleReject' | 'quorum'> & {
             approvers: Pick<Required<TpPasswordResetUserApprover>, 'name' | 'email' | 'state'>[];

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/plan/plan.types.d.ts

@@ -3,7 +3,6 @@ export interface IssuePlanOptions {
     issuerUid: string;
     planUid: string;
     priceId: string;
-    disableTrial: boolean;
     promotionalCode?: string;
 }
 export interface CancelPlanOptions {

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

@@ -293,13 +293,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 +322,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/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;