/**
 * Copyright (c) 2020-present, Goldman Sachs
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import { V1_Lambda, type V1_ValueSpecification, type V1_EngineServerClient, V1_PureGraphManager, TDSExecutionResult, V1_PureModelContextData, V1_AppliedFunction, V1_Variable, type QueryInfo, type V1_PureModelContext } from '@finos/legend-graph';
import { DataCubeEngine, type CompletionItem, CachedDataCubeSource, type DataCubeExecutionOptions, type DataCubeCacheInitializationOptions, type DataCubeSource, DataCubeGridClientExportFormat } from '@finos/legend-data-cube';
import { LogEvent, type PlainObject, type StopWatch, type TimingsRecord } from '@finos/legend-shared';
import type { LegendDataCubeApplicationStore } from './LegendDataCubeBaseStore.js';
import { RawLegendQueryDataCubeSource } from './model/LegendQueryDataCubeSource.js';
import { type DepotServerClient } from '@finos/legend-server-depot';
import { type LakehouseContractServerClient, type LakehouseIngestServerClient } from '@finos/legend-server-lakehouse';
export declare class LegendDataCubeDataCubeEngine extends DataCubeEngine {
    private readonly _application;
    private readonly _depotServerClient;
    private readonly _engineServerClient;
    private readonly _lakehouseContractServerClient;
    private readonly _lakehouseIngestServerClient;
    private readonly _graphManager;
    private readonly _duckDBEngine;
    private _secondaryOauthClient?;
    private LAKEHOUSE_SECTION;
    constructor(application: LegendDataCubeApplicationStore, depotServerClient: DepotServerClient, engineServerClient: V1_EngineServerClient, lakehouseContractServerClient: LakehouseContractServerClient, lakehouseIngestServerClient: LakehouseIngestServerClient, graphManager: V1_PureGraphManager);
    private get secondaryOauthClient();
    initialize(): Promise<void>;
    dispose(): Promise<void>;
    getDataFromSource(source?: DataCubeSource): PlainObject;
    getDataFromRawSource(source?: PlainObject): PlainObject;
    finalizeTimingRecord(stopWatch: StopWatch, timings?: TimingsRecord): TimingsRecord | undefined;
    processSource(value: PlainObject): Promise<DataCubeSource>;
    parseValueSpecification(code: string, returnSourceInformation?: boolean | undefined): Promise<V1_ValueSpecification>;
    getValueSpecificationCode(value: V1_ValueSpecification, pretty?: boolean | undefined): Promise<string>;
    getQueryTypeahead(code: string, baseQuery: V1_Lambda, context: DataCubeSource | PlainObject): Promise<CompletionItem[]>;
    getQueryRelationReturnType(query: V1_Lambda, source: DataCubeSource): Promise<{
        columns: {
            name: string;
            type: string;
        }[];
    }>;
    getQueryCodeRelationReturnType(code: string, baseQuery: V1_ValueSpecification, source: DataCubeSource): Promise<{
        columns: {
            name: string;
            type: string;
        }[];
    }>;
    executeQuery(query: V1_Lambda, source: DataCubeSource, options?: DataCubeExecutionOptions | undefined): Promise<{
        result: TDSExecutionResult;
        executedQuery: string;
        executedSQL: string | undefined;
        executionTime: number;
    }>;
    exportData(query: V1_Lambda, source: DataCubeSource, format: DataCubeGridClientExportFormat, options?: DataCubeExecutionOptions | undefined): Promise<void | Response>;
    private _processLegendQueryParams;
    buildExecutionContext(source: DataCubeSource): V1_AppliedFunction | undefined;
    parseCompatibleModel(code: string): Promise<PlainObject<V1_PureModelContextData>>;
    initializeCache(source: DataCubeSource, options?: DataCubeCacheInitializationOptions | undefined): Promise<CachedDataCubeSource | undefined>;
    disposeCache(source: CachedDataCubeSource): Promise<void>;
    private _getQueryRelationType;
    private _getLambdaReturnType;
    _getLambdaRelationType(lambda: PlainObject<V1_Lambda>, model: PlainObject<V1_PureModelContext>): Promise<{
        columns: {
            name: string;
            type: string;
        }[];
    }>;
    _getQueryParameterValues(rawSource: RawLegendQueryDataCubeSource, lambda: V1_Lambda, queryInfo: QueryInfo): Promise<{
        variable: V1_Variable;
        valueSpec: V1_ValueSpecification;
    }[]>;
    private _runQuery;
    private _runExportQuery;
    private _generateExecutionPlan;
    ingestLocalFileData(data: string, format: string, refId?: string): Promise<{
        dbReference: string;
        columnNames: string[];
    }>;
    private _getColumnType;
    private _synthesizeMinimalModelContext;
    private _synthesizeLakehouseProducerPMCD;
    private _synthesizeLakehouseConsumerPMCD;
    logDebug(message: string, ...data: unknown[]): void;
    debugProcess(processName: string, ...data: [string, unknown][]): void;
    logInfo(event: LogEvent, ...data: unknown[]): void;
    logWarning(event: LogEvent, ...data: unknown[]): void;
    logError(event: LogEvent, ...data: unknown[]): void;
    logUnhandledError(error: Error): void;
    logIllegalStateError(message: string, error?: Error): void;
    getDocumentationEntry(key: string): import("@finos/legend-shared").DocumentationEntry | undefined;
    openLink(url: string): void;
    sendTelemetry(event: string, data: PlainObject): void;
    private _isPermissionDeniedError;
}
//# sourceMappingURL=LegendDataCubeDataCubeEngine.d.ts.map