@secrecy/lib 1.74.6 → 1.75.0-feat-groups-identity.2

package/dist/lib/client/index.js

@@ -11,7 +11,9 @@ import { SecrecyPseudonymClient } from './SecrecyPseudonymClient.js';
 import { decryptAnonymous } from '../crypto/index.js';
 import { SecrecyOrganizationClient } from './SecrecyOrganizationClient.js';
 export class SecrecyClient extends BaseClient {
-    #keys;
+    #groupIdentities;
+    #uaIdentity;
+    #keyPairs;
     cloud;
     mail;
     app;
@@ -36,22 +38,53 @@ export class SecrecyClient extends BaseClient {
                 }
             },
         });
-        this.#keys = opts.uaKeys;
-        this.cloud = new SecrecyCloudClient(this, this.#keys, this.client);
-        this.mail = new SecrecyMailClient(this, this.#keys, this.client);
-        this.app = new SecrecyAppClient(opts.uaJwt, this, this.#keys, this.client);
-        this.db = new SecrecyDbClient(this, this.#keys, this.client);
-        this.organization = new SecrecyOrganizationClient(this, this.#keys, this.client);
+        this.#keyPairs = opts.keyPairs;
+        this.#groupIdentities = opts.identities.filter((i) => i.kind === 'GROUP');
+        const uaIdentities = opts.identities.filter((i) => i.kind === 'USER_APP');
+        if (!uaIdentities[0]) {
+            throw new Error('One USER_APP identity is required');
+        }
+        this.#uaIdentity = uaIdentities[0];
+        this.cloud = new SecrecyCloudClient(this);
+        this.mail = new SecrecyMailClient(this);
+        this.app = new SecrecyAppClient(opts.uaJwt, this);
+        this.db = new SecrecyDbClient(this);
+        this.organization = new SecrecyOrganizationClient(this);
         this.wallet = new SecrecyWalletClient(this);
-        this.pay = new SecrecyPayClient(this, this.#keys, this.client);
-        this.user = new SecrecyUserClient(this, this.#keys, this.client);
-        this.pseudonym = new SecrecyPseudonymClient(this, this.#keys, this.client);
+        this.pay = new SecrecyPayClient(this);
+        this.user = new SecrecyUserClient(this);
+        this.pseudonym = new SecrecyPseudonymClient(this);
     }
     get publicKey() {
-        return this.#keys.publicKey;
+        return this.#uaIdentity.identityPubKey;
+    }
+    get apiClient() {
+        return this.client;
+    }
+    get keyPairs() {
+        return this.#keyPairs;
+    }
+    getPrivateKey(pubKey) {
+        const privateKey = this.#keyPairs[pubKey];
+        if (privateKey === undefined) {
+            throw new Error(`Missing private key for public key ${pubKey}`);
+        }
+        return privateKey;
+    }
+    get uaPrivateKey() {
+        return this.getPrivateKey(this.#uaIdentity.identityPubKey);
+    }
+    get groupIdentities() {
+        return this.#groupIdentities;
+    }
+    get uaIdentity() {
+        return this.#uaIdentity;
     }
     decryptAnonymous(data) {
-        return decryptAnonymous(data, this.#keys);
+        return decryptAnonymous(data, {
+            publicKey: this.#uaIdentity.identityPubKey,
+            privateKey: this.uaPrivateKey,
+        });
     }
     async logout(sessionId) {
         nodesCache.clear();
@@ -59,4 +92,7 @@ export class SecrecyClient extends BaseClient {
         publicKeysCache.clear();
         await super.logout(sessionId);
     }
+    async getIdentities(input) {
+        return await this.client.identity.getMany.query(input);
+    }
 }

package/dist/lib/client/storage.js

@@ -1,7 +1,8 @@
 import { storeBuddy } from '../utils/store-buddy.js';
 export function getStorage(session) {
     const userAppSession = storeBuddy(`secrecy.user_app_session`, session).init(null);
-    const userAppKeys = storeBuddy(`secrecy.user_app_keys`, session).init(null);
+    const identities = storeBuddy(`secrecy.identities`, session).init(null);
+    const keyPairs = storeBuddy(`secrecy.key_pairs`, session).init(null);
     const jwt = storeBuddy(`secrecy.jwt`, session).init(null);
-    return { userAppKeys, userAppSession, jwt };
+    return { identities, keyPairs, userAppSession, jwt };
 }

package/dist/lib/client/types/identity.js

@@ -0,0 +1,19 @@
+import { z } from 'zod/v4';
+export const userAppSchema = z.object({
+    kind: z.literal('USER_APP'),
+    identityPubKey: z.string(),
+    userId: z.string(),
+    appId: z.string(),
+});
+export const groupSchema = z.object({
+    kind: z.literal('GROUP'),
+    identityPubKey: z.string(),
+    groupId: z.string(),
+    groupRole: z.enum(['ADMIN', 'MEMBER']),
+    sharedByPubKey: z.string(),
+    groupOwnerPubKey: z.string(),
+});
+export const accessIdentitySchema = z.discriminatedUnion('kind', [
+    userAppSchema,
+    groupSchema,
+]);

package/dist/lib/client/types/index.js

@@ -1,13 +1,9 @@
 import { z } from 'zod';
-const keyPair = z
-    .object({
-    publicKey: z.string(),
-    privateKey: z.string(),
-})
-    .strict();
+import { accessIdentitySchema } from './identity.js';
 export const secrecyUserApp = z
     .object({
-    keys: keyPair,
+    identities: accessIdentitySchema.array(),
+    keyPairs: z.record(z.string(), z.string()),
     jwt: z.string(),
     uaSession: z.string(),
 })

package/dist/lib/client/upload.js

@@ -11,11 +11,11 @@ import { promiseAllLimit } from '../utils/promise.js';
 import { encryptDataAndKey } from '../crypto/domain.js';
 import { derivePassword, generatePassword } from '../crypto/helpers.js';
 import { decryptCryptoBox, encryptSecretBox } from '../crypto/index.js';
-export async function uploadData({ storageType, data, password, forcePassword = false, encrypted = true, encryptProgress, uploadProgress, signal, meta, keyPair, apiClient, }) {
+export async function uploadData({ storageType, data, password, forcePassword = false, encrypted = true, encryptProgress, uploadProgress, signal, meta, uaIdentity, keyPairs, apiClient, }) {
     if (!encrypted && (password || forcePassword)) {
         throw new Error('Cannot share unencrypted data with a password!');
     }
-    if (encrypted && !password && !forcePassword && !keyPair) {
+    if (encrypted && !password && !forcePassword && !uaIdentity) {
         throw new Error('Cannot share encrypted data without a password!');
     }
     apiClient ??= getTrpcGuestClient();
@@ -37,7 +37,7 @@ export async function uploadData({ storageType, data, password, forcePassword =
     if (storageType === 'lite' && dataBuffer.byteLength > kiloToBytes(1024)) {
         throw new Error('The data is too big for lite upload!');
     }
-    if (!keyPair && storageType === 'cold') {
+    if (!uaIdentity && storageType === 'cold') {
         throw new Error('Cold storage is only for logged users!');
     }
     const compressed = encrypted ? compress(dataBuffer) : dataBuffer;
@@ -45,7 +45,8 @@ export async function uploadData({ storageType, data, password, forcePassword =
         ? await encryptDataAndKey({
             data: compressed,
             progress: encryptProgress,
-            keyPair,
+            uaIdentity,
+            keyPairs,
             signal,
         })
         : {
@@ -73,13 +74,17 @@ export async function uploadData({ storageType, data, password, forcePassword =
                 key = dataKey;
             }
             else {
-                if (!keyPair) {
+                if (!uaIdentity) {
                     throw new Error('Unable to encrypt data without keyPair!');
                 }
                 if (!data.key) {
                     throw new Error('Unable to encrypt data without key!');
                 }
-                key = decryptCryptoBox(sodium.from_hex(data.key), data.keyPair.pub, keyPair.privateKey);
+                const priv = keyPairs?.[data.keyPair.pub];
+                if (typeof priv !== 'string') {
+                    throw new Error('Unable to encrypt data without keyPair!');
+                }
+                key = decryptCryptoBox(sodium.from_hex(data.key), data.keyPair.pub, priv);
             }
             // NOTE: Process to create a sharing for a auth client (todo: endpoint)
             return {
@@ -105,7 +110,6 @@ export async function uploadData({ storageType, data, password, forcePassword =
                 type: 'unencrypted',
                 content: Buffer.from(encryptedData),
                 md5: md5Data,
-                sizeEncrypted: undefined,
                 size: BigInt(dataBuffer.byteLength),
                 ...filetype,
             };
@@ -120,7 +124,9 @@ export async function uploadData({ storageType, data, password, forcePassword =
             id: uploadData.id,
             storageType: 'lite',
             size: uploadDataArgs.size,
-            sizeEncrypted: uploadDataArgs.sizeEncrypted ?? null,
+            sizeEncrypted: uploadDataArgs.type === 'encrypted'
+                ? uploadDataArgs.sizeEncrypted
+                : null,
             data: dataBuffer,
             ...filetype,
         };
@@ -145,7 +151,6 @@ export async function uploadData({ storageType, data, password, forcePassword =
                 type: 'unencrypted',
                 md5: md5Data,
                 size: BigInt(dataBuffer.byteLength),
-                sizeEncrypted: undefined,
                 ...filetype,
             };
         const uploadDataCaller = storageType === 's3'
@@ -155,12 +160,6 @@ export async function uploadData({ storageType, data, password, forcePassword =
             signal,
         });
         if (uploadData.parts.length === 0) {
-            if (uploadData.type === 'authed' &&
-                (typeof keyPair === 'undefined' ||
-                    typeof keyPair === 'string' ||
-                    uploadData.keyPair.pub !== keyPair.publicKey)) {
-                throw new Error('The public key does not match with cached key!');
-            }
             await uploadProgress?.({
                 total: encryptedData.byteLength,
                 current: encryptedData.byteLength,
@@ -171,7 +170,9 @@ export async function uploadData({ storageType, data, password, forcePassword =
                 id: uploadData.id,
                 storageType: storageType,
                 size: uploadDataArgs.size,
-                sizeEncrypted: uploadDataArgs.sizeEncrypted ?? null,
+                sizeEncrypted: uploadDataArgs.type === 'encrypted'
+                    ? uploadDataArgs.sizeEncrypted
+                    : null,
                 data: dataBuffer,
                 ...filetype,
             };
@@ -231,7 +232,9 @@ export async function uploadData({ storageType, data, password, forcePassword =
             id: uploadData.id,
             storageType: storageType,
             size: uploadDataArgs.size,
-            sizeEncrypted: uploadDataArgs.sizeEncrypted ?? null,
+            sizeEncrypted: uploadDataArgs.type === 'encrypted'
+                ? uploadDataArgs.sizeEncrypted
+                : null,
             data: dataBuffer,
             ...filetype,
         };

package/dist/lib/crypto/data.js

@@ -46,7 +46,7 @@ function decrypt(header, key) {
     };
 }
 export const CHUNK_SIZE = 8192;
-export async function encryptSecretStream(key, data, progress, abort) {
+export async function encryptSecretStream(key, data, progress, signal) {
     await setup();
     const { encrypt: crypt, destroy, header } = encrypt(key);
     const encryptedChunk = CHUNK_SIZE + sodium.crypto_secretstream_xchacha20poly1305_ABYTES;
@@ -69,7 +69,7 @@ export async function encryptSecretStream(key, data, progress, abort) {
     });
     let lastPercent = total / max;
     for (const chunk of chunks(data, CHUNK_SIZE)) {
-        if (abort?.signal.aborted === true) {
+        if (signal?.aborted === true) {
             throw new Error(`Encrypt aborted`);
         }
         spark.append(chunk.buffer);
@@ -102,7 +102,7 @@ export async function encryptSecretStream(key, data, progress, abort) {
         md5: spark.end(),
     };
 }
-export async function decryptSecretStream(key, data, progress, abort) {
+export async function decryptSecretStream(key, data, progress, signal) {
     await setup();
     const header = data.slice(0, sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES);
     data = data.slice(sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES);
@@ -118,7 +118,7 @@ export async function decryptSecretStream(key, data, progress, abort) {
     let total = 0;
     let lastPercent = total / max;
     for (const chunk of chunks(data, chunkSize)) {
-        if (abort?.signal.aborted === true) {
+        if (signal?.aborted === true) {
             throw new Error(`Decrypt aborted`);
         }
         const messageTag = decryptFn(chunk);

package/dist/lib/crypto/domain.js

@@ -10,10 +10,10 @@ import { concatenate } from '../utils/array.js';
  * If a string is provided as keypair, it should be considered as guest with password case.
  * If keypair is not provided, then we generate a key to be used as password for guest too.
  */
-export async function encryptDataAndKey({ data, keyPair, progress, signal, }) {
+export async function encryptDataAndKey({ data, uaIdentity, keyPairs, progress, signal, }) {
     const dataKey = secretStreamKeygen();
     const { data: encryptedData, md5: md5Data, md5Encrypted, } = await encrypt(dataKey, data, progress, signal);
-    if (!keyPair) {
+    if (!uaIdentity || !keyPairs) {
         return {
             encryptedData,
             dataKey,
@@ -21,7 +21,11 @@ export async function encryptDataAndKey({ data, keyPair, progress, signal, }) {
             md5Encrypted,
         };
     }
-    const encDataKey = encryptCryptoBox(dataKey, keyPair.publicKey, keyPair.privateKey);
+    const priv = keyPairs[uaIdentity.identityPubKey];
+    if (!priv) {
+        throw new Error('No private key found for user app identity');
+    }
+    const encDataKey = encryptCryptoBox(dataKey, uaIdentity.identityPubKey, priv);
     return {
         encryptedDataKey: encDataKey,
         encryptedData,
@@ -39,19 +43,15 @@ const encryptedContentFromParts = async (arg) => {
             onDownloadProgress: (pr) => {
                 arg.onProgress(`${arg.dataId}-${part.order}`, pr);
             },
-            signal: arg.signal,
+            signal: arg.signal ?? null,
         })
             .arrayBuffer());
         const md5Part = await md5(buf);
         if (md5Part !== part.md5) {
             throw new Error(`Invalid md5 for part ${part.order} of data ${arg.dataId}`);
         }
-        if (typeof parts[arg.dataId] === 'undefined') {
-            parts[arg.dataId] = [{ data: buf, order: part.order }];
-        }
-        else {
-            parts[arg.dataId].push({ data: buf, order: part.order });
-        }
+        parts[arg.dataId] ??= [];
+        parts[arg.dataId].push({ data: buf, order: part.order });
     };
     await promiseAllLimit(3, arg.dataParts.map((p) => async () => byPart(p)));
     return concatenate(...parts[arg.dataId].sort((a, b) => a.order - b.order).map((p) => p.data));

package/dist/lib/index.js

@@ -1,6 +1,7 @@
 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/lib/minify/lz4.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 // lz4-ts @license BSD-3-Clause / Copyright (c) 2015, Pierre Curto / 2016, oov. All rights reserved.
 /**
  * Copyright (c) 2015, Pierre Curto

package/dist/lib/utils/links.js

@@ -8,8 +8,8 @@ export const secrecyApplications = [
 ];
 function getEnv() {
     if (typeof window === 'undefined') {
-        return process.env.VERCEL_ENV
-            ? process.env.VERCEL_ENV
+        return process.env['VERCEL_ENV']
+            ? process.env['VERCEL_ENV']
             : 'production';
     }
     if (window.location.hostname.includes('secrecy.tech')) {
@@ -24,10 +24,10 @@ function getEnv() {
     return 'production';
 }
 const env = getEnv();
-const secrecyUrl = process.env.NEXT_PUBLIC_IS_SECRECY_INTERNAL !== 'true'
+const secrecyUrl = process.env['NEXT_PUBLIC_IS_SECRECY_INTERNAL'] !== 'true'
     ? 'www.secrecy.tech'
-    : (process.env.VERCEL_URL ??
-        process.env.NEXT_PUBLIC_VERCEL_URL ??
+    : (process.env['VERCEL_URL'] ??
+        process.env['NEXT_PUBLIC_VERCEL_URL'] ??
         'www.secrecy.tech');
 function withPath(origin, path) {
     if (!path) {

package/dist/lib/utils.js

@@ -2,7 +2,7 @@ export const kiloToBytes = (kb) => kb * 1024;
 export const gigaToBytes = (gb) => gb * 2 ** 30;
 // Returns the first "primary" email that's found, else returns the first email in the array.
 export const getPreferedEmail = (emails) => {
-    if (emails.length === 0) {
+    if (!emails[0]) {
         throw new Error("There's no email!");
     }
     return emails.find(({ isPrimary }) => isPrimary) ?? emails[0];

package/dist/lib/worker/sodium.js

@@ -55,7 +55,7 @@ export const encrypt = process.env.NODE_ENV !== 'test'
         });
     }
     : async (key, dataToEncrypt, progress, signal) => {
-        return encryptSecretStream(key, dataToEncrypt);
+        return encryptSecretStream(key, dataToEncrypt, progress, signal);
     };
 export const decrypt = process.env.NODE_ENV !== 'test'
     ? async (key, dataToDecrypt, progress, signal) => {
@@ -100,5 +100,5 @@ export const decrypt = process.env.NODE_ENV !== 'test'
         });
     }
     : async (key, dataToDecrypt, progress, signal) => {
-        return decryptSecretStream(key, dataToDecrypt);
+        return decryptSecretStream(key, dataToDecrypt, progress, signal);
     };

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

@@ -1,4 +1,4 @@
-import { type ApiClient, type RouterOutputs, type RouterInputs, CreateTrpcClientOptions } from './client.js';
+import { type ApiClient, type RouterOutputs, type RouterInputs, type CreateTrpcClientOptions } from './client.js';
 import { type InfuraNetwork, type PublicUser } from './index.js';
 import { type SelfUser } from './client/types/user.js';
 export type SecrecyUrls = {
@@ -24,6 +24,8 @@ 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,12 +1,11 @@
 import type { SecrecyClient, UserAppNotifications, UserAppSettings } from '../index.js';
 import type { JwtPayload } from 'jsonwebtoken';
-import { type RouterOutputs, type ApiClient, type RouterInputs } from '../client.js';
-import { type KeyPair } from './types/index.js';
+import { type RouterOutputs, type RouterInputs } from '../client.js';
 export declare class SecrecyAppClient {
     #private;
     jwt: string;
     jwtDecoded: JwtPayload;
-    constructor(uaJwt: string, _client: SecrecyClient, _keys: KeyPair, apiClient: ApiClient);
+    constructor(uaJwt: string, client: SecrecyClient);
     get userId(): string;
     get appId(): string;
     getJwt(): Promise<string>;

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

@@ -1,11 +1,11 @@
 import type { ProgressCallback, SecrecyClient, UploadDataOptions } from '../index.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 { DataMetadata, DataStorageType, LocalData, Node, NodeFull, NodeType } from './types/index.js';
 import { type Progress } from '../types.js';
-import { DownloadDataFromLinkOptions } from './data-link.js';
+import { type RouterInputs, type RouterOutputs } from '../client.js';
+import { type DownloadDataFromLinkOptions } from './data-link.js';
 export declare class SecrecyCloudClient {
     #private;
-    constructor(client: SecrecyClient, keys: KeyPair, apiClient: ApiClient);
+    constructor(client: SecrecyClient);
     addDataToHistory({ dataId, nodeId, }: {
         dataId: string;
         nodeId: string;
@@ -28,9 +28,9 @@ export declare class SecrecyCloudClient {
     deletedNodes(): Promise<Node[]>;
     sharedNodes(): Promise<Node[]>;
     nodesSharedWithMe(type?: NodeType): Promise<Node[]>;
-    deleteNodeSharing({ nodeId, userId, }: {
+    deleteNodeSharing({ nodeId, destPubKey, }: {
         nodeId: string;
-        userId: string;
+        destPubKey: string;
     }): Promise<boolean>;
     duplicateNode({ nodeId, folderId, name, }: {
         nodeId: string;
@@ -51,7 +51,7 @@ export declare class SecrecyCloudClient {
     dataMetadata({ id }: {
         id: string;
     }): Promise<DataMetadata>;
-    shareNode(input: RouterInputs['cloud']['shareNode'], progress?: ProgressCallback): Promise<RouterOutputs['cloud']['shareNodeFinish']>;
+    shareNode(accesses: RouterInputs['cloud']['shareNode']['accesses'], progress?: ProgressCallback): Promise<RouterOutputs['cloud']['shareNodeFinish']>;
     updateNode({ nodeId, name, isFavorite, deletedAt, }: {
         nodeId: string;
         name?: string | null | undefined;
@@ -93,7 +93,7 @@ export declare class SecrecyCloudClient {
         name: string;
         nodeId?: string;
     }): Promise<NodeFull>;
-    private readonly encryptNodesForUsers;
+    private readonly encryptNodesForIdentities;
     reportData({ id, reasons, }: Omit<RouterInputs['cloud']['reportData'], 'encryptedDataKey'>): Promise<RouterOutputs['cloud']['reportData']>;
     updateDataStorageType(input: RouterInputs['cloud']['moveToStorageType']): Promise<{
         isMoved: boolean;
@@ -126,32 +126,32 @@ export declare class SecrecyCloudClient {
         isMatching: false;
         details: {
             missingNodeAccesses: {
-                userId: string;
+                pubKey: string;
                 nodeId: string;
             }[];
             missingDataAccesses: {
-                userId: string;
+                pubKey: string;
                 nodeId: string;
                 dataId: string;
             }[];
             invalidRightsAccesses: {
-                userId: string;
+                pubKey: string;
                 nodeId: string;
                 expect: {
                     rights: "delete" | "read" | "write";
                 } & {
-                    addAccess?: "delete" | "read" | "write" | null | undefined;
-                    sharingAddAccess?: "delete" | "read" | "write" | null | undefined;
-                    delAccess?: "delete" | "read" | "write" | null | undefined;
-                    sharingDelAccess?: "delete" | "read" | "write" | null | undefined;
+                    addAccess: "delete" | "read" | "write" | null;
+                    sharingAddAccess: "delete" | "read" | "write" | null;
+                    delAccess: "delete" | "read" | "write" | null;
+                    sharingDelAccess: "delete" | "read" | "write" | null;
                 };
                 current: {
                     rights: "delete" | "read" | "write";
                 } & {
-                    addAccess?: "delete" | "read" | "write" | null | undefined;
-                    sharingAddAccess?: "delete" | "read" | "write" | null | undefined;
-                    delAccess?: "delete" | "read" | "write" | null | undefined;
-                    sharingDelAccess?: "delete" | "read" | "write" | null | undefined;
+                    addAccess: "delete" | "read" | "write" | null;
+                    sharingAddAccess: "delete" | "read" | "write" | null;
+                    delAccess: "delete" | "read" | "write" | null;
+                    sharingDelAccess: "delete" | "read" | "write" | null;
                 };
             }[];
         };

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

@@ -1,7 +1,4 @@
-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, _keys: KeyPair, apiClient: ApiClient);
+    constructor(_client: SecrecyClient);
 }

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

@@ -1,10 +1,9 @@
-import { type ApiClient, type RouterInputs } from '../client.js';
+import { 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, keys: KeyPair, apiClient: ApiClient);
+    constructor(client: SecrecyClient);
     get({ id }: {
         id: string;
     }): Promise<Mail>;

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

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

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

@@ -1,9 +1,8 @@
-import { type RouterInputs, type RouterOutputs, type ApiClient } from '../client.js';
+import { type RouterInputs, type RouterOutputs } from '../client.js';
 import type { SecrecyClient } from '../index.js';
-import { type KeyPair } from './types/index.js';
 export declare class SecrecyPseudonymClient {
     #private;
-    constructor(client: SecrecyClient, keys: KeyPair, apiClient: ApiClient);
+    constructor(client: SecrecyClient);
     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,9 +1,8 @@
-import type { RouterInputs, ApiClient, RouterOutputs } from '../client.js';
+import type { RouterInputs, 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, _keys: KeyPair, apiClient: ApiClient);
+    constructor(client: SecrecyClient);
     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, KeyPair } from '../types/index.js';
-export declare function apiDataToInternal(apiData: ApiData, keyPair: KeyPair): InternalData;
+import type { ApiData, InternalData, DataMetadata } from '../types/index.js';
+export declare function apiDataToInternal(apiData: ApiData, keyPairs: Record<string, string>): InternalData;
 export declare function internalDataToExternalData(internal: InternalData): DataMetadata;
-export declare function apiDataToExternal(apiData: ApiData, keyPair: KeyPair): DataMetadata;
+export declare function apiDataToExternal(apiData: ApiData, keyPairs: Record<string, string>): DataMetadata;

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

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

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

@@ -1,6 +1,6 @@
-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>;
+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>;
 export declare function internalNodeFullToNodeFull(internal: InternalNodeFull): NodeFull;
-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>;
+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>;