import AbstractDimension from './dimension/abstract';
import InMemoryStore from './store/in-memory';
import { Expression } from './parser';
type DataType = 'int32' | 'uint32' | 'float32' | 'float64';
type AggregationMethod = 'sum' | 'average' | 'highest' | 'lowest' | 'first' | 'last';
interface MeasureRules {
    [dimensionId: string]: AggregationMethod | undefined;
}
interface StoredMeasuresRules {
    [measureId: string]: MeasureRules;
}
declare class Cube {
    dimensions: AbstractDimension[];
    storedMeasures: Record<string, InMemoryStore>;
    storedMeasuresRules: StoredMeasuresRules;
    computedMeasures: Record<string, Expression>;
    get storeSize(): number;
    get byteLength(): number;
    get dimensionIds(): string[];
    get storedMeasureIds(): string[];
    get computedMeasureIds(): string[];
    constructor(dimensions: AbstractDimension[]);
    getDimension(dimensionId: string): AbstractDimension | undefined;
    getDimensionIndex(dimensionId: string): number;
    createComputedMeasure(measureId: string, formula: string): void;
    createStoredMeasure(measureId: string, rules?: MeasureRules, type?: DataType, defaultValue?: number): void;
    renameMeasure(oldMeasureId: string, newMeasureId: string): Cube;
    dropMeasure(measureId: string): void;
    getData(measureId: string): number[];
    getStatus(measureId: string): number[];
    setData(measureId: string, values: number[]): void;
    getNestedArray(measureId: string): unknown;
    setNestedArray(measureId: string, values: unknown[]): void;
    getNestedObject(measureId: string, withTotals?: boolean, withMetadata?: boolean): unknown;
    setNestedObject(measureId: string, value: Record<string, unknown>): void;
    hydrateFromSparseNestedObject(measureId: string, obj: Record<string, unknown>, offset?: number, dimOffset?: number): void;
    hydrateFromCube(otherCube: Cube): void;
    project(dimensionIds: string[]): Cube;
    reorderDimensions(dimensionIds: string[]): Cube;
    slice(dimensionId: string, attribute: string, value: string): Cube;
    diceRange(dimensionId: string, attribute: string, start: string | null, end: string | null): Cube;
    dice(dimensionId: string, attribute: string, items: string[], reorder?: boolean): Cube;
    keepDimensions(dimensionIds: string[]): Cube;
    removeDimensions(dimensionIds: string[]): Cube;
    addDimension(newDimension: AbstractDimension, aggregation?: Record<string, AggregationMethod>, index?: number | null): Cube;
    removeDimension(dimensionId: string): Cube;
    drillDown(dimensionId: string, attribute: string): Cube;
    /**
     * Aggregate a dimension by group values.
     * ie: minutes by hour, or cities by region.
     */
    drillUp(dimensionId: string, attribute: string): Cube;
    /**
     * Create a new cube that contains the union of the measures
     *
     * This is useful when we want to create computed measures from different sources.
     * For instance, composing a cube with sells by day, and number of open hour per week,
     * to compute average sell by opening hour per week.
     */
    compose(otherCube: Cube, union?: boolean): Cube;
    reshape(targetDims: AbstractDimension[]): Cube;
    serialize(): Buffer;
    static deserialize(buffer: Buffer): Cube;
}
export default Cube;
//# sourceMappingURL=cube.d.ts.map