export class CompilerApi {
    /**
     * Class constructor.
     * @param {SchemaFileRepository} repository
     * @param {DbTypeAsyncFn} dbType
     * @param {*} options
     */
    constructor(repository: SchemaFileRepository, dbType: DbTypeAsyncFn, options: any);
    repository: SchemaFileRepository;
    dbType: DbTypeAsyncFn;
    dialectClass: any;
    options: any;
    allowNodeRequire: any;
    logger: any;
    preAggregationsSchema: any;
    allowUngroupedWithoutPrimaryKey: any;
    convertTzForRawTimeDimension: any;
    schemaVersion: any;
    contextToRoles: any;
    contextToGroups: any;
    compileContext: any;
    allowJsDuplicatePropsInSchema: any;
    sqlCache: any;
    standalone: any;
    nativeInstance: NativeInstance;
    compiledScriptCache: LRUCache<{}, {}, unknown>;
    compiledScriptCacheInterval: NodeJS.Timeout;
    dispose(): void;
    setGraphQLSchema(schema: any): void;
    graphqlSchema: any;
    getGraphQLSchema(): any;
    createNativeInstance(): NativeInstance;
    getCompilers({ requestId }?: {
        requestId: any;
    }): Promise<any>;
    compilers: any;
    compilerVersion: any;
    /**
     * Creates the compilers instances without model compilation,
     * because it could fail and no compilers will be returned.
     */
    createCompilerInstances(): {
        compiler: import("@cubejs-backend/schema-compiler/dist/src/compiler/DataSchemaCompiler").DataSchemaCompiler;
        metaTransformer: import("@cubejs-backend/schema-compiler/dist/src/compiler/CubeToMetaTransformer").CubeToMetaTransformer;
        cubeEvaluator: import("@cubejs-backend/schema-compiler/dist/src/compiler/CubeEvaluator").CubeEvaluator;
        contextEvaluator: import("@cubejs-backend/schema-compiler/dist/src/compiler/ContextEvaluator").ContextEvaluator;
        joinGraph: import("@cubejs-backend/schema-compiler/dist/src/compiler/JoinGraph").JoinGraph;
        compilerCache: import("@cubejs-backend/schema-compiler/dist/src/compiler/CompilerCache").CompilerCache;
        headCommitId: string;
        compilerId: string;
    };
    compileSchema(compilerVersion: any, requestId: any): Promise<any>;
    queryFactory: QueryFactory;
    createQueryFactory(compilers: any): Promise<QueryFactory>;
    getDbType(dataSource?: string): Promise<any>;
    getDialectClass(dataSource: string, dbType: any): any;
    getSqlGenerator(query: any, dataSource: any): Promise<{
        sqlGenerator: any;
        compilers: any;
    }>;
    getSql(query: any, options?: {}): Promise<any>;
    getRolesFromContext(context: any): Promise<Set<any>>;
    getGroupsFromContext(context: any): Promise<Set<any>>;
    userHasRole(userRoles: any, role: any): any;
    userHasGroup(userGroups: any, group: any): any;
    roleMeetsConditions(evaluatedConditions: any): any;
    getCubesFromQuery(query: any, context: any): Promise<Set<any>>;
    hashRequestContext(context: any): any;
    getApplicablePolicies(cube: any, context: any, compilers: any): Promise<any>;
    evaluateNestedFilter(filter: any, cube: any, context: any, cubeEvaluator: any): {
        member: any;
        operator: any;
        values: any;
        or: any;
        and: any;
    };
    /**
     * This method rewrites the query according to RBAC row level security policies.
     *
     * If RBAC is enabled, it looks at all the Cubes from the query with accessPolicy defined.
     * It extracts all policies applicable to for the current user context (contextToRoles() + conditions).
     * It then generates an rls filter by
     * - combining all filters for the same role with AND
     * - combining all filters for different roles with OR
     * - combining cube and view filters with AND
    */
    applyRowLevelSecurity(query: any, evaluatedQuery: any, context: any): Promise<{
        query: any;
        denied: boolean;
    }>;
    removeEmptyFilters(filter: any): any;
    buildFinalRlsFilter(cubeFiltersPerCubePerRole: any, viewFiltersPerCubePerRole: any, hasAllowAllForCube: any): any;
    compilerCacheFn(requestId: any, key: any, path: any): Promise<(subKey: any, cacheFn: any) => any>;
    /**
     *
     * @param {unknown} filter
     * @returns {Promise<Array<PreAggregationInfo>>}
     */
    preAggregations(filter: unknown): Promise<Array<PreAggregationInfo>>;
    scheduledPreAggregations(): Promise<any>;
    createQueryByDataSource(compilers: any, query: any, dataSource: any, dbType: any): Promise<any>;
    createQuery(compilers: any, dbType: any, dialectClass: any, query: any): any;
    /**
     * if RBAC is enabled, this method is used to patch isVisible property of cube members
     * based on access policies.
    */
    patchVisibilityByAccessPolicy(compilers: any, context: any, cubes: any): Promise<{
        cubes: any;
        visibilityMaskHash: string;
    }>;
    mixInVisibilityMaskHash(compilerId: any, visibilityMaskHash: any): string;
    metaConfig(requestContext: any, options?: {}): Promise<any>;
    metaConfigExtended(requestContext: any, options: any): Promise<{
        metaConfig: any;
        cubeDefinitions: any;
    }>;
    compilerId(options?: {}): Promise<any>;
    cubeNameToDataSource(query: any): Promise<any>;
    memberToDataSource(query: any): Promise<{
        [k: string]: any;
    }>;
    dataSources(orchestratorApi: any, query: any): Promise<{
        dataSources: any[];
    }>;
    canUsePreAggregationForTransformedQuery(transformedQuery: any, refs: any): import("@cubejs-backend/schema-compiler").CanUsePreAggregationFn;
}
import { NativeInstance } from '@cubejs-backend/native';
import { LRUCache } from 'lru-cache';
import { QueryFactory } from '@cubejs-backend/schema-compiler';
//# sourceMappingURL=CompilerApi.d.ts.map