@secrecy/lib 1.74.0-feat-groups-identity.4 → 1.74.0-feat-transfer-adaptations.1

package/dist/lib/crypto/helpers.js

@@ -0,0 +1,23 @@
+import { encryptCryptoBox } from '.';
+import { sodium } from '../sodium';
+import { encryptSecretStream, secretStreamKeygen } from './data';
+export function generatePassword() {
+    return sodium.randombytes_buf(16, 'hex');
+}
+export function derivePassword(password, salt) {
+    return sodium.crypto_pwhash(sodium.crypto_secretbox_KEYBYTES, password, salt, sodium.crypto_pwhash_OPSLIMIT_INTERACTIVE, sodium.crypto_pwhash_MEMLIMIT_INTERACTIVE, sodium.crypto_pwhash_ALG_ARGON2ID13, 'hex');
+}
+export async function encryptName(name, nameKey) {
+    const { data } = await encryptSecretStream(sodium.from_hex(nameKey), sodium.from_string(name));
+    return sodium.to_hex(data);
+}
+export async function generateAndEncryptNameAndKey(args) {
+    const nameKey = secretStreamKeygen();
+    const encryptedName = await encryptName(args.name, sodium.to_hex(nameKey));
+    const encryptedNameKey = sodium.to_hex(encryptCryptoBox(nameKey, args.publicKey, args.privateKey));
+    return {
+        nameKey,
+        encryptedName,
+        encryptedNameKey,
+    };
+}

package/dist/lib/index.js

@@ -1,7 +1,6 @@
 export * from './client/index.js';
 export * from './crypto/index.js';
 export { BaseClient } from './base-client.js';
-export * from './client/types/identity.js';
 export * from './client/helpers.js';
 export * from './sodium.js';
 export * from './utils/store-buddy.js';

package/dist/types/base-client.d.ts

@@ -5,6 +5,7 @@ export type SecrecyUrls = {
     auth: string;
     account: string;
     api: string;
+    data: string;
 };
 export type BaseClientOptions = {
     session: string;
@@ -23,8 +24,6 @@ export declare class BaseClient {
     me(): Promise<SelfUser>;
     static getUser(userId: string, opts?: CreateTrpcClientOptions): Promise<PublicUser>;
     getUser(userId: string): Promise<PublicUser>;
-    static getUsers(userIds: string[], opts?: CreateTrpcClientOptions): Promise<PublicUser[]>;
-    getUsers(userIds: string[]): Promise<PublicUser[]>;
     searchUsers(search: string): Promise<PublicUser[]>;
     updateProfile(data: RouterInputs['user']['updateProfile']): Promise<RouterOutputs['user']['updateProfile']>;
     static isCryptoTransactionDone({ idOrHash, network, opts, }: {

package/dist/types/client/SecrecyAppClient.d.ts

@@ -1,11 +1,12 @@
 import type { SecrecyClient, UserAppNotifications, UserAppSettings } from '../index.js';
 import type { JwtPayload } from 'jsonwebtoken';
-import { type RouterOutputs, type RouterInputs } from '../client.js';
+import { type RouterOutputs, type ApiClient, type RouterInputs } from '../client.js';
+import { type KeyPair } from './types/index.js';
 export declare class SecrecyAppClient {
     #private;
     jwt: string;
     jwtDecoded: JwtPayload;
-    constructor(uaJwt: string, client: SecrecyClient);
+    constructor(uaJwt: string, _client: SecrecyClient, _keys: KeyPair, apiClient: ApiClient);
     get userId(): string;
     get appId(): string;
     getJwt(): Promise<string>;

package/dist/types/client/SecrecyCloudClient.d.ts

@@ -1,24 +1,31 @@
 import type { ProgressCallback, SecrecyClient } from '../index.js';
-import type { DataMetadata, DataStorageType, LocalData, Node, NodeFull, NodeType } from './types/index.js';
-import { type RouterInputs, type RouterOutputs } from '../client.js';
+import type { DataMetadata, DataStorageType, KeyPair, LocalData, Node, NodeFull, NodeType } from './types/index.js';
+import { type RouterInputs, type ApiClient, type RouterOutputs } from '../client.js';
 import { type Progress } from '../types.js';
 import { FileTypeResult } from 'file-type';
+import { DownloadDataFromLinkOptions } from './data-link.js';
 export declare class SecrecyCloudClient {
     #private;
-    constructor(client: SecrecyClient);
+    constructor(client: SecrecyClient, keys: KeyPair, apiClient: ApiClient);
     addDataToHistory({ dataId, nodeId, }: {
         dataId: string;
         nodeId: string;
     }): Promise<NodeFull>;
-    uploadData({ storageType, data, encrypted, encryptProgress, uploadProgress, signal, meta, }: {
+    uploadData(opts: {
         storageType: DataStorageType;
         data: globalThis.File | Uint8Array<ArrayBuffer>;
+        password?: string;
         encrypted?: boolean;
         encryptProgress?: ProgressCallback;
         uploadProgress?: ProgressCallback;
         signal?: AbortSignal;
         meta?: FileTypeResult | true;
-    }): Promise<LocalData>;
+    }): Promise<LocalData & {
+        sharing: {
+            password: string;
+            encryptedDataKey: string;
+        } | null;
+    }>;
     uploadDataInCloud({ data, name, nodeId, encryptProgress, uploadProgress, storageType, signal, }: {
         data: globalThis.File | Uint8Array<ArrayBuffer>;
         name: string;
@@ -31,9 +38,9 @@ export declare class SecrecyCloudClient {
     deletedNodes(): Promise<Node[]>;
     sharedNodes(): Promise<Node[]>;
     nodesSharedWithMe(type?: NodeType): Promise<Node[]>;
-    deleteNodeSharing({ nodeId, destPubKey, }: {
+    deleteNodeSharing({ nodeId, userId, }: {
         nodeId: string;
-        destPubKey: string;
+        userId: string;
     }): Promise<boolean>;
     duplicateNode({ nodeId, folderId, name, }: {
         nodeId: string;
@@ -54,7 +61,7 @@ export declare class SecrecyCloudClient {
     dataMetadata({ id }: {
         id: string;
     }): Promise<DataMetadata>;
-    shareNode(accesses: RouterInputs['cloud']['shareNode']['accesses'], progress?: ProgressCallback): Promise<RouterOutputs['cloud']['shareNodeFinish']>;
+    shareNode(input: RouterInputs['cloud']['shareNode'], progress?: ProgressCallback): Promise<RouterOutputs['cloud']['shareNodeFinish']>;
     updateNode({ nodeId, name, isFavorite, deletedAt, }: {
         nodeId: string;
         name?: string | null | undefined;
@@ -96,7 +103,7 @@ export declare class SecrecyCloudClient {
         name: string;
         nodeId?: string;
     }): Promise<NodeFull>;
-    private readonly encryptNodesForIdentities;
+    private readonly encryptNodesForUsers;
     reportData({ id, reasons, }: Omit<RouterInputs['cloud']['reportData'], 'encryptedDataKey'>): Promise<RouterOutputs['cloud']['reportData']>;
     updateDataStorageType(input: RouterInputs['cloud']['moveToStorageType']): Promise<{
         isMoved: boolean;
@@ -129,32 +136,32 @@ export declare class SecrecyCloudClient {
         isMatching: false;
         details: {
             missingNodeAccesses: {
-                pubKey: string;
+                userId: string;
                 nodeId: string;
             }[];
             missingDataAccesses: {
-                pubKey: string;
+                userId: string;
                 nodeId: string;
                 dataId: string;
             }[];
             invalidRightsAccesses: {
-                pubKey: string;
+                userId: string;
                 nodeId: string;
                 expect: {
                     rights: "delete" | "read" | "write";
                 } & {
-                    addAccess: "delete" | "read" | "write" | null;
-                    sharingAddAccess: "delete" | "read" | "write" | null;
-                    delAccess: "delete" | "read" | "write" | null;
-                    sharingDelAccess: "delete" | "read" | "write" | null;
+                    addAccess?: "delete" | "read" | "write" | null | undefined;
+                    sharingAddAccess?: "delete" | "read" | "write" | null | undefined;
+                    delAccess?: "delete" | "read" | "write" | null | undefined;
+                    sharingDelAccess?: "delete" | "read" | "write" | null | undefined;
                 };
                 current: {
                     rights: "delete" | "read" | "write";
                 } & {
-                    addAccess: "delete" | "read" | "write" | null;
-                    sharingAddAccess: "delete" | "read" | "write" | null;
-                    delAccess: "delete" | "read" | "write" | null;
-                    sharingDelAccess: "delete" | "read" | "write" | null;
+                    addAccess?: "delete" | "read" | "write" | null | undefined;
+                    sharingAddAccess?: "delete" | "read" | "write" | null | undefined;
+                    delAccess?: "delete" | "read" | "write" | null | undefined;
+                    sharingDelAccess?: "delete" | "read" | "write" | null | undefined;
                 };
             }[];
         };
@@ -189,5 +196,6 @@ export declare class SecrecyCloudClient {
         createdByOrgId: string | null;
         createdByAppId: string | null;
     }>;
+    downloadDataFromLink(input: DownloadDataFromLinkOptions): Promise<Uint8Array<ArrayBuffer>>;
     private _handleDataContent;
 }

package/dist/types/client/SecrecyDbClient.d.ts

@@ -1,5 +1,7 @@
+import { type ApiClient } from '../client.js';
 import type { SecrecyClient } from '../index.js';
+import { type KeyPair } from './types/index.js';
 export declare class SecrecyDbClient {
     #private;
-    constructor(client: SecrecyClient);
+    constructor(_client: SecrecyClient, _keys: KeyPair, apiClient: ApiClient);
 }

package/dist/types/client/SecrecyMailClient.d.ts

@@ -1,9 +1,10 @@
-import { type RouterInputs } from '../client.js';
+import { type ApiClient, type RouterInputs } from '../client.js';
 import type { DraftMail, Mail, NewMail, ReceivedMail, SecrecyClient, SentMail, WaitingReceivedMail } from '../index.js';
+import { type KeyPair } from './types/index.js';
 import { type ApiMail } from './types/mail.js';
 export declare class SecrecyMailClient {
     #private;
-    constructor(client: SecrecyClient);
+    constructor(client: SecrecyClient, keys: KeyPair, apiClient: ApiClient);
     get({ id }: {
         id: string;
     }): Promise<Mail>;

package/dist/types/client/SecrecyOrganizationClient.d.ts

@@ -1,8 +1,9 @@
-import { RouterInputs, RouterOutputs } from '../client.js';
+import { RouterInputs, RouterOutputs, type ApiClient } from '../client.js';
 import type { SecrecyClient } from '../index.js';
+import { type KeyPair } from './types/index.js';
 export declare class SecrecyOrganizationClient {
     #private;
-    constructor(client: SecrecyClient);
+    constructor(_client: SecrecyClient, _keys: KeyPair, apiClient: ApiClient);
     create(input: RouterInputs['org']['create']): Promise<RouterOutputs['org']['create']>;
     update(input: Omit<RouterInputs['org']['update'], 'billingProfileStripeCustomerId'>): Promise<RouterOutputs['org']['update']>;
     addMember(input: RouterInputs['org']['addMember']): Promise<RouterOutputs['org']['addMember']>;

package/dist/types/client/SecrecyPayClient.d.ts

@@ -1,4 +1,6 @@
 import type { SecrecyClient } from '../index.js';
+import { type ApiClient } from '../client.js';
+import { type KeyPair } from './types/index.js';
 interface SuccessPayResponse<T> {
     success: true;
     data: T;
@@ -10,7 +12,7 @@ interface ErrorPayResponse {
 export type SecrecyPayResponse<T> = SuccessPayResponse<T> | ErrorPayResponse;
 export declare class SecrecyPayClient {
     #private;
-    constructor(client: SecrecyClient);
+    constructor(client: SecrecyClient, _keys: KeyPair, _apiClient: ApiClient);
     confirmPaymentIntent({ paymentIntentId, secrecyIdWhoCreatedPaymentIntent, secrecyIdWhoNeedToConfirmPaymentIntent, amount, currency, }: {
         paymentIntentId: string;
         secrecyIdWhoCreatedPaymentIntent: string;

package/dist/types/client/SecrecyPseudonymClient.d.ts

@@ -1,8 +1,9 @@
-import { type RouterInputs, type RouterOutputs } from '../client.js';
+import { type RouterInputs, type RouterOutputs, type ApiClient } from '../client.js';
 import type { SecrecyClient } from '../index.js';
+import { type KeyPair } from './types/index.js';
 export declare class SecrecyPseudonymClient {
     #private;
-    constructor(client: SecrecyClient);
+    constructor(client: SecrecyClient, keys: KeyPair, apiClient: ApiClient);
     askForLabel(input: RouterInputs['pseudonym']['askForLabel']): Promise<RouterOutputs['pseudonym']['askForLabel']>;
     askForUser(input: RouterInputs['pseudonym']['askForUser']): Promise<RouterOutputs['pseudonym']['askForUser']>;
     cross(input: RouterInputs['pseudonym']['cross']): Promise<RouterOutputs['pseudonym']['cross']>;

package/dist/types/client/SecrecyUserClient.d.ts

@@ -1,8 +1,9 @@
-import type { RouterInputs, RouterOutputs } from '../client.js';
+import type { RouterInputs, ApiClient, RouterOutputs } from '../client.js';
 import type { SecrecyClient } from '../index.js';
+import type { KeyPair } from './types/index.js';
 export declare class SecrecyUserClient {
     #private;
-    constructor(client: SecrecyClient);
+    constructor(_client: SecrecyClient, _keys: KeyPair, apiClient: ApiClient);
     answerInvitation(input: RouterInputs['contacts']['answerInvitation']): Promise<RouterOutputs['contacts']['answerInvitation']>;
     cancelInvitation(input: RouterInputs['contacts']['cancelInvitation']): Promise<RouterOutputs['contacts']['cancelInvitation']>;
     createInvitation(input: RouterInputs['contacts']['createInvitation']): Promise<RouterOutputs['contacts']['createInvitation']>;

package/dist/types/client/convert/data.d.ts

@@ -1,4 +1,4 @@
-import type { ApiData, InternalData, DataMetadata } from '../types/index.js';
-export declare function apiDataToInternal(apiData: ApiData, keyPairs: Record<string, string>): InternalData;
+import type { ApiData, InternalData, DataMetadata, KeyPair } from '../types/index.js';
+export declare function apiDataToInternal(apiData: ApiData, keyPair: KeyPair): InternalData;
 export declare function internalDataToExternalData(internal: InternalData): DataMetadata;
-export declare function apiDataToExternal(apiData: ApiData, keyPairs: Record<string, string>): DataMetadata;
+export declare function apiDataToExternal(apiData: ApiData, keyPair: KeyPair): DataMetadata;

package/dist/types/client/convert/mail.d.ts

@@ -1,6 +1,8 @@
-import { type Mail } from '../../index.js';
+import { type Mail, type SecrecyClient } from '../../index.js';
+import { type KeyPair } from '../types/index.js';
 import { type ApiMail } from '../types/mail.js';
-export declare function convertInternalMailToExternal({ mail, keyPairs, }: {
+export declare function convertInternalMailToExternal({ client, mail, keyPair, }: {
     mail: ApiMail;
-    keyPairs: Record<string, string>;
+    client: SecrecyClient;
+    keyPair: KeyPair;
 }): Promise<Mail>;

package/dist/types/client/convert/node.d.ts

@@ -1,6 +1,6 @@
-import type { Node, ApiNode, ApiNodeFull, InternalNodeFull, NodeFull, ApiNodeParent, ApiNodeForEncryption, InternalMinimalNodeForEncryption } from '../types/index.js';
-export declare function apiNodeFullToInternalFull(apiNodeFull: ApiNodeFull, keyPairs: Record<string, string>): Promise<InternalNodeFull>;
+import type { Node, ApiNode, ApiNodeFull, InternalNodeFull, NodeFull, KeyPair, ApiNodeParent, ApiNodeForEncryption, InternalMinimalNodeForEncryption } from '../types/index.js';
+export declare function apiNodeFullToInternalFull(apiNodeFull: ApiNodeFull, keyPair: KeyPair): Promise<InternalNodeFull>;
 export declare function internalNodeFullToNodeFull(internal: InternalNodeFull): NodeFull;
-export declare function apiNodeToExternalNodeFull(apiNodeFull: ApiNodeFull, keyPairs: Record<string, string>): Promise<NodeFull>;
-export declare function apiNodeToExternal(apiNode: ApiNode | ApiNodeParent, keyPairs: Record<string, string>): Promise<Node>;
-export declare function apiNodeForEncryptionToInternal(apiNode: ApiNodeForEncryption, keyPairs: Record<string, string>): Promise<InternalMinimalNodeForEncryption>;
+export declare function apiNodeToExternalNodeFull(apiNodeFull: ApiNodeFull, keyPair: KeyPair): Promise<NodeFull>;
+export declare function apiNodeToExternal(apiNode: ApiNode | ApiNodeParent, keyPair: KeyPair): Promise<Node>;
+export declare function apiNodeForEncryptionToInternal(apiNode: ApiNodeForEncryption, keyPair: KeyPair): Promise<InternalMinimalNodeForEncryption>;

package/dist/types/client/data-link.d.ts

@@ -0,0 +1,37 @@
+import z from 'zod';
+import { ProgressCallback } from '.';
+import { Progress } from 'ky';
+export declare const downloadDataLinkSchema: z.ZodUnion<readonly [z.ZodObject<{
+    name: z.ZodString;
+    md5: z.ZodString;
+    md5Encrypted: z.ZodNullable<z.ZodString>;
+    size: z.ZodCoercedBigInt<unknown>;
+    parts: z.ZodArray<z.ZodObject<{
+        order: z.ZodNumber;
+        md5: z.ZodString;
+        contentUrl: z.ZodString;
+    }, z.core.$strip>>;
+    mime: z.ZodString;
+    isEncrypted: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodString;
+    md5: z.ZodString;
+    md5Encrypted: z.ZodNullable<z.ZodString>;
+    size: z.ZodCoercedBigInt<unknown>;
+    bytes: z.ZodString;
+    mime: z.ZodString;
+    isEncrypted: z.ZodBoolean;
+}, z.core.$strip>]>;
+export type DownloadDataFromLinkOptions = {
+    dataLinkSlug: string;
+    crypto?: {
+        password: string;
+        key: string;
+    };
+    decryptProgress?: ProgressCallback;
+    downloadProgress?: (progress: Progress) => void;
+    signal?: AbortSignal;
+};
+export declare function downloadDataFromLink(opts: DownloadDataFromLinkOptions & {
+    dataUrl?: string;
+}): Promise<Uint8Array<ArrayBuffer>>;

package/dist/types/client/download.d.ts

@@ -0,0 +1,2 @@
+export declare const downloadFileLite: (file: BlobPart, name: string) => Promise<void>;
+export declare const downloadFileSmart: (file: BlobPart, name: string) => Promise<boolean>;

package/dist/types/client/index.d.ts

@@ -6,17 +6,16 @@ import { SecrecyAppClient } from './SecrecyAppClient.js';
 import { SecrecyDbClient } from './SecrecyDbClient.js';
 import { SecrecyWalletClient } from './SecrecyWalletClient.js';
 import { SecrecyPayClient } from './SecrecyPayClient.js';
-import { ApiClient, type RouterInputs, type RouterOutputs } from '../client.js';
+import { ApiClient, type RouterInputs } from '../client.js';
+import { type KeyPair } from './types/index.js';
 import { SecrecyUserClient } from './SecrecyUserClient.js';
 import { SecrecyPseudonymClient } from './SecrecyPseudonymClient.js';
 import { SecrecyOrganizationClient } from './SecrecyOrganizationClient.js';
-import type { AccessIdentity, GroupIdentity, UserAppIdentity } from './types/identity.js';
 export type NewMail = Pick<RouterInputs['mail']['createDraft'], 'body' | 'subject' | 'senderFiles' | 'recipients' | 'replyToId'>;
 export type ProgressCallback = (progress: SecretStreamProgress) => Promise<void>;
 export interface SecrecyClientOptions {
     uaSession: string;
-    identities: AccessIdentity[];
-    keyPairs: Record<string, string>;
+    uaKeys: KeyPair;
     uaJwt: string;
     apiClient?: ApiClient;
     secrecyUrls?: Partial<SecrecyUrls>;
@@ -34,13 +33,6 @@ export declare class SecrecyClient extends BaseClient {
     pseudonym: SecrecyPseudonymClient;
     constructor(opts: SecrecyClientOptions);
     get publicKey(): string;
-    get apiClient(): Readonly<ApiClient>;
-    get keyPairs(): Readonly<Record<string, string>>;
-    getPrivateKey(pubKey: string): string;
-    get uaPrivateKey(): string;
-    get groupIdentities(): ReadonlyArray<Readonly<GroupIdentity>>;
-    get uaIdentity(): Readonly<UserAppIdentity>;
     decryptAnonymous(data: Uint8Array): Uint8Array;
     logout(sessionId?: string | null | undefined): Promise<void>;
-    getIdentities(input: RouterInputs['identity']['getMany']): Promise<RouterOutputs['identity']['getMany']>;
 }

package/dist/types/client/storage.d.ts

@@ -1,8 +1,7 @@
 import type { StoreBuddy } from '../utils/store-buddy.js';
-import type { AccessIdentity } from './types/identity.js';
+import { type KeyPair } from './types/index.js';
 export declare function getStorage(session?: boolean | undefined): {
-    identities: StoreBuddy<AccessIdentity[] | null>;
-    keyPairs: StoreBuddy<Record<string, string> | null>;
+    userAppKeys: StoreBuddy<KeyPair | null>;
     userAppSession: StoreBuddy<string | null>;
     jwt: StoreBuddy<string | null>;
 };

package/dist/types/client/types/index.d.ts

@@ -4,20 +4,16 @@ export type * from './data.js';
 export type * from './node.js';
 export type * from './mail.js';
 export type * from './user.js';
+declare const keyPair: z.ZodObject<{
+    publicKey: z.ZodString;
+    privateKey: z.ZodString;
+}, z.core.$strict>;
+export type KeyPair = z.infer<typeof keyPair>;
 export declare const secrecyUserApp: z.ZodReadonly<z.ZodObject<{
-    identities: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"USER_APP">;
-        identityPubKey: z.ZodString;
-        userId: z.ZodString;
-        appId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"GROUP">;
-        identityPubKey: z.ZodString;
-        groupId: z.ZodString;
-        sharedByPubKey: z.ZodString;
-        groupOwnerPubKey: z.ZodString;
-    }, z.core.$strip>], "kind">>;
-    keyPairs: z.ZodRecord<z.ZodString, z.ZodString>;
+    keys: z.ZodObject<{
+        publicKey: z.ZodString;
+        privateKey: z.ZodString;
+    }, z.core.$strict>;
     jwt: z.ZodString;
     uaSession: z.ZodString;
 }, z.core.$strict>>;

package/dist/types/client/types/mail.d.ts

@@ -13,7 +13,7 @@ export interface BaseMail {
     deletedAt: Date | null;
     openedAt: Date | null;
     isAltered: boolean;
-    recipients: Array<PublicUser>;
+    recipients: Array<Omit<PublicUser, 'publicKey'>>;
     temporaryRecipients: TemporaryMailUser[];
     attachments: Array<{
         id: string;
@@ -24,7 +24,6 @@ export interface BaseMail {
 export interface ReceivedMail extends BaseMail {
     type: 'received';
     sender: PublicUser;
-    senderPublicKey: string;
 }
 export interface InternalSentMail {
     user: {

package/dist/types/client/types/node.d.ts

@@ -1,19 +1,17 @@
 import { type RouterOutputs } from '../../client.js';
-import type { DataMetadata, InternalData, UserAppOrg } from './index.js';
-export type Permissions = ApiNode['identities'][number];
+import type { DataMetadata, InternalData, PublicUser } from './index.js';
+export type Permissions = ApiNode['users'][number][1];
 export type Rights = Permissions['rights'];
 export type NodeAccess<T extends Record<string, unknown> = Record<string, unknown>> = T & Permissions & {
     isRoot: boolean;
     sharedByPubKey: string;
-    identityPubKey: string;
 };
 export interface NodeBreadcrumbItem {
     id: string;
     name: string;
 }
 export interface NodeBreadcrumbItemWithPubKey extends NodeBreadcrumbItem {
-    sharedByPubKey: string;
-    identityPubKey: string;
+    pubKey: string;
 }
 export interface NodeSize {
     size: bigint;
@@ -33,10 +31,9 @@ export interface Node<T extends NodeBreadcrumbItem = NodeBreadcrumbItem, U exten
     sizes: NodeSize;
     name: string;
     breadcrumb: T[];
-    owner: UserAppOrg;
-    accesses: NodeAccess<U>[];
-    permissions: Permissions;
-    identities: Record<string, Permissions>;
+    owner: PublicUser;
+    access: NodeAccess<U>;
+    users: Array<[PublicUser, Permissions]>;
     currentDataId: string | null;
     parentId: string | null;
 }
@@ -75,16 +72,16 @@ export type EncryptedNodeInfos = {
 };
 export type ShareNodeDetails = {
     missingNodeAccesses: {
-        pubKey: string;
+        userId: string;
         nodeId: string;
     }[];
     missingDataAccesses: {
-        pubKey: string;
+        userId: string;
         dataId: string;
         nodeId: string;
     }[];
     invalidRightsAccesses: {
-        pubKey: string;
+        userId: string;
         current: Permissions;
         nodeId: string;
         expect: Permissions;

package/dist/types/client/types/user.d.ts

@@ -1,18 +1,3 @@
 import { type RouterOutputs } from '../../client.js';
 export type SelfUser = RouterOutputs['user']['self'];
 export type PublicUser = RouterOutputs['user']['byId'];
-export type UserAppOrg = RouterOutputs['cloud']['nodeById']['owner'];
-export type AccessIdentity = RouterOutputs['identity']['list']['identities'][number];
-export type PublicAccessIdentity = RouterOutputs['identity']['get']['identity'];
-export type PublicUserAppIdentity = Extract<PublicAccessIdentity, {
-    kind: 'USER_APP';
-}>;
-export type PublicGroupIdentity = Extract<PublicAccessIdentity, {
-    kind: 'GROUP';
-}>;
-export type UserAppIdentity = Extract<AccessIdentity, {
-    kind: 'USER_APP';
-}>;
-export type GroupIdentity = Extract<AccessIdentity, {
-    kind: 'GROUP';
-}>;

package/dist/types/client/upload.d.ts

@@ -0,0 +1,38 @@
+import { DataStorageType, LocalData } from './types/data.js';
+import { ProgressCallback } from './index.js';
+import { FileTypeResult } from 'file-type';
+import { KeyPair } from './types/index.js';
+import { ApiClient, RouterInputs } from '../client.js';
+export type UploadDataOptions = {
+    storageType: DataStorageType;
+    data: globalThis.File | Uint8Array<ArrayBuffer>;
+    password?: string;
+    encrypted?: boolean;
+    encryptProgress?: ProgressCallback;
+    uploadProgress?: ProgressCallback;
+    signal?: AbortSignal;
+    meta?: FileTypeResult | true;
+};
+export declare function uploadData({ storageType, data, password, forcePassword, encrypted, encryptProgress, uploadProgress, signal, meta, keyPair, apiClient, }: UploadDataOptions & {
+    keyPair?: KeyPair;
+    apiClient?: ApiClient;
+    forcePassword?: boolean;
+}): Promise<LocalData & {
+    sharing: {
+        password: string;
+        encryptedDataKey: string;
+    } | null;
+}>;
+export type CreateDataLinkOptions = RouterInputs['cloud']['createDataLink'];
+export declare function createPublicDataLink({ apiClient, ...opts }: CreateDataLinkOptions & Pick<{
+    apiClient?: ApiClient;
+}, 'apiClient'>): Promise<{
+    id: string;
+    name: string;
+    slug: string;
+    expireAt: Date | null;
+    dataId: string;
+    createdByUserId: string | null;
+    createdByOrgId: string | null;
+    createdByAppId: string | null;
+}>;