bedrock-ts-sdk 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,1212 @@
+import { ETHAccount } from '@aleph-sdk/ethereum';
+export { ETHAccount } from '@aleph-sdk/ethereum';
+import { PrivateKey } from 'eciesjs';
+import { AuthenticatedAlephHttpClient } from '@aleph-sdk/client';
+export { AlephHttpClient, AuthenticatedAlephHttpClient } from '@aleph-sdk/client';
+import { StoreMessage, ForgetMessage, AggregateMessage, PostMessage } from '@aleph-sdk/message';
+import { z } from 'zod';
+export { Account } from '@aleph-sdk/account';
+
+/**
+ * Low-level Aleph SDK wrapper (matches Bedrock implementation)
+ */
+declare class AlephService {
+    private subAccountClient;
+    private account;
+    private channel;
+    constructor(account: ETHAccount, channel?: string, apiServer?: string);
+    /**
+     * Get the account address
+     */
+    getAddress(): string;
+    /**
+     * Get the account's public key
+     */
+    getPublicKey(): string;
+    /**
+     * Get the underlying Aleph client
+     */
+    getClient(): AuthenticatedAlephHttpClient;
+    /**
+     * Get the account
+     */
+    getAccount(): ETHAccount;
+    /**
+     * Upload a file to Aleph storage
+     * @param fileObject - File content as Buffer or File
+     * @returns Store message
+     */
+    uploadFile(fileObject: Buffer | File): Promise<StoreMessage>;
+    /**
+     * Download a file from Aleph storage
+     * @param storeHash - The STORE message item_hash
+     * @returns File content as ArrayBuffer
+     */
+    downloadFile(storeHash: string): Promise<ArrayBuffer>;
+    /**
+     * Delete files from Aleph storage
+     * @param itemHashes - Array of item hashes to forget
+     * @returns Forget message
+     */
+    deleteFiles(itemHashes: string[]): Promise<ForgetMessage>;
+    createAggregate<T extends Record<string, unknown>>(key: string, content: T): Promise<AggregateMessage<T>>;
+    fetchAggregate<T extends z.ZodTypeAny>(key: string, schema: T, owner?: string): Promise<z.TypeOf<T>>;
+    updateAggregate<S extends z.ZodTypeAny, T extends z.infer<S>>(key: string, schema: S, update_content: (content: T) => Promise<T>): Promise<AggregateMessage<T>>;
+    createPost<T extends Record<string, unknown>>(type: string, content: T): Promise<PostMessage<T>>;
+    fetchPosts<T extends z.ZodTypeAny>(type: string, schema: T, addresses?: string[], hashes?: string[]): Promise<z.TypeOf<T>[]>;
+    fetchPost<T extends z.ZodTypeAny>(type: string, schema: T, addresses: string[] | undefined, hash: string): Promise<z.TypeOf<T>>;
+    updatePost<S extends z.ZodTypeAny, T extends z.infer<S>>(type: string, hash: string, addresses: string[], schema: S, update_content: (content: T) => Promise<T>): Promise<PostMessage<T>>;
+}
+
+/**
+ * Configuration for BedrockCore
+ */
+interface BedrockCoreConfig {
+    channel?: string;
+    apiServer?: string;
+}
+/**
+ * Core Bedrock functionality: authentication, sub-accounts, encryption key derivation
+ */
+declare class BedrockCore {
+    private mainAccount;
+    private subAccount;
+    private alephService;
+    private encryptionPrivateKey;
+    private constructor();
+    /**
+     * Initialize from signature hash (matches Bedrock app pattern)
+     * @param signatureHash - Signature hash from wallet
+     * @param provider - EIP-1193 provider (for MetaMask/Rabby)
+     * @param config - Optional configuration
+     */
+    static fromSignature(signatureHash: string, provider: any, config?: BedrockCoreConfig): Promise<BedrockCore>;
+    /**
+     * Create BedrockCore from a private key (for testing/CLI)
+     * @param privateKey - Ethereum private key (hex string with or without 0x prefix)
+     * @param config - Optional configuration
+     */
+    static fromPrivateKey(privateKey: string, config?: BedrockCoreConfig): Promise<BedrockCore>;
+    /**
+     * Create BedrockCore from a wallet provider (e.g., MetaMask)
+     * This will automatically request signature from the user
+     * @param provider - EIP-1193 provider
+     * @param config - Optional configuration
+     */
+    static fromProvider(provider: any, config?: BedrockCoreConfig): Promise<BedrockCore>;
+    /**
+     * Get the main account
+     */
+    getMainAccount(): ETHAccount;
+    /**
+     * Get the sub-account
+     */
+    getSubAccount(): ETHAccount;
+    /**
+     * Get the AlephService instance
+     */
+    getAlephService(): AlephService;
+    /**
+     * Get the encryption key
+     */
+    getEncryptionKey(): Buffer;
+    /**
+     * Get the encryption private key
+     */
+    getEncryptionPrivateKey(): PrivateKey;
+    /**
+     * Get the main account's address
+     */
+    getMainAddress(): string;
+    /**
+     * Get the sub-account's address
+     */
+    getSubAddress(): string;
+    /**
+     * Get the main account's public key
+     */
+    getPublicKey(): string;
+    /**
+     * Get the sub-account's private key (as hex string)
+     */
+    getSubAccountPrivateKey(): string;
+    /**
+     * Setup security permissions (matches Bedrock app pattern)
+     */
+    private static setupSecurityPermissions;
+}
+
+declare const BEDROCK_MESSAGE = "Bedrock.im";
+declare const SECURITY_AGGREGATE_KEY = "security";
+declare const ALEPH_GENERAL_CHANNEL = "BEDROCK_STORAGE";
+declare const AGGREGATE_KEYS: {
+    readonly FILE_ENTRIES: "bedrock_file_entries";
+    readonly CONTACTS: "bedrock_contacts";
+    readonly KNOWLEDGE_BASES: "bedrock_knowledge_bases";
+    readonly CREDITS: "credits";
+};
+declare const POST_TYPES: {
+    readonly FILE: "bedrock_file";
+    readonly PUBLIC_FILE: "bedrock_public_file";
+};
+/**
+ * 64-character hex string (32 bytes)
+ */
+declare const HexString64Schema: z.ZodString;
+/**
+ * 32-character hex string (16 bytes)
+ */
+declare const HexString32Schema: z.ZodString;
+/**
+ * ISO 8601 datetime string
+ */
+declare const DatetimeSchema: z.ZodString;
+/**
+ * Ethereum address
+ */
+declare const AddressSchema: z.ZodString;
+/**
+ * File entry in the file index aggregate
+ */
+declare const FileEntrySchema: z.ZodObject<{
+    path: z.ZodString;
+    post_hash: z.ZodString;
+    shared_with: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    post_hash: string;
+    shared_with: string[];
+}, {
+    path: string;
+    post_hash: string;
+    shared_with?: string[] | undefined;
+}>;
+type FileEntry = z.infer<typeof FileEntrySchema>;
+/**
+ * File metadata stored in POST messages
+ */
+declare const FileMetaEncryptedSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    key: z.ZodString;
+    iv: z.ZodString;
+    store_hash: z.ZodString;
+    size: z.ZodString;
+    created_at: z.ZodString;
+    deleted_at: z.ZodNullable<z.ZodString>;
+    shared_keys: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        key: z.ZodString;
+        iv: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        iv: string;
+    }, {
+        key: string;
+        iv: string;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    name: string;
+    key: string;
+    iv: string;
+    store_hash: string;
+    size: string;
+    created_at: string;
+    deleted_at: string | null;
+    shared_keys: Record<string, {
+        key: string;
+        iv: string;
+    }>;
+}, {
+    path: string;
+    name: string;
+    key: string;
+    iv: string;
+    store_hash: string;
+    size: string;
+    created_at: string;
+    deleted_at: string | null;
+    shared_keys?: Record<string, {
+        key: string;
+        iv: string;
+    }> | undefined;
+}>;
+type FileMetaEncrypted = z.infer<typeof FileMetaEncryptedSchema>;
+/**
+ * Decrypted file metadata
+ */
+declare const FileMetaSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    key: z.ZodString;
+    iv: z.ZodString;
+    store_hash: z.ZodString;
+    size: z.ZodNumber;
+    created_at: z.ZodString;
+    deleted_at: z.ZodNullable<z.ZodString>;
+    shared_keys: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        key: z.ZodString;
+        iv: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        iv: string;
+    }, {
+        key: string;
+        iv: string;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    name: string;
+    key: string;
+    iv: string;
+    store_hash: string;
+    size: number;
+    created_at: string;
+    deleted_at: string | null;
+    shared_keys: Record<string, {
+        key: string;
+        iv: string;
+    }>;
+}, {
+    path: string;
+    name: string;
+    key: string;
+    iv: string;
+    store_hash: string;
+    size: number;
+    created_at: string;
+    deleted_at: string | null;
+    shared_keys?: Record<string, {
+        key: string;
+        iv: string;
+    }> | undefined;
+}>;
+type FileMeta = z.infer<typeof FileMetaSchema>;
+/**
+ * Combined file entry and metadata
+ */
+type FileFullInfo = FileEntry & FileMeta;
+/**
+ * Public file metadata (unencrypted, accessible by anyone)
+ */
+declare const PublicFileMetaSchema: z.ZodObject<{
+    name: z.ZodString;
+    size: z.ZodNumber;
+    created_at: z.ZodString;
+    store_hash: z.ZodString;
+    username: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    store_hash: string;
+    size: number;
+    created_at: string;
+    username: string;
+}, {
+    name: string;
+    store_hash: string;
+    size: number;
+    created_at: string;
+    username: string;
+}>;
+type PublicFileMeta = z.infer<typeof PublicFileMetaSchema>;
+/**
+ * Contact information
+ */
+declare const ContactSchema: z.ZodObject<{
+    name: z.ZodString;
+    address: z.ZodString;
+    public_key: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    address: string;
+    public_key: string;
+}, {
+    name: string;
+    address: string;
+    public_key: string;
+}>;
+type Contact = z.infer<typeof ContactSchema>;
+/**
+ * Contacts aggregate
+ */
+declare const ContactsAggregateSchema: z.ZodObject<{
+    contacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        address: z.ZodString;
+        public_key: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        address: string;
+        public_key: string;
+    }, {
+        name: string;
+        address: string;
+        public_key: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    contacts: {
+        name: string;
+        address: string;
+        public_key: string;
+    }[];
+}, {
+    contacts?: {
+        name: string;
+        address: string;
+        public_key: string;
+    }[] | undefined;
+}>;
+type ContactsAggregate = z.infer<typeof ContactsAggregateSchema>;
+/**
+ * Knowledge base configuration
+ */
+declare const KnowledgeBaseSchema: z.ZodObject<{
+    name: z.ZodString;
+    file_paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    created_at: string;
+    file_paths: string[];
+    updated_at: string;
+}, {
+    name: string;
+    created_at: string;
+    updated_at: string;
+    file_paths?: string[] | undefined;
+}>;
+type KnowledgeBase = z.infer<typeof KnowledgeBaseSchema>;
+/**
+ * Knowledge bases aggregate
+ */
+declare const KnowledgeBasesAggregateSchema: z.ZodObject<{
+    knowledge_bases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        file_paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        created_at: string;
+        file_paths: string[];
+        updated_at: string;
+    }, {
+        name: string;
+        created_at: string;
+        updated_at: string;
+        file_paths?: string[] | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    knowledge_bases: {
+        name: string;
+        created_at: string;
+        file_paths: string[];
+        updated_at: string;
+    }[];
+}, {
+    knowledge_bases?: {
+        name: string;
+        created_at: string;
+        updated_at: string;
+        file_paths?: string[] | undefined;
+    }[] | undefined;
+}>;
+type KnowledgeBasesAggregate = z.infer<typeof KnowledgeBasesAggregateSchema>;
+/**
+ * Credit transaction record
+ */
+declare const CreditTransactionSchema: z.ZodObject<{
+    id: z.ZodString;
+    amount: z.ZodNumber;
+    type: z.ZodEnum<["top_up", "deduct"]>;
+    timestamp: z.ZodNumber;
+    description: z.ZodString;
+    txHash: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "top_up" | "deduct";
+    id: string;
+    amount: number;
+    timestamp: number;
+    description: string;
+    txHash?: string | undefined;
+}, {
+    type: "top_up" | "deduct";
+    id: string;
+    amount: number;
+    timestamp: number;
+    description: string;
+    txHash?: string | undefined;
+}>;
+type CreditTransaction = z.infer<typeof CreditTransactionSchema>;
+/**
+ * User credit data
+ */
+declare const UserCreditSchema: z.ZodObject<{
+    balance: z.ZodDefault<z.ZodNumber>;
+    transactions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodNumber;
+        type: z.ZodEnum<["top_up", "deduct"]>;
+        timestamp: z.ZodNumber;
+        description: z.ZodString;
+        txHash: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "top_up" | "deduct";
+        id: string;
+        amount: number;
+        timestamp: number;
+        description: string;
+        txHash?: string | undefined;
+    }, {
+        type: "top_up" | "deduct";
+        id: string;
+        amount: number;
+        timestamp: number;
+        description: string;
+        txHash?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    balance: number;
+    transactions: {
+        type: "top_up" | "deduct";
+        id: string;
+        amount: number;
+        timestamp: number;
+        description: string;
+        txHash?: string | undefined;
+    }[];
+}, {
+    balance?: number | undefined;
+    transactions?: {
+        type: "top_up" | "deduct";
+        id: string;
+        amount: number;
+        timestamp: number;
+        description: string;
+        txHash?: string | undefined;
+    }[] | undefined;
+}>;
+type UserCredit = z.infer<typeof UserCreditSchema>;
+/**
+ * Credit aggregate (backend-managed)
+ */
+declare const CreditAggregateSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    balance: z.ZodDefault<z.ZodNumber>;
+    transactions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        amount: z.ZodNumber;
+        type: z.ZodEnum<["top_up", "deduct"]>;
+        timestamp: z.ZodNumber;
+        description: z.ZodString;
+        txHash: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "top_up" | "deduct";
+        id: string;
+        amount: number;
+        timestamp: number;
+        description: string;
+        txHash?: string | undefined;
+    }, {
+        type: "top_up" | "deduct";
+        id: string;
+        amount: number;
+        timestamp: number;
+        description: string;
+        txHash?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    balance: number;
+    transactions: {
+        type: "top_up" | "deduct";
+        id: string;
+        amount: number;
+        timestamp: number;
+        description: string;
+        txHash?: string | undefined;
+    }[];
+}, {
+    balance?: number | undefined;
+    transactions?: {
+        type: "top_up" | "deduct";
+        id: string;
+        amount: number;
+        timestamp: number;
+        description: string;
+        txHash?: string | undefined;
+    }[] | undefined;
+}>>;
+type CreditAggregate = z.infer<typeof CreditAggregateSchema>;
+/**
+ * File entries aggregate
+ */
+declare const FileEntriesAggregateSchema: z.ZodObject<{
+    files: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        post_hash: z.ZodString;
+        shared_with: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        post_hash: string;
+        shared_with: string[];
+    }, {
+        path: string;
+        post_hash: string;
+        shared_with?: string[] | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    files: {
+        path: string;
+        post_hash: string;
+        shared_with: string[];
+    }[];
+}, {
+    files?: {
+        path: string;
+        post_hash: string;
+        shared_with?: string[] | undefined;
+    }[] | undefined;
+}>;
+/**
+ * Sub-account authorization in security aggregate
+ */
+declare const SecurityAggregateSchema: z.ZodObject<{
+    authorizations: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        chain: z.ZodString;
+        channels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        post_types: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        aggregate_keys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        chain: string;
+        channels?: string[] | undefined;
+        post_types?: string[] | undefined;
+        aggregate_keys?: string[] | undefined;
+    }, {
+        address: string;
+        chain: string;
+        channels?: string[] | undefined;
+        post_types?: string[] | undefined;
+        aggregate_keys?: string[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    authorizations: {
+        address: string;
+        chain: string;
+        channels?: string[] | undefined;
+        post_types?: string[] | undefined;
+        aggregate_keys?: string[] | undefined;
+    }[];
+}, {
+    authorizations: {
+        address: string;
+        chain: string;
+        channels?: string[] | undefined;
+        post_types?: string[] | undefined;
+        aggregate_keys?: string[] | undefined;
+    }[];
+}>;
+type SecurityAggregate = z.infer<typeof SecurityAggregateSchema>;
+/**
+ * Aleph POST message content
+ */
+interface AlephPostContent<T = unknown> {
+    time: number;
+    type: string;
+    ref?: string;
+    content: T;
+}
+/**
+ * Aleph AGGREGATE content
+ */
+interface AlephAggregateContent<T = unknown> {
+    key: string;
+    content: T;
+}
+/**
+ * Aleph STORE message
+ */
+interface AlephStoreMessage {
+    item_hash: string;
+    size: number;
+}
+/**
+ * Generic Aleph message response
+ */
+interface AlephMessage {
+    chain: string;
+    item_hash: string;
+    sender: string;
+    type: string;
+    channel: string;
+    confirmed: boolean;
+    content: unknown;
+    item_content: string;
+    item_type: string;
+    signature: string;
+    size: number;
+    time: number;
+}
+
+/**
+ * File input type for uploads
+ */
+interface FileInput {
+    name: string;
+    path: string;
+    content: Buffer | File;
+}
+/**
+ * File service for managing encrypted files
+ */
+declare class FileService {
+    private core;
+    constructor(core: BedrockCore);
+    /**
+     * Initialize file entries aggregate if it doesn't exist
+     */
+    setup(): Promise<void>;
+    /**
+     * Upload files with encryption
+     * @param files - Array of files to upload
+     * @param directoryPath - Optional directory path prefix
+     * @returns Array of uploaded file info
+     */
+    uploadFiles(files: FileInput[], directoryPath?: string): Promise<FileFullInfo[]>;
+    /**
+     * Download and decrypt a file
+     * @param fileInfo - File information
+     * @returns Decrypted file buffer
+     */
+    downloadFile(fileInfo: FileFullInfo): Promise<Buffer>;
+    /**
+     * Fetch all file entries
+     */
+    fetchFileEntries(): Promise<FileEntry[]>;
+    /**
+     * Fetch file metadata from entries
+     * @param entries - File entries
+     * @param owner - Optional owner address
+     * @returns Array of full file info
+     */
+    fetchFilesMetaFromEntries(entries: FileEntry[], owner?: string): Promise<FileFullInfo[]>;
+    /**
+     * List all files
+     * @param includeDeleted - Include soft-deleted files
+     */
+    listFiles(includeDeleted?: boolean): Promise<FileFullInfo[]>;
+    /**
+     * Get a file by path
+     * @param path - File path
+     */
+    getFile(path: string): Promise<FileFullInfo>;
+    /**
+     * Soft delete files
+     * @param filePaths - Paths of files to delete
+     * @param deletionDate - Optional deletion date
+     */
+    softDeleteFiles(filePaths: string[], deletionDate?: Date): Promise<void>;
+    /**
+     * Restore soft-deleted files
+     * @param filePaths - Paths of files to restore
+     */
+    restoreFiles(filePaths: string[]): Promise<void>;
+    /**
+     * Hard delete files (permanently remove from Aleph)
+     * @param filePaths - Paths of files to delete
+     */
+    hardDeleteFiles(filePaths: string[]): Promise<void>;
+    /**
+     * Move/rename files
+     * @param moves - Array of {oldPath, newPath} objects
+     */
+    moveFiles(moves: Array<{
+        oldPath: string;
+        newPath: string;
+    }>): Promise<void>;
+    /**
+     * Duplicate a file
+     * @param sourcePath - Source file path
+     * @param newPath - New file path
+     */
+    duplicateFile(sourcePath: string, newPath: string): Promise<FileFullInfo>;
+    /**
+     * Share a file with a contact
+     * @param filePath - File path
+     * @param contactPublicKey - Contact's public key
+     */
+    shareFile(filePath: string, contactPublicKey: string): Promise<void>;
+    /**
+     * Unshare a file with a contact
+     * @param filePath - File path
+     * @param contactPublicKey - Contact's public key
+     */
+    unshareFile(filePath: string, contactPublicKey: string): Promise<void>;
+    /**
+     * Share a file publicly (unencrypted, anyone can access)
+     * @param fileInfo - File to share publicly
+     * @param username - Username for attribution
+     * @returns Public post hash for sharing
+     */
+    shareFilePublicly(fileInfo: FileFullInfo, username: string): Promise<string>;
+    /**
+     * Fetch public file metadata (static - no auth required)
+     * @param postHash - Public post hash
+     * @returns Public file metadata or null if not found
+     */
+    static fetchPublicFileMeta(postHash: string): Promise<PublicFileMeta | null>;
+    /**
+     * Download public file (static - no auth required)
+     * @param storeHash - Store hash from public metadata
+     * @returns File content as ArrayBuffer
+     */
+    static downloadPublicFile(storeHash: string): Promise<ArrayBuffer>;
+    private saveFileEntries;
+    private encryptFileMeta;
+    private decryptFileMeta;
+}
+
+/**
+ * Contact service for managing contacts and shared files
+ */
+declare class ContactService {
+    private core;
+    private fileService;
+    constructor(core: BedrockCore, fileService: FileService);
+    /**
+     * Initialize contacts aggregate if it doesn't exist
+     */
+    setup(): Promise<void>;
+    /**
+     * Fetch all contacts
+     */
+    listContacts(): Promise<Contact[]>;
+    /**
+     * Get a contact by public key
+     * @param publicKey - Contact's public key
+     */
+    getContact(publicKey: string): Promise<Contact>;
+    /**
+     * Get a contact by address
+     * @param address - Contact's Ethereum address
+     */
+    getContactByAddress(address: string): Promise<Contact>;
+    /**
+     * Add a new contact
+     * @param name - Contact name
+     * @param address - Contact's Ethereum address
+     * @param publicKey - Contact's public key (hex string)
+     */
+    addContact(name: string, address: string, publicKey: string): Promise<Contact>;
+    /**
+     * Remove a contact
+     * @param publicKey - Contact's public key
+     */
+    removeContact(publicKey: string): Promise<void>;
+    /**
+     * Update a contact's name
+     * @param publicKey - Contact's public key
+     * @param newName - New name for the contact
+     */
+    updateContactName(publicKey: string, newName: string): Promise<Contact>;
+    /**
+     * Fetch files shared by a contact
+     * @param publicKey - Contact's public key
+     */
+    getSharedFiles(publicKey: string): Promise<FileFullInfo[]>;
+    /**
+     * Fetch files that a contact has shared with the current user
+     * @param publicKey - Contact's public key
+     * @returns Files shared by the contact with current user
+     */
+    fetchFilesSharedByContact(publicKey: string): Promise<FileFullInfo[]>;
+    /**
+     * Share a file with a contact
+     * @param filePath - Path of the file to share
+     * @param publicKey - Contact's public key
+     */
+    shareFileWithContact(filePath: string, publicKey: string): Promise<void>;
+    /**
+     * Unshare a file with a contact
+     * @param filePath - Path of the file to unshare
+     * @param publicKey - Contact's public key
+     */
+    unshareFileWithContact(filePath: string, publicKey: string): Promise<void>;
+}
+
+/**
+ * Knowledge base service for organizing files into collections
+ */
+declare class KnowledgeBaseService {
+    private core;
+    constructor(core: BedrockCore);
+    /**
+     * Initialize knowledge bases aggregate if it doesn't exist
+     */
+    setup(): Promise<void>;
+    /**
+     * Fetch all knowledge bases
+     */
+    listKnowledgeBases(): Promise<KnowledgeBase[]>;
+    /**
+     * Get a knowledge base by name
+     * @param name - Knowledge base name
+     */
+    getKnowledgeBase(name: string): Promise<KnowledgeBase>;
+    /**
+     * Create a new knowledge base
+     * @param name - Knowledge base name
+     * @param filePaths - Optional initial file paths
+     */
+    createKnowledgeBase(name: string, filePaths?: string[]): Promise<KnowledgeBase>;
+    /**
+     * Delete a knowledge base
+     * @param name - Knowledge base name
+     */
+    deleteKnowledgeBase(name: string): Promise<void>;
+    /**
+     * Rename a knowledge base
+     * @param oldName - Current name
+     * @param newName - New name
+     */
+    renameKnowledgeBase(oldName: string, newName: string): Promise<KnowledgeBase>;
+    /**
+     * Set the files in a knowledge base (replaces all existing files)
+     * @param name - Knowledge base name
+     * @param filePaths - File paths
+     */
+    setFiles(name: string, filePaths: string[]): Promise<KnowledgeBase>;
+    /**
+     * Add files to a knowledge base
+     * @param name - Knowledge base name
+     * @param filePaths - File paths to add
+     */
+    addFiles(name: string, filePaths: string[]): Promise<KnowledgeBase>;
+    /**
+     * Remove files from a knowledge base
+     * @param name - Knowledge base name
+     * @param filePaths - File paths to remove
+     */
+    removeFiles(name: string, filePaths: string[]): Promise<KnowledgeBase>;
+    /**
+     * Clear all files from a knowledge base
+     * @param name - Knowledge base name
+     */
+    clearFiles(name: string): Promise<KnowledgeBase>;
+}
+
+/**
+ * Service for managing user credits (read-only, backend-managed)
+ */
+declare class CreditService {
+    private core;
+    private static readonly BACKEND_ADDRESS;
+    constructor(core: BedrockCore);
+    /**
+     * Get user's credit balance and transaction history
+     * @returns User credit data with balance and transactions
+     */
+    getCreditBalance(): Promise<UserCredit>;
+}
+
+/**
+ * Main Bedrock SDK client
+ *
+ * @example
+ * ```typescript
+ * // Initialize from private key
+ * const client = await BedrockClient.fromPrivateKey('0x...');
+ *
+ * // Initialize from wallet provider (MetaMask, etc.)
+ * const client = await BedrockClient.fromProvider(window.ethereum);
+ *
+ * // Upload files
+ * const files = await client.files.uploadFiles([
+ *   { name: 'doc.txt', path: 'documents/doc.txt', content: buffer }
+ * ]);
+ *
+ * // List files
+ * const allFiles = await client.files.listFiles();
+ *
+ * // Add contact
+ * await client.contacts.addContact('Alice', '0x...', 'publicKey');
+ *
+ * // Create knowledge base
+ * await client.knowledgeBases.createKnowledgeBase('My Documents');
+ *
+ * // Check credit balance
+ * const balance = await client.credits.getCreditBalance();
+ *
+ * // Share file publicly
+ * const publicHash = await client.files.shareFilePublicly(file, 'username');
+ * const meta = await FileService.fetchPublicFileMeta(publicHash);
+ * const content = await FileService.downloadPublicFile(meta.store_hash);
+ *
+ * // Get files shared by contact
+ * const sharedFiles = await client.contacts.fetchFilesSharedByContact(contactPubKey);
+ * ```
+ */
+declare class BedrockClient {
+    private core;
+    /**
+     * File operations service
+     */
+    readonly files: FileService;
+    /**
+     * Contact management service
+     */
+    readonly contacts: ContactService;
+    /**
+     * Knowledge base management service
+     */
+    readonly knowledgeBases: KnowledgeBaseService;
+    /**
+     * Credit management service
+     */
+    readonly credits: CreditService;
+    private constructor();
+    /**
+     * Create BedrockClient from a private key
+     *
+     * @param privateKey - Ethereum private key (hex string with or without 0x prefix)
+     * @param config - Optional configuration
+     * @returns Initialized BedrockClient
+     *
+     * @example
+     * ```typescript
+     * const client = await BedrockClient.fromPrivateKey('0xabc123...');
+     * ```
+     */
+    static fromPrivateKey(privateKey: string, config?: BedrockCoreConfig): Promise<BedrockClient>;
+    /**
+     * Create BedrockClient from a wallet provider (e.g., MetaMask)
+     *
+     * @param provider - EIP-1193 provider
+     * @param config - Optional configuration
+     * @returns Initialized BedrockClient
+     *
+     * @example
+     * ```typescript
+     * const client = await BedrockClient.fromProvider(window.ethereum);
+     * ```
+     */
+    static fromProvider(provider: any, config?: BedrockCoreConfig): Promise<BedrockClient>;
+    /**
+     * Create BedrockClient from a signature hash
+     *
+     * @param signatureHash - Signature hash from wallet
+     * @param provider - EIP-1193 provider
+     * @param config - Optional configuration
+     * @returns Initialized BedrockClient
+     *
+     * @example
+     * ```typescript
+     * const signature = await wallet.signMessage({ message: 'Bedrock.im' });
+     * const client = await BedrockClient.fromSignature(signature, window.ethereum);
+     * ```
+     */
+    static fromSignature(signatureHash: string, provider: any, config?: BedrockCoreConfig): Promise<BedrockClient>;
+    /**
+     * Get the main account address
+     */
+    getMainAddress(): string;
+    /**
+     * Get the sub-account address
+     */
+    getSubAddress(): string;
+    /**
+     * Get the account's public key
+     */
+    getPublicKey(): string;
+    /**
+     * Get the encryption key (32 bytes derived from signature)
+     */
+    getEncryptionKey(): Buffer;
+    /**
+     * Reset all data (files, contacts, knowledge bases)
+     * WARNING: This will delete all user data from Aleph
+     */
+    resetAllData(): Promise<void>;
+    /**
+     * Reset all files
+     * WARNING: This will delete all files from Aleph
+     */
+    resetFiles(): Promise<void>;
+    /**
+     * Reset all contacts
+     * WARNING: This will delete all contacts
+     */
+    resetContacts(): Promise<void>;
+    /**
+     * Reset all knowledge bases
+     * WARNING: This will delete all knowledge bases
+     */
+    resetKnowledgeBases(): Promise<void>;
+    /**
+     * Setup all services (create aggregates if they don't exist)
+     */
+    private setup;
+}
+
+/**
+ * Universal crypto utilities that work in both Node.js and browser
+ */
+declare class CryptoUtils {
+    static isBrowser: boolean;
+    /**
+     * Get crypto implementation (Node.js or browser)
+     */
+    static getCrypto(): any;
+    /**
+     * Generate random bytes
+     */
+    static getRandomBytes(length: number): Uint8Array;
+    /**
+     * Convert buffer to hex string
+     */
+    static bufferToHex(buffer: Buffer | Uint8Array): string;
+    /**
+     * Convert hex string to buffer
+     */
+    static hexToBuffer(hex: string): Buffer;
+    /**
+     * Hash using SHA-256
+     */
+    static sha256(data: string | Buffer): Promise<Buffer>;
+}
+/**
+ * Encryption service for AES-256-CBC and ECIES operations
+ */
+declare class EncryptionService {
+    /**
+     * Generate a random encryption key (32 bytes for AES-256)
+     */
+    static generateKey(): Buffer;
+    /**
+     * Generate a random initialization vector (16 bytes for AES)
+     */
+    static generateIv(): Buffer;
+    /**
+     * Encrypt data using AES-256-CBC
+     * @param data - Data to encrypt
+     * @param key - 32-byte encryption key
+     * @param iv - 16-byte initialization vector
+     * @returns Hex-encoded encrypted data
+     */
+    static encrypt(data: string, key: Buffer, iv: Buffer): Promise<string>;
+    /**
+     * Decrypt data using AES-256-CBC
+     * @param encryptedData - Hex-encoded encrypted data
+     * @param key - 32-byte encryption key
+     * @param iv - 16-byte initialization vector
+     * @returns Decrypted string
+     */
+    static decrypt(encryptedData: string, key: Buffer, iv: Buffer): Promise<string>;
+    /**
+     * Encrypt file buffer using AES-256-CBC
+     * @param fileBuffer - File data as Buffer or ArrayBuffer
+     * @param key - 32-byte encryption key
+     * @param iv - 16-byte initialization vector
+     * @returns Encrypted file buffer
+     */
+    static encryptFile(fileBuffer: Buffer | ArrayBuffer, key: Buffer, iv: Buffer): Promise<Buffer>;
+    /**
+     * Decrypt file buffer using AES-256-CBC
+     * @param encryptedBuffer - Encrypted file data
+     * @param key - 32-byte encryption key
+     * @param iv - 16-byte initialization vector
+     * @returns Decrypted file buffer
+     */
+    static decryptFile(encryptedBuffer: Buffer | ArrayBuffer, key: Buffer, iv: Buffer): Promise<Buffer>;
+    /**
+     * Encrypt data using ECIES (Elliptic Curve Integrated Encryption Scheme)
+     * @param data - Data to encrypt
+     * @param publicKey - Recipient's public key (hex or Buffer)
+     * @returns Hex-encoded encrypted data
+     */
+    static encryptEcies(data: string, publicKey: string | Buffer): string;
+    /**
+     * Decrypt data using ECIES
+     * @param encryptedData - Hex-encoded encrypted data
+     * @param privateKey - Recipient's private key (hex or Buffer)
+     * @returns Decrypted string
+     */
+    static decryptEcies(encryptedData: string, privateKey: string | Buffer): string;
+    /**
+     * Hash data using SHA-256
+     */
+    static hash(data: string | Buffer): Promise<string>;
+    private static encryptNode;
+    private static decryptNode;
+    private static encryptFileNode;
+    private static decryptFileNode;
+    private static encryptBrowser;
+    private static decryptBrowser;
+    private static encryptFileBrowser;
+    private static decryptFileBrowser;
+}
+
+/**
+ * Base error class for Bedrock SDK
+ */
+declare class BedrockError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+/**
+ * Authentication/authorization errors
+ */
+declare class AuthenticationError extends BedrockError {
+    constructor(message: string);
+}
+/**
+ * Encryption/decryption errors
+ */
+declare class EncryptionError extends BedrockError {
+    constructor(message: string);
+}
+/**
+ * File operation errors
+ */
+declare class FileError extends BedrockError {
+    constructor(message: string);
+}
+/**
+ * File not found error
+ */
+declare class FileNotFoundError extends FileError {
+    constructor(path: string);
+}
+/**
+ * Contact-related errors
+ */
+declare class ContactError extends BedrockError {
+    constructor(message: string);
+}
+/**
+ * Knowledge base errors
+ */
+declare class KnowledgeBaseError extends BedrockError {
+    constructor(message: string);
+}
+/**
+ * Credit-related errors
+ */
+declare class CreditError extends BedrockError {
+    constructor(message: string);
+}
+/**
+ * Network/Aleph API errors
+ */
+declare class NetworkError extends BedrockError {
+    constructor(message: string);
+}
+/**
+ * Validation errors
+ */
+declare class ValidationError extends BedrockError {
+    constructor(message: string);
+}
+
+export { AGGREGATE_KEYS, ALEPH_GENERAL_CHANNEL, AddressSchema, type AlephAggregateContent, type AlephMessage, type AlephPostContent, AlephService, type AlephStoreMessage, AuthenticationError, BEDROCK_MESSAGE, BedrockClient, BedrockCore, type BedrockCoreConfig, BedrockError, type Contact, ContactError, ContactSchema, ContactService, type ContactsAggregate, ContactsAggregateSchema, type CreditAggregate, CreditAggregateSchema, CreditError, CreditService, type CreditTransaction, CreditTransactionSchema, CryptoUtils, DatetimeSchema, EncryptionError, EncryptionService, FileEntriesAggregateSchema, type FileEntry, FileEntrySchema, FileError, type FileFullInfo, type FileInput, type FileMeta, type FileMetaEncrypted, FileMetaEncryptedSchema, FileMetaSchema, FileNotFoundError, FileService, HexString32Schema, HexString64Schema, type KnowledgeBase, KnowledgeBaseError, KnowledgeBaseSchema, KnowledgeBaseService, type KnowledgeBasesAggregate, KnowledgeBasesAggregateSchema, NetworkError, POST_TYPES, type PublicFileMeta, PublicFileMetaSchema, SECURITY_AGGREGATE_KEY, type SecurityAggregate, SecurityAggregateSchema, type UserCredit, UserCreditSchema, ValidationError };