/**
 * 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 { type RenderResult } from '@testing-library/react';
import { type AbstractPlugin, type AbstractPreset, type PlainObject } from '@finos/legend-shared';
import { LegendDataCubePluginManager } from '../../application/LegendDataCubePluginManager.js';
import { type LegendDataCubeBuilderState, LegendDataCubeBuilderStore } from '../../stores/builder/LegendDataCubeBuilderStore.js';
import { type LegendDataCubeApplicationStore, LegendDataCubeBaseStore } from '../../stores/LegendDataCubeBaseStore.js';
import { V1_EngineServerClient, type PersistentDataCube, type V1_Query, V1_PureGraphManager, V1_PureModelContextData, type V1_EntitlementsDataProductDetailsResponse } from '@finos/legend-graph';
import type { Entity } from '@finos/legend-storage';
import { LegendDataCubeDataCubeEngine } from '../../stores/LegendDataCubeDataCubeEngine.js';
import { DepotServerClient } from '@finos/legend-server-depot';
import { LakehouseContractServerClient, LakehouseIngestServerClient } from '@finos/legend-server-lakehouse';
export declare const DEFAULT_MOCK_ADHOC_DATA_PRODUCT: PlainObject;
export declare const DEFAULT_MOCK_PMCD: PlainObject<V1_PureModelContextData>;
export declare const TEST__provideMockedLegendDataCubeEngine: (customization?: {
    mock?: LegendDataCubeDataCubeEngine | undefined;
    applicationStore?: LegendDataCubeApplicationStore | undefined;
    pluginManager?: LegendDataCubePluginManager | undefined;
    extraPlugins?: AbstractPlugin[] | undefined;
    extraPresets?: AbstractPreset[] | undefined;
    depotServerClient?: DepotServerClient | undefined;
    enginerServerClient?: V1_EngineServerClient | undefined;
    lakehouseContractServerClient?: LakehouseContractServerClient | undefined;
    ingestServer?: LakehouseIngestServerClient | undefined;
    graphManager?: V1_PureGraphManager | undefined;
    mockPMCD?: PlainObject<V1_PureModelContextData>;
    mockEntitlementsAdHocDataProduct?: PlainObject<V1_EntitlementsDataProductDetailsResponse>;
}) => Promise<LegendDataCubeDataCubeEngine>;
export declare const mockLakehouseConsumerAdHocDataProduct: {
    _type: string;
    warehouse: string;
    environment: string;
    paths: string[];
    origin: {
        _type: string;
    };
    deploymentId: number;
};
export declare const mockLakehouseProducerAdHocDataProduct: {
    _type: string;
    ingestDefinitionUrn: string;
    warehouse: string;
    ingestServerUrl: string;
    paths: string[];
};
export declare const columns: {
    name: string;
    type: string;
}[];
export declare const mockAdHocDataProductPMCD: {
    _type: string;
    elements: ({
        _type: string;
        package: string;
        name: string;
        owner: {
            _type: string;
            production: {
                appDirId: number;
                level: string;
            };
        };
        title?: never;
        description?: never;
        accessPointGroups?: never;
        sections?: never;
    } | {
        _type: string;
        package: string;
        name: string;
        title: string;
        description: string;
        accessPointGroups: {
            _type: string;
            id: string;
            description: string;
            accessPoints: {
                _type: string;
                id: string;
                func: {
                    _type: string;
                    body: {
                        _type: string;
                        type: string;
                        value: {
                            metadata: boolean;
                            path: string[];
                        };
                    }[];
                    parameters: never[];
                };
            }[];
        }[];
        owner?: never;
        sections?: never;
    } | {
        package: string;
        name: string;
        sections: ({
            parserName: string;
            elements: string[];
            _type: string;
            imports?: never;
        } | {
            parserName: string;
            elements: string[];
            imports: never[];
            _type: string;
        })[];
        _type: string;
        owner?: never;
        title?: never;
        description?: never;
        accessPointGroups?: never;
    })[];
};
export declare const TEST__provideMockedLegendDataCubeBaseStore: (customization?: {
    mock?: LegendDataCubeBaseStore | undefined;
    applicationStore?: LegendDataCubeApplicationStore | undefined;
    pluginManager?: LegendDataCubePluginManager | undefined;
    extraPlugins?: AbstractPlugin[] | undefined;
    extraPresets?: AbstractPreset[] | undefined;
}) => Promise<LegendDataCubeBaseStore>;
export declare const TEST__provideMockedLegendDataCubeBuilderStore: (customization?: {
    mock?: LegendDataCubeBuilderStore;
    mockBaseStore?: LegendDataCubeBaseStore;
    applicationStore?: LegendDataCubeApplicationStore;
    pluginManager?: LegendDataCubePluginManager;
    extraPlugins?: AbstractPlugin[];
    extraPresets?: AbstractPreset[];
}) => Promise<LegendDataCubeBuilderStore>;
export declare const TEST__setUpDataCubeBuilder: (MOCK__builderStore: LegendDataCubeBuilderStore, mockDataCube?: PersistentDataCube, mockQuery?: V1_Query, mockEntities?: PlainObject<Entity>[], forceUseInputModel?: boolean) => Promise<{
    renderResult: RenderResult;
    legendDataCubeBuilderState: LegendDataCubeBuilderState | undefined;
}>;
//# sourceMappingURL=LegendDataCubeStoreTestUtils.d.ts.map