/**
 * Set of the schema compilers.
 * @typedef {Object} Compilers
 * @property {import('../compiler/DataSchemaCompiler').DataSchemaCompiler} compiler
 * @property {import('../compiler/CubeToMetaTransformer').CubeToMetaTransformer} metaTransformer
 * @property {import('../compiler/CubeEvaluator').CubeEvaluator} cubeEvaluator
 * @property {import('../compiler/ContextEvaluator').ContextEvaluator} contextEvaluator
 * @property {import('../compiler/JoinGraph').JoinGraph} joinGraph
 * @property {import('../compiler/CompilerCache').CompilerCache} compilerCache
 * @property {*} headCommitId
 */
/**
 * @typedef {Object} JoinRoot
 * @property {string} sql
 * @property {string} alias
 */
/**
 * @typedef {Object} JoinItem
 * @property {string} sql
 * @property {string} alias
 * @property {string} on
 */
/**
 * @typedef {[JoinRoot, ...JoinItem]} JoinChain
 */
/**
 * BaseQuery class. BaseQuery object encapsulates the logic of
 * transforming an incoming to a specific cube request to the
 * SQL-query string.
 *
 * This class is a parent class for the set of dialect specific
 * query adapters (for ex. MysqlQuery, OracleQuery, etc.).
 *
 * You should never instantiate this class manually. Instead, you
 * should use {@code CompilerApi#getDialectClass} method, which
 * should return query object based on the datasource, database type
 * and {@code CompilerApi} configuration.
 */
export class BaseQuery {
    static emptyParametrizedContextSymbols(cubeEvaluator: any, allocateParam: any): {
        filterParams: {};
        filterGroup: () => string;
        sqlUtils: {
            convertTz: (field: any) => any;
        };
        securityContext: object;
    };
    static extractFilterMembers(filter: any): any;
    static findAndSubTreeForFilterGroup(filter: any, groupMembers: any, newGroupFilter: any, aliases: any): any;
    static renderFilterParams(filter: any, filterParamArgs: any, allocateParam: any, newGroupFilter: any, aliases: any): any;
    static filterProxyFromAllFilters(allFilters: any, cubeEvaluator: any, allocateParam: any, newGroupFilter: any): {};
    /**
     * BaseQuery class constructor.
     * @param {Compilers|*} compilers
     * @param {*} options
     */
    constructor(compilers: Compilers | any, options: any);
    /** @type {import('./PreAggregations').PreAggregations} */
    preAggregations: import('./PreAggregations').PreAggregations;
    /** @type {import('./BaseMeasure').BaseMeasure[]} */
    measures: import('./BaseMeasure').BaseMeasure[];
    /** @type {import('./BaseDimension').BaseDimension[]} */
    dimensions: import('./BaseDimension').BaseDimension[];
    /** @type {import('./BaseDimension').BaseDimension[]} */
    multiStageDimensions: import('./BaseDimension').BaseDimension[];
    /** @type {import('./BaseTimeDimension').BaseTimeDimension[]} */
    multiStageTimeDimensions: import('./BaseTimeDimension').BaseTimeDimension[];
    /** @type {import('./BaseSegment').BaseSegment[]} */
    segments: import('./BaseSegment').BaseSegment[];
    /** @type {(BaseFilter|BaseGroupFilter)[]} */
    filters: (BaseFilter | BaseGroupFilter)[];
    /** @type {(BaseFilter|BaseGroupFilter)[]} */
    measureFilters: (BaseFilter | BaseGroupFilter)[];
    /** @type {import('./BaseTimeDimension').BaseTimeDimension[]} */
    timeDimensions: import('./BaseTimeDimension').BaseTimeDimension[];
    /** @type {import('../compiler/JoinGraph').FinishedJoinTree} */
    join: import('../compiler/JoinGraph').FinishedJoinTree;
    compilers: any;
    /** @type {import('../compiler/CubeEvaluator').CubeEvaluator} */
    cubeEvaluator: import('../compiler/CubeEvaluator').CubeEvaluator;
    /** @type {import('../compiler/JoinGraph').JoinGraph} */
    joinGraph: import('../compiler/JoinGraph').JoinGraph;
    options: any;
    /**
     * @param {{ id: string, desc: boolean }} hash
     * @returns {string|null}
     */
    orderHashToString(hash: {
        id: string;
        desc: boolean;
    }): string | null;
    defaultOrder(): {
        id: any;
        desc: boolean;
    }[];
    /** @type {ParamAllocator} */
    paramAllocator: ParamAllocator;
    extractDimensionsAndMeasures(filters?: any[]): any[];
    keepFilters(filters: any[] | undefined, fn: any): any;
    extractFiltersAsTree(filters?: any[]): any;
    /**
     * @protected
     */
    protected initFromOptions(): void;
    contextSymbols: any;
    maskedMembers: Set<any> | undefined;
    memberMaskFilters: {} | undefined;
    compilerCache: any;
    queryCache: any;
    from: any;
    multiStageQuery: any;
    timezone: any;
    rowLimit: any;
    offset: any;
    allFilters: BaseTimeDimension[] | undefined;
    /**
     * For now this might come only from SQL API, it might be some queries that uses measures and filters to
     * get the dimensions that are then used as join conditions to get the final results.
     * As consequence - if there are such sub query joins - pre-aggregations can't be used.
     * @type {Array<{sql: string, on: {expression: Function}, joinType: 'LEFT' | 'INNER', alias: string}>}
     */
    customSubQueryJoins: {
        sql: string;
        on: {
            expression: Function;
        };
        joinType: 'LEFT' | 'INNER';
        alias: string;
    }[] | undefined;
    useNativeSqlPlanner: any;
    canUseNativeSqlPlannerPreAggregation: any;
    queryLevelJoinHints: any;
    cubeAliasPrefix: any;
    preAggregationsSchemaOption: any;
    externalQueryClass: any;
    order: any;
    neverUseSqlPlannerPreaggregation(): boolean;
    prebuildJoin(): void;
    joinGraphPaths: Record<string, string[]> | undefined;
    /**
     * This function follows the same logic as in this.collectJoinHints()
     * skipQueryJoinMap is used by PreAggregations to build join tree without user's query all members map
     * @public
     * @param {Array<(Array<string> | string)>} hints
     * @param { boolean } skipQueryJoinMap
     * @return {import('../compiler/JoinGraph').FinishedJoinTree}
     */
    public joinTreeForHints(hints: Array<(Array<string> | string)>, skipQueryJoinMap?: boolean): import('../compiler/JoinGraph').FinishedJoinTree;
    cacheValue(key: any, fn: any, { contextPropNames, inputProps, cache }?: {
        contextPropNames: any;
        inputProps: any;
        cache: any;
    }): any;
    get allCubeNames(): string[];
    collectedCubeNames: string[] | undefined;
    /**
     *
     * @returns {Array<string | Array<string>>}
     */
    get allJoinHints(): (string | string[])[];
    collectedJoinHints: (string | string[])[] | undefined;
    /**
     * @private
     * @return { Record<string, string[][]>}
     */
    private queryJoinMap;
    /**
     * @private
     * @param { import('../compiler/JoinGraph').FinishedJoinTree } joinTree
     * @param { string[] } joinHints
     * @return { string[][] }
     */
    private enrichedJoinHintsFromJoinTree;
    /**
     * @private
     * @param { (string|string[])[] } hints
     * @param { Record<string, string[][]>} joinMap
     * @return {(string|string[])[]}
     */
    private enrichHintsWithJoinMap;
    get dataSource(): string;
    cubeDataSource(cube: any): string;
    get aliasNameToMember(): {
        [index: string]: any;
    };
    initUngrouped(): void;
    ungrouped: any;
    get subQueryDimensions(): string[];
    _subQueryDimensions: string[] | undefined;
    get asSyntaxTable(): string;
    get asSyntaxJoin(): string;
    /**
     *
     * @param measurePath
     * @returns {BaseMeasure}
     */
    newMeasure(measurePath: any): BaseMeasure;
    /**
     *
     * @param dimensionPath
     * @returns {BaseDimension}
     */
    newDimension(dimensionPath: any): BaseDimension;
    /**
     *
     * @param segmentPath
     * @returns {BaseSegment}
     */
    newSegment(segmentPath: any): BaseSegment;
    /**
     * @returns {BaseGroupFilter|BaseFilter}
     */
    initFilter(filter: any): BaseGroupFilter | BaseFilter;
    /**
     * @returns {BaseFilter}
     */
    newFilter(filter: any): BaseFilter;
    /**
     *
     * @param filter
     * @returns {BaseGroupFilter}
     */
    newGroupFilter(filter: any): BaseGroupFilter;
    /**
     * @param timeDimension
     * @return {BaseTimeDimension}
     */
    newTimeDimension(timeDimension: any): BaseTimeDimension;
    /**
     *
     * @param expressionParams
     * @returns {ParamAllocator}
     */
    newParamAllocator(expressionParams: any): ParamAllocator;
    /**
     *
     * @returns {PreAggregations}
     */
    newPreAggregations(): PreAggregations;
    /**
     * Wrap specified column/table name with the double quote.
     * @param {string} name
     * @returns {string}
     */
    escapeColumnName(name: string): string;
    /**
     * Returns SQL query string.
     * @returns {string}
     */
    buildParamAnnotatedSql(): string;
    /**
     * Generate SQL query to calculate total number of rows of the
     * specified SQL query.
     * @param {string} sql
     * @returns {string}
     */
    countAllQuery(sql: string): string;
    regularAndTimeSeriesRollupQuery(regularMeasures: any, multipliedMeasures: any, cumulativeMeasures: any, preAggregationForQuery: any): string;
    externalPreAggregationQuery(): boolean;
    newQueryWithoutNative(): any;
    /**
     * Returns a pair of SQL query string and parameter values for the query.
     * @param {boolean} [exportAnnotatedSql] - returns annotated sql with not rendered params if true
     * @returns {[string, Array<unknown>]}
     */
    buildSqlAndParams(exportAnnotatedSql?: boolean | undefined): [string, Array<unknown>];
    driverTools(external: any): any;
    buildSqlAndParamsRust(exportAnnotatedSql: any): any[];
    findPreAggregationForQueryRust(): import("./PreAggregations").PreAggregationForQuery | undefined;
    applyNativePreAggResult(preAggResult: any): void;
    allCubeMembers(path: any): string[];
    getAllocatedParams(): unknown[];
    generateTimeSeries(granularity: any, dateRange: any): import("@cubejs-backend/shared").QueryDateRange[];
    generateCustomTimeSeries(granularityInterval: any, dateRange: any, origin: any): import("@cubejs-backend/shared").QueryDateRange[];
    getPreAggregationByName(cube: any, preAggregationName: any): {} | import("./PreAggregations").PreAggregationForQueryWithTableName;
    get shouldReuseParams(): boolean;
    /**
     * Returns a dictionary mapping each preagregation to its corresponding query fragment.
     * @returns {Record<string, Array<string>>}
     */
    buildLambdaQuery(): Record<string, Array<string>>;
    externalQuery(): any;
    runningTotalDateJoinCondition(): (BaseTimeDimension | ((_dateFrom: any, dateTo: any, dateField: any, dimensionDateFrom: any, _dimensionDateTo: any) => string))[][];
    rollingWindowToDateJoinCondition(granularity: any): any[][];
    rollingWindowDateJoinCondition(trailingInterval: any, leadingInterval: any, offset: any): any[][];
    /**
     * @param {string} date
     * @param {string} interval
     * @returns {string}
     */
    subtractInterval(date: string, interval: string): string;
    /**
     * @param {string} date
     * @param {string} interval
     * @returns {string}
     */
    addInterval(date: string, interval: string): string;
    supportGeneratedSeriesForCustomTd(): boolean;
    /**
     * @param {string} interval
     * @returns {string}
     */
    intervalString(interval: string): string;
    /**
     * @param {string} timestamp
     * @param {string} interval
     * @returns {string}
     */
    addTimestampInterval(timestamp: string, interval: string): string;
    /**
     * @param {string} timestamp
     * @param {string} interval
     * @returns {string}
     */
    subtractTimestampInterval(timestamp: string, interval: string): string;
    cumulativeMeasures(): BaseMeasure[];
    isRolling(): boolean;
    simpleQuery(): string;
    /**
     * Returns SQL query string.
     * @returns {string}
     */
    fullKeyQueryAggregate(): string;
    joinFullKeyQueryAggregate(multipliedMeasures: any, regularMeasures: any, cumulativeMeasures: any, toJoin: any): string;
    outerMeasuresJoinFullKeyQueryAggregate(innerMembers: any, outerMembers: any, toJoin: any): string;
    wrapInParenthesis(select: any): any;
    withQueries(select: any, withQueries: any): any;
    fullKeyQueryAggregateMeasures(context: any): {
        multipliedMeasures: BaseMeasure[];
        regularMeasures: BaseMeasure[];
        cumulativeMeasures: R.KeyValuePair<any, BaseMeasure>[];
        multiStageMembers: any[];
        withQueries: any[];
    };
    collectAllMemberChildren(context: any): any;
    collectAllMultiStageMembers(allMemberChildren: any): {
        [index: string]: any;
    };
    memberInstanceByPath(m: any): BaseMeasure | BaseDimension | BaseSegment;
    multiStageWithQueries(member: any, queryContext: any, memberChildren: any, withQueries: any): any;
    collectUsedWithQueries(usedQueries: any, member: any): void;
    childrenMultiStageContext(memberPath: any, queryContext: any): any;
    selfMultiStageContext(memberPath: any, queryContext: any, wouldNodeApplyFilters: any): any;
    renderWithQuery(withQuery: any): {
        query: string;
        alias: any;
    };
    dimensionsJoinCondition(leftAlias: any, rightAlias: any): string;
    baseWhere(filters: any): string;
    baseHaving(filters: any): string;
    timeStampInClientTz(dateParam: any): string;
    granularityHierarchies(): any;
    granularityParentHierarchy(granularity: any): any;
    minGranularity(granularityA: any, granularityB: any): any;
    overTimeSeriesQuery(baseQueryFn: any, cumulativeMeasure: any, fromRollup: any): any;
    overTimeSeriesSelect(cumulativeMeasures: any, dateSeriesSql: any, baseQuery: any, dateJoinConditionSql: any, baseQueryAlias: any, dateSeriesGranularity: any): string;
    overTimeSeriesForSelect(cumulativeMeasures: any, dateSeriesGranularity: any): string;
    /**
     * BigQuery has strict date type and can not automatically convert between date
     * and timestamp, so we override dateFromStartToEndConditionSql() in BigQuery Dialect
     * @protected
     */
    protected dateFromStartToEndConditionSql(dateJoinCondition: any, fromRollup: any, isFromStartToEnd: any): any;
    /**
     * @param {import('./BaseTimeDimension').BaseTimeDimension} timeDimension
     * @return {string}
     */
    dateSeriesSql(timeDimension: import('./BaseTimeDimension').BaseTimeDimension): string;
    /**
     * BigQuery has strict date type and can not automatically convert between date
     * and timestamp, so we override seriesSql() in BigQuery Dialect
     * @param {import('./BaseTimeDimension').BaseTimeDimension} timeDimension
     * @return {string}
     */
    seriesSql(timeDimension: import('./BaseTimeDimension').BaseTimeDimension): string;
    /**
     * @param {import('./BaseDimension').BaseDimension|import('./BaseTimeDimension').BaseTimeDimension} timeDimension
     * @return {string}
     */
    timeStampParam(timeDimension: import('./BaseDimension').BaseDimension | import('./BaseTimeDimension').BaseTimeDimension): string;
    timeRangeFilter(dimensionSql: any, fromTimeStampParam: any, toTimeStampParam: any): string;
    timeNotInRangeFilter(dimensionSql: any, fromTimeStampParam: any, toTimeStampParam: any): string;
    beforeDateFilter(dimensionSql: any, timeStampParam: any): string;
    beforeOrOnDateFilter(dimensionSql: any, timeStampParam: any): string;
    afterDateFilter(dimensionSql: any, timeStampParam: any): string;
    afterOrOnDateFilter(dimensionSql: any, timeStampParam: any): string;
    timeStampCast(value: any): string;
    dateTimeCast(value: any): string;
    /**
     * Converts the input interval (e.g. "2 years", "3 months", "5 days")
     * into a format compatible with the target SQL dialect.
     * Also returns the minimal time unit required (e.g. for use in DATEDIFF).
     *
     * Returns a tuple: (formatted interval, minimal time unit)
     */
    intervalAndMinimalTimeUnit(interval: any): any[];
    commonQuery(): string;
    dimensionOnlyMeasureToHierarchy(context: any, m: any): any[];
    collectRootMeasureToHierarchy(context: any): {
        [index: string]: any;
    };
    query(): any;
    /**
     *
     * @param {string} cube
     * @param {boolean} [isLeftJoinCondition]
     * @returns {[string, string, string?]}
     */
    rewriteInlineCubeSql(cube: string, isLeftJoinCondition?: boolean | undefined): [string, string, string?];
    /**
     * @param {import('../compiler/JoinGraph').FinishedJoinTree} join
     * @param {Array<string>} subQueryDimensions
     * @returns {string}
     */
    joinQuery(join: import('../compiler/JoinGraph').FinishedJoinTree, subQueryDimensions: Array<string>): string;
    /**
     * @param {JoinChain} toJoin
     * @returns {string}
     */
    joinSql(toJoin: [JoinRoot, ...any[]]): string;
    /**
     *
     * @param {{sql: string, on: {cubeName: string, expression: Function}, joinType: 'LEFT' | 'INNER', alias: string}}
     *   customJoin
     * @returns {JoinItem}
     */
    customSubQueryJoin(customJoin: {
        sql: string;
        on: {
            cubeName: string;
            expression: Function;
        };
        joinType: 'LEFT' | 'INNER';
        alias: string;
    }): JoinItem;
    /**
     *
     * @param {string} dimension
     * @returns {JoinItem}
     */
    subQueryJoin(dimension: string): JoinItem;
    get filtersWithoutSubQueries(): BaseTimeDimension[];
    filtersWithoutSubQueriesValue: BaseTimeDimension[] | undefined;
    /**
     *
     * @param {string} dimension
     * @returns {{ prefix: string, subQuery: this, cubeName: string }}
     */
    subQueryDescription(dimension: string): {
        prefix: string;
        subQuery: any;
        cubeName: string;
    };
    /**
     *
     * @param {string} cubeName
     * @param {string} name
     * @returns {string}
     */
    subQueryName(cubeName: string, name: string): string;
    regularMeasuresSubQuery(measures: any, filters: any): string;
    /**
     * Returns SQL query for the "aggregating on top of sub-queries" uses cases.
     * @param {string} keyCubeName
     * @param {Array<BaseMeasure>} measures
     * @param {Array<BaseFilter>} filters
     * @returns {string}
     */
    aggregateSubQuery(keyCubeName: string, measures: Array<BaseMeasure>, filters: Array<BaseFilter>): string;
    /**
     * @param {Array<BaseMeasure>} measures
     * @param {string} keyCubeName
     * @returns {boolean}
     */
    checkShouldBuildJoinForMeasureSelect(measures: Array<BaseMeasure>, keyCubeName: string): boolean;
    aggregateSubQueryMeasureJoin(keyCubeName: any, measures: any, measuresJoin: any, primaryKeyDimensions: any, measureSubQueryDimensions: any): any;
    groupedUngroupedSelect(select: any, ungrouped: any, granularityOverride: any): any;
    ungroupedMeasureSelect(select: any): any;
    keysQuery(primaryKeyDimensions: any, filters: any): string;
    keysSelect(primaryKeyDimensions: any): string;
    keyDimensions(primaryKeyDimensions: any): (BaseDimension | BaseTimeDimension)[];
    /**
     * @param {string} cube
     */
    cubeSql(cube: string): any;
    traverseSymbol(s: any): any;
    /**
     *
     * @returns {Array<string>}
     */
    collectCubeNames(): Array<string>;
    /**
     * Just a helper to avoid copy/paste
     * @private
     * @param {import('../compiler/JoinGraph').FinishedJoinTree} a
     * @param {import('../compiler/JoinGraph').FinishedJoinTree} b
     * @return {boolean}
     */
    private isJoinTreesEqual;
    /**
     * @private
     * @param {boolean} [excludeTimeDimensions=false]
     * @returns {Array<(Array<string> | string)>}
     */
    private collectJoinHints;
    joinMembersFromCustomSubQuery(): {
        getMembers: () => {
            path: () => null;
            cube: () => import("../compiler/CubeEvaluator").EvaluatedCube;
            definition: () => {
                sql: Function;
                type: string;
            };
        }[];
    }[];
    joinMembersFromJoin(join: any): any;
    collectJoinHintsFromMembers(members: any): any[];
    /**
     * @template T
     * @param {boolean} excludeTimeDimensions
     * @param {(t: () => void) => T} fn
     * @param {string | Array<string>} methodName
     * @returns {T}
     */
    collectFromMembers<T>(excludeTimeDimensions: boolean, fn: (t: () => void) => T, methodName: string | Array<string>): T;
    /**
     *
     * @param {boolean} excludeTimeDimensions
     * @returns {Array<BaseMeasure | BaseDimension | BaseSegment>}
     */
    allMembersConcat(excludeTimeDimensions: boolean): Array<BaseMeasure | BaseDimension | BaseSegment>;
    /**
     * @template T
     * @param {Array<unknown>} membersToCollectFrom
     * @param {(t: () => void) => T} fn
     * @param {string | Array<string>} methodName
     * @param {unknown} [cache]
     * @returns {T}
     */
    collectFrom<T_1>(membersToCollectFrom: Array<unknown>, fn: (t: () => void) => T_1, methodName: string | Array<string>, cache?: unknown): T_1;
    /**
     *
     * @param {() => void} fn
     * @returns {Array<string>}
     */
    collectSubQueryDimensionsFor(fn: () => void): Array<string>;
    rewriteInlineWhere(fn: any, inlineWhereConditions: any): any;
    /**
     * Returns `GROUP BY` clause for the "aggregating on top of sub-queries" uses
     * cases. By the default returns the result of the `groupByClause` method.
     * @returns {string}
     */
    aggregateSubQueryGroupByClause(): string;
    /**
     * Returns `GROUP BY` clause for the basic uses cases.
     * @returns {string}
     */
    groupByClause(): string;
    /**
     * XXX: String as return value is added because of HiveQuery.getFieldIndex() and DatabricksQuery.getFieldIndex()
     * @protected
     * @param {string} id member name in form of "cube.member[.granularity]"
     * @returns {number|string|null}
     */
    protected getFieldIndex(id: string): number | string | null;
    /**
     * @protected
     * @param {string} id member name in form of "cube.member[.granularity]"
     * @returns {null|string}
     */
    protected getFieldAlias(id: string): null | string;
    orderBy(): string;
    /**
     * Returns a complete list of the aliased dimensions, including time
     * dimensions.
     * @returns {Array<string>}
     */
    dimensionAliasNames(): Array<string>;
    /**
     * Returns an array of column names correlated to the specified cube dimensions.
     * @param {string} cubeAlias
     * @returns {Array<string>}
     */
    dimensionColumns(cubeAlias: string): Array<string>;
    groupByDimensionLimit(): string;
    /**
     * @protected
     * @param {Array<string>} dimensionNames
     * @returns {string}
     */
    protected rollupGroupByClause(dimensionNames: Array<string>): string;
    /**
     * @protected
     * @param limit
     * @param offset
     * @returns {string}
     */
    protected limitOffsetClause(limit: any, offset: any): string;
    topLimit(): string;
    baseSelect(): string;
    selectAllDimensionsAndMeasures(measures: any): string;
    /**
     * @returns {Array<BaseDimension|BaseMeasure>}
     */
    forSelect(): Array<BaseDimension | BaseMeasure>;
    /**
     * Returns a complete list of the dimensions, including time dimensions.
     * @returns {(BaseDimension|BaseTimeDimension)[]}
     */
    dimensionsForSelect(): (BaseDimension | BaseTimeDimension)[];
    dimensionSql(dimension: any): any;
    segmentSql(segment: any): any;
    measureSql(measure: any): any;
    autoPrefixWithCubeName(cubeName: any, sql: any, isMemberExpr?: boolean): any;
    wrapSegmentForDimensionSelect(sql: any): any;
    pushCubeNameForCollectionIfNecessary(cubeName: any): void;
    pushJoinHints(joinHints: any): void;
    pushMemberNameForCollectionIfNecessary(cubeName: any, name: any): void;
    safeEvaluateSymbolContext(): any;
    evaluateSymbolSql(cubeName: any, name: any, symbol: any, memberExpressionType: any, subPropertyName: any): any;
    memberMaskSql(cubeName: any, name: any, symbol: any): any;
    conditionalMemberMaskSql(cubeName: any, name: any, symbol: any, maskFilter: any): any;
    maskFilterToSql(filter: any): any;
    defaultMaskSql(memberType: any): string;
    escapeStringLiteral(str: any): string;
    autoPrefixAndEvaluateSql(cubeName: any, sql: any, isMemberExpr?: boolean): any;
    concatStringsSql(strings: any): any;
    /**
     *
     * @param {string} cubeName
     * @returns {Array<string>}
     */
    primaryKeyNames(cubeName: string): Array<string>;
    primaryKeyName(cubeName: any, primaryKey: any): string;
    evaluateSql(cubeName: any, sql: any, options: any): any;
    withCubeAliasPrefix(cubeAliasPrefix: any, fn: any): any;
    /**
     * Evaluate escaped SQL-alias for cube or cube's property
     * (measure, dimension).
     * @param {string} cubeName
     * @returns string
     */
    cubeAlias(cubeName: string): string;
    /**
     *
     * @param fn
     * @returns {Array<string>}
     */
    collectCubeNamesFor(fn: any): Array<string>;
    collectJoinHintsFor(fn: any): never[];
    /**
     *
     * @param fn
     * @returns {Array<string>}
     */
    collectMemberNamesFor(fn: any): Array<string>;
    collectAllMemberNames(): string[];
    collectMultipliedMeasures(context: any): (fn: any) => any[];
    collectLeafMeasures(fn: any): unknown[];
    /**
     * @template T
     * @param {() => T} fn
     * @param {unknown} context
     * @returns {T}
     */
    evaluateSymbolSqlWithContext<T_2>(fn: () => T_2, context: unknown): T_2;
    evaluateSymbolContext: any;
    renderSqlMeasure(name: any, evaluateSql: any, symbol: any, cubeName: any, parentMeasure: any, orderBySql: any): any;
    aggregateOnGroupedColumn(symbol: any, evaluateSql: any, topLevelMerge: any, measurePath: any): string | void;
    topAggregateWrap(symbol: any, evaluateSql: any): any;
    hllInit(_sql: any): void;
    hllMerge(_sql: any): void;
    hllCardinality(_sql: any): void;
    hllMergeOnly(sql: any): void;
    hllCardinalityMerge(sql: any): void;
    castToString(sql: any): string;
    countDistinctApprox(sql: any): void;
    primaryKeyCount(cubeName: any, distinct: any): string;
    renderDimensionCase(symbol: any, cubeName: any): string;
    renderDimensionCaseLabel(label: any, cubeName: any): any;
    caseWhenStatement(when: any, elseLabel: any): string;
    applyMeasureFilters(evaluateSql: any, symbol: any, cubeName: any): any;
    evaluateMeasureFilters(symbol: any, cubeName: any): any;
    evaluateFiltersArray(filtersArray: any, cubeName: any): any;
    /**
     * @param {string} primaryKeyName
     * @param {string} cubeName
     * @returns {unknown}
     */
    primaryKeySql(primaryKeyName: string, cubeName: string): unknown;
    /**
     * @param cubeName
     * @returns Boolean
     */
    multipliedJoinRowResult(cubeName: any): boolean;
    inDbTimeZone(date: any): string | null;
    /**
     * @return {string}
     */
    timestampFormat(): string;
    /**
     * @return {number}
     */
    timestampPrecision(): number;
    /**
     * @param {string} field
     * @return {string}
     */
    convertTz(field: string): string;
    /**
     * @param {string} granularity
     * @param {string} dimension
     * @return {string}
     */
    timeGroupedColumn(granularity: string, dimension: string): string;
    /**
     * Returns sql for source expression floored to timestamps aligned with
     * intervals relative to origin timestamp point
     * @param {string} interval (a value expression of type interval)
     * @param {string} source (a value expression of type timestamp/date)
     * @param {string} origin (a value expression of type timestamp/date without timezone)
     * @returns {string}
     */
    dateBin(interval: string, source: string, origin: string): string;
    /**
     * Returns the lowest time unit for the interval
     * @protected
     * @param {string} interval
     * @returns {string}
     */
    protected diffTimeUnitForInterval(interval: string): string;
    /**
     * @param {string} dimension
     * @param {import('./Granularity').Granularity} granularity
     * @return {string}
     */
    dimensionTimeGroupedColumn(dimension: string, granularity: import('./Granularity').Granularity): string;
    /**
     * Evaluate alias for specific cube's property.
     * @param {string} name Property name.
     * @param {boolean?} isPreAggregationName Pre-agg flag.
     * @returns {string}
     */
    aliasName(name: string, isPreAggregationName?: boolean | null): string;
    /**
     *
     * @param {unknown} options
     * @returns {this}
     */
    newSubQuery(options: unknown): this;
    newSubQueryForCube(cube: any, options: any): any;
    subQueryOptions(options: any): any;
    cacheKeyQueries(transformFn: any): any;
    refreshKeysByCubes(cubes: any, transformFn: any): any;
    aggSelectForDimension(cube: any, dimension: any, aggFunction: any): string;
    cubeCardinalityQueries(): {
        [index: string]: [string, unknown[]];
    };
    renewalThreshold(refreshKeyAllSetManually: any): number;
    nowTimestampSql(): string;
    unixTimestampSql(): string;
    preAggregationTableName(cube: any, preAggregationName: any, skipSchema: any): string;
    preAggregationSchema(): any;
    preAggregationLoadSql(cube: any, preAggregation: any, tableName: any): any[];
    preAggregationPreviewSql(tableName: any): [string, unknown[]];
    indexSql(cube: any, preAggregation: any, index: any, indexName: any, tableName: any): any;
    evaluateIndexColumns(cube: any, index: any): any;
    createIndexSql(indexName: any, tableName: any, escapedColumns: any): string;
    preAggregationSql(cube: any, preAggregation: any): any;
    preAggregationOutputColumnTypes(cube: any, preAggregation: any): any;
    preAggregationUniqueKeyColumns(cube: any, preAggregation: any): any;
    preAggregationReadOnly(_cube: any, _preAggregation: any): boolean;
    preAggregationAllowUngroupingWithPrimaryKey(_cube: any, _preAggregation: any): boolean;
    /**
     * @public
     * @returns {any}
     */
    public sqlTemplates(): any;
    /**
     *
     * @param cube
     * @param preAggregation
     * @returns {BaseQuery}
     */
    preAggregationQueryForSqlEvaluation(cube: any, preAggregation: any, context?: {}): BaseQuery;
    parseCronSyntax(every: any): {
        start: cronParser.CronDate;
        end: cronParser.CronDate;
        dayOffset: number;
    };
    calcIntervalForCronString(refreshKey: any): {
        utcOffset: number;
        interval: number;
        dayOffset: number;
    };
    everyRefreshKeySql(refreshKey: any, external?: boolean): any;
    granularityFor(momentDate: any): "hour" | "day" | "week" | "month" | "year" | "minute" | "second";
    /**
     * @protected
     * @param {string} interval
     * @return {[number, string]}
     */
    protected parseInterval(interval: string): [number, string];
    negateInterval(interval: any): string;
    parseSecondDuration(interval: any): number;
    floorSql(numeric: any): string;
    incrementalRefreshKey(query: any, originalRefreshKey: any, options?: {}): any;
    defaultRefreshKeyRenewalThreshold(): number;
    defaultEveryRefreshKey(): {
        every: string;
    };
    /**
     * Some databases can return dynamically column name, for example Cube Store
     *
     * SELECT FLOOR((UNIX_TIMESTAMP()) / 60);
     * +-------------------------------------------+
     * | floor(Int64(1625395697) Divide Int64(60)) |
     * +-------------------------------------------+
     * | 27089928                                  |
     * +-------------------------------------------+
     * 1 row in set (0.00 sec)
     *
     * @protected
     *
     * @param {string} sql
     * @return {string}
     */
    protected refreshKeySelect(sql: string): string;
    partitionInvalidateKeyQueries(_cube: any, _preAggregation: any): void;
    preAggregationInvalidateKeyQueries(cube: any, preAggregation: any, preAggregationName: any): any;
    refreshKeyRenewalThresholdForInterval(refreshKey: any, everyWithoutSql?: boolean): number;
    preAggregationStartEndQueries(cube: any, preAggregation: any): [string, unknown[]][];
    parametrizedContextSymbols(): any;
    parametrizedContextSymbolsValue: any;
    securityContextForRust(): object;
    sqlUtilsForRust(): {
        convertTz: (field: string) => string;
    };
    contextSymbolsProxy(symbols: any): object;
    filtersProxy(): {};
    filtersProxyForRust(usedFilters: any): {};
    filterGroupFunctionForRust(usedFilters: any): (...filterParamArgs: any[]) => string;
    filterGroupFunction(): (...filterParamArgs: any[]) => string;
    filterGroupFunctionImpl(allFilters: any): (...filterParamArgs: any[]) => string;
    /**
     *
     * @param {boolean} excludeSegments
     * @returns {Array<BaseMeasure | BaseDimension | BaseSegment>}
     */
    flattenAllMembers(excludeSegments?: boolean): Array<BaseMeasure | BaseDimension | BaseSegment>;
    /**
     * @returns {Record<string, string>}
     */
    allBackAliasTimeDimensions(): Record<string, string>;
    /**
     * @returns {Record<string, string>}
     */
    allBackAliasMembersExceptSegments(): Record<string, string>;
    /**
     * @returns {Record<string, string>}
     */
    allBackAliasMembers(): Record<string, string>;
    /**
     *
     * @param {Array<BaseMeasure | BaseDimension | BaseSegment>} members
     * @returns {Record<string, string>}
     */
    backAliasMembers(members: Array<BaseMeasure | BaseDimension | BaseSegment>): Record<string, string>;
    buildJoinPathFn(): (target: any) => string | null;
    /**
     * Returns a function that constructs the full member path
     * based on the query's join structure.
     * @returns {(function(member: string): (string))}
     */
    resolveFullMemberPathFn(): ((arg0: member) => string);
}
/**
 * Set of the schema compilers.
 */
export type Compilers = {
    compiler: import('../compiler/DataSchemaCompiler').DataSchemaCompiler;
    metaTransformer: import('../compiler/CubeToMetaTransformer').CubeToMetaTransformer;
    cubeEvaluator: import('../compiler/CubeEvaluator').CubeEvaluator;
    contextEvaluator: import('../compiler/ContextEvaluator').ContextEvaluator;
    joinGraph: import('../compiler/JoinGraph').JoinGraph;
    compilerCache: import('../compiler/CompilerCache').CompilerCache;
    headCommitId: any;
};
export type JoinRoot = {
    sql: string;
    alias: string;
};
export type JoinItem = {
    sql: string;
    alias: string;
    on: string;
};
export type JoinChain = [JoinRoot, ...JoinItem];
import { BaseFilter } from './BaseFilter';
import { BaseGroupFilter } from './BaseGroupFilter';
import { ParamAllocator } from './ParamAllocator';
import { BaseTimeDimension } from './BaseTimeDimension';
import { BaseMeasure } from './BaseMeasure';
import { BaseDimension } from './BaseDimension';
import { BaseSegment } from './BaseSegment';
import { PreAggregations } from './PreAggregations';
import R from 'ramda';
import cronParser from 'cron-parser';
//# sourceMappingURL=BaseQuery.d.ts.map