hackpro-sdk/build/source-destination/source-destination.d.ts

Etcher SDK

/// <reference types="node" />
import { EventEmitter } from "events";
import { ReadResult, WriteResult } from "file-disk";
import { GetPartitionsResult } from "partitioninfo";
import { Stream as HashStream } from "xxhash";
import { BlocksWithChecksum, SparseReadable } from "../sparse-stream/shared";
import { SparseWritable } from "../sparse-stream/sparse-write-stream";
import { Metadata } from "./metadata";
import { ProgressEvent } from "./progress";
import { SourceSource } from "./source-source";
export declare class CountingHashStream extends HashStream {
    bytesWritten: number;
    _transform(chunk: Buffer, encoding: string, callback: () => void): void;
}
export declare const ProgressHashStream: {
    new (...args: any[]): {
        _attributeValue: number;
        _attributeDelta: number;
        addListener(event: string | symbol, listener: Function): any;
        on(event: string | symbol, listener: Function): any;
        once(event: string | symbol, listener: Function): any;
        prependListener(event: string | symbol, listener: Function): any;
        prependOnceListener(event: string | symbol, listener: Function): any;
        removeListener(event: string | symbol, listener: Function): any;
        removeAllListeners(event?: string | symbol | undefined): any;
        setMaxListeners(n: number): any;
        getMaxListeners(): number;
        listeners(event: string | symbol): Function[];
        emit(event: string | symbol, ...args: any[]): boolean;
        eventNames(): (string | symbol)[];
        listenerCount(type: string | symbol): number;
    };
} & typeof CountingHashStream;
export declare function createHasher(): {
    _attributeValue: number;
    _attributeDelta: number;
    addListener(event: string | symbol, listener: Function): any;
    on(event: string | symbol, listener: Function): any;
    once(event: string | symbol, listener: Function): any;
    prependListener(event: string | symbol, listener: Function): any;
    prependOnceListener(event: string | symbol, listener: Function): any;
    removeListener(event: string | symbol, listener: Function): any;
    removeAllListeners(event?: string | symbol | undefined): any;
    setMaxListeners(n: number): any;
    getMaxListeners(): number;
    listeners(event: string | symbol): Function[];
    emit(event: string | symbol, ...args: any[]): boolean;
    eventNames(): (string | symbol)[];
    listenerCount(type: string | symbol): number;
} & CountingHashStream;
export declare class SourceDestinationFs {
    private source;
    constructor(source: SourceDestination);
    open(_path: string, _options: any, callback: (error: Error | null, fd?: number) => void): void;
    close(_fd: number, callback: (error: Error | null) => void): void;
    fstat(_fd: number, callback: (error: Error | null, stats?: {
        size: number;
    }) => void): void;
    read(_fd: number, buffer: Buffer, bufferOffset: number, length: number, sourceOffset: number, callback: (error: Error | null, bytesRead?: number, buffer?: Buffer) => void): void;
}
export declare abstract class Verifier extends EventEmitter {
    progress: ProgressEvent;
    abstract run(): Promise<void>;
    protected handleEventsAndPipe(stream: NodeJS.ReadableStream, meter: NodeJS.WritableStream): void;
}
export declare class StreamVerifier extends Verifier {
    private source;
    private checksum;
    private size;
    constructor(source: SourceDestination, checksum: string, size: number);
    run(): Promise<void>;
}
export declare class SparseStreamVerifier extends Verifier {
    private source;
    private blocks;
    constructor(source: SourceDestination, blocks: BlocksWithChecksum[]);
    run(): Promise<void>;
}
export declare class SourceDestination extends EventEmitter {
    static readonly imageExtensions: string[];
    static readonly mimetype?: string;
    private static mimetypes;
    private metadata;
    private isOpen;
    static register(Cls: typeof SourceSource): void;
    canRead(): Promise<boolean>;
    canWrite(): Promise<boolean>;
    canCreateReadStream(): Promise<boolean>;
    canCreateSparseReadStream(): Promise<boolean>;
    canCreateWriteStream(): Promise<boolean>;
    canCreateSparseWriteStream(): Promise<boolean>;
    getMetadata(): Promise<Metadata>;
    protected _getMetadata(): Promise<Metadata>;
    read(_buffer: Buffer, _bufferOffset: number, _length: number, _sourceOffset: number): Promise<ReadResult>;
    write(_buffer: Buffer, _bufferOffset: number, _length: number, _fileOffset: number): Promise<WriteResult>;
    createReadStream(_emitProgress?: boolean, _start?: number, _end?: number): Promise<NodeJS.ReadableStream>;
    createSparseReadStream(_generateChecksums?: boolean): Promise<SparseReadable>;
    getBlocks(): Promise<BlocksWithChecksum[]>;
    createWriteStream(): Promise<NodeJS.WritableStream>;
    createSparseWriteStream(): Promise<SparseWritable>;
    open(): Promise<void>;
    close(): Promise<void>;
    protected _open(): Promise<void>;
    protected _close(): Promise<void>;
    createVerifier(checksumOrBlocks: string | BlocksWithChecksum[], size?: number): Verifier;
    private getMimeTypeFromName;
    private getMimeTypeFromContent;
    private getInnerSourceHelper;
    getInnerSource(): Promise<SourceDestination>;
    getPartitionTable(): Promise<GetPartitionsResult | undefined>;
}