rotating-file-stream/dist/types/index.d.ts

Opens a stream.Writable to a file rotated by interval and/or size. A logrotate alternative.

import { Readable, Writable } from "stream";
export declare class RotatingFileStreamError extends Error {
    code: string;
    constructor();
}
export type Compressor = (source: string, dest: string) => string;
export type Generator = (time: number | Date, index?: number) => string;
interface RotatingFileStreamEvents {
    close: () => void;
    drain: () => void;
    error: (err: Error) => void;
    finish: () => void;
    pipe: (src: Readable) => void;
    unpipe: (src: Readable) => void;
    external: (stdout: string, stderr: string) => void;
    history: () => void;
    open: (filename: string) => void;
    removed: (filename: string, number: boolean) => void;
    rotation: () => void;
    rotated: (filename: string) => void;
    warning: (error: Error) => void;
}
export declare interface RotatingFileStream extends Writable {
    addListener<Event extends keyof RotatingFileStreamEvents>(event: Event, listener: RotatingFileStreamEvents[Event]): this;
    emit<Event extends keyof RotatingFileStreamEvents>(event: Event, ...args: Parameters<RotatingFileStreamEvents[Event]>): boolean;
    on<Event extends keyof RotatingFileStreamEvents>(event: Event, listener: RotatingFileStreamEvents[Event]): this;
    once<Event extends keyof RotatingFileStreamEvents>(event: Event, listener: RotatingFileStreamEvents[Event]): this;
    prependListener<Event extends keyof RotatingFileStreamEvents>(event: Event, listener: RotatingFileStreamEvents[Event]): this;
    prependOnceListener<Event extends keyof RotatingFileStreamEvents>(event: Event, listener: RotatingFileStreamEvents[Event]): this;
    removeListener<Event extends keyof RotatingFileStreamEvents>(event: Event, listener: RotatingFileStreamEvents[Event]): this;
}
export type IntervalUnit = "M" | "d" | "h" | "m" | "s";
type HourInterval = 1 | 2 | 3 | 4 | 6 | 8 | 12 | 24;
type MinuteInterval = 1 | 2 | 3 | 4 | 5 | 6 | 10 | 12 | 15 | 20 | 30 | 60;
export type Interval = `${number}${"M" | "d"}` | `${HourInterval}h` | `${MinuteInterval}${"m" | "s"}`;
export type FileSizeUnit = "B" | "K" | "M" | "G";
export type FileSize = `${number}${FileSizeUnit}`;
type IntervalOpt<I extends string = string> = string extends I ? string : I extends Interval ? I : never;
type FileSizeOpt<S extends string = string> = string extends S ? string : S extends FileSize ? S : never;
export interface Options<I extends string = string, MS extends string = string, RS extends string = string> {
    compress?: boolean | "gzip" | Compressor;
    encoding?: BufferEncoding;
    history?: string;
    immutable?: boolean;
    initialRotation?: boolean;
    interval?: IntervalOpt<I>;
    intervalBoundary?: boolean;
    intervalUTC?: boolean;
    maxFiles?: number;
    maxSize?: FileSizeOpt<MS>;
    mode?: number;
    omitExtension?: boolean;
    path?: string;
    rotate?: number;
    size?: FileSizeOpt<RS>;
    teeToStdout?: boolean;
}
interface Opts {
    compress?: boolean | "gzip" | Compressor;
    encoding?: BufferEncoding;
    history?: string;
    immutable?: boolean;
    initialRotation?: boolean;
    interval?: {
        num: number;
        unit: IntervalUnit;
    };
    intervalBoundary?: boolean;
    intervalUTC?: boolean;
    maxFiles?: number;
    maxSize?: number;
    mode?: number;
    omitExtension?: boolean;
    path?: string;
    rotate?: number;
    size?: number;
    teeToStdout?: boolean;
}
type Callback = (error?: Error) => void;
interface Chunk {
    chunk: Buffer;
    encoding: BufferEncoding;
}
export declare class RotatingFileStream extends Writable {
    private createGzip;
    private exec;
    private file;
    private filename;
    private finished;
    private fsCreateReadStream;
    private fsCreateWriteStream;
    private fsOpen;
    private fsReadFile;
    private fsStat;
    private fsUnlink;
    private generator;
    private initPromise;
    private last;
    private maxTimeout;
    private next;
    private options;
    private prev;
    private rotation;
    private size;
    private stdout;
    private timeout;
    private timeoutPromise;
    constructor(generator: Generator, options: Opts);
    _destroy(error: Error, callback: Callback): void;
    _final(callback: Callback): void;
    _write(chunk: Buffer, encoding: BufferEncoding, callback: Callback): void;
    _writev(chunks: Chunk[], callback: Callback): void;
    private refinal;
    private rewrite;
    private init;
    private makePath;
    private reopen;
    private reclose;
    private now;
    private rotate;
    private findName;
    private move;
    private touch;
    private classical;
    private clear;
    private intervalBoundsBig;
    private intervalBounds;
    private interval;
    private compress;
    private gzip;
    private rotated;
    private history;
    private immutate;
    private unlink;
}
export declare function createStream<I extends string = string, MS extends string = string, RS extends string = string>(filename: string | Generator, options?: Options<I, MS, RS>): RotatingFileStream;
export {};