import type { GraphObject, NodeObject } from 'jsonld';
import type { Frame } from 'jsonld/jsonld-spec';
import type { FindAllOptions, FindOneOptions, FindOptionsWhere } from './storage/FindOptionsTypes';
import type { MemoryQueryAdapterOptions } from './storage/memory/MemoryQueryAdapterOptions';
import type { RawQueryResult } from './storage/QueryAdapter';
import type { SparqlQueryAdapterOptions } from './storage/sparql/SparqlQueryAdapterOptions';
import type { OrArray, Entity } from './util/Types';
import type { JSONObject } from './util/Util';
export declare type VerbHandler = (args: JSONObject) => Promise<NodeObject>;
export declare type VerbInterface = Record<string, VerbHandler>;
export declare type MappingResponseOption<T extends boolean> = T extends true ? JSONObject : NodeObject;
export declare type SkqlOptions = MemoryQueryAdapterOptions | SparqlQueryAdapterOptions;
export interface ErrorMatcher {
    status: number;
    messageRegex: string;
}
export interface OperationResponse {
    data: JSONObject;
}
export declare class Skql {
    private readonly mapper;
    private readonly adapter;
    private readonly inputFiles?;
    readonly verb: VerbInterface;
    constructor(options: SkqlOptions);
    executeRawQuery<T extends RawQueryResult>(query: string): Promise<T[]>;
    executeRawEntityQuery(query: string, frame?: Frame): Promise<GraphObject>;
    find(options?: FindOneOptions): Promise<Entity>;
    findBy(where: FindOptionsWhere): Promise<Entity>;
    findAll(options?: FindAllOptions): Promise<Entity[]>;
    findAllBy(where: FindOptionsWhere): Promise<Entity[]>;
    exists(where: FindOptionsWhere): Promise<boolean>;
    count(where?: FindOptionsWhere): Promise<number>;
    save(entity: Entity): Promise<Entity>;
    save(entities: Entity[]): Promise<Entity[]>;
    destroy(entity: Entity): Promise<Entity>;
    destroy(entities: Entity[]): Promise<Entity[]>;
    destroyAll(): Promise<void>;
    performMapping(args: JSONObject, mapping: OrArray<NodeObject>, frame?: Record<string, any>): Promise<NodeObject>;
    performMappingAndConvertToJSON(args: JSONObject, mapping: OrArray<NodeObject>, convertToJsonDeep?: boolean, frame?: Record<string, any>): Promise<JSONObject>;
    private handleVerb;
    private findVerbWithName;
    private handleIntegrationVerb;
    private findVerbIntegrationMapping;
    private performOperationMappingWithArgs;
    private performOperation;
    private performReturnValueMappingWithFrame;
    private resolveMappingReferences;
    private performParameterMappingOnArgsIfDefined;
    private getOpenApiDescriptionForIntegration;
    private findSecurityCredentialsForAccount;
    private findSecurityCredentialsForAccountIfDefined;
    private createOpenApiOperationExecutorWithSpec;
    private handleNounMappingVerb;
    private findVerbNounMapping;
    private performVerbMappingWithArgs;
    private assertVerbParamsMatchParameterSchemas;
    private performOpenapiOperationWithCredentials;
    private isInvalidTokenError;
    private refreshOpenApiToken;
    private getConfigurationFromSecurityCredentials;
    private assertVerbReturnValueMatchesReturnTypeSchema;
    private getReturnTypeSchemaFromVerb;
    private convertToQuadsAndValidateAgainstShape;
    private performSecuritySchemeStageWithCredentials;
    private getDataFromDataSource;
    private getDataFromJsonDataSource;
    private getJsonDataFromSource;
}