import type { PodTable } from '../schema';
import type { PodOperation } from '../pod-dialect';
import type { QueryCondition } from '../query-conditions';
import type { SelectQueryPlan } from '../select-plan';
import type { InsertQueryPlan, UpdateQueryPlan, DeleteQueryPlan } from '../pod-session';
import type { ASTToSPARQLConverter } from '../ast-to-sparql';
import type { ComunicaSPARQLExecutor } from '../sparql-executor';
import type { ExecutionStrategy } from './types';
import type { TableResourceDescriptor } from './pod-executor-types';
export interface PodExecutorDeps {
    ensureConnected: () => Promise<void>;
    ensureTableResourcePath: (table: PodTable) => Promise<void>;
    resolveTableResource: (table: PodTable) => TableResourceDescriptor;
    resolveTableUrls: (table: PodTable) => {
        containerUrl: string;
        resourceUrl: string;
    };
    normalizeResourceUrl: (resourceUrl: string) => string;
    normalizeContainerKey: (containerUrl: string) => string;
    normalizeResourceKey: (resourceUrl: string) => string;
    ensureContainerExists: (containerUrl: string) => Promise<void>;
    ensureResourceExists: (resourceUrl: string, options?: {
        createIfMissing?: boolean;
    }) => Promise<void>;
    shouldSkipResourcePreparation?: () => boolean;
    shouldUseWriteTimeResourcePreparation?: () => boolean;
    shouldContinueAfterResourcePreparationError?: () => boolean;
    getTableRegistries?: () => {
        tableRegistry: Map<string, PodTable[]>;
        tableNameRegistry: Map<string, PodTable>;
    };
    ensureIdentifierCondition: (condition: QueryCondition | undefined, table: PodTable, resourceUrl: string) => Promise<QueryCondition | undefined>;
    resourceExists: (resourceUrl: string) => Promise<boolean>;
    getStrategy: (table: PodTable) => ExecutionStrategy;
    getLdpStrategy: () => ExecutionStrategy;
    preparedContainers: Set<string>;
    preparedResources: Set<string>;
    sparqlConverter: ASTToSPARQLConverter;
    sparqlExecutor: ComunicaSPARQLExecutor;
    isSelectPlan: (plan: unknown) => plan is SelectQueryPlan;
    isInsertPlan: (plan: unknown) => plan is InsertQueryPlan;
    isUpdatePlan: (plan: unknown) => plan is UpdateQueryPlan;
    isDeletePlan: (plan: unknown) => plan is DeleteQueryPlan;
}
export declare class PodExecutor {
    private deps;
    constructor(deps: PodExecutorDeps);
    query(operation: PodOperation): Promise<unknown[]>;
    private shouldSkipResourcePreparation;
    private shouldUseWriteTimeResourcePreparation;
    private shouldContinueAfterResourcePreparationError;
    private prepareResource;
    /**
     * Execute SELECT operation via ExecutionStrategy
     */
    private executeSelect;
    private getSelectStrategy;
    private isExactIriSelect;
    private getExactSelectResourceUrl;
    /**
     * Execute INSERT operation via ExecutionStrategy
     */
    private executeInsert;
    /**
     * Execute UPDATE operation via ExecutionStrategy
     */
    private executeUpdate;
    /**
     * Execute DELETE operation via ExecutionStrategy
     */
    private executeDelete;
}
//# sourceMappingURL=pod-executor.d.ts.map