type MeasureType = 'sum' | 'count' | 'min' | 'max' | 'average' | 'first' | 'last' | 'distinct' | 'variance' | 'stddev';
interface MeasureDefinition {
    type: MeasureType;
    key: string;
    name: string;
}
interface DimensionDefinition {
    type: 'string' | 'number' | 'date';
    key: string;
}
interface QubeOptions {
    measures: MeasureDefinition[];
    dimensions: DimensionDefinition[];
}
interface QueryOptions {
    measure: string;
    dimensions?: {
        [key: string]: any;
    };
}
interface FilterOptions {
    dimensions?: {
        [key: string]: any | any[];
    };
    predicate?: (dimensions: {
        [key: string]: any;
    }, measures: {
        [key: string]: any;
    }) => boolean;
}
interface RollupResult {
    dimensions: {
        [key: string]: any;
    };
    value: number | undefined;
}
interface InMemoryQubeData {
    [key: string]: InMemoryQubeData | any;
}
interface SerializedQube {
    options: QubeOptions;
    dimensionIndices: string[];
    cube: InMemoryQubeData;
    rowCount: number;
}
interface QubeRow {
    [key: string]: any;
}
interface DimensionInfo {
    key: string;
    type: string;
    cardinality: number;
    values: any[];
}

declare class Qube {
    private options;
    private readonly dimensionKeys;
    private readonly numDimensions;
    private readonly compiledMeasures;
    private data;
    private _rowCount;
    constructor(options: QubeOptions);
    get rowCount(): number;
    get dimensionCount(): number;
    get dimensionIndices(): string[];
    push(rows: QubeRow[]): void;
    query(opts: QueryOptions): number | undefined;
    private aggregateAll;
    private traverseQuery;
    private finalizeMeasure;
    queryWithEnumeration(dimensionToEnumerate: string, opts: QueryOptions): any[];
    enumerateDimension(dimensionName: string): any[];
    slice(opts: QueryOptions): number | undefined;
    dice(opts: QueryOptions): number | undefined;
    one(opts: QueryOptions): number | undefined;
    rollup(dimensionToRollup: string, opts: QueryOptions): RollupResult[];
    drilldown(dimensionToDrill: string, opts: QueryOptions): RollupResult[];
    filter(opts: FilterOptions): QubeRow[];
    private traverseFilter;
    clear(): void;
    getDimensionInfo(dimensionName?: string): DimensionInfo | DimensionInfo[];
    getMeasureInfo(): {
        name: string;
        key: string;
        type: MeasureType;
    }[];
    serializeCube(): SerializedQube;
    /**
     * Serialize and compress the cube using gzip.
     * Returns a Buffer that can be written to disk or sent over network.
     */
    serializeCompressed(): Promise<Buffer>;
    /**
     * Synchronous version of serializeCompressed.
     */
    serializeCompressedSync(): Buffer;
    /**
     * Restore a cube from compressed data.
     */
    static fromCompressed(data: Buffer): Promise<Qube>;
    /**
     * Synchronous version of fromCompressed.
     */
    static fromCompressedSync(data: Buffer): Qube;
    private makeSerializable;
    static fromCube(sQube: SerializedQube): Qube;
    private static deserializeCube;
}

export { Qube };