polyfact/generate.d.ts

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

/// <reference types="node" />
import { Readable } from "readable-stream";
import { UUID } from "crypto";
import { InputClientOptions } from "./clientOpts";
import { Memory } from "./memory";
import { LoaderFunction } from "./dataloader";
export type Exclusive<T, U> = (T & Partial<Record<Exclude<keyof U, keyof T>, never>>) | (U & Partial<Record<Exclude<keyof T, keyof U>, never>>);
export type ExclusiveN<T extends Record<string, unknown>[]> = T extends [infer F, ...infer Rest] ? F extends Record<string, unknown> ? Exclusive<F, ExclusiveN<Extract<Rest, Record<string, unknown>[]>>> : never : unknown;
export type AndN<T extends Record<string, unknown>[]> = T extends [infer F, ...infer Rest] ? F extends Record<string, unknown> ? Partial<F> & AndN<Extract<Rest, Record<string, unknown>[]>> : never : unknown;
export type NeverN<T extends Record<string, unknown>[]> = T extends [infer F, ...infer Rest] ? F extends Record<string, unknown> ? Partial<{
    [x in keyof F]: never;
}> & NeverN<Extract<Rest, Record<string, unknown>[]>> : never : unknown;
export type Language = "english" | "french" | "spanish" | "german" | "italian" | "portuguese" | "russian" | "mandarin" | "japanese" | "arabic" | "hindi" | "bengali" | "punjabi" | "javanese" | "swahili" | "korean" | "turkish" | "vietnamese" | "telugu" | "marathi" | "";
export type GenerationSimpleOptions = {
    provider?: "openai" | "cohere" | "llama" | "" | undefined;
    model?: string;
    stop?: string[];
    temperature?: number;
    language?: Language;
};
export type ChatOptions = [{
    chatId: string;
}];
export type MemoryOptions = [
    {
        memoryId: string;
    },
    {
        memory: Memory;
    },
    {
        data: [LoaderFunction] | LoaderFunction;
    }
];
export type SystemPromptOptions = [{
    systemPromptId: UUID;
}, {
    systemPrompt: string;
}];
export type GenerationWithWebOptions = GenerationSimpleOptions & NeverN<ChatOptions> & NeverN<MemoryOptions> & NeverN<SystemPromptOptions> & {
    web: true;
};
export type GenerationWithoutWebOptions = GenerationSimpleOptions & ExclusiveN<ChatOptions> & ExclusiveN<MemoryOptions> & ExclusiveN<SystemPromptOptions>;
export type GenerationOptions = GenerationWithWebOptions | (GenerationWithoutWebOptions & {
    web?: false;
});
export type GenerationCompleteOptions = GenerationSimpleOptions & AndN<ChatOptions> & AndN<MemoryOptions> & AndN<SystemPromptOptions> & {
    web?: boolean;
};
export type TokenUsage = {
    input: number;
    output: number;
};
export type Ressource = {
    similarity: number;
    id: string;
    content: string;
};
export type GenerationResult = {
    result: string;
    tokenUsage: {
        input: number;
        output: number;
    };
    ressources?: Ressource[];
};
export declare class Generation extends Readable implements Promise<string> {
    [Symbol.toStringTag]: string;
    stop: () => void;
    clientOptions: InputClientOptions;
    constructor({ stop, clientOptions }: {
        stop?: () => void;
        clientOptions: InputClientOptions;
    });
    pipeInto(stream: Generation): Generation;
    stopWrap(): void;
    then<TResult1 = string, TResult2 = never>(onfulfilled?: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: unknown) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: (reason: unknown) => TResult | PromiseLike<TResult>): Promise<string | TResult>;
    finally(onfinally?: () => void): Promise<string>;
    infos(): Promise<GenerationResult>;
    generate(task: string, options?: GenerationOptions): Generation;
}
export declare function generate(task: string, options?: GenerationOptions, clientOptions?: InputClientOptions): Generation;
export type GenerationClient = {
    generate: (task: string, options?: GenerationOptions) => Generation;
};
export default function client(clientOptions?: InputClientOptions): GenerationClient;