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

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

@@ -1,6 +1,6 @@
 import z from 'zod';
-import { ProgressCallback } from '.';
-import { Progress } from 'ky';
+import { type ProgressCallback } from '.';
+import { type Progress } from 'ky';
 export declare const downloadDataLinkSchema: z.ZodUnion<readonly [z.ZodObject<{
     name: z.ZodString;
     md5: z.ZodString;

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

@@ -6,16 +6,17 @@ import { SecrecyAppClient } from './SecrecyAppClient.js';
 import { SecrecyDbClient } from './SecrecyDbClient.js';
 import { SecrecyWalletClient } from './SecrecyWalletClient.js';
 import { SecrecyPayClient } from './SecrecyPayClient.js';
-import { ApiClient, type RouterInputs } from '../client.js';
-import { type KeyPair } from './types/index.js';
+import { type ApiClient, type RouterInputs, type RouterOutputs } from '../client.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;
-    uaKeys: KeyPair;
+    identities: AccessIdentity[];
+    keyPairs: Record<string, string>;
     uaJwt: string;
     apiClient?: ApiClient;
     secrecyUrls?: Partial<SecrecyUrls>;
@@ -33,6 +34,13 @@ 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,7 +1,8 @@
 import type { StoreBuddy } from '../utils/store-buddy.js';
-import { type KeyPair } from './types/index.js';
+import type { AccessIdentity } from './types/identity.js';
 export declare function getStorage(session?: boolean | undefined): {
-    userAppKeys: StoreBuddy<KeyPair | null>;
+    identities: StoreBuddy<AccessIdentity[] | null>;
+    keyPairs: StoreBuddy<Record<string, string> | null>;
     userAppSession: StoreBuddy<string | null>;
     jwt: StoreBuddy<string | null>;
 };

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

@@ -0,0 +1,37 @@
+import { z } from 'zod/v4';
+export declare const userAppSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"USER_APP">;
+    identityPubKey: z.ZodString;
+    userId: z.ZodString;
+    appId: z.ZodString;
+}, z.core.$strip>;
+export declare const groupSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"GROUP">;
+    identityPubKey: z.ZodString;
+    groupId: z.ZodString;
+    groupRole: z.ZodEnum<{
+        ADMIN: "ADMIN";
+        MEMBER: "MEMBER";
+    }>;
+    sharedByPubKey: z.ZodString;
+    groupOwnerPubKey: z.ZodString;
+}, z.core.$strip>;
+export declare const accessIdentitySchema: 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;
+    groupRole: z.ZodEnum<{
+        ADMIN: "ADMIN";
+        MEMBER: "MEMBER";
+    }>;
+    sharedByPubKey: z.ZodString;
+    groupOwnerPubKey: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type AccessIdentity = z.infer<typeof accessIdentitySchema>;
+export type UserAppIdentity = z.infer<typeof userAppSchema>;
+export type GroupIdentity = z.infer<typeof groupSchema>;

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

@@ -4,16 +4,24 @@ 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<{
-    keys: z.ZodObject<{
-        publicKey: z.ZodString;
-        privateKey: z.ZodString;
-    }, z.core.$strict>;
+    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;
+        groupRole: z.ZodEnum<{
+            ADMIN: "ADMIN";
+            MEMBER: "MEMBER";
+        }>;
+        sharedByPubKey: z.ZodString;
+        groupOwnerPubKey: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    keyPairs: z.ZodRecord<z.ZodString, z.ZodString>;
     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<Omit<PublicUser, 'publicKey'>>;
+    recipients: Array<PublicUser>;
     temporaryRecipients: TemporaryMailUser[];
     attachments: Array<{
         id: string;
@@ -24,6 +24,7 @@ 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,17 +1,19 @@
 import { type RouterOutputs } from '../../client.js';
-import type { DataMetadata, InternalData, PublicUser } from './index.js';
-export type Permissions = ApiNode['users'][number][1];
+import type { DataMetadata, InternalData, UserAppOrg } from './index.js';
+export type Permissions = ApiNode['identities'][number];
 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 {
-    pubKey: string;
+    sharedByPubKey: string;
+    identityPubKey: string;
 }
 export interface NodeSize {
     size: bigint;
@@ -31,9 +33,10 @@ export interface Node<T extends NodeBreadcrumbItem = NodeBreadcrumbItem, U exten
     sizes: NodeSize;
     name: string;
     breadcrumb: T[];
-    owner: PublicUser;
-    access: NodeAccess<U>;
-    users: Array<[PublicUser, Permissions]>;
+    owner: UserAppOrg;
+    accesses: NodeAccess<U>[];
+    permissions: Permissions;
+    identities: Record<string, Permissions>;
     currentDataId: string | null;
     parentId: string | null;
 }
@@ -72,16 +75,16 @@ export type EncryptedNodeInfos = {
 };
 export type ShareNodeDetails = {
     missingNodeAccesses: {
-        userId: string;
+        pubKey: string;
         nodeId: string;
     }[];
     missingDataAccesses: {
-        userId: string;
+        pubKey: string;
         dataId: string;
         nodeId: string;
     }[];
     invalidRightsAccesses: {
-        userId: string;
+        pubKey: string;
         current: Permissions;
         nodeId: string;
         expect: Permissions;

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

@@ -1,3 +1,18 @@
 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

@@ -1,8 +1,8 @@
-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';
+import type { DataStorageType, LocalData } from './types/data.js';
+import type { ProgressCallback } from './index.js';
+import { type FileTypeResult } from 'file-type';
+import { type ApiClient, type RouterInputs } from '../client.js';
+import type { UserAppIdentity } from './types/identity.js';
 export type UploadDataOptions = {
     storageType: DataStorageType;
     data: globalThis.File | Uint8Array<ArrayBuffer>;
@@ -14,8 +14,9 @@ export type UploadDataOptions = {
     meta?: FileTypeResult | true;
     forcePassword?: boolean;
 };
-export declare function uploadData({ storageType, data, password, forcePassword, encrypted, encryptProgress, uploadProgress, signal, meta, keyPair, apiClient, }: UploadDataOptions & {
-    keyPair?: KeyPair;
+export declare function uploadData({ storageType, data, password, forcePassword, encrypted, encryptProgress, uploadProgress, signal, meta, uaIdentity, keyPairs, apiClient, }: UploadDataOptions & {
+    uaIdentity?: UserAppIdentity;
+    keyPairs?: Record<string, string>;
     apiClient?: ApiClient;
 }): Promise<LocalData & {
     sharing: {