/// <reference types="node" />
import 'reflect-metadata';
import { AESKey } from './encryption-service';
import { EthereumService } from './ethereum-service';
import { BackendService } from './backend-service';
import { FileStoreInterface, FileMetadata } from './file-store-service';
export declare class KeyPacket {
    readonly aesKey: AESKey;
    readonly filesAddresses: Array<string>;
    constructor(aesKey: AESKey, filesAddresses: Array<string>);
    static fromJson(json: string): KeyPacket;
}
export declare class TrackingData {
    readonly cmw: number;
    readonly rawAmount: number;
    readonly grade: number;
    readonly mineLatitude: number;
    readonly mineLongitude: number;
    readonly materialId: string;
    constructor(cmw: number, rawAmount: number, grade: number, mineLatitude: number, mineLongitude: number, materialId: string);
}
interface AESKeyInterface {
    iv: {
        type: string;
        data: Array<Number>;
    };
    key: {
        type: string;
        data: Array<Number>;
    };
}
interface DataPacketEnvelopeInterface {
    packetId: string;
    publicFilesKey: AESKeyInterface;
    privateFilesKey: AESKeyInterface;
}
export declare class Packet {
    readonly id: string;
    readonly cmw: number;
    readonly materialId: string;
    readonly publicFilesAddresses: Array<string>;
    readonly privateFilesAddresses: Array<string>;
    readonly status: string;
    constructor(id: string, cmw: number, materialId: string, publicFilesAddresses: Array<string>, privateFilesAddresses: Array<string>, status: string);
}
export declare class DataPacketEnvelope {
    readonly packetId: string;
    readonly publicFilesKey: AESKey;
    readonly privateFilesKey: AESKey;
    constructor(packetId: string, publicFilesKey: AESKey, privateFilesKey: AESKey);
    toJson(): string;
    static fromJson(rawDataPacketEnvelope: DataPacketEnvelopeInterface): DataPacketEnvelope;
}
export declare class DataPacketService {
    private fileStore;
    private ethereumService;
    private backendService;
    constructor(fileStore: FileStoreInterface, ethereumService: EthereumService, backendService: BackendService);
    certifyDataPacket(trackingData: TrackingData, publicFiles: FileList | File[], privateFiles: FileList | File[]): Promise<string>;
    sellDataPacket(dataPacketEnvelope: DataPacketEnvelope, cmw: number, newOwnerAddress: string, publicFiles: FileList, privateFiles: FileList, currentOwnerPrivateKey: Buffer): Promise<string>;
    createEncryptedPacketEnvelope(packetEnvelope: DataPacketEnvelope, publicKey: Buffer): Promise<string>;
    downloadDataPacketEnvelope(dataPacketEnvelopeAddress: string, privateKey: Buffer): Promise<DataPacketEnvelope>;
    getPacket(packetId: string): Promise<Packet>;
    getMyDataPackets(): Promise<Packet[]>;
    getDataPackets(owner: string): Promise<Packet[]>;
    uploadFiles(files: FileList | File[], aesKey?: AESKey): Promise<KeyPacket>;
    downloadMetadataFiles(keyPacket: KeyPacket): Promise<Map<string, FileMetadata>>;
    downloadFile(key: AESKey, address: string): Promise<File>;
    downloadFiles(keyPacket: KeyPacket): Promise<File[]>;
    private fileToBuffer;
    decryptKeyPacket(encryptedKeyPacket: Buffer, aesKey: AESKey): Promise<File>;
}
export {};