@secrecy/lib 1.7.0-integration-mixed-feats.3 → 1.7.0-integration-trpc-client.1

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

@@ -0,0 +1,27 @@
+import type { SecrecyClient, InfuraNetwork } from '../index.js';
+import { type TransactionRequest } from 'ethers';
+interface SuccessWalletResponse<T> {
+    success: true;
+    data: T;
+}
+interface ErrorWalletResponse {
+    success: false;
+    error: string;
+}
+export type SecrecyWalletResponse<T> = SuccessWalletResponse<T> | ErrorWalletResponse;
+export declare class SecrecyWalletClient {
+    #private;
+    constructor(client: SecrecyClient);
+    createTransaction({ network, tx, }: {
+        network?: InfuraNetwork;
+        tx: TransactionRequest;
+    }): Promise<SecrecyWalletResponse<{
+        id: string;
+        hash: string;
+    }>>;
+    createSignature({ network, message, }: {
+        network?: InfuraNetwork;
+        message: string;
+    }): Promise<SecrecyWalletResponse<string>>;
+}
+export {};

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

@@ -0,0 +1,4 @@
+import type { ApiFile, InternalFile, FileMetadata, KeyPair } from '../types/index.js';
+export declare function apiFileToInternal(apiFile: ApiFile, keyPair: KeyPair): InternalFile;
+export declare function internalFileToFile(internal: InternalFile): FileMetadata;
+export declare function apiFileToExternal(apiFile: ApiFile, keyPair: KeyPair): FileMetadata;

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

@@ -0,0 +1,8 @@
+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({ client, mail, keyPair, }: {
+    mail: ApiMail;
+    client: SecrecyClient;
+    keyPair: KeyPair;
+}): Promise<Mail>;

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

@@ -0,0 +1,7 @@
+import type { Node, ApiNode, InternalNode, ApiNodeFull, InternalNodeFull, NodeFull, KeyPair } from '../types/index.js';
+export declare function apiNodeToInternal(apiNode: ApiNode | ApiNodeFull, keyPair: KeyPair): Promise<InternalNode>;
+export declare function apiNodeFullToInternalFull(apiNodeFull: ApiNodeFull, keyPair: KeyPair): Promise<InternalNodeFull>;
+export declare function internalNodeToNode(internal: InternalNode): Node;
+export declare function internalNodeFullToNodeFull(internal: InternalNodeFull): NodeFull;
+export declare function apiNodeToExternalNodeFull(apiNodeFull: ApiNodeFull, keyPair: KeyPair): Promise<NodeFull>;
+export declare function apiNodeToExternal(apiNode: ApiNode, keyPair: KeyPair): Promise<Node>;

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

@@ -0,0 +1,25 @@
+import { SecrecyClient } from './index.js';
+import { type SecrecyUserApp } from './types/index.js';
+export declare function parseInfos(): SecrecyUserApp | null;
+export declare const getUrl: ({ hash, path, }: {
+    hash: string;
+    path: string;
+}) => string;
+export interface HashInfos {
+    appUrl: string;
+    backPath?: string;
+    appCode?: string | null | undefined;
+    path?: string | null | undefined;
+    redirect?: boolean;
+    scopes?: {
+        email: boolean;
+    };
+}
+export type UseSecrecyParams = Omit<HashInfos, 'appUrl'> & {
+    session?: boolean | undefined;
+};
+export type Value<T extends UseSecrecyParams> = T extends {
+    redirect: true;
+} ? SecrecyClient | null : SecrecyClient;
+export declare function getSecrecyClient(session?: boolean | undefined): SecrecyClient | null;
+export declare function login<T extends UseSecrecyParams>({ appCode, path, redirect, scopes, backPath, session, }: T): Promise<Value<T>>;

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

@@ -0,0 +1,25 @@
+import { BaseClient } from '../base-client.js';
+import type { Progress } from '../crypto/file.js';
+import { SecrecyCloudClient } from './SecrecyCloudClient.js';
+import { SecrecyMailClient } from './SecrecyMailClient.js';
+import { SecrecyAppClient } from './SecrecyAppClient.js';
+import { SecrecyDbClient } from './SecrecyDbClient.js';
+import { SecrecyWalletClient } from './SecrecyWalletClient.js';
+import { SecrecyPayClient } from './SecrecyPayClient.js';
+import { type RouterInputs } from '../client.js';
+import { type KeyPair } from './types/index.js';
+export type NewMail = Pick<RouterInputs['mail']['createDraft'], 'body' | 'subject' | 'senderFiles' | 'recipients' | 'replyToId'>;
+export type ProgressCallback = (progress: Progress) => Promise<void>;
+export declare const encryptName: (name: string, nameKey: string) => Promise<string>;
+export declare class SecrecyClient extends BaseClient {
+    #private;
+    cloud: SecrecyCloudClient;
+    mail: SecrecyMailClient;
+    app: SecrecyAppClient;
+    db: SecrecyDbClient;
+    wallet: SecrecyWalletClient;
+    pay: SecrecyPayClient;
+    constructor(uaSession: string, uaKeys: KeyPair, uaJwt: string);
+    get publicKey(): string;
+    logout(sessionId?: string | null | undefined): Promise<void>;
+}

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

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

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

@@ -0,0 +1,6 @@
+import { type RouterOutputs } from '../../client.js';
+export type FileMetadata = Pick<ApiFile, 'id' | 'size' | 'sizeBefore' | 'md5' | 'md5Encrypted' | 'createdAt'>;
+export type InternalFile = FileMetadata & {
+    key: string;
+};
+export type ApiFile = NonNullable<RouterOutputs['cloud']['fileById']>;

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

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export * from './file.js';
+export * from './node.js';
+export * from './mail.js';
+export * from './user.js';
+declare const keyPair: z.ZodObject<{
+    publicKey: z.ZodString;
+    privateKey: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    publicKey: string;
+    privateKey: string;
+}, {
+    publicKey: string;
+    privateKey: string;
+}>;
+export type KeyPair = z.infer<typeof keyPair>;
+export declare const secrecyUserApp: z.ZodReadonly<z.ZodObject<{
+    keys: z.ZodObject<{
+        publicKey: z.ZodString;
+        privateKey: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        publicKey: string;
+        privateKey: string;
+    }, {
+        publicKey: string;
+        privateKey: string;
+    }>;
+    jwt: z.ZodString;
+    uaSession: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    keys: {
+        publicKey: string;
+        privateKey: string;
+    };
+    jwt: string;
+    uaSession: string;
+}, {
+    keys: {
+        publicKey: string;
+        privateKey: string;
+    };
+    jwt: string;
+    uaSession: string;
+}>>;
+export type SecrecyUserApp = z.infer<typeof secrecyUserApp>;

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

@@ -0,0 +1,87 @@
+import { type RouterOutputs } from '../../client.js';
+import { type PublicUser } from './user.js';
+export type MailType = 'sent' | 'received' | 'draft';
+export type ApiMail = RouterOutputs['mail']['byId'];
+export interface BaseMail {
+    type: MailType;
+    id: string;
+    mailIntegrityId: string;
+    replyTo?: string;
+    body: string;
+    subject: string;
+    createdAt: Date;
+    deletedAt: Date | null;
+    openedAt: Date | null;
+    isAltered: boolean;
+    recipients: Array<Omit<PublicUser, 'publicKey'>>;
+    temporaryRecipients: TemporaryMailUser[];
+    files: Array<{
+        id: string;
+        name: string;
+        key: string;
+    }>;
+}
+export interface ReceivedMail extends BaseMail {
+    type: 'received';
+    sender: PublicUser;
+}
+export interface InternalSentMail {
+    user: {
+        sentMails: ApiMail[];
+    };
+}
+export interface InternalDraftMails {
+    user: {
+        draftMails: ApiMail[];
+    };
+}
+export interface SentMail extends BaseMail {
+    type: 'sent';
+}
+export interface DraftMail extends BaseMail {
+    type: 'draft';
+}
+export type Mail = DraftMail | SentMail | ReceivedMail;
+export interface MailIntegrity {
+    id: string;
+    hash: string;
+    hashKey: string;
+    replyTo?: {
+        id: string;
+    };
+    temporaryRecipients: TemporaryMailUser[];
+    recipients: PublicUser[];
+}
+export type MailIntegrityDraft = MailIntegrity & {
+    recipients: PublicUser[];
+};
+export interface TemporaryMailUser {
+    email?: string;
+}
+export interface InternalWaitingReceivedMail {
+    sender: PublicUser;
+    date: string;
+    attachmentsCount: number;
+    recipients: PublicUser[];
+    temporaryRecipients: TemporaryMailUser[];
+}
+export interface WaitingReceivedMail {
+    id: string;
+    sender: PublicUser;
+    date: Date;
+    attachmentsCount: number;
+    recipients: PublicUser[];
+    temporaryRecipients: TemporaryMailUser[];
+}
+export interface MailFile {
+    fileKey: string;
+    filename: string;
+    file: {
+        id: string;
+    };
+}
+export interface InternalReceivedMail {
+    user: {
+        receivedMails: ApiMail[];
+    };
+}

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

@@ -0,0 +1,51 @@
+import { type RouterOutputs } from '../../client.js';
+import type { FileMetadata, InternalFile, PublicUser } from './index.js';
+export type Rights = ApiNode['users'][number][1];
+export type NodeAccess<T extends Record<string, unknown> = Record<string, unknown>> = T & {
+    rights: Rights;
+    isRoot: boolean;
+    sharedByPubKey: string;
+};
+export interface NodeBreadcrumbItem {
+    id: string;
+    name: string;
+}
+export interface NodeBreadcrumbItemWithPubKey extends NodeBreadcrumbItem {
+    pubKey: string;
+}
+export interface NodeSize {
+    size: bigint;
+    sizeBefore: bigint;
+}
+type NameKey = {
+    nameKey: string | null;
+};
+export type InternalNodeBreadcrumbItem = NodeBreadcrumbItemWithPubKey & NameKey;
+export interface Node<T extends NodeBreadcrumbItem = NodeBreadcrumbItem, U extends Record<string, unknown> = Record<string, unknown>> {
+    id: string;
+    isFavorite: boolean;
+    type: NodeType;
+    createdAt: Date;
+    deletedAt: Date | null;
+    updatedAt: Date;
+    sizes: NodeSize;
+    name: string;
+    breadcrumb: T[];
+    createdBy: PublicUser;
+    access: NodeAccess<U>;
+    users: Array<[PublicUser, Rights]>;
+    parentId: string | null;
+    currentFileId: string | null;
+}
+export type NodeFull<T extends NodeBreadcrumbItem = NodeBreadcrumbItem, U extends Record<string, unknown> = Record<string, unknown>, V extends FileMetadata = FileMetadata> = Node<T, U> & {
+    parent: Node<T, U> | null;
+    children: Array<Node<T, U>>;
+    current?: V;
+    history: V[];
+};
+export type InternalNode = Node<InternalNodeBreadcrumbItem, NameKey>;
+export type InternalNodeFull = NodeFull<InternalNodeBreadcrumbItem, NameKey, InternalFile>;
+export type ApiNode = RouterOutputs['cloud']['nodeById'];
+export type ApiNodeFull = RouterOutputs['cloud']['nodeFullById'];
+export type NodeType = ApiNode['type'];
+export {};

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

@@ -0,0 +1,3 @@
+import { type RouterOutputs } from '../../client.js';
+export type SelfUser = RouterOutputs['user']['self'];
+export type PublicUser = RouterOutputs['user']['byId'];