import { DynamicReference } from './DynamicReference';
import type { ErrorReporter } from './ErrorReporter';
import { TranspilerSymbolResolver } from './transpilers';
import { CompilerInterface } from './PrepareCompiler';
export type ToString = {
    toString(): string;
};
export type GranularityDefinition = {
    sql?: (...args: any[]) => string;
    name?: string;
    title?: string;
    interval?: string;
    offset?: string;
    origin?: string;
};
export type TimeshiftDefinition = {
    interval?: string;
    type?: string;
    name?: string;
    timeDimension?: (...args: any[]) => string;
};
export type CubeSymbolDefinition = {
    type?: string;
    sql?: (...args: any[]) => string;
    primaryKey?: boolean;
    granularities?: Record<string, GranularityDefinition>;
    timeShift?: TimeshiftDefinition[];
    format?: string;
    currency?: string;
    order?: 'asc' | 'desc';
    key?: (...args: any[]) => ToString;
    keyReference?: string;
};
export type HierarchyDefinition = {
    title?: string;
    public?: boolean;
    levels?: (...args: any[]) => string[];
};
export type EveryInterval = string;
type EveryCronInterval = string;
type EveryCronTimeZone = string;
export type CubeRefreshKeySqlVariant = {
    sql: () => string;
    every?: EveryInterval;
};
export type CubeRefreshKeyEveryVariant = {
    every: EveryInterval | EveryCronInterval;
    timezone?: EveryCronTimeZone;
    incremental?: boolean;
    updateWindow?: EveryInterval;
};
export type CubeRefreshKeyImmutableVariant = {
    immutable: true;
};
export type CubeRefreshKey = CubeRefreshKeySqlVariant | CubeRefreshKeyEveryVariant | CubeRefreshKeyImmutableVariant;
type BasePreAggregationDefinition = {
    allowNonStrictDateRangeMatch?: boolean;
    useOriginalSqlPreAggregations?: boolean;
    timeDimensionReference?: (...args: any[]) => ToString;
    indexes?: Record<string, any>;
    refreshKey?: CubeRefreshKey;
    ownedByCube?: boolean;
};
export type PreAggregationDefinitionOriginalSql = BasePreAggregationDefinition & {
    type: 'originalSql';
    partitionGranularity?: string;
    partition_granularity?: string;
    time_dimension?: (...args: any[]) => ToString;
};
export type PreAggregationDefinitionRollup = BasePreAggregationDefinition & {
    type: 'autoRollup' | 'rollupJoin' | 'rollupLambda' | 'rollup';
    granularity: string;
    timeDimensionReferences: Array<{
        dimension: () => ToString;
        granularity: string;
    }>;
    dimensionReferences: (...args: any[]) => ToString[];
    segmentReferences: (...args: any[]) => ToString[];
    measureReferences: (...args: any[]) => ToString[];
    rollupReferences: (...args: any[]) => ToString[];
    scheduledRefresh: boolean;
    external: boolean;
};
export type PreAggregationDefinition = PreAggregationDefinitionRollup;
export type JoinDefinition = {
    name: string;
    relationship: string;
    sql: (...args: any[]) => string;
};
export type Filter = {
    member: string;
    memberReference?: string;
    [key: string]: any;
} | {
    and?: Filter[];
    or?: Filter[];
    [key: string]: any;
};
export type AccessPolicyDefinition = {
    role?: string;
    group?: string;
    groups?: string[];
    rowLevel?: {
        filters: Filter[];
    };
    memberLevel?: {
        includes?: string | string[];
        excludes?: string | string[];
        includesMembers?: string[];
        excludesMembers?: string[];
    };
    memberMasking?: {
        includes?: string | string[];
        excludes?: string | string[];
        includesMembers?: string[];
        excludesMembers?: string[];
    };
    conditions?: {
        if: Function;
    }[];
};
export type ViewDefaultValueFilter = {
    member: (...args: Array<unknown>) => ToString;
    memberReference?: string;
    operator: string;
    values?: (...args: Array<unknown>) => Array<unknown>;
    valuesReferences?: Array<unknown>;
    unless?: (...args: Array<unknown>) => Array<ToString>;
    unlessReferences?: string[];
};
export type ViewIncludedMember = {
    type: string;
    memberPath: string;
    name: string;
};
export type FolderJoinPathMember = {
    joinPath: () => ToString;
};
export type FolderMember = {
    type?: 'folder';
    name: string;
    includes?: FolderMember[];
};
export type FolderInclude = string | FolderJoinPathMember | FolderMember;
export type Folder = {
    name: string;
    includes: FolderInclude[] | '*';
};
export type ViewCubeIncludeMember = {
    name: string;
    alias?: string;
    title?: string;
    description?: string;
    format?: string;
    meta?: any;
};
export type ViewCubeInclude = {
    joinPath: () => ToString;
    prefix?: boolean;
    split?: boolean;
    alias?: string;
    includes: '*' | (string | ViewCubeIncludeMember)[];
    excludes?: string[];
};
export interface CubeDefinition {
    name: string;
    extends?: (...args: Array<unknown>) => {
        __cubeName: string;
    };
    sql?: string | ((...args: any[]) => string);
    sql_table?: string | ((...args: any[]) => string);
    sqlTable?: string | ((...args: any[]) => string);
    dataSource?: string;
    measures?: Record<string, CubeSymbolDefinition>;
    dimensions?: Record<string, CubeSymbolDefinition>;
    segments?: Record<string, CubeSymbolDefinition>;
    hierarchies?: Record<string, HierarchyDefinition>;
    preAggregations?: Record<string, PreAggregationDefinitionRollup | PreAggregationDefinitionOriginalSql>;
    pre_aggregations?: Record<string, PreAggregationDefinitionRollup | PreAggregationDefinitionOriginalSql>;
    joins?: JoinDefinition[];
    accessPolicy?: AccessPolicyDefinition[];
    access_policy?: any[];
    folders?: Folder[];
    includes?: any;
    excludes?: any;
    cubes?: any;
    isView?: boolean;
    viewGroup?: string | ((...args: any[]) => any);
    viewGroups?: string[] | ((...args: any[]) => any);
    filters?: ViewDefaultValueFilter[];
    calendar?: boolean;
    isSplitView?: boolean;
    includedMembers?: ViewIncludedMember[];
    joinMap?: string[][];
    fileName?: string;
}
export interface CubeDefinitionExtended extends CubeDefinition {
    allDefinitions: (type: string) => Record<string, any>;
    rawFolders: () => Folder[];
    rawCubes: () => ViewCubeInclude[];
}
interface SplitViews {
    [key: string]: any;
}
export interface CubeSymbolsBase {
    cubeName: () => string;
    cubeObj: () => CubeDefinitionExtended;
}
export type CubeSymbolsDefinition = CubeSymbolsBase & Record<string, CubeSymbolDefinition>;
type MemberSets = {
    resolvedMembers: Set<string>;
    allMembers: Set<string>;
};
type ViewResolvedMember = {
    member: string;
    name: string;
};
type ViewExcludedMember = {
    member: string;
};
export declare const CONTEXT_SYMBOLS: {
    SECURITY_CONTEXT: string;
    security_context: string;
    securityContext: string;
    FILTER_PARAMS: string;
    FILTER_GROUP: string;
    SQL_UTILS: string;
};
export declare const CURRENT_CUBE_CONSTANTS: string[];
export declare class CubeSymbols implements TranspilerSymbolResolver, CompilerInterface {
    symbols: Record<string | symbol, CubeSymbolsDefinition>;
    private builtCubes;
    cubeDefinitions: Record<string, CubeDefinition>;
    private funcArgumentsValues;
    cubeList: CubeDefinitionExtended[];
    private readonly evaluateViews;
    private resolveSymbolsCallContext;
    constructor(evaluateViews?: boolean);
    free(): void;
    compile(cubes: CubeDefinition[], errorReporter: ErrorReporter): void;
    getCubeDefinition(cubeName: string): CubeDefinitionExtended;
    createCube(cubeDefinition: CubeDefinition): CubeDefinitionExtended;
    protected transform(cubeName: string, errorReporter: ErrorReporter, splitViews: SplitViews): CubeSymbolsDefinition;
    private camelCaseTypes;
    private evaluateDimensionKeys;
    protected transformPreAggregations(preAggregations: Object): void;
    protected transformPreAggregationIndexes(indexes: Object): void;
    protected prepareIncludes(cube: CubeDefinitionExtended, errorReporter: ErrorReporter, splitViews: SplitViews): void;
    protected applyIncludeMembers(includeMembers: any[], cube: CubeDefinition, type: string, errorReporter: ErrorReporter): void;
    protected membersFromCubes(parentCube: CubeDefinition, cubes: any[], type: string, errorReporter: ErrorReporter, splitViews: SplitViews, memberSets: MemberSets): ViewResolvedMember[];
    protected diffByMember(includes: ViewResolvedMember[], excludes: ViewExcludedMember[]): ViewResolvedMember[];
    protected getResolvedMember(type: string, cubeName: string, memberName: string): any;
    protected processKeyReferenceForView(keyReference: string, viewName: string, viewAllMembers: ViewResolvedMember[], dimensionName: string): {
        keyReference: string;
    };
    protected generateIncludeMembers(members: any[], type: string, targetCube: CubeDefinitionExtended, viewAllMembers: ViewResolvedMember[]): any[][];
    /**
     * This method is mainly used for evaluating RLS conditions and filters.
     * It allows referencing security_context (lowercase) in dynamic conditions or filter values.
     *
     * It currently does not support async calls because inner resolveSymbol and
     * resolveSymbolsCall are sync. Async support may be added later with deeper
     * refactoring.
     */
    evaluateContextFunction(cube: any, contextFn: any, context?: any): unknown;
    evaluateReferences<T extends ToString | Array<ToString>>(cube: string | null, referencesFn: (...args: Array<unknown>) => T, options?: {
        collectJoinHints?: boolean;
        originalSorting?: boolean;
    }): T extends Array<ToString> ? Array<string> : T extends ToString ? string : string | Array<string>;
    evaluateReference(cube: string, referencesFn: (...args: Array<unknown>) => ToString, context: string): string;
    pathFromArray(array: string[]): string;
    /**
     * Split join path to member to join hint and member path: `A.B.C.D.E.dim` => `[A, B, C, D, E]` + `E.dim`
     */
    static joinHintFromPath(path: string): {
        path: string;
        joinHint: string[];
    };
    protected resolveSymbolsCall<T>(func: (...args: Array<unknown>) => T | DynamicReference<T>, nameResolver: (id: string) => unknown, context?: unknown): T;
    protected withSymbolsCallContext(func: Function, context: any): any;
    funcArguments(func: Function): string[];
    protected joinHints(): string | string[] | undefined;
    protected resolveSymbolsCallDeps(cubeName: any, sql: any): any[];
    protected depsContextSymbols(): {
        filterParams: {};
        filterGroup: (...filterParamArgs: any[]) => string;
        securityContext: object;
        sqlUtils: {
            convertTz: (f: any) => any;
        };
    };
    protected filtersProxyDep(): {};
    protected filterGroupFunctionDep(): (...filterParamArgs: any[]) => string;
    resolveSymbol(cubeName: any, name: string): any;
    protected cubeReferenceProxy(cubeName: any, joinHints?: any[], refProperty?: any): any;
    /**
     * Tries to resolve Granularity object.
     * For predefined granularity it constructs it on the fly.
     * @param {string|string[]} path
     * @param [refCube] Optional cube object to operate on
     */
    resolveGranularity(path: string | string[], refCube?: any): any;
    protected cubeDependenciesProxy(parentIndex: any, cubeName: any): any;
    protected timeDimDependenciesProxy(parentIndex: any): {};
    isCurrentCube(name: any): boolean;
    static isCalculatedMeasureType(type: string): boolean;
    /**
     TODO: support type qualifiers on min and max
     */
    static toMemberDataType(type: string): string;
    static contextSymbolsProxyFrom(symbols: object, allocateParam: (param: unknown) => unknown): object;
}
export {};
//# sourceMappingURL=CubeSymbols.d.ts.map