@dra2020/baseclient 1.0.11 → 1.0.14

package/dist/dbabstract/all.d.ts

@@ -0,0 +1 @@
+export * from './db';

package/dist/dbabstract/db.d.ts

@@ -0,0 +1,83 @@
+import * as LogAbstract from '../logabstract/all';
+import * as Context from '../context/all';
+import * as Storage from '../storage/all';
+import * as FSM from '../fsm/all';
+export declare const FSM_CREATING: number;
+export declare const FSM_NEEDRELEASE: number;
+export declare const FSM_RELEASING: number;
+export declare const FSM_READING: number;
+export interface DBEnvironment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+}
+export declare function fromCompactSchema(c: any): any;
+export declare function fromCompactKey(c: any): any;
+export declare function fromCompactIndex(c: any): any;
+export declare function toCompactSchema(s: any): any;
+export declare class DBClient extends FSM.Fsm {
+    constructor(env: DBEnvironment);
+    get env(): DBEnvironment;
+    createCollection(name: string, options: any): DBCollection;
+    createStream(col: DBCollection): FSM.FsmArray;
+    closeStream(col: DBCollection): void;
+    createUpdate(col: DBCollection, query: any, values: any): DBUpdate;
+    createUnset(col: DBCollection, query: any, values: any): DBUnset;
+    createDelete(col: DBCollection, query: any): DBDelete;
+    createFind(col: DBCollection, filter: any): DBFind;
+    createQuery(col: DBCollection, filter: any): DBQuery;
+    createIndex(col: DBCollection, uid: string): DBIndex;
+    createClose(): DBClose;
+    close(): void;
+}
+export declare class DBCollection extends FSM.Fsm {
+    name: string;
+    options: any;
+    col: any;
+    client: DBClient;
+    constructor(env: DBEnvironment, client: DBClient, name: string, options: any);
+}
+export declare class DBUpdate extends FSM.Fsm {
+    col: DBCollection;
+    query: any;
+    values: any;
+    result: any;
+    constructor(env: DBEnvironment, col: DBCollection, query: any, values: any);
+}
+export declare class DBUnset extends FSM.Fsm {
+    col: DBCollection;
+    query: any;
+    values: any;
+    result: any;
+    constructor(env: DBEnvironment, col: DBCollection, query: any, values: any);
+}
+export declare class DBDelete extends FSM.Fsm {
+    col: DBCollection;
+    query: any;
+    result: any;
+    constructor(env: DBEnvironment, col: DBCollection, query: any);
+}
+export declare class DBFind extends FSM.Fsm {
+    col: DBCollection;
+    filter: any;
+    result: any;
+    constructor(env: DBEnvironment, col: DBCollection, filter: any);
+}
+export declare class DBQuery extends FSM.Fsm {
+    col: DBCollection;
+    filter: any;
+    fsmResult: FSM.FsmArray;
+    constructor(env: DBEnvironment, col: DBCollection, filter: any);
+    get result(): any[];
+}
+export declare class DBIndex extends FSM.Fsm {
+    col: DBCollection;
+    uid: string;
+    constructor(env: DBEnvironment, col: DBCollection, uid: string);
+}
+export declare class DBClose extends FSM.Fsm {
+    client: DBClient;
+    constructor(env: DBEnvironment, client: DBClient);
+    tick(): void;
+}

package/dist/dbdynamo/all.d.ts

@@ -0,0 +1 @@
+export * from './dbdynamo';

package/dist/dbdynamo/dbdynamo.d.ts

@@ -0,0 +1,190 @@
+import * as DynamoDB from 'aws-sdk/clients/dynamodb';
+import * as DynamoDBStreams from 'aws-sdk/clients/dynamodbstreams';
+import * as Util from '../util/all';
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+import * as DB from '../dbabstract/all';
+import * as Storage from '../storage/all';
+export interface Environment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+}
+export interface EnvironmentEx {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+    dbx: DynamoClient;
+}
+declare class Deadline {
+    elapsed: Util.Elapsed;
+    msDeadline: number;
+    constructor(msDeadline: number);
+    start(): void;
+    get msRemaining(): number;
+    get passed(): boolean;
+}
+declare class FsmAPIWatch extends FSM.Fsm {
+    constructor(env: Environment);
+    get env(): Environment;
+    tick(): void;
+}
+declare class FsmListTables extends FSM.Fsm {
+    tables: any;
+    workStack: string[];
+    constructor(env: Environment);
+    get env(): EnvironmentEx;
+    tick(): void;
+}
+export declare function create(env: Environment): DB.DBClient;
+export declare class DynamoClient extends DB.DBClient {
+    serializerUpdate: FSM.FsmSerializer;
+    fsmAPIWatch: FsmAPIWatch;
+    fsmListTables: FsmListTables;
+    dynamodb: DynamoDB;
+    dynamostream: DynamoDBStreams;
+    pendingCols: DynamoCollection[];
+    existingCols: {
+        [name: string]: DynamoCollection;
+    };
+    bList: boolean;
+    constructor(env: Environment);
+    get env(): EnvironmentEx;
+    get Production(): boolean;
+    get DBName(): string;
+    get dynamoErrorFrequency(): number;
+    createCollection(name: string, options: any): DB.DBCollection;
+    createStream(col: DynamoCollection): FSM.FsmArray;
+    closeStream(col: DynamoCollection): void;
+    ensureCollection(col: DynamoCollection): void;
+    createUpdate(col: DynamoCollection, query: any, values: any): DB.DBUpdate;
+    createUnset(col: DynamoCollection, query: any, values: any): DB.DBUnset;
+    createDelete(col: DynamoCollection, query: any): DB.DBDelete;
+    createFind(col: DynamoCollection, filter: any): DB.DBFind;
+    createQuery(col: DynamoCollection, filter: any): DB.DBQuery;
+    createIndex(col: DynamoCollection, uid: string): DB.DBIndex;
+    createClose(): DB.DBClose;
+    forceError(): boolean;
+    tick(): void;
+}
+export declare class DynamoCollection extends DB.DBCollection {
+    attributeIndex: any;
+    keyIndex: any;
+    fsmStream: FsmTableStream;
+    constructor(env: Environment, client: DynamoClient, name: string, options: any);
+    get env(): Environment;
+    get dynclient(): DynamoClient;
+    get dynamodb(): DynamoDB;
+    createStream(): FSM.FsmArray;
+    closeStream(): void;
+    constructIndex(): void;
+    addConditionExpression(query: any, key: any): void;
+    toInternalQuery(query: any): any;
+    toInternalExpression(o: any): any;
+    toTestExpression(expr: any): string;
+    toUpdateExpression(expr: any): string;
+    toRemoveExpression(expr: any): string;
+    toExternal(result: any): any;
+    forceError(): boolean;
+    tick(): void;
+}
+export declare class DynamoUpdate extends DB.DBUpdate {
+    trace: LogAbstract.AsyncTimer;
+    constructor(env: Environment, col: DynamoCollection, query: any, values: any);
+    get env(): Environment;
+    get dyncol(): DynamoCollection;
+    forceError(): boolean;
+    tick(): void;
+}
+export declare class DynamoUnset extends DB.DBUnset {
+    trace: LogAbstract.AsyncTimer;
+    constructor(env: Environment, col: DynamoCollection, query: any, values: any);
+    get env(): Environment;
+    get dyncol(): DynamoCollection;
+    forceError(): boolean;
+    tick(): void;
+}
+export declare class DynamoDelete extends DB.DBDelete {
+    trace: LogAbstract.AsyncTimer;
+    constructor(env: Environment, col: DynamoCollection, query: any);
+    get env(): Environment;
+    get dyncol(): DynamoCollection;
+    forceError(): boolean;
+    tick(): void;
+}
+export declare class DynamoFind extends DB.DBFind {
+    trace: LogAbstract.AsyncTimer;
+    constructor(env: Environment, col: DynamoCollection, filter: any);
+    get env(): Environment;
+    get dyncol(): DynamoCollection;
+    forceError(): boolean;
+    tick(): void;
+}
+export declare class DynamoQuery extends DB.DBQuery {
+    trace: LogAbstract.AsyncTimer;
+    lastKey: any;
+    constructor(env: Environment, col: DynamoCollection, filter: any);
+    get env(): Environment;
+    get dyncol(): DynamoCollection;
+    forceError(): boolean;
+    doScan(): void;
+    tick(): void;
+}
+export declare class DynamoIndex extends DB.DBIndex {
+    constructor(env: Environment, col: DynamoCollection, uid: string);
+}
+export declare class DynamoClose extends DB.DBClose {
+    constructor(env: Environment, client: DynamoClient);
+}
+interface RangeDescription {
+    StartingSequenceNumber: string;
+    EndingSequenceNumber?: string;
+}
+interface ShardDescription {
+    ShardId: string;
+    SequenceNumberRange: RangeDescription;
+    ShardIterator?: string;
+    ParentShardId?: string;
+    LastSequenceNumber?: string;
+}
+export declare class FsmTableShards extends FSM.Fsm {
+    table: any;
+    stream: any;
+    lastKey: string;
+    fsmResult: FSM.FsmArray;
+    constructor(env: Environment, table: any);
+    get env(): EnvironmentEx;
+    tick(): void;
+}
+declare class FsmReadOneShard extends FSM.Fsm {
+    col: DynamoCollection;
+    stream: any;
+    shard: ShardDescription;
+    shardClosed: boolean;
+    fsmResult: FSM.FsmArray;
+    elapsed: Util.Elapsed;
+    nTries: number;
+    deadline: Deadline;
+    constructor(env: Environment, col: DynamoCollection, stream: any, shard: ShardDescription, fsmResult: FSM.FsmArray);
+    get env(): EnvironmentEx;
+    tick(): void;
+}
+export declare class FsmTableStream extends FSM.Fsm {
+    col: DynamoCollection;
+    table: any;
+    fsmShards: FsmTableShards;
+    shardsDone: any;
+    shardsLast: any;
+    shardsQueue: FsmReadOneShard[];
+    fsmResult: FSM.FsmArray;
+    deadline: Deadline;
+    constructor(env: Environment, col: DB.DBCollection);
+    get env(): Environment;
+    end(): void;
+    error(): void;
+    tick(): void;
+}
+export {};

package/dist/filterexpr/filterexpr.d.ts

@@ -58,9 +58,6 @@ export declare class FilterExpr {
     set(expr: string): void;
     test(o: any, types?: any): boolean;
     asString(): string;
-    containsClause(expr: string): boolean;
-    addClause(expr: string): void;
-    removeClause(expr: string): void;
     asStringClause(clause: Clause): string;
     testClause(o: any, types: any, clause: Clause, prop?: string, relation?: TokType): boolean;
 }

package/dist/fsm/fsm.d.ts

@@ -63,7 +63,6 @@ export declare class FsmOnDone extends Fsm {
 }
 export declare class FsmSleep extends Fsm {
     delay: number;
-    timeoutHandle: any;
     constructor(env: FsmEnvironment, delay: number);
     tick(): void;
 }

package/dist/fsmfile/all.d.ts

@@ -0,0 +1 @@
+export * from './fsmfile';

package/dist/fsmfile/fsmfile.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+export interface Environment {
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+}
+export declare class FsmUnlink extends FSM.Fsm {
+    path: string;
+    err: any;
+    constructor(env: Environment, path: string);
+    tick(): void;
+}
+export declare class FsmMkdir extends FSM.Fsm {
+    dir: string;
+    bAllowExist: boolean;
+    err: any;
+    constructor(env: Environment, dir: string, bAllowExist?: boolean);
+    tick(): void;
+}
+export declare class FsmRmdir extends FSM.Fsm {
+    dir: string;
+    err: any;
+    constructor(env: Environment, dir: string);
+    tick(): void;
+}
+export declare class FsmLs extends FSM.Fsm {
+    dir: string;
+    err: any;
+    entries: string[];
+    constructor(env: Environment, dir: string);
+    tick(): void;
+}
+export declare class FsmReadFile extends FSM.Fsm {
+    path: string;
+    result: string;
+    err: any;
+    constructor(env: Environment, path: string);
+    tick(): void;
+}
+export declare class FsmWriteFile extends FSM.Fsm {
+    path: string;
+    contents: string | Buffer;
+    err: any;
+    constructor(env: Environment, path: string, contents: string | Buffer);
+    tick(): void;
+}

package/dist/jsonstream/all.d.ts

@@ -0,0 +1 @@
+export * from './jsonstream';

package/dist/jsonstream/jsonstream.d.ts

@@ -0,0 +1,130 @@
+/// <reference types="node" />
+import * as Stream from 'stream';
+import * as Events from 'events';
+export declare class Readable extends Events.EventEmitter {
+    constructor();
+}
+export declare class Writable extends Events.EventEmitter {
+    constructor();
+    write(b: any, encoding?: BufferEncoding, cb?: () => void): boolean;
+    end(): void;
+}
+export declare class BufferWritable extends Writable {
+    _bufs: Buffer[];
+    _buf: Buffer;
+    constructor();
+    write(b: any, encoding?: BufferEncoding, cb?: () => void): boolean;
+    end(): void;
+}
+export declare class BufferReadable extends Stream.Readable {
+    _b: Buffer;
+    constructor(b: Buffer);
+    _read(): void;
+}
+export declare class MultiBufferReadable extends Stream.Readable {
+    constructor();
+    _read(): void;
+    more(buf: Buffer): void;
+    end(): void;
+}
+declare enum ReadState {
+    Start = 0,
+    ObjectPropertyStart = 1,
+    ObjectPropertyEnd = 2,
+    ValueStart = 3,
+    ValueEnd = 4,
+    InName = 5,
+    InNameBackslash = 6,
+    NeedColon = 7,
+    InNumber = 8,
+    InString = 9,
+    InStringBackslash = 10,
+    InTrue = 11,
+    InFalse = 12,
+    InNull = 13,
+    InUndefined = 14,
+    Error = 15,
+    Ended = 16
+}
+declare enum TokType {
+    TTNone = 0,
+    TTArray = 1,
+    TTObject = 2,
+    TTName = 3,
+    TTString = 4,
+    TTNumber = 5,
+    TTTrue = 6,
+    TTFalse = 7,
+    TTNull = 8,
+    TTUndefined = 9
+}
+interface Token {
+    tt: TokType;
+    v: any;
+    emit?: string;
+}
+export interface JSONStreamOptions {
+    maxTokenSize?: number;
+    outBufferSize?: number;
+    encoding?: BufferEncoding;
+    syncChunkSize?: number;
+}
+export declare class JSONStreamReader extends Events.EventEmitter {
+    _s: Readable;
+    _charCount: number;
+    _lineCount: number;
+    _state: ReadState;
+    _tok: Buffer;
+    _tokLen: number;
+    _stack: Token[];
+    _result: any;
+    _incr: any;
+    _options: JSONStreamOptions;
+    _chunks: Buffer[];
+    _chunkCur: number;
+    _chunkIndex: number;
+    _chunkScheduled: boolean;
+    _ended: boolean;
+    _closed: boolean;
+    constructor(options?: JSONStreamOptions);
+    start(s: Readable): void;
+    finish(): void;
+    emitIncremental(name: string): void;
+    pushToken(tok: Token): void;
+    private badJSON;
+    private startTok;
+    private addToTok;
+    private consumeTok;
+    private produceValue;
+    private produceValidatedValue;
+    private onData;
+    private scheduleNext;
+    private nextChunk;
+    private onClose;
+    private doClose;
+    private onError;
+    private onEnd;
+    private doEnd;
+}
+interface ObjectWriteState {
+    o: any;
+    keys: string[];
+    index: number;
+}
+export declare class JSONStreamWriter extends Events.EventEmitter {
+    _s: Writable;
+    _stack: ObjectWriteState[];
+    _chunk: Buffer;
+    _chunkLen: number;
+    _options: JSONStreamOptions;
+    _bDone: boolean;
+    constructor(options?: JSONStreamOptions);
+    start(o: any, s: Writable): void;
+    addToChunk(s: string): boolean;
+    drainChunk(): boolean;
+    onDrain(): void;
+    onError(e: Error): void;
+    onClose(): void;
+    onFinish(): void;
+}
+export {};

package/dist/lambda/all.d.ts

@@ -0,0 +1 @@
+export * from './lambda';

package/dist/lambda/env.d.ts

@@ -0,0 +1,10 @@
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+import * as Lambda from './lambda';
+export interface Environment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    lambdaManager: Lambda.Manager;
+}

package/dist/lambda/lambda.d.ts

@@ -0,0 +1,18 @@
+import * as FSM from '../fsm/all';
+import { Environment } from './env';
+import * as Lambda from 'aws-sdk/clients/lambda';
+export declare class FsmInvoke extends FSM.Fsm {
+    name: string;
+    params: any;
+    result: any;
+    constructor(env: Environment, name: string, params: any);
+    get env(): Environment;
+    tick(): void;
+}
+export declare class Manager extends FSM.Fsm {
+    awslambda: Lambda;
+    constructor(env: Environment);
+    get env(): Environment;
+    invoke(name: string, params?: any): FsmInvoke;
+}
+export declare function create(env: Environment): Manager;

package/dist/logserver/all.d.ts

@@ -0,0 +1,5 @@
+export * from './log';
+export * from './logkey';
+export * from './logblob';
+export * from './logaccum';
+export * from './logconcat';

package/dist/logserver/log.d.ts

@@ -0,0 +1,11 @@
+import * as LogAbstract from '../logabstract/all';
+import * as Context from '../context/all';
+import * as Storage from '../storage/all';
+import * as FSM from '../fsm/all';
+export interface LogEnvironment {
+    context: Context.IContext;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+    log: LogAbstract.ILog;
+}
+export declare function create(env: LogEnvironment): LogAbstract.ILog;

package/dist/logserver/logaccum.d.ts

@@ -0,0 +1,154 @@
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+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;
+}
+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 declare type IValueAccumulatorIndex = {
+    [key: string]: IValueAccumulator;
+};
+export declare type IValueAccumulatorIndexIndex = {
+    [key: string]: {
+        [key: string]: IValueAccumulator;
+    };
+};
+export declare 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 declare type IEventAccumulatorIndex = {
+    [key: string]: IEventAccumulator;
+};
+export declare 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 declare type IDayAccumulatorIndex = {
+    [key: string]: IDayAccumulator;
+};
+export declare 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;
+}