polyfact/utils.d.ts

<h1 align="center">PolyFact</h1>

/// <reference types="node" />
import { Mutex } from "async-mutex";
import { Buffer } from "buffer";
export declare const POLYFACT_TOKEN: string | undefined;
export declare const POLYFACT_ENDPOINT: string | undefined;
type UnresolvedResult = {
    status: "pending";
};
type ResolvedResult<T> = {
    value: T;
    status: "resolved";
};
type ErrorResult = {
    error: Error;
    status: "rejected";
};
type Result<T> = UnresolvedResult | ResolvedResult<T> | ErrorResult;
export declare class MutablePromise<T> implements PromiseLike<T> {
    result: Result<T>;
    promiseResult: Promise<ResolvedResult<T> | ErrorResult>;
    resolver: (v: ResolvedResult<T> | ErrorResult) => void;
    mutex: Mutex;
    constructor();
    set(value: T): void;
    throw(error: Error): void;
    deresolve(): Promise<void>;
    then<R1 = never, R2 = never>(res?: null | ((c: T) => R1 | Promise<R1>), rej?: null | ((e: Error) => R2 | Promise<R2>)): Promise<R1 | R2>;
}
export type OnFn<R> = ((t: "data", listener: (chunk: Buffer) => void) => R) & ((t: "error", listener: (err: Error) => void) => R) & ((t: string, listener: (...args: unknown[]) => void) => R);
export interface MinimalStream {
    on: OnFn<this>;
}
export interface FetchReadableStream {
    getReader(): {
        read(): Promise<{
            done: boolean;
            value?: Uint8Array | undefined;
        }>;
    };
}
export type FileInput = MinimalStream | Buffer | FetchReadableStream;
export declare function fileInputToBuffer(input: FileInput): Promise<Buffer>;
export {};