import { AccessPolicyDefinition, CubeDefinitionExtended, CubeSymbols, HierarchyDefinition, JoinDefinition, PreAggregationDefinition, PreAggregationDefinitionRollup, type ToString, ViewDefaultValueFilter, ViewIncludedMember } from './CubeSymbols';
import { PreAggregationDefinitionExtended } from '../adapter';
import type { CubeValidator } from './CubeValidator';
import type { ErrorReporter } from './ErrorReporter';
import { FinishedJoinTree } from './JoinGraph';
export type SegmentDefinition = {
    type: string;
    sql(): string;
    primaryKey?: true;
    ownedByCube: boolean;
    fieldType?: string;
    multiStage?: boolean;
};
export type DimensionDefinition = {
    type: string;
    sql(): string;
    primaryKey?: true;
    ownedByCube: boolean;
    fieldType?: string;
    multiStage?: boolean;
    shiftInterval?: string;
    order?: 'asc' | 'desc';
    key?: (...args: any[]) => ToString;
    keyReference?: string;
};
export type TimeShiftDefinition = {
    timeDimension?: (...args: Array<unknown>) => ToString;
    name?: string;
    interval?: string;
    type?: 'next' | 'prior';
};
export type TimeShiftDefinitionReference = {
    timeDimension?: string;
    name?: string;
    interval?: string;
    type?: 'next' | 'prior';
};
export type MeasureDefinition = {
    type: string;
    aggType?: string;
    sql(): string;
    ownedByCube: boolean;
    rollingWindow?: any;
    filters?: any;
    primaryKey?: true;
    drillFilters?: any;
    multiStage?: boolean;
    groupBy?: (...args: Array<unknown>) => Array<ToString>;
    reduceBy?: (...args: Array<unknown>) => Array<ToString>;
    addGroupBy?: (...args: Array<unknown>) => Array<ToString>;
    timeShift?: TimeShiftDefinition[];
    groupByReferences?: string[];
    reduceByReferences?: string[];
    addGroupByReferences?: string[];
    timeShiftReferences?: TimeShiftDefinitionReference[];
    patchedFrom?: {
        cubeName: string;
        name: string;
    };
};
export type PreAggregationFilters = {
    dataSources?: string[];
    cubes?: string[];
    preAggregationIds?: string[];
    scheduled?: boolean;
};
export type PreAggregationDefinitions = Record<string, PreAggregationDefinition>;
export type PreAggregationTimeDimensionReference = {
    dimension: string;
    granularity: string;
};
export type PreAggregationReferences = {
    allowNonStrictDateRangeMatch?: boolean;
    dimensions: Array<string>;
    measures: Array<string>;
    timeDimensions: Array<PreAggregationTimeDimensionReference>;
    rollups: Array<string>;
    rollupsReferences: Array<PreAggregationReferences>;
    multipliedMeasures?: Array<string>;
    joinTree?: FinishedJoinTree;
};
export type PreAggregationInfo = {
    id: string;
    preAggregationName: string;
    preAggregation: any;
    cube: string;
    references: PreAggregationReferences;
    refreshKey: unknown;
    indexesReferences: unknown;
};
export type EvaluatedHierarchy = {
    name: string;
    title?: string;
    public?: boolean;
    levels: string[];
    aliasMember?: string;
    [key: string]: any;
};
export type EvaluatedFolder = {
    name: string;
    includes: (EvaluatedFolder | ViewIncludedMember)[];
    type: 'folder';
    [key: string]: any;
};
export type EvaluatedCube = {
    name: string;
    measures: Record<string, MeasureDefinition>;
    dimensions: Record<string, DimensionDefinition>;
    segments: Record<string, SegmentDefinition>;
    joins: JoinDefinition[];
    hierarchies: Record<string, HierarchyDefinition>;
    evaluatedHierarchies: EvaluatedHierarchy[];
    preAggregations: Record<string, PreAggregationDefinitionExtended>;
    dataSource?: string;
    folders: EvaluatedFolder[];
    sql?: (...args: any[]) => string;
    sqlTable?: (...args: any[]) => string;
    accessPolicy?: AccessPolicyDefinition[];
    isView?: boolean;
    includedMembers?: ViewIncludedMember[];
    defaultFilters?: ViewDefaultValueFilter[];
};
export declare class CubeEvaluator extends CubeSymbols {
    protected readonly cubeValidator: CubeValidator;
    evaluatedCubes: Record<string, EvaluatedCube>;
    primaryKeys: Record<string, string[]>;
    byFileName: Record<string, CubeDefinitionExtended[]>;
    private isRbacEnabledCache;
    constructor(cubeValidator: CubeValidator);
    compile(cubes: any[], errorReporter: ErrorReporter): void;
    protected prepareCube(cube: any, errorReporter: ErrorReporter): EvaluatedCube;
    private prepareViewFilters;
    private allMembersOrList;
    private prepareAccessPolicy;
    private getFolderMembersFromJoinPath;
    private prepareFolders;
    private prepareHierarchies;
    private evaluateMultiStageReferences;
    protected prepareJoins(cube: any, errorReporter: ErrorReporter): void;
    protected preparePreAggregations(cube: any, errorReporter: ErrorReporter): void;
    protected prepareMembers(members: any, cube: any, errorReporter: ErrorReporter): void;
    cubesByFileName(fileName: any): CubeDefinitionExtended[];
    timeDimensionPathsForCube(cube: string): string[];
    measuresForCube(cube: string): Record<string, MeasureDefinition>;
    timeDimensionsForCube(cube: string): Record<string, DimensionDefinition>;
    preAggregationsForCube(path: string): Record<string, PreAggregationDefinitionExtended>;
    preAggregationsForCubeAsArray(path: string): {
        name: string;
    }[];
    preAggregationDescriptionByName(cubeName: string, preAggName: string): {
        name: string;
    } | undefined;
    /**
     * Returns pre-aggregations filtered by the specified selector.
     */
    preAggregations(filter: PreAggregationFilters): Array<PreAggregationInfo>;
    scheduledPreAggregations(): Array<PreAggregationInfo>;
    cubeNames(): string[];
    isMeasure(measurePath: string | string[]): boolean;
    isDimension(path: string | string[]): boolean;
    isSegment(path: string | string[]): boolean;
    measureByPath(measurePath: string | string[]): MeasureDefinition;
    dimensionByPath(dimensionPath: string | string[]): DimensionDefinition;
    segmentByPath(segmentPath: string | string[]): SegmentDefinition;
    cubeExists(cube: string): boolean;
    memberShortNameFromPath(path: string | string[]): string;
    cubeFromPath(path: string): EvaluatedCube;
    cubeNameFromPath(path: string): string;
    isInstanceOfType(type: 'measures' | 'dimensions' | 'segments', path: string | string[]): boolean;
    byPathAnyType(path: string | string[]): MeasureDefinition | SegmentDefinition;
    byPath<T extends 'measures' | 'dimensions' | 'segments' | 'preAggregations'>(type: T, path: string | string[]): EvaluatedCube[T][string];
    parsePath(type: 'measures' | 'dimensions' | 'segments' | 'preAggregations', path: string): string[];
    isRbacEnabledForCube(cube: any): boolean;
    isRbacEnabled(): boolean;
    parsePathAnyType(path: string): string[];
    collectUsedCubeReferences(cube: any, sqlFn: any): {
        cubeReferencesUsed: string[];
        pathReferencesUsed: string[][];
        evaluatedSql: unknown;
    };
    /**
     * Evaluates rollup references for retrieving rollupReference used in Tesseract.
     * This is a temporary solution until Tesseract takes ownership of all pre-aggregations.
     */
    evaluateRollupReferences<T extends ToString | Array<ToString>>(cube: string, rollupReferences: (...args: Array<unknown>) => T): T extends ToString[] ? string[] : T extends ToString ? string : string | string[];
    evaluatePreAggregationReferences(cube: string, aggregation: PreAggregationDefinitionRollup): PreAggregationReferences;
}
//# sourceMappingURL=CubeEvaluator.d.ts.map