import { Context, LogAbstract, FSM } from '@dra2020/baseclient';
import * as Storage from '../storage/all';
import { LogBlob } from './logblob';
import { LogKey } from './logkey';
export interface Environment {
    context: Context.IContext;
    log: LogAbstract.ILog;
    fsmManager: FSM.FsmManager;
    storageManager: Storage.StorageManager;
}
export interface AccumOptions {
    onlyAggregateClosed?: boolean;
    dontAggregate?: boolean;
    dateFilter?: string;
}
export declare class LogItem {
    id: string;
    key?: LogKey;
    present?: boolean;
    parent?: LogItem;
    children?: {
        [id: string]: LogItem;
    };
    accum?: ILogAccumulator;
    blob?: LogBlob;
    constructor(id: string);
    query(filter: (item: LogItem) => boolean): LogItem[];
    addListing(ls: string[]): void;
    addChild(id: string, child: LogItem): void;
    add(item: LogItem): void;
}
export interface IValueAccumulator {
    count: number;
    total: number;
    min?: number;
    max?: number;
}
export declare class ValueAccumulator {
    constructor();
    static create(): IValueAccumulator;
    static avg(va: IValueAccumulator): number;
    static incr(va: IValueAccumulator): void;
    static accum(va: IValueAccumulator, v: number): void;
    static reduce(va: IValueAccumulator, reduction: IValueAccumulator): void;
    static log(va: IValueAccumulator): string;
}
export type IValueAccumulatorIndex = {
    [key: string]: IValueAccumulator;
};
export type IValueAccumulatorIndexIndex = {
    [key: string]: {
        [key: string]: IValueAccumulator;
    };
};
export type IEventAccumulator = IValueAccumulatorIndex;
export declare class EventAccumulator {
    constructor();
    static create(): IEventAccumulator;
    static getAccumulator(ea: IEventAccumulator, o: any, prop: string | string[]): IValueAccumulator;
    static NUnique(ea: IEventAccumulator): number;
    static incr(ea: IEventAccumulator, o: any, prop: string | string[]): void;
    static accum(ea: IEventAccumulator, o: any, name: string, value: string): void;
    static reduce(ea: IEventAccumulator, event: string, reduction: IValueAccumulator): void;
}
export type IEventAccumulatorIndex = {
    [key: string]: IEventAccumulator;
};
export type IDayAccumulator = IEventAccumulatorIndex;
export declare class DayAccumulator {
    constructor();
    static create(): IDayAccumulator;
    static count(da: IDayAccumulator): number;
    static getAccumulator(da: IDayAccumulator, date: string): IEventAccumulator;
    static incr(da: IDayAccumulator, date: string, o: any, prop: string | string[]): void;
    static accum(da: IDayAccumulator, date: string, o: any, name: string, value: string): void;
    static reduce(da: IDayAccumulator, event: string, reduction: IValueAccumulator): void;
    static reduceByDateKeys(da: IDayAccumulator, dateKeys: IKeyIndex, event: string, reduction: IValueAccumulator): void;
    static reduceByDate(da: IDayAccumulator, date: string, event: string, dayReduction: IValueAccumulator): void;
    static reduceUniqueByDate(da: IDayAccumulator, date: string, days: IValueAccumulatorIndexIndex): void;
}
export type IDayAccumulatorIndex = {
    [key: string]: IDayAccumulator;
};
export type IKeyIndex = {
    [key: string]: boolean;
};
export interface IInstanceAccumulator {
    dateKeys: IKeyIndex;
    uniqueKeys: IKeyIndex;
    instances: IDayAccumulatorIndex;
}
export declare class InstanceAccumulator {
    constructor();
    static create(): IInstanceAccumulator;
    static getToday(ia: IInstanceAccumulator): string;
    static getAccumulator(ia: IInstanceAccumulator, instance: string): IDayAccumulator;
    static incr(ia: IInstanceAccumulator, instance: string, date: string, o: any, prop: string | string[]): void;
    static accum(ia: IInstanceAccumulator, instance: string, date: string, o: any, name: string, value: string): void;
    static NInstances(ia: IInstanceAccumulator): number;
    static NDays(ia: IInstanceAccumulator): number;
    static NUniques(ia: IInstanceAccumulator): number;
    static NUniquesByDay(ia: IInstanceAccumulator, dateKeys?: IKeyIndex): IValueAccumulatorIndex;
    static AllCountsByDay(ia: IInstanceAccumulator, dateKeys?: IKeyIndex, eventKeys?: IKeyIndex): IValueAccumulatorIndexIndex;
    static TotalCountsByDay(ia: IInstanceAccumulator, dateKeys?: IKeyIndex, eventKeys?: IKeyIndex): IValueAccumulatorIndex;
    static ValuesByEvent(ia: IInstanceAccumulator, dateKeys?: IKeyIndex, eventKeys?: IKeyIndex): IValueAccumulatorIndex;
    static ValuesByDay(ia: IInstanceAccumulator, dateKeys?: IKeyIndex, eventKeys?: IKeyIndex): IValueAccumulatorIndexIndex;
    static filterNoisyProperty(p: string): boolean;
    static getCountRows(ia: IInstanceAccumulator, dateKeys?: IKeyIndex, eventKeys?: IKeyIndex): any[];
    static getValueRows(ia: IInstanceAccumulator, dateKeys?: IKeyIndex, eventKeys?: IKeyIndex): any[];
}
export interface ILogAccumulator {
    users: IInstanceAccumulator;
    sessions: IInstanceAccumulator;
    events: IInstanceAccumulator;
    errors: IInstanceAccumulator;
    values: IInstanceAccumulator;
    syncTimers: IInstanceAccumulator;
    asyncTimers: IInstanceAccumulator;
    logsSeen: {
        [id: string]: boolean;
    };
}
export declare class LogAccumulator {
    static create(): ILogAccumulator;
    static accumulate(la: ILogAccumulator, instance: string, dateKey: string, o: any): void;
    static unquoteFields(fields: string[]): string[];
    static gather(la: ILogAccumulator, logid: string, instance: string, dateKey: string, csvblob: string): void;
    static aggregate(agg: ILogAccumulator, la: ILogAccumulator): void;
    static datePatternToKeys(la: ILogAccumulator, pat: string): IKeyIndex;
    static getToday(la: ILogAccumulator): IKeyIndex;
    static getTodayRows(la: ILogAccumulator): any[];
    static getDailyRows(la: ILogAccumulator, datePattern?: string, eventKeys?: IKeyIndex): any[];
    static getLastDay(la: ILogAccumulator): any[];
    static getTimerRows(la: ILogAccumulator, datePattern?: string, eventKeys?: IKeyIndex): any[];
    static getErrorRows(la: ILogAccumulator, datePattern?: string, eventKeys?: IKeyIndex): any[];
    static getEventRows(la: ILogAccumulator, datePattern?: string, eventKeys?: IKeyIndex): any[];
    static getValueRows(la: ILogAccumulator, datePattern?: string, eventKeys?: IKeyIndex): any[];
}
export declare class FsmLogAccum extends FSM.Fsm {
    options: AccumOptions;
    root: LogItem;
    blobLs: LogBlob;
    lastErrorsRows: any[];
    firstScanDone: boolean;
    constructor(env: Environment, accum?: ILogAccumulator, options?: AccumOptions);
    get env(): Environment;
    resetLastErrors(): void;
    getIncrementalErrors(): any[];
    refresh(): void;
    getCategories(): string[];
    getSummaryRows(): any[];
    getRows(category: string, datePattern?: string, eventKeys?: IKeyIndex): any[];
    tick(): void;
}