@metanodejs/file-module 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,1276 @@
+import z$1, { z } from 'zod';
+import { MtnContract } from '@metanodejs/mtn-contract';
+import { MarkOptional } from 'ts-essentials';
+import { EventLog, DecodeAbi } from '@metanodejs/event-log';
+import { Emitter, EventHandlerMap } from 'mitt';
+
+declare const appConfig: {
+    file: string;
+};
+
+/**
+ * Interface for logging functionality, providing methods for different log levels.
+ */
+interface LoggerPort {
+    /**
+     * Logs a message at the log level.
+     * @param message - The message to log.
+     * @param meta - Additional metadata to include in the log.
+     */
+    log(message: string, ...meta: unknown[]): void;
+    /**
+     * Logs a message at the error level.
+     * @param message - The error message to log.
+     * @param trace - Optional stack trace or additional error details.
+     * @param meta - Additional metadata to include in the log.
+     */
+    error(message: string, trace?: unknown, ...meta: unknown[]): void;
+    /**
+     * Logs a message at the warn level.
+     * @param message - The warning message to log.
+     * @param meta - Additional metadata to include in the log.
+     */
+    warn(message: string, ...meta: unknown[]): void;
+    /**
+     * Logs a message at the debug level.
+     * @param message - The debug message to log.
+     * @param meta - Additional metadata to include in the log.
+     */
+    debug(message: string, ...meta: unknown[]): void;
+    /**
+     * Logs a message at the info level.
+     * @param message - The info message to log.
+     * @param meta - Additional metadata to include in the log.
+     */
+    info(message: string, ...meta: unknown[]): void;
+}
+
+declare class Logger implements LoggerPort {
+    private readonly isDev;
+    private readonly prefix;
+    constructor(prefix?: string);
+    private formatMessage;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    log(...args: any[]): void;
+}
+declare const logger: Logger;
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'log';
+
+interface IAbiItemBase {
+    internalType: string;
+    name: string;
+    type: string;
+    indexed: boolean;
+    [key: string]: any;
+}
+interface IAbiBase {
+    inputs: IAbiItemBase[];
+    name: string;
+    stateMutability?: string;
+    type: string;
+    [key: string]: any;
+}
+interface AbiData {
+    functionName: string;
+    outputs: IAbiBase['outputs'];
+}
+declare class DecodeAbiService {
+    #private;
+    constructor(abis: IAbiBase[]);
+    get abiArray(): [string, AbiData][];
+    getAbiData(raw: string): AbiData | undefined;
+    handleDecodeAbi(topic: string, raw: string): Promise<{
+        decodedData: unknown;
+        event: string;
+    } | undefined>;
+}
+declare const decodeAbiService: DecodeAbiService;
+
+/**
+ * Giao diện định nghĩa các phương thức chung để xử lý các hoạt động blockchain,
+ * bao gồm xác thực dữ liệu và thực thi giao dịch với hợp đồng thông minh.
+ *
+ * @interface BlockchainRepositoryPort
+ */
+interface BlockchainRepositoryPort {
+    /**
+     * Xác thực dữ liệu yêu cầu bằng schema Zod.
+     *
+     * @param schema - Schema Zod để xác thực dữ liệu.
+     * @param data - Dữ liệu cần xác thực.
+     * @returns Dữ liệu đã được xác thực.
+     * @throws {ArgumentNotProvidedException} Nếu dữ liệu là null, undefined hoặc đối tượng rỗng.
+     * @throws {ArgumentInvalidException} Nếu dữ liệu không thỏa mãn schema.
+     */
+    validateRequest<T>(schema: z.ZodSchema<T>, data: unknown): T;
+    /**
+     * Thực thi giao dịch blockchain với cơ chế retry.
+     *
+     * @param params - Tham số giao dịch bao gồm địa chỉ, dữ liệu đầu vào, tên hàm, ABI và số lần thử lại.
+     * @returns Kết quả giao dịch.
+     * @throws {InternalServerErrorException} Nếu giao dịch thất bại sau số lần thử lại.
+     */
+    executeTransaction<T>(params: {
+        to: string;
+        from: string;
+        inputData: unknown;
+        functionName: string;
+        feeType: string;
+        abiData: unknown;
+        retries?: number;
+    }): Promise<T>;
+}
+
+/**
+ * Schema để xác thực một chuỗi hex 32 bytes (bytes32 trong Solidity).
+ * Chuỗi phải chứa chính xác 64 ký tự hex (0-9, a-f, A-F), có thể có hoặc không có tiền tố "0x".
+ *
+ * @example
+ *   "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" // Hợp lệ
+ *   "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" // Hợp lệ
+ *   "0x123" // Không hợp lệ (quá ngắn)
+ *   "0xGHI" // Không hợp lệ (không phải hex)
+ */
+declare const Bytes32Schema: z.ZodString;
+type Bytes32DTO = z.infer<typeof Bytes32Schema>;
+/**
+ * Schema để xác thực địa chỉ Ethereum (40 ký tự hex, tùy chọn "0x").
+ * Hỗ trợ kiểm tra checksum EIP-55 nếu cần.
+ *
+ * @example
+ *   "0x1234567890abcdef1234567890abcdef12345678" // Hợp lệ
+ *   "1234567890abcdef1234567890abcdef12345678" // Hợp lệ
+ *   "0x123" // Không hợp lệ (quá ngắn)
+ *   "0xGHI" // Không hợp lệ (không phải hex)
+ */
+declare const AddressSchema: z.ZodString;
+type AddressDTO = z.infer<typeof AddressSchema>;
+/**
+ * Schema để xác thực khóa công khai không nén (128 ký tự hex, tương ứng 64 bytes).
+ *
+ * @example
+ *   "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" // Hợp lệ
+ *   "0x123" // Không hợp lệ (quá ngắn)
+ *   "0xGHI" // Không hợp lệ (không phải hex)
+ */
+declare const PublicKeySchema: z.ZodString;
+type PublicKeyDTO = z.infer<typeof PublicKeySchema>;
+/**
+ * Schema để xác thực và chuyển đổi timestamp từ chuỗi thành số nguyên không âm.
+ * Dùng để xử lý các giá trị timestamp trả về từ hợp đồng thông minh (ví dụ: "1698765432").
+ *
+ * @example
+ * ```typescript
+ * TimestampSchema.parse("1698765432") // Kết quả: 1698765432
+ * TimestampSchema.parse("abc") // Lỗi: "Timestamp phải là chuỗi số nguyên không âm"
+ * ```
+ */
+declare const TimestampSchema: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
+type TimestampDTO = z.infer<typeof TimestampSchema>;
+/**
+ * Schema cơ bản cho các yêu cầu blockchain, chứa địa chỉ người gửi và hợp đồng đích (tùy chọn).
+ *
+ * @example
+ * ```typescript
+ * {
+ *   from: "0x1234567890abcdef1234567890abcdef12345678",
+ *   to: "0xabcdef1234567890abcdef1234567890abcdef12" // Tùy chọn
+ * }
+ * ```
+ */
+declare const BaseRequestSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type BaseRequestDTO = z.infer<typeof BaseRequestSchema>;
+
+/**
+ * Lớp cơ sở trừu tượng để xử lý các hoạt động blockchain, cung cấp các phương thức chung để xác thực,
+ * thực thi giao dịch và ghi log. Các lớp con như FileBlockchainRepository
+ * có thể kế thừa để triển khai các tác vụ cụ thể như upload file hoặc download file.
+ *
+ * @class BlockchainRepositoryBase
+ * @extends {MtnContract}
+ * @implements {BlockchainRepositoryPort}
+ */
+declare abstract class BlockchainRepositoryBase extends MtnContract implements BlockchainRepositoryPort {
+    protected readonly logger: LoggerPort;
+    /**
+     * Khởi tạo BlockchainRepositoryBase với địa chỉ hợp đồng và logger.
+     *
+     * @param to - Địa chỉ hợp đồng blockchain.
+     * @param logger - Đối tượng logger để ghi log các sự kiện và lỗi.
+     * @throws {ArgumentInvalidException} Nếu địa chỉ hợp đồng không hợp lệ.
+     */
+    protected constructor(to: AddressDTO, logger: LoggerPort);
+    /**
+     * Xác thực dữ liệu yêu cầu bằng schema Zod.
+     *
+     * @param schema - Schema Zod để xác thực dữ liệu.
+     * @param data - Dữ liệu cần xác thực.
+     * @returns Dữ liệu đã được xác thực.
+     * @throws {ArgumentNotProvidedException} Nếu dữ liệu là null, undefined hoặc đối tượng rỗng.
+     * @throws {ArgumentInvalidException} Nếu dữ liệu không thỏa mãn schema.
+     */
+    validateRequest<T>(schema: z$1.ZodSchema<T>, data: unknown): T;
+    /**
+     * Thực thi giao dịch blockchain với cơ chế retry.
+     *
+     * @param params - Tham số giao dịch bao gồm địa chỉ, dữ liệu đầu vào, tên hàm, ABI và số lần thử lại.
+     * @returns Kết quả giao dịch.
+     * @throws {InternalServerErrorException} Nếu giao dịch thất bại sau số lần thử lại.
+     */
+    executeTransaction<T>(params: {
+        to?: string;
+        from: string;
+        inputData?: unknown;
+        functionName: string;
+        feeType: string;
+        abiData: unknown;
+        value?: string | bigint;
+    }): Promise<T>;
+}
+
+declare const CalculatePriceRequestSchema: z$1.ZodObject<{
+    from: z$1.ZodString;
+    to: z$1.ZodOptional<z$1.ZodString>;
+    numChunks: z$1.ZodNumber;
+}, z$1.core.$strip>;
+type CalculatePriceRequestDTO = z$1.infer<typeof CalculatePriceRequestSchema>;
+declare const CalculatePriceResponseSchema: z$1.ZodString;
+type CalculatePriceResponseDTO = z$1.infer<typeof CalculatePriceResponseSchema>;
+
+declare const PushFileInfoRequestSchema: z$1.ZodObject<{
+    from: z$1.ZodString;
+    to: z$1.ZodOptional<z$1.ZodString>;
+    info: z$1.ZodObject<{
+        owner: z$1.ZodString;
+        merkleRoot: z$1.ZodString;
+        contentLen: z$1.ZodNumber;
+        totalChunks: z$1.ZodNumber;
+        expireTime: z$1.ZodNumber;
+        name: z$1.ZodString;
+        ext: z$1.ZodString;
+        contentDisposition: z$1.ZodString;
+        contentID: z$1.ZodString;
+        status: z$1.ZodNumber;
+    }, z$1.core.$strip>;
+    value: z$1.ZodString;
+}, z$1.core.$strip>;
+type PushFileInfoRequestDTO = z$1.infer<typeof PushFileInfoRequestSchema>;
+declare const PushFileInfoResponseSchema: z$1.ZodObject<{
+    fileKey: z$1.ZodString;
+}, z$1.core.$strip>;
+type PushFileInfoResponseDTO = z$1.infer<typeof PushFileInfoResponseSchema>;
+
+declare const UploadChunkRequestSchema: z$1.ZodObject<{
+    from: z$1.ZodString;
+    to: z$1.ZodOptional<z$1.ZodString>;
+    fileKey: z$1.ZodString;
+    chunkData: z$1.ZodString;
+    chunkIndex: z$1.ZodNumber;
+    merkleProof: z$1.ZodArray<z$1.ZodString>;
+}, z$1.core.$strip>;
+type UploadChunkRequestDTO = z$1.infer<typeof UploadChunkRequestSchema>;
+type UploadChunkResponseDTO = void;
+
+declare const GetFileInfoRequestSchema: z$1.ZodObject<{
+    from: z$1.ZodString;
+    to: z$1.ZodOptional<z$1.ZodString>;
+    fileKey: z$1.ZodString;
+}, z$1.core.$strip>;
+type GetFileInfoRequestDTO = z$1.infer<typeof GetFileInfoRequestSchema>;
+declare const GetFileInfoResponseSchema: z$1.ZodObject<{
+    owner: z$1.ZodString;
+    merkleRoot: z$1.ZodString;
+    contentLen: z$1.ZodNumber;
+    totalChunks: z$1.ZodNumber;
+    expireTime: z$1.ZodNumber;
+    name: z$1.ZodString;
+    ext: z$1.ZodString;
+    contentDisposition: z$1.ZodString;
+    contentID: z$1.ZodString;
+    status: z$1.ZodNumber;
+}, z$1.core.$strip>;
+type GetFileInfoResponseDTO = z$1.infer<typeof GetFileInfoResponseSchema>;
+
+declare const PayForDownloadRequestSchema: z$1.ZodObject<{
+    from: z$1.ZodString;
+    to: z$1.ZodOptional<z$1.ZodString>;
+    fileKey: z$1.ZodString;
+    downloadTimes: z$1.ZodNumber;
+    value: z$1.ZodString;
+}, z$1.core.$strip>;
+type PayForDownloadRequestDTO = z$1.infer<typeof PayForDownloadRequestSchema>;
+declare const PayForDownloadResponseSchema: z$1.ZodObject<{
+    transactionHash: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.core.$strip>;
+type PayForDownloadResponseDTO = z$1.infer<typeof PayForDownloadResponseSchema>;
+
+declare const ConfirmServerDownloadRequestSchema: z$1.ZodObject<{
+    from: z$1.ZodString;
+    to: z$1.ZodOptional<z$1.ZodString>;
+    downloadKey: z$1.ZodString;
+}, z$1.core.$strip>;
+type ConfirmServerDownloadRequestDTO = z$1.infer<typeof ConfirmServerDownloadRequestSchema>;
+declare const ConfirmServerDownloadResponseSchema: z$1.ZodString;
+type ConfirmServerDownloadResponseDTO = z$1.infer<typeof ConfirmServerDownloadResponseSchema>;
+
+declare const GetRustServerAddressesRequestSchema: z$1.ZodObject<{
+    from: z$1.ZodString;
+    to: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.core.$strip>;
+type GetRustServerAddressesRequestDTO = z$1.infer<typeof GetRustServerAddressesRequestSchema>;
+declare const GetRustServerAddressesResponseSchema: z$1.ZodArray<z$1.ZodString>;
+type GetRustServerAddressesResponseDTO = z$1.infer<typeof GetRustServerAddressesResponseSchema>;
+
+declare const SetPublicStatusRequestSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodOptional<z.ZodString>;
+    fileKey: z.ZodString;
+    status: z.ZodBoolean;
+}, z.core.$strip>;
+type SetPublicStatusRequestDTO = z.infer<typeof SetPublicStatusRequestSchema>;
+type SetPublicStatusResponseDTO = void;
+
+declare const AddWhitelistRequestSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodOptional<z.ZodString>;
+    fileKey: z.ZodString;
+    users: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type AddWhitelistRequestDTO = z.infer<typeof AddWhitelistRequestSchema>;
+type AddWhitelistResponseDTO = void;
+
+declare const GetWhitelistRequestSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodOptional<z.ZodString>;
+    fileKey: z.ZodString;
+}, z.core.$strip>;
+type GetWhitelistRequestDTO = z.infer<typeof GetWhitelistRequestSchema>;
+type GetWhitelistResponseDTO = string[];
+
+declare const IsPublicFileRequestSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodOptional<z.ZodString>;
+    fileKey: z.ZodString;
+}, z.core.$strip>;
+type IsPublicFileRequestDTO = z.infer<typeof IsPublicFileRequestSchema>;
+type IsPublicFileResponseDTO = boolean;
+
+interface FileBlockchainRepositoryPort {
+    calculatePrice(request: CalculatePriceRequestDTO): Promise<CalculatePriceResponseDTO>;
+    pushFileInfo(request: PushFileInfoRequestDTO): Promise<PushFileInfoResponseDTO>;
+    uploadChunk(request: UploadChunkRequestDTO): Promise<UploadChunkResponseDTO>;
+    getFileInfo(request: GetFileInfoRequestDTO): Promise<GetFileInfoResponseDTO>;
+    payForDownload(request: PayForDownloadRequestDTO): Promise<PayForDownloadResponseDTO>;
+    confirmServerDownload(request: ConfirmServerDownloadRequestDTO): Promise<ConfirmServerDownloadResponseDTO>;
+    getRustServerAddresses(request: GetRustServerAddressesRequestDTO): Promise<GetRustServerAddressesResponseDTO>;
+    setPublicStatus(request: SetPublicStatusRequestDTO): Promise<SetPublicStatusResponseDTO>;
+    addWhitelist(request: AddWhitelistRequestDTO): Promise<AddWhitelistResponseDTO>;
+    getWhitelist(request: GetWhitelistRequestDTO): Promise<GetWhitelistResponseDTO>;
+    isPublicFile(request: IsPublicFileRequestDTO): Promise<IsPublicFileResponseDTO>;
+}
+
+declare class FileBlockchainRepository extends BlockchainRepositoryBase implements FileBlockchainRepositoryPort {
+    constructor();
+    calculatePrice(request: CalculatePriceRequestDTO): Promise<CalculatePriceResponseDTO>;
+    pushFileInfo(request: PushFileInfoRequestDTO): Promise<PushFileInfoResponseDTO>;
+    uploadChunk(request: UploadChunkRequestDTO): Promise<UploadChunkResponseDTO>;
+    getFileInfo(request: GetFileInfoRequestDTO): Promise<GetFileInfoResponseDTO>;
+    payForDownload(request: PayForDownloadRequestDTO): Promise<PayForDownloadResponseDTO>;
+    confirmServerDownload(request: ConfirmServerDownloadRequestDTO): Promise<ConfirmServerDownloadResponseDTO>;
+    getRustServerAddresses(request: GetRustServerAddressesRequestDTO): Promise<GetRustServerAddressesResponseDTO>;
+    setPublicStatus(request: SetPublicStatusRequestDTO): Promise<SetPublicStatusResponseDTO>;
+    addWhitelist(request: AddWhitelistRequestDTO): Promise<AddWhitelistResponseDTO>;
+    getWhitelist(request: GetWhitelistRequestDTO): Promise<GetWhitelistResponseDTO>;
+    isPublicFile(request: IsPublicFileRequestDTO): Promise<IsPublicFileResponseDTO>;
+}
+declare const fileBlockchainRepository: FileBlockchainRepository;
+
+declare const calculatePriceAbi: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+
+declare const confirmServerDownloadAbi: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+}[];
+
+declare const getFileInfoAbi: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+
+declare const GetRustServerAddressesAbi: {
+    inputs: never[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+
+declare const payForDownloadAbi: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+}[];
+
+declare const pushFileInfoAbi: {
+    inputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+
+declare const uploadChunkAbi: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+}[];
+
+declare const setPublicStatusAbi: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+}[];
+
+declare const addWhitelistAbi: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+}[];
+
+declare const getWhitelistAbi: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+
+declare const isPublicFileAbi: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+
+type EntityId = string | number
+type StringEnum<T> = T | (string & Record<never, never>)
+
+declare module '@metanodejs/event-log' {
+  export class DecodeAbi {
+    registerAbi(abi: any): Promise<void>
+  }
+  export class EventLog<T> {
+    constructor(decodeAbi: DecodeAbi)
+    registerEvent(from: string, to: string[]): Promise<void>
+    onEventLog(callback: (event: any) => void): () => void
+  }
+}
+
+declare class UniqueEntityID {
+    protected readonly id: EntityId;
+    constructor(_id?: EntityId);
+    equals(_id?: UniqueEntityID): boolean;
+    toString(): string;
+    toValue(): EntityId;
+}
+
+interface BaseEntityProps {
+    id: UniqueEntityID;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface CreateEntityProps<T> extends MarkOptional<BaseEntityProps, 'createdAt' | 'updatedAt'> {
+    props: T;
+}
+declare abstract class Entity<Props> {
+    #private;
+    constructor({ id, props, createdAt, updatedAt }: CreateEntityProps<Props>);
+    static isEntity(entity: unknown): entity is Entity<unknown>;
+    get id(): UniqueEntityID;
+    get createdAt(): Date;
+    get updatedAt(): Date;
+    getProps(): Props & BaseEntityProps;
+    protected getMutableProps(): Props;
+    /**
+     * Convert an Entity and all sub-entities/Value Objects it
+     * contains to a plain object with primitive types. Can be
+     * useful when logging an entity during testing/debugging
+     */
+    toObject(): any;
+    /**
+     * Each entity must have some validate/business rules
+     * This method is called every time before save this entity to the database
+     */
+    abstract validate(): void;
+}
+
+interface Mapper<DomainEntity extends Entity<unknown>, DbRecord, Response = unknown> {
+    toPersistence(entity: DomainEntity): DbRecord;
+    toDomain(record: DbRecord): DomainEntity;
+    toResponse(entity: DomainEntity): Response;
+}
+
+type NumericValue = number | string | bigint;
+type EventMap = {
+    DownloadKeyGenerated: {
+        downloadKey: string;
+        fileKey: string;
+        user: string;
+        amount: NumericValue;
+    };
+    FileActivated: {
+        user: string;
+        fileKey: string;
+    };
+};
+
+declare class EventLogs {
+    private static instance;
+    private readonly _decodeAbi;
+    private readonly _eventLog;
+    private _abiRegistrationPromise;
+    private _registeredEvents;
+    private constructor();
+    static getInstance(): EventLogs;
+    get eventLog(): EventLog<EventMap>;
+    get decodeAbi(): DecodeAbi;
+    registerAbi(): Promise<void>;
+    registerEvent(userAddress: string, contractAddress: string): Promise<void>;
+}
+declare const eventLogs: EventLogs;
+
+interface UseCase<Request, Response> {
+    execute(request?: Request): Promise<Response> | Response;
+}
+
+interface EventLogData {
+    type: string;
+    payload: any;
+}
+interface IEventLogRepository {
+    registerEvent(from: string, to: string | string[]): Promise<void>;
+    onEventLog(callback: (data: EventLogData) => void): () => void;
+}
+
+interface DecodedAbiResult {
+    decodedData: Record<string, unknown>;
+    event: string;
+}
+interface IDecodeAbiRepository {
+    decodeAbi(hash: string, raw: string): Promise<DecodedAbiResult>;
+    registerAbi?(abiEvents: any[]): Promise<void>;
+}
+
+type DomainEventMetadata = {
+    /** Timestamp when this domain event occurred */
+    readonly timestamp: number;
+    /** ID for correlation purposes (for Integration Events,logs correlation, etc).
+     */
+    readonly correlationId?: string | undefined;
+    /**
+     * Causation id used to reconstruct execution order if needed
+     */
+    readonly causationId?: string | undefined;
+};
+type IDomainEvent<T> = Omit<T, 'id' | '_metadata' | 'eventName'> & {
+    _metadata: DomainEventMetadata;
+    aggregateId: UniqueEntityID;
+};
+declare abstract class DomainEvent {
+    readonly id: UniqueEntityID;
+    readonly aggregateId: UniqueEntityID;
+    readonly _metadata: DomainEventMetadata;
+    abstract eventName: string;
+    constructor(domainEvent: IDomainEvent<unknown>);
+}
+
+type EmitDomainEvents = any;
+
+interface AsyncEventBus extends Emitter<EmitDomainEvents> {
+    emitAsync<Key extends keyof EmitDomainEvents>(type: Key, event: EmitDomainEvents[Key]): Promise<void>;
+}
+declare function createMittAsync(all?: EventHandlerMap<EmitDomainEvents>): AsyncEventBus;
+declare const emitter: AsyncEventBus;
+
+declare abstract class AggregateRoot<Props> extends Entity<Props> {
+    #private;
+    get domainEvents(): readonly DomainEvent[];
+    protected addEvent(event: DomainEvent | DomainEvent[]): void;
+    clearEvents(): void;
+    /**
+     * Publish tất cả domain events qua AsyncEventBus
+     * - Logger để debug
+     * - await cho từng handler async
+     */
+    publishEvents(logger: LoggerPort, emitter: AsyncEventBus): Promise<void>;
+}
+
+/**
+ * Domain Primitive is an object that contains only a single value
+ */
+type Primitives = string | number | boolean;
+interface DomainPrimitive<T extends Primitives | Date> {
+    value: T;
+}
+type ValueObjectProps<T> = T extends Primitives | Date ? DomainPrimitive<T> : T;
+declare abstract class ValueObject<Props> {
+    #private;
+    protected readonly props: ValueObjectProps<Props>;
+    constructor(props: ValueObjectProps<Props>);
+    protected abstract validate(props: ValueObjectProps<Props>): void;
+    static isValueObject(obj: unknown): obj is ValueObject<unknown>;
+    equals(vo?: ValueObject<Props>): boolean;
+    /**
+     * Convert value obj to get raw properties
+     */
+    raw(): any;
+}
+
+interface RepositoryPorts<Entity> {
+    save(entity: Entity): Promise<void>;
+    update(id: string, entity: Partial<Entity>): Promise<void>;
+    delete(id: string): Promise<void>;
+    findById(id: string): Promise<Entity | null>;
+    findAll(): Promise<Entity[]>;
+    clear(): Promise<void>;
+    findByField<K extends keyof Entity>(field: K, entity: Entity): Promise<Entity[]>;
+}
+
+interface NormalizedException {
+    message: string;
+    code: string;
+    correlationId: string;
+    stack?: string | undefined;
+    cause?: string | undefined;
+    /**
+     * ^ Consider adding optional `metadata` object to
+     * exceptions (if language doesn't support anything
+     * similar by default) and pass some useful technical
+     * information about the exception when throwing.
+     * This will make debugging easier.
+     */
+    metadata?: Record<string, unknown> | undefined;
+}
+declare abstract class ExceptionBase extends Error {
+    readonly message: string;
+    readonly metadata?: Record<string, unknown> | undefined;
+    abstract code: string;
+    readonly correlationId: string;
+    /**
+     * @param {string} message
+     * @param {ObjectLiteral} [metadata={}]
+     * **BE CAREFUL** not to include sensitive info in 'metadata'
+     * to prevent leaks since all exception's data will end up
+     * in application's log files. Only include non-sensitive
+     * info that may help with debugging.
+     */
+    constructor(message: string, metadata?: Record<string, unknown> | undefined);
+    toJSON(): NormalizedException;
+}
+
+/**
+ * Adding a `code` string with a custom status code for every
+ * exception is a good practice.
+ *
+ * Since when that exception is transferred to another process `instanceof`
+ * check cannot be performed anymore so a `code` string is used instead.
+ *
+ * Code constants can be stored in a separate file so they
+ * can be shared and reused on a receiving side (code sharing is
+ * useful when developing fullstack apps or microservices)
+ */
+declare const ARGUMENT_INVALID = "GENERIC.ARGUMENT_INVALID";
+declare const ARGUMENT_OUT_OF_RANGE = "GENERIC.ARGUMENT_OUT_OF_RANGE";
+declare const ARGUMENT_NOT_PROVIDED = "GENERIC.ARGUMENT_NOT_PROVIDED";
+declare const NOT_FOUND = "GENERIC.NOT_FOUND";
+declare const CONFLICT = "GENERIC.CONFLICT";
+declare const INTERNAL_SERVER_ERROR = "GENERIC.INTERNAL_SERVER_ERROR";
+
+/**
+ * Used to indicate that an argument was not provided (is empty object/array, null of undefined).
+ *
+ * @class ArgumentNotProvidedException
+ * @extends {ExceptionBase}
+ */
+declare class ArgumentNotProvidedException extends ExceptionBase {
+    readonly code = "GENERIC.ARGUMENT_NOT_PROVIDED";
+}
+/**
+ * Used to indicate that an incorrect argument was provided to a method/function/class constructor
+ *
+ * @class ArgumentInvalidException
+ * @extends {ExceptionBase}
+ */
+declare class ArgumentInvalidException extends ExceptionBase {
+    readonly code = "GENERIC.ARGUMENT_INVALID";
+}
+/**
+ * Used to indicate that an argument is out of allowed range
+ * (for example: incorrect string/array length, number not in allowed min/max range etc)
+ *
+ * @class ArgumentOutOfRangeException
+ * @extends {ExceptionBase}
+ */
+declare class ArgumentOutOfRangeException extends ExceptionBase {
+    readonly code = "GENERIC.ARGUMENT_OUT_OF_RANGE";
+}
+/**
+ * Used to indicate conflicting entities (usually in the database)
+ *
+ * @class ConflictException
+ * @extends {ExceptionBase}
+ */
+declare class ConflictException extends ExceptionBase {
+    readonly code = "GENERIC.CONFLICT";
+}
+/**
+ * Used to indicate that entity is not found
+ *
+ * @class NotFoundException
+ * @extends {ExceptionBase}
+ */
+declare class NotFoundException extends ExceptionBase {
+    readonly code = "GENERIC.NOT_FOUND";
+}
+/**
+ * Used to indicate an internal server error that does not fall under all other errors
+ *
+ * @class InternalServerErrorException
+ * @extends {ExceptionBase}
+ */
+declare class InternalServerErrorException extends ExceptionBase {
+    readonly code = "GENERIC.INTERNAL_SERVER_ERROR";
+}
+
+declare function isValidAddress(address: string): boolean;
+declare function isValidPublicKey(publicKey: string): boolean;
+
+/**
+ * You just increase the length if necessary to improve performance
+ * Attention to the security(id is key)
+ *
+ * Characters	Length	Total   States
+ * UUID	      16	    32	    16^32 = 3.4e+38
+ * Base58	    58	    22	    58^22 = 6.2e+38
+ * ---------------------------------------------------------
+ * Length	    Example	                          Total States
+ * nanoid(8)	re6ZkUUV	                        1.3e+14
+ * nanoid(12)	pfpPYdZGbZvw	                    1.4e+21
+ * nanoid(16)	sFDUZScHfZTfkLwk	                1.6e+28
+ * nanoid(24)	u7vzXJL9cGqUeabGPAZ5XUJ6	        2.1e+42
+ * nanoid(32)	qkvPDeH6JyAsRhaZ3X4ZLDPSLFP7MnJz	2.7e+56
+ *
+ *  See @https://unkey.dev/blog/uuid-ux
+ */
+declare const generateId: (size?: number) => string;
+declare const DEFAULT_PREFIX_ID_LENGTH = 22;
+declare const ENTITY_ID_LENGTH = 25;
+declare function generatePrefixId(prefix?: string, length?: number): string;
+
+/**
+ * Converts Entity/Value Objects props to a plain object.
+ * Useful for testing and debugging.
+ * @param props
+ */
+declare function convertPropsToObject(props: any): any;
+
+type InvariantMessage = string | (() => string) | Error;
+declare function invariant(condition: any, message?: InvariantMessage): asserts condition;
+
+declare function isNotNull<T>(v: T | null): v is Exclude<T, null>;
+declare function isArray<T = unknown>(val: any): val is T[];
+declare function isPrimitive(value: unknown): boolean;
+declare const isDef: <T = any>(val?: T) => val is T;
+declare const isUndef: <T = any>(val?: T) => val is T;
+declare const isBoolean: (val: any) => val is boolean;
+declare const isFunction: (val: any) => boolean;
+declare const isNumber: (val: any) => val is number;
+declare const isString: (val: unknown) => val is string;
+declare const isObject: (val: any) => val is object;
+declare const isMap: (val: unknown) => val is Map<any, any>;
+declare const isSet: (val: unknown) => val is Set<any>;
+declare const isDate: (val: unknown) => val is Date;
+declare const isSymbol: (val: unknown) => val is symbol;
+declare const isPromise: <T = any>(val: unknown) => val is Promise<T>;
+declare const isFalsy: (val: any) => val is false | undefined | null;
+declare const isWindow: (val: any) => boolean;
+declare const isStream: (val: any) => boolean;
+declare const isBrowser: boolean;
+/**
+ * Check a value is empty or not
+ * Currently not support check WeakMap/WeakSet/WeakRef
+ */
+declare function isEmpty<T = unknown>(val: T): val is T;
+declare function isNotEmpty<T = unknown>(val: T): val is T;
+/**
+ * Use for case you validate multiple values is not empty
+ *
+ * @param {any} args any arguments
+ * @returns {boolean} will return true if all value is not empty
+ */
+declare function isNotEmpties(...args: any[]): boolean;
+/**
+ * Use for case you validate multiple values is not empty
+ * @param args
+ */
+declare function isEmpties(...args: any[]): boolean;
+/**
+ * {@link} https://en.wikipedia.org/wiki/Portable_Network_Graphics
+ *
+ * @param {Buffer | Uint8Array} buffer Input is a buffer
+ * @returns {boolean} return true if the input is a PNG Image
+ */
+declare function isPngImage(buffer: Buffer | Uint8Array): boolean;
+declare const isAndroid: boolean;
+declare const isMobile: boolean | undefined;
+declare const isCrawler: boolean;
+
+declare function delay(ms: number): Promise<void>;
+
+declare function humanFileSize(bytes: number, si?: boolean, dp?: number): string;
+
+declare function generateRandomHex(length: number): string;
+
+declare const fulfilledPromises: <T extends Promise<any>>(promises: T[]) => Promise<Awaited<T>[]>;
+declare function formatSize(bytes: number): string;
+
+declare const UploadFileRequestSchema: z$1.ZodObject<{
+    file: z$1.ZodCustom<File, File>;
+    from: z$1.ZodString;
+    chunkSize: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodNumber>>;
+}, z$1.core.$strip>;
+type UploadFileRequestDTO = z$1.infer<typeof UploadFileRequestSchema>;
+declare const UploadFileResponseSchema: z$1.ZodObject<{
+    fileKey: z$1.ZodString;
+    merkleRoot: z$1.ZodString;
+    totalChunks: z$1.ZodNumber;
+}, z$1.core.$strip>;
+type UploadFileResponseDTO = z$1.infer<typeof UploadFileResponseSchema>;
+
+declare const DownloadFileRequestSchema: z$1.ZodObject<{
+    fileKey: z$1.ZodString;
+    from: z$1.ZodString;
+    downloadTimes: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodNumber>>;
+}, z$1.core.$strip>;
+type DownloadFileRequestDTO = z$1.infer<typeof DownloadFileRequestSchema>;
+declare const DownloadFileResponseSchema: z$1.ZodObject<{
+    fileData: z$1.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    fileName: z$1.ZodString;
+    fileExt: z$1.ZodString;
+}, z$1.core.$strip>;
+type DownloadFileResponseDTO = z$1.infer<typeof DownloadFileResponseSchema>;
+
+interface SetPublicStatusUseCaseRequestDTO {
+    from: string;
+    fileKey: string;
+    status: boolean;
+}
+type SetPublicStatusUseCaseResponseDTO = void;
+interface AddWhitelistUseCaseRequestDTO {
+    from: string;
+    fileKey: string;
+    users: string[];
+}
+type AddWhitelistUseCaseResponseDTO = void;
+interface GetWhitelistUseCaseRequestDTO {
+    from: string;
+    fileKey: string;
+}
+type GetWhitelistUseCaseResponseDTO = string[];
+interface IsPublicFileUseCaseRequestDTO {
+    from: string;
+    fileKey: string;
+}
+type IsPublicFileUseCaseResponseDTO = boolean;
+
+/**
+ * File Activated Listener Service
+ *
+ * Service lắng nghe event FileActivated và cung cấp confirmation
+ * khi file đã được activate sau khi upload hết chunks
+ */
+interface FileActivatedProvider {
+    waitForFileActivated(fileKey: string, timeout?: number): Promise<{
+        fileKey: string;
+        user: string;
+    }>;
+}
+declare class FileActivatedListenerService implements FileActivatedProvider {
+    private activatedFiles;
+    private pendingRequests;
+    private unsubscribe;
+    private isInitialized;
+    constructor();
+    initialize(userAddress: string, contractAddress: string): Promise<void>;
+    /**
+     * Bắt đầu lắng nghe event FileActivated
+     */
+    private startListening;
+    /**
+     * Xử lý event FileActivated
+     */
+    private handleFileActivated;
+    /**
+     * Normalize fileKey để so sánh (remove 0x prefix, lowercase, pad)
+     */
+    private normalizeFileKey;
+    /**
+     * Đợi FileActivated event cho fileKey
+     */
+    waitForFileActivated(fileKey: string, timeout?: number): Promise<{
+        fileKey: string;
+        user: string;
+    }>;
+    /**
+     * Dọn dẹp và dừng lắng nghe
+     */
+    stop(): void;
+    /**
+     * Clear cache (có thể dùng để test hoặc reset)
+     */
+    clearCache(): void;
+}
+
+declare class UploadFileUseCase {
+    private readonly fileBlockchainRepository;
+    private readonly fileActivatedProvider?;
+    constructor(fileBlockchainRepository: FileBlockchainRepositoryPort, fileActivatedProvider?: FileActivatedProvider | undefined);
+    execute(request: UploadFileRequestDTO): Promise<UploadFileResponseDTO>;
+}
+
+interface DownloadKeyProvider {
+    getDownloadKey(fileKey: string, timeout?: number): Promise<{
+        downloadKey: string;
+        user: string;
+        amount: string;
+    }>;
+}
+declare class DownloadFileUseCase {
+    private readonly fileBlockchainRepository;
+    private readonly downloadKeyProvider;
+    constructor(fileBlockchainRepository: FileBlockchainRepositoryPort, downloadKeyProvider: DownloadKeyProvider);
+    execute(request: DownloadFileRequestDTO): Promise<DownloadFileResponseDTO>;
+}
+
+declare class SetPublicStatusUseCase {
+    private readonly fileBlockchainRepository;
+    constructor(fileBlockchainRepository: FileBlockchainRepositoryPort);
+    execute(request: SetPublicStatusUseCaseRequestDTO): Promise<SetPublicStatusUseCaseResponseDTO>;
+}
+
+declare class AddWhitelistUseCase {
+    private readonly fileBlockchainRepository;
+    constructor(fileBlockchainRepository: FileBlockchainRepositoryPort);
+    execute(request: AddWhitelistUseCaseRequestDTO): Promise<AddWhitelistUseCaseResponseDTO>;
+}
+
+declare class GetWhitelistUseCase {
+    private readonly fileBlockchainRepository;
+    constructor(fileBlockchainRepository: FileBlockchainRepositoryPort);
+    execute(request: GetWhitelistUseCaseRequestDTO): Promise<GetWhitelistUseCaseResponseDTO>;
+}
+
+declare class IsPublicFileUseCase {
+    private readonly fileBlockchainRepository;
+    constructor(fileBlockchainRepository: FileBlockchainRepositoryPort);
+    execute(request: IsPublicFileUseCaseRequestDTO): Promise<IsPublicFileUseCaseResponseDTO>;
+}
+
+/**
+ * File Repository Port
+ * Interface cho file operations
+ */
+interface IFileRepository extends FileBlockchainRepositoryPort {
+}
+
+/**
+ * Rust Server Client
+ *
+ * Kết nối và request chunks từ Rust Servers sử dụng Native QUIC Connection
+ *
+ * Implementation sử dụng native functions:
+ * - connectQuicServer: Connect đến Rust server
+ * - sendQuicMessage: Gửi message và nhận response
+ * - disconnectQuicServer: Disconnect khi không dùng nữa
+ * - Load Balancing: Chunk chẵn từ Server 1, chunk lẻ từ Server 2
+ * - Retry logic khi request fail (max 3 lần)
+ * - Không retry nếu lỗi chứa "to store chunk on disk" (đã thành công)
+ */
+interface DownloadChunkPayload {
+    file_key: string;
+    download_key: string;
+    chunk_index: number;
+    signature: string;
+}
+interface DownloadChunkRequest {
+    command: string;
+    requestId?: string;
+    chunkIndex?: number;
+    totalChunks?: number;
+    payload: DownloadChunkPayload;
+}
+interface DownloadResponse {
+    status: string;
+    message: string;
+    chunk_data_base64?: string;
+    chunkIndex?: number;
+    requestId?: string;
+}
+declare class NativeQuicError extends Error {
+    code: string;
+    retryable: boolean;
+    retryAfterMs?: number | undefined;
+    constructor(code: string, retryable: boolean, retryAfterMs?: number | undefined, message?: string);
+}
+/**
+ * Request chunk với automatic server selection và retry logic
+ */
+declare function requestChunk(fileKey: string, downloadKey: string, chunkIndex: number, totalChunks: number, signature: string, serverAddresses: string[]): Promise<{
+    chunkIndex: number;
+    data: Uint8Array;
+}>;
+/**
+ * Download all chunks using a worker pool concurrency model
+ *
+ * Chia chunks thành 2 nhóm (chẵn/lẻ) và download song song
+ * - Chunks chẵn (0, 2, 4...) → Server 1
+ * - Chunks lẻ (1, 3, 5...) → Server 2
+ * - Tương tự Go code với Goroutines
+ *
+ * @param fileKey - File key
+ * @param downloadKey - Download key from event
+ * @param totalChunks - Total number of chunks
+ * @param signature - Signature for authentication
+ * @param onProgress - Callback for progress updates
+ * @returns Array of chunks in correct order
+ */
+declare function downloadAllChunks(fileKey: string, downloadKey: string, totalChunks: number, signature: string, from: string, onProgress?: (downloaded: number, total: number) => void): Promise<Uint8Array[]>;
+/**
+ * Download all chunks and merge into single file
+ *
+ * @param fileKey - File key
+ * @param downloadKey - Download key from event
+ * @param totalChunks - Total number of chunks
+ * @param signature - Signature for authentication
+ * @param onProgress - Callback for progress updates
+ * @returns Merged file as Uint8Array
+ */
+declare function downloadAndMergeFile(fileKey: string, downloadKey: string, totalChunks: number, signature: string, from: string, onProgress?: (downloaded: number, total: number) => void): Promise<Uint8Array>;
+
+/**
+ * Download Key Listener Service
+ *
+ * Service lắng nghe event DownloadKeyGenerated và cung cấp downloadKey
+ * khi được yêu cầu
+ */
+
+declare class DownloadKeyListenerService implements DownloadKeyProvider {
+    private downloadKeys;
+    private pendingRequests;
+    private unsubscribe;
+    private isInitialized;
+    constructor();
+    initialize(userAddress: string, contractAddress: string): Promise<void>;
+    /**
+     * Bắt đầu lắng nghe event DownloadKeyGenerated
+     */
+    private startListening;
+    /**
+     * Xử lý event DownloadKeyGenerated
+     */
+    private handleDownloadKeyGenerated;
+    /**
+     * Normalize fileKey để so sánh (remove 0x prefix, lowercase, pad)
+     */
+    private normalizeFileKey;
+    /**
+     * Lấy downloadKey cho fileKey
+     */
+    getDownloadKey(fileKey: string, timeout?: number): Promise<{
+        downloadKey: string;
+        user: string;
+        amount: string;
+    }>;
+    /**
+     * Dọn dẹp và dừng lắng nghe
+     */
+    stop(): void;
+    /**
+     * Clear cache (có thể dùng để test hoặc reset)
+     */
+    clearCache(): void;
+}
+
+/**
+ * File Module Container
+ * Dependency injection container cho file module
+ */
+declare class FileModuleContainer {
+    private uploadFileUseCase;
+    private downloadFileUseCase;
+    private downloadKeyListenerService;
+    private fileActivatedListenerService;
+    private setPublicStatusUseCase;
+    private addWhitelistUseCase;
+    private getWhitelistUseCase;
+    private isPublicFileUseCase;
+    private initPromise;
+    constructor(downloadKeyProvider?: DownloadKeyProvider, options?: {
+        userAddress?: string;
+        contractAddress?: string;
+    });
+    /**
+     * Tạo DownloadKeyProvider mặc định sử dụng EventLog
+     */
+    private createDefaultDownloadKeyProvider;
+    /**
+     * Tạo FileActivatedProvider mặc định sử dụng EventLog
+     */
+    private createDefaultFileActivatedProvider;
+    getUploadFileUseCase(): UploadFileUseCase;
+    getDownloadFileUseCase(): DownloadFileUseCase;
+    getSetPublicStatusUseCase(): SetPublicStatusUseCase;
+    getAddWhitelistUseCase(): AddWhitelistUseCase;
+    getGetWhitelistUseCase(): GetWhitelistUseCase;
+    getIsPublicFileUseCase(): IsPublicFileUseCase;
+    /**
+     * Khởi tạo và đăng ký event với native
+     * Cần gọi method này trước khi sử dụng download/upload để native biết gửi event về
+     * @param userAddress Địa chỉ ví của user
+     * @param contractAddress Địa chỉ contract file
+     */
+    initialize(userAddress: string, contractAddress: string): Promise<void>;
+    /**
+     * Dọn dẹp resources
+     */
+    cleanup(): void;
+}
+/**
+ * Factory function để tạo file module container
+ * Nếu không truyền downloadKeyProvider, sẽ tự động tạo DownloadKeyListenerService
+ * @param downloadKeyProvider Optional custom provider
+ * @param options Optional configuration: userAddress để tự động đăng ký events, contractAddress
+ */
+declare function createFileModule(downloadKeyProvider?: DownloadKeyProvider, options?: {
+    userAddress?: string;
+    contractAddress?: string;
+}): FileModuleContainer;
+
+declare const buildMerkleTreePadded: (chunks: Uint8Array[]) => Promise<[string[], string, string[][]]>;
+/**
+ * Get Merkle proof sử dụng cached tree levels (không rebuild tree)
+ * @param levels Các levels của Merkle tree đã được build (từ buildMerkleTreePadded)
+ * @param index Index của leaf cần lấy proof
+ */
+declare const getMerkleProofPadded: (levels: string[][], index: number) => Promise<string[]>;
+declare const verifyMerkleProof: (leafHash: string, proof: string[], root: string, index: number) => Promise<boolean>;
+
+/**
+ * Generate signature for downloadKey
+ * Logic matches Go code: hash = Keccak256Hash("0x00" + downloadKey bytes)
+ */
+declare function generateSignature(downloadKey: string, privateKey: string): Promise<string>;
+
+export { ARGUMENT_INVALID, ARGUMENT_NOT_PROVIDED, ARGUMENT_OUT_OF_RANGE, type AddWhitelistRequestDTO, AddWhitelistRequestSchema, type AddWhitelistResponseDTO, AddWhitelistUseCase, type AddWhitelistUseCaseRequestDTO, type AddWhitelistUseCaseResponseDTO, type AddressDTO, AddressSchema, AggregateRoot, ArgumentInvalidException, ArgumentNotProvidedException, ArgumentOutOfRangeException, type AsyncEventBus, type BaseEntityProps, type BaseRequestDTO, BaseRequestSchema, BlockchainRepositoryBase, type BlockchainRepositoryPort, type Bytes32DTO, Bytes32Schema, CONFLICT, type CalculatePriceRequestDTO, CalculatePriceRequestSchema, type CalculatePriceResponseDTO, CalculatePriceResponseSchema, type ConfirmServerDownloadRequestDTO, ConfirmServerDownloadRequestSchema, type ConfirmServerDownloadResponseDTO, ConfirmServerDownloadResponseSchema, ConflictException, type CreateEntityProps, DEFAULT_PREFIX_ID_LENGTH, DecodeAbiService, type DecodedAbiResult, DomainEvent, type DomainPrimitive, type DownloadChunkPayload, type DownloadChunkRequest, type DownloadFileRequestDTO, DownloadFileRequestSchema, type DownloadFileResponseDTO, DownloadFileResponseSchema, DownloadFileUseCase, DownloadKeyListenerService, type DownloadKeyProvider, type DownloadResponse, ENTITY_ID_LENGTH, type EmitDomainEvents, Entity, type EntityId, type EventLogData, type EventMap, ExceptionBase, FileActivatedListenerService, type FileActivatedProvider, FileBlockchainRepository, type FileBlockchainRepositoryPort, FileModuleContainer, type GetFileInfoRequestDTO, GetFileInfoRequestSchema, type GetFileInfoResponseDTO, GetFileInfoResponseSchema, GetRustServerAddressesAbi, type GetRustServerAddressesRequestDTO, GetRustServerAddressesRequestSchema, type GetRustServerAddressesResponseDTO, GetRustServerAddressesResponseSchema, type GetWhitelistRequestDTO, GetWhitelistRequestSchema, type GetWhitelistResponseDTO, GetWhitelistUseCase, type GetWhitelistUseCaseRequestDTO, type GetWhitelistUseCaseResponseDTO, type IDecodeAbiRepository, type IDomainEvent, type IEventLogRepository, type IFileRepository, INTERNAL_SERVER_ERROR, InternalServerErrorException, type IsPublicFileRequestDTO, IsPublicFileRequestSchema, type IsPublicFileResponseDTO, IsPublicFileUseCase, type IsPublicFileUseCaseRequestDTO, type IsPublicFileUseCaseResponseDTO, type LogLevel, Logger, type LoggerPort, type Mapper, NOT_FOUND, NativeQuicError, type NormalizedException, NotFoundException, type PayForDownloadRequestDTO, PayForDownloadRequestSchema, type PayForDownloadResponseDTO, PayForDownloadResponseSchema, type Primitives, type PublicKeyDTO, PublicKeySchema, type PushFileInfoRequestDTO, PushFileInfoRequestSchema, type PushFileInfoResponseDTO, PushFileInfoResponseSchema, type RepositoryPorts, type SetPublicStatusRequestDTO, SetPublicStatusRequestSchema, type SetPublicStatusResponseDTO, SetPublicStatusUseCase, type SetPublicStatusUseCaseRequestDTO, type SetPublicStatusUseCaseResponseDTO, type StringEnum, type TimestampDTO, TimestampSchema, UniqueEntityID, type UploadChunkRequestDTO, UploadChunkRequestSchema, type UploadChunkResponseDTO, type UploadFileRequestDTO, UploadFileRequestSchema, type UploadFileResponseDTO, UploadFileResponseSchema, UploadFileUseCase, type UseCase, ValueObject, addWhitelistAbi, appConfig, buildMerkleTreePadded, calculatePriceAbi, confirmServerDownloadAbi, convertPropsToObject, createFileModule, createMittAsync, decodeAbiService, delay, downloadAllChunks, downloadAndMergeFile, emitter, eventLogs, fileBlockchainRepository, formatSize, fulfilledPromises, generateId, generatePrefixId, generateRandomHex, generateSignature, getFileInfoAbi, getMerkleProofPadded, getWhitelistAbi, humanFileSize, invariant, isAndroid, isArray, isBoolean, isBrowser, isCrawler, isDate, isDef, isEmpties, isEmpty, isFalsy, isFunction, isMap, isMobile, isNotEmpties, isNotEmpty, isNotNull, isNumber, isObject, isPngImage, isPrimitive, isPromise, isPublicFileAbi, isSet, isStream, isString, isSymbol, isUndef, isValidAddress, isValidPublicKey, isWindow, logger, payForDownloadAbi, pushFileInfoAbi, requestChunk, setPublicStatusAbi, uploadChunkAbi, verifyMerkleProof };