/**
 * 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 { ExecutionResult, EXECUTION_SERIALIZATION_FORMAT, ExecutionResultWithMetadata } from './action/execution/ExecutionResult.js';
import type { ServiceRegistrationResult, ServiceRegistrationSuccess } from './action/service/ServiceRegistrationResult.js';
import type { Service } from '../graph/metamodel/pure/packageableElements/service/Service.js';
import type { FileGenerationSpecification } from '../graph/metamodel/pure/packageableElements/fileGeneration/FileGenerationSpecification.js';
import type { GenerationOutput } from './action/generation/GenerationOutput.js';
import type { PackageableElement } from '../graph/metamodel/pure/packageableElements/PackageableElement.js';
import { PureModel, CoreModel, SystemModel, GenerationModel, type GraphTextInputOption } from '../graph/PureModel.js';
import type { Mapping } from '../graph/metamodel/pure/packageableElements/mapping/Mapping.js';
import type { Runtime } from '../graph/metamodel/pure/packageableElements/runtime/Runtime.js';
import { DependencyManager } from '../graph/DependencyManager.js';
import type { Class } from '../graph/metamodel/pure/packageableElements/domain/Class.js';
import type { RawLambda } from '../graph/metamodel/pure/rawValueSpecification/RawLambda.js';
import type { GenerationConfigurationDescription, GenerationMode } from './action/generation/GenerationConfigurationDescription.js';
import type { ValueSpecification } from '../graph/metamodel/pure/valueSpecification/ValueSpecification.js';
import type { RawValueSpecification } from '../graph/metamodel/pure/rawValueSpecification/RawValueSpecification.js';
import type { ServiceExecutionMode } from './action/service/ServiceExecutionMode.js';
import type { TEMPORARY__AbstractEngineConfig } from './action/TEMPORARY__AbstractEngineConfig.js';
import type { DatabaseBuilderInput } from './action/generation/DatabaseBuilderInput.js';
import type { RawRelationalOperationElement } from '../graph/metamodel/pure/packageableElements/store/relational/model/RawRelationalOperationElement.js';
import type { ExecutionPlan, RawExecutionPlan } from '../graph/metamodel/pure/executionPlan/ExecutionPlan.js';
import type { ExecutionNode } from '../graph/metamodel/pure/executionPlan/nodes/ExecutionNode.js';
import { type ContentType, type LogService, type PlainObject, type ServerClientConfig, type TracerService, ActionState } from '@finos/legend-shared';
import type { LightQuery, Query, QueryInfo } from './action/query/Query.js';
import type { EntitiesWithOrigin, Entity } from '@finos/legend-storage';
import type { QuerySearchSpecification } from './action/query/QuerySearchSpecification.js';
import type { ExternalFormatDescription } from './action/externalFormat/ExternalFormatDescription.js';
import type { ConfigurationProperty } from '../graph/metamodel/pure/packageableElements/fileGeneration/ConfigurationProperty.js';
import type { GraphManagerOperationReport } from './GraphManagerStatistics.js';
import type { RunTestsTestableInput } from '../graph/metamodel/pure/test/result/RunTestsTestableInput.js';
import type { TestResult } from '../graph/metamodel/pure/test/result/TestResult.js';
import type { GraphManagerPluginManager } from './GraphManagerPluginManager.js';
import type { MappingModelCoverageAnalysisResult, RawMappingModelCoverageAnalysisResult } from './action/analytics/MappingModelCoverageAnalysis.js';
import type { SchemaSet } from '../graph/metamodel/pure/packageableElements/externalFormat/schemaSet/DSL_ExternalFormat_SchemaSet.js';
import type { CompilationResult, TextCompilationResult } from './action/compilation/CompilationResult.js';
import type { ParameterValue, PostValidationAssertionResult } from '../DSL_Service_Exports.js';
import type { ModelUnit } from '../graph/metamodel/pure/packageableElements/externalFormat/store/DSL_ExternalFormat_ModelUnit.js';
import type { DatasetEntitlementReport, DatasetSpecification } from './action/analytics/StoreEntitlementAnalysis.js';
import type { GraphDataOrigin } from '../graph/GraphDataOrigin.js';
import type { GraphData } from './GraphData.js';
import type { DEPRECATED__MappingTest } from '../graph/metamodel/pure/packageableElements/mapping/DEPRECATED__MappingTest.js';
import type { EnumerationMapping } from '../graph/metamodel/pure/packageableElements/mapping/EnumerationMapping.js';
import type { SetImplementation } from '../graph/metamodel/pure/packageableElements/mapping/SetImplementation.js';
import type { AssociationImplementation } from '../graph/metamodel/pure/packageableElements/mapping/AssociationImplementation.js';
import { InstanceSetImplementation } from '../graph/metamodel/pure/packageableElements/mapping/InstanceSetImplementation.js';
import type { SourceInformation } from './action/SourceInformation.js';
import type { ClassifierPathMapping, SubtypeInfo } from './action/protocol/ProtocolInfo.js';
import type { FunctionActivatorConfiguration } from './action/functionActivator/FunctionActivatorConfiguration.js';
import type { RelationalDatabaseTypeConfiguration } from './action/relational/RelationalDatabaseTypeConfiguration.js';
import type { FunctionActivator } from '../graph/metamodel/pure/packageableElements/function/FunctionActivator.js';
import type { RelationalDatabaseConnection } from '../STO_Relational_Exports.js';
import type { ArtifactGenerationExtensionResult } from './action/generation/ArtifactGenerationExtensionResult.js';
import type { TestDataGenerationResult } from '../graph/metamodel/pure/packageableElements/service/TestGenerationResult.js';
import type { TableRowIdentifiers } from '../graph/metamodel/pure/packageableElements/service/TableRowIdentifiers.js';
import type { EngineError } from './action/EngineError.js';
import type { TestDebug } from '../graph/metamodel/pure/test/result/DebugTestsResult.js';
import type { RelationTypeMetadata } from './action/relation/RelationTypeMetadata.js';
import type { CodeCompletionResult } from './action/compilation/Completion.js';
import type { DeploymentResult } from './action/DeploymentResult.js';
import type { LightPersistentDataCube, PersistentDataCube } from './action/query/PersistentDataCube.js';
import type { LineageModel, RawLineageModel } from '../graph/metamodel/pure/lineage/LineageModel.js';
import type { DeployProjectResponse } from './action/dev-metadata/DeployProjectResponse.js';
import type { MetadataRequestOptions } from './action/dev-metadata/MetadataRequestOptions.js';
export interface TEMPORARY__EngineSetupConfig {
    env: string;
    tabSize: number;
    clientConfig: ServerClientConfig;
    /**
     * Theses are workarounds we need to manually supply the configuration data
     * for roundtrip grammar test, as the network call to engine is blocked in test
     * environment, till we figure out the best way to do this, we can remove this
     * config
     */
    TEMPORARY__classifierPathMapping?: ClassifierPathMapping[] | undefined;
    TEMPORARY__subtypeInfo?: SubtypeInfo | undefined;
}
export interface GraphBuilderOptions {
    /**
     * This flag will be kept until we have full support for section index
     * See https://github.com/finos/legend-studio/issues/1067
     */
    TEMPORARY__preserveSectionIndex?: boolean;
    /**
     * If strict mode is enabled, certain validations, which, in normal mode, are often considered as warnings or non-problems,
     * will be treated as error and will be thrown. This is to compensate for discrepancies in strictness between engine compilation
     * and graph builder algorithm. Ideally, a lot of these errors will eventually be treated as errors by engine compilation.
     *
     * See https://github.com/finos/legend-studio/issues/941
     */
    strict?: boolean;
    /**
     * This ties a graph to an sdlc pointer. Meaning the graph is immutable and tied to a specific `versioned` SDLC.
     */
    origin?: GraphDataOrigin | undefined;
}
export interface ExecutionOptions {
    /**
     * Use lossless algorithm while parsing the execution result object.
     * NOTE: This will result in numeric values being stored as object instead of primitive type number values.
     */
    useLosslessParse?: boolean | undefined;
    convertUnsafeNumbersToString?: boolean | undefined;
    serializationFormat?: EXECUTION_SERIALIZATION_FORMAT | undefined;
    parameterValues?: ParameterValue[];
    abortController?: AbortController | undefined;
    preservedResponseHeadersList?: string[];
    tracingtags?: PlainObject | undefined;
    /**
     * If set will force lambda to append ->from(mapping/runtime)
     * instead of providing in separate input property
     */
    forceFromExpression?: boolean | undefined;
}
export interface ServiceRegistrationOptions {
    TEMPORARY__useStoreModel?: boolean | undefined;
    TEMPORARY__semiInteractiveOverridePattern?: string | undefined;
    TEMPORARY__useGenerateLineage?: boolean | undefined;
    TEMPORARY__useGenerateOpenApi?: boolean | undefined;
}
export declare abstract class AbstractPureGraphManagerExtension {
    graphManager: AbstractPureGraphManager;
    constructor(graphManager: AbstractPureGraphManager);
    abstract getSupportedProtocolVersion(): string;
}
export declare abstract class AbstractPureGraphManager {
    readonly extensions: AbstractPureGraphManagerExtension[];
    readonly pluginManager: GraphManagerPluginManager;
    readonly logService: LogService;
    constructor(pluginManager: GraphManagerPluginManager, logService: LogService);
    /**
     * TODO: we should not expose a fixed config like this, we probably
     * should not mention anything about engine because it is an internal construct
     * used by the graph manager, different graph manager may not need engine.
     *
     * As such, we should expose a generic config instead.
     * See https://github.com/finos/legend-studio/issues/407
     */
    abstract TEMPORARY__getEngineConfig(): TEMPORARY__AbstractEngineConfig;
    abstract initialize(config: TEMPORARY__EngineSetupConfig, options?: {
        tracerService?: TracerService | undefined;
        disableGraphConfiguration?: boolean | undefined;
    }): Promise<void>;
    abstract getSupportedProtocolVersion(): string;
    /**
     * Removes the SectionIndex from the list of enitites
     */
    abstract getElementEntities(entities: Entity[]): Entity[];
    /**
     * Build immutable system models
     *
     * NOTE: Ideally should only be build once since the elements will never change in these models
     * System models MUST not depend on the main model, dependency models, nor generation models.
     */
    abstract buildSystem(coreModel: CoreModel, systemModel: SystemModel, buildState: ActionState, options?: GraphBuilderOptions, report?: GraphManagerOperationReport): Promise<void>;
    /**
     * Build immutable models which holds dependencies.
     * Dependency models MUST not depend on the main model.
     *
     * NOTE: loading all dependencies in the graph like this can be costly and definitely not scalable, so we might need to modify this in the future
     * As such, we might want to compress the dependency models to a smaller shape (or this could be done in the server) and only maintain that
     * so the app can use less memory
     */
    abstract buildDependencies(coreModel: CoreModel, systemModel: SystemModel, dependencyManager: DependencyManager, dependencyEntitiesIndex: Map<string, EntitiesWithOrigin>, buildState: ActionState, options?: GraphBuilderOptions, report?: GraphManagerOperationReport): Promise<void>;
    /**
     * Process entities and build the main graph.
     */
    abstract buildGraph(graph: PureModel, entities: Entity[], buildState: ActionState, options?: GraphBuilderOptions, report?: GraphManagerOperationReport): Promise<void>;
    /**
     * Process entities and build the light graph.
     */
    abstract buildLightGraph(graph: PureModel, entities: Entity[], buildState: ActionState, options?: GraphBuilderOptions, report?: GraphManagerOperationReport): Promise<void>;
    abstract buildGenerations(graph: PureModel, generationEntities: Map<string, Entity[]>, buildState: ActionState, options?: GraphBuilderOptions, report?: GraphManagerOperationReport): Promise<void>;
    abstract graphToPureCode(graph: PureModel, options?: {
        pretty?: boolean | undefined;
        excludeUnknown?: boolean | undefined;
    }): Promise<string>;
    abstract pureCodeToEntities(code: string, options?: {
        sourceInformationIndex?: Map<string, SourceInformation>;
        TEMPORARY__keepSectionIndex?: boolean;
    }): Promise<Entity[]>;
    abstract entitiesToPureCode(entities: Entity[], options?: {
        pretty?: boolean | undefined;
    }): Promise<string>;
    abstract pureCodeToLambda(lambda: string, lambdaId?: string, options?: {
        pruneSourceInformation?: boolean;
    }): Promise<RawLambda>;
    abstract prettyLambdaContent(lambda: string): Promise<string>;
    abstract lambdaToPureCode(lambda: RawLambda, pretty?: boolean): Promise<string>;
    abstract lambdasToPureCode(lambdas: Map<string, RawLambda>, pretty?: boolean): Promise<Map<string, string>>;
    abstract valueSpecificationsToPureCode(lambdas: Map<string, ValueSpecification>, pretty?: boolean): Promise<Map<string, string>>;
    abstract valueSpecificationToPureCode(valSpec: PlainObject<ValueSpecification>, pretty?: boolean): Promise<string>;
    abstract pureCodeToValueSpecification(valSpec: string, returnSourceInformation?: boolean): Promise<PlainObject<ValueSpecification>>;
    abstract pureCodeToValueSpecifications(lambdas: Map<string, string>, graph: PureModel): Promise<Map<string, ValueSpecification>>;
    abstract pureCodeToRelationalOperationElement(operation: string, operationId: string): Promise<RawRelationalOperationElement>;
    abstract relationalOperationElementToPureCode(operations: Map<string, RawRelationalOperationElement>): Promise<Map<string, string>>;
    abstract compileEntities(entities: Entity[]): Promise<void>;
    abstract compileGraph(graph: PureModel, options?: {
        onError?: () => void;
        keepSourceInformation?: boolean;
    }, report?: GraphManagerOperationReport): Promise<CompilationResult>;
    abstract compileText(graphGrammar: string, graph: PureModel, options?: {
        onError?: () => void;
    }, report?: GraphManagerOperationReport): Promise<TextCompilationResult>;
    abstract getLambdaReturnType(lambda: RawLambda, graph: PureModel, options?: {
        keepSourceInformation?: boolean;
    }): Promise<string>;
    abstract getLambdaRelationType(lambda: RawLambda, graph: PureModel, options?: {
        keepSourceInformation?: boolean;
    }): Promise<RelationTypeMetadata>;
    abstract getCodeComplete(codeBlock: string, graph: PureModel, offset: number | undefined, options?: {
        ignoreElements: string[] | undefined;
    }): Promise<CodeCompletionResult>;
    abstract getLambdasReturnType(lambdas: Map<string, RawLambda>, graph: PureModel): Promise<{
        results: Map<string, string>;
        errors: Map<string, EngineError>;
    }>;
    abstract createSandboxProject(): Promise<{
        projectId: string;
        webUrl: string | undefined;
        owner: string;
    }>;
    abstract userHasPrototypeProjectAccess(userId: string): Promise<boolean>;
    abstract pushToDevMetadata(groupId: string, artiactId: string, versionId: string | undefined, options: MetadataRequestOptions | undefined, graph: PureModel): Promise<DeployProjectResponse>;
    abstract runTests(inputs: RunTestsTestableInput[], graph: PureModel): Promise<TestResult[]>;
    abstract debugTests(inputs: RunTestsTestableInput[], graph: PureModel): Promise<TestDebug[]>;
    abstract buildValueSpecification(json: PlainObject, graph: PureModel): ValueSpecification;
    abstract serializeValueSpecification(valueSpecification: ValueSpecification): PlainObject;
    abstract transformValueSpecToRawValueSpec(valueSpecification: ValueSpecification, graph: PureModel): RawValueSpecification;
    abstract buildRawValueSpecification(valuSpec: object, graph: PureModel): RawValueSpecification;
    abstract serializeRawValueSpecification(rawValueSpecification: RawValueSpecification): PlainObject;
    abstract createGetAllRawLambda(_class: Class): RawLambda;
    abstract createDefaultBasicRawLambda(options?: {
        addDummyParameter?: boolean;
    }): RawLambda;
    abstract getAvailableGenerationConfigurationDescriptions(): Promise<GenerationConfigurationDescription[]>;
    abstract generateArtifacts(graph: PureModel, graphOptions?: GraphTextInputOption, elementPaths?: string[]): Promise<ArtifactGenerationExtensionResult>;
    abstract generateFile(fileGeneration: FileGenerationSpecification, generationMode: GenerationMode, graph: PureModel, graphOptions?: GraphTextInputOption): Promise<GenerationOutput[]>;
    abstract generateModel(generationElement: PackageableElement, graph: PureModel, graphOptions?: GraphTextInputOption): Promise<Entity[]>;
    abstract generateTestData(query: RawLambda, mapping: string, runtime: string, graph: PureModel): Promise<TestDataGenerationResult>;
    abstract getAvailableExternalFormatsDescriptions(): Promise<ExternalFormatDescription[]>;
    abstract generateModelFromExternalFormat(schemaSet: SchemaSet, targetBinding: string | undefined, configs: ConfigurationProperty[], graph: PureModel): Promise<string>;
    abstract generateSchemaFromExternalFormatConfig(modelUnit: ModelUnit, targetBinding: string | undefined, configurationProperties: ConfigurationProperty[], graph: PureModel): Promise<SchemaSet[]>;
    abstract getExamplePureProtocolText(): string;
    abstract getExampleExternalFormatImportText(): string;
    abstract entitiesToPureProtocolText(entities: Entity[]): Promise<string>;
    abstract pureProtocolTextToEntities(protocol: string): Entity[];
    abstract runQuery(lambda: RawLambda, mapping: Mapping | undefined, runtime: Runtime | undefined, graph: PureModel, options?: ExecutionOptions, report?: GraphManagerOperationReport): Promise<ExecutionResultWithMetadata>;
    abstract runQueryWithUncompiledGraph(lambda: RawLambda | string, mapping: string | undefined, runtime: string | undefined, graph: PureModel, options?: ExecutionOptions, report?: GraphManagerOperationReport): Promise<ExecutionResultWithMetadata>;
    abstract exportData(lambda: RawLambda, mapping: Mapping | undefined, runtime: Runtime | undefined, graph: PureModel, options?: ExecutionOptions | undefined, report?: GraphManagerOperationReport | undefined, contentType?: ContentType | undefined): Promise<Response>;
    abstract cancelUserExecutions(broadcastToCluster: boolean): Promise<string>;
    abstract DEPRECATED__runLegacyMappingTests(tests: {
        test: DEPRECATED__MappingTest;
        runtime: Runtime;
        handleResult: (val: ExecutionResult) => void;
        handleError: (message: Error) => void;
    }[], mapping: Mapping, graph: PureModel, options?: ExecutionOptions, _report?: GraphManagerOperationReport): Promise<void>;
    abstract generateExecutionPlan(lambda: RawLambda, mapping: Mapping | undefined, runtime: Runtime | undefined, graph: PureModel, options?: ExecutionOptions, report?: GraphManagerOperationReport): Promise<RawExecutionPlan>;
    abstract generateLineage(lambda: RawLambda, mapping: Mapping | undefined, runtime: Runtime | undefined, graph: PureModel, report?: GraphManagerOperationReport): Promise<RawLineageModel>;
    abstract debugExecutionPlanGeneration(lambda: RawLambda, mapping: Mapping | undefined, runtime: Runtime | undefined, graph: PureModel, options?: ExecutionOptions, report?: GraphManagerOperationReport): Promise<{
        plan: RawExecutionPlan;
        debug: string;
    }>;
    abstract generateExecuteTestData(lambda: RawLambda, parameters: (string | number | boolean)[], mapping: Mapping, runtime: Runtime, graph: PureModel, options?: {
        anonymizeGeneratedData?: boolean;
        parameterValues?: ParameterValue[];
    }, report?: GraphManagerOperationReport): Promise<string>;
    abstract generateExecuteTestDataWithSeedData(lambda: RawLambda, tableRowIdentifiers: TableRowIdentifiers[], mapping: Mapping, runtime: Runtime, graph: PureModel, options?: {
        anonymizeGeneratedData?: boolean;
        parameterValues?: ParameterValue[];
    }, report?: GraphManagerOperationReport): Promise<string>;
    abstract buildExecutionPlan(executionPlanJson: RawExecutionPlan, graph: PureModel): ExecutionPlan;
    abstract serializeExecutionPlan(executionPlan: ExecutionPlan): RawExecutionPlan;
    abstract buildLineage(lineageJSON: RawLineageModel): LineageModel;
    abstract serializeExecutionNode(executionNode: ExecutionNode): object;
    abstract analyzeExecuteInput(data: PlainObject, executablePath: string): Promise<{
        origin: GraphDataOrigin;
        entities: Entity[];
    }>;
    abstract searchQueries(searchSpecification: QuerySearchSpecification): Promise<LightQuery[]>;
    abstract getQueries(queryIds: string[]): Promise<LightQuery[]>;
    abstract getLightQuery(queryId: string): Promise<LightQuery>;
    abstract getQuery(queryId: string, graph: PureModel): Promise<Query>;
    abstract getQueryInfo(queryId: string): Promise<QueryInfo>;
    abstract createQuery(query: Query, graph: PureModel): Promise<Query>;
    abstract updateQuery(query: Query, graph: PureModel): Promise<Query>;
    abstract patchQuery(query: Partial<Query>, graph: PureModel): Promise<Query>;
    abstract renameQuery(queryId: string, queryName: string): Promise<LightQuery>;
    abstract deleteQuery(queryId: string): Promise<void>;
    abstract productionizeQueryToServiceEntity(query: QueryInfo, serviceConfig: {
        name: string;
        packageName: string;
        pattern: string;
        serviceOwners: string[];
    }, graph: Entity[]): Promise<Entity>;
    abstract resolveQueryInfoExecutionContext(query: QueryInfo, graphLoader: () => Promise<PlainObject<Entity>[]>): Promise<{
        mapping: string | undefined;
        runtime: string;
    }>;
    abstract searchDataCubes(searchSpecification: QuerySearchSpecification): Promise<LightPersistentDataCube[]>;
    abstract getDataCubes(ids: string[]): Promise<LightPersistentDataCube[]>;
    abstract getDataCube(id: string): Promise<PersistentDataCube>;
    abstract createDataCube(dataCube: PersistentDataCube): Promise<PersistentDataCube>;
    abstract updateDataCube(dataCube: PersistentDataCube): Promise<PersistentDataCube>;
    abstract deleteDataCube(id: string): Promise<void>;
    abstract analyzeMappingModelCoverage(mapping: Mapping, graph: PureModel): Promise<MappingModelCoverageAnalysisResult>;
    abstract buildMappingModelCoverageAnalysisResult(input: RawMappingModelCoverageAnalysisResult, mapping: Mapping): MappingModelCoverageAnalysisResult;
    abstract surveyDatasets(mapping: string, runtime: string, query: RawLambda | undefined, graphData: GraphData): Promise<DatasetSpecification[]>;
    abstract checkDatasetEntitlements(datasets: DatasetSpecification[], mapping: string, runtime: string, query: RawLambda | undefined, graphData: GraphData): Promise<DatasetEntitlementReport[]>;
    /**
     * TODO: Move these to store relational extension
     *
     * @modularize
     * See https://github.com/finos/legend-studio/issues/65
     */
    abstract buildDatabase(input: DatabaseBuilderInput): Promise<Entity[]>;
    abstract executeRawSQL(connection: RelationalDatabaseConnection, sql: string): Promise<string>;
    abstract getAvailableFunctionActivatorConfigurations(coreModel: CoreModel, systemModel: SystemModel): Promise<FunctionActivatorConfiguration[]>;
    abstract validateFunctionActivator(functionActivator: FunctionActivator, graphData: GraphData): Promise<void>;
    abstract renderFunctionActivatorArtifact(functionActivator: FunctionActivator, graphData: GraphData): Promise<PlainObject>;
    abstract publishFunctionActivatorToSandbox(functionActivator: FunctionActivator, graphData: GraphData): Promise<DeploymentResult>;
    abstract generateModelsFromDatabaseSpecification(databasePath: string, targetPackage: undefined | string, graph: PureModel): Promise<Entity[]>;
    abstract getAvailableRelationalDatabaseTypeConfigurations(): Promise<RelationalDatabaseTypeConfiguration[] | undefined>;
    /**
     * @modularize
     * See https://github.com/finos/legend-studio/issues/65
     */
    abstract registerService(service: Service, graph: PureModel, groupId: string, artifactId: string, version: string | undefined, server: string, executionMode: ServiceExecutionMode, options?: ServiceRegistrationOptions): Promise<ServiceRegistrationSuccess>;
    abstract bulkServiceRegistration(service: Service[], graph: PureModel, groupId: string, artifactId: string, version: string | undefined, server: string, executionMode: ServiceExecutionMode, options?: ServiceRegistrationOptions): Promise<ServiceRegistrationResult[]>;
    abstract activateService(serviceUrl: string, serviceId: string): Promise<void>;
    abstract runServicePostValidations(service: Service, graph: PureModel, assertionId: string): Promise<PostValidationAssertionResult>;
    abstract buildHashesIndex(entities: Entity[]): Promise<Map<string, string>>;
    abstract elementToEntity(element: PackageableElement, options?: {
        pruneSourceInformation?: boolean;
    }): Entity;
    abstract elementsToPureCode(elements: PackageableElement[], options?: {
        pruneSourceInformation?: boolean;
    }): Promise<string>;
    createBasicGraph(options?: {
        initializeSystem?: boolean;
    }): Promise<PureModel>;
    createDependencyManager(): DependencyManager;
    createGenerationModel(): GenerationModel;
    /**
     * Check if a mapping element is an instance set implementation
     *
     * NOTE: This would account for embedded property mappings as well
     * these are technically instance of `InstanceSetImplementation`
     * but since unlike Pure, Typescript cannot do multiple inheritance
     * we only can make embedded property mapping extends `PropertyMapping`
     *
     * Potentially, we might need to apply an extension mechanism on this
     */
    isInstanceSetImplementation(setImplementation: EnumerationMapping | SetImplementation | AssociationImplementation): setImplementation is InstanceSetImplementation;
    /**
     * Filter the list of system elements that will be shown in selection options
     * to users. This is helpful to avoid overwhelming and confusing users in form
     * mode since many system elements are needed to build the graph, but should
     * not present at all as selection options in form mode.
     */
    collectExposedSystemElements<T extends PackageableElement>(systemElements: T[]): T[];
}
//# sourceMappingURL=AbstractPureGraphManager.d.ts.map