import { Dict, NNil, Maybe, ReturnType } from "./utils/util-types";
import * as types from "./utils/types";
import * as Knex from "knex";
import { GraphQLInputType, GraphQLOutputType } from "graphql";
import { MappedField } from "./MappedField";
import { MappedAssociation } from "./MappedAssociation";
import { StoreQueryParams } from "./SingleSourceQueryOperationResolver";
import { AliasHierarchyVisitor } from "./AliasHierarchyVisitor";
import { DataSourceMapping } from "./DataSourceMapping";
declare type AssociationsIn<T extends DataSourceMapping> = ReturnType<NNil<T["associations"]>>;
declare type FieldsIn<T extends DataSourceMapping> = ReturnType<NNil<T["fields"]>>;
declare type AssociationKeysIn<T extends DataSourceMapping> = keyof AssociationsIn<T>;
declare type FieldKeysIn<T extends DataSourceMapping> = keyof FieldsIn<T>;
declare type AssociatedDataSource<T extends DataSourceMapping, K extends AssociationKeysIn<T>> = AssociationsIn<T>[K]["target"];
declare type ShallowEntityType<T extends DataSourceMapping> = {
    [K in FieldKeysIn<T>]: FieldsIn<T>[K]["Type"];
};
declare type NestedEntityType<T extends DataSourceMapping> = ShallowEntityType<T> & {
    [K in AssociationKeysIn<T>]: AssociatedDataSource<T, K>["EntityType"];
};
/**
 * Represents mapping between a relational data source and associated GraphQL types
 * originating from the schema of this data source.
 *
 * @api-category MapperClass
 */
export declare class MappedDataSource<T extends DataSourceMapping = any> {
    private mapping;
    fields: Dict<MappedField>;
    associations: Dict<MappedAssociation>;
    constructor(mapping: T);
    /**
     * Knex instance used to connect to data source.
     *
     * This can be a data-source specific connector (if provided in the mapping configuration), and if not,
     * will fall back to global connector.
     *
     * Throws if a connector is not found.
     */
    get connector(): Knex;
    /**
     * Get a knex query builder for this data source
     *
     * This internally aliases tables for ease of reverse-mapping.
     */
    rootQueryBuilder(aliasHierarchyVisitor?: Maybe<AliasHierarchyVisitor>): Knex.QueryBuilder;
    /**
     * Get list of fields representing columns covered by primary key constraint
     */
    get primaryFields(): MappedField<any, any>[];
    get primaryColumnNames(): string[];
    /**
     * Name of the GraphQL output type representing an entity from this data source. Also used in other GraphQL output
     * types for this data source.
     */
    get mappedName(): string;
    /**
     * Name of the GraphQL output type representing a shallow entity (containing only fields and not associations) from this data source.
     */
    get shallowMappedName(): string;
    /**
     * Name of the table/view backing this data source
     */
    get storedName(): string;
    /**
     * Name of the GraphQL output type representing a page container that wraps page specific metadata along with
     * entities in the page (in a paginated query)
     */
    get pageContainerName(): string;
    /**
     * Name of the GraphQL output type representing a page container that wraps page specific metadata along with
     * shallow entities in the page (in a paginated query)
     */
    get shallowPageContainerName(): string;
    /**
     * Name of the GraphQL output type representing a page that wraps a subset of result entities (in a paginated query)
     */
    get pageName(): string;
    /**
     * Name of the GraphQL output type representing a page that wraps a subset of shallow result entities (in a paginated query)
     */
    get shallowPageName(): string;
    /**
     * List of names of the columns in the data source which are mapped through the fields in the data source mapping
     *
     * It is not necessary that all columns of backing table are covered by fields of the data source.
     */
    get storedColumnNames(): string[];
    /**
     * io-ts type props for field properties of a member entity
     */
    get shallowEntityTypeSpecProps(): Dict<types.AnyTypeSpec>;
    /**
     * io-ts type props for association properties of a member entity
     */
    get associationTypeSpecProps(): Dict<types.AnyTypeSpec>;
    /**
     * io-ts type props for all properties (from fields and associations)
     */
    get entityTypeSpecProps(): Dict<types.AnyTypeSpec>;
    /**
     * io-ts runtime type for shallow member entity (excludes associations) from this data source.
     */
    get shallowEntityTypeSpec(): types.ObjectTypeSpec<Dict<types.AnyTypeSpec>, types.SourceFromTypeSpecMapping<Dict<types.AnyTypeSpec>>, any>;
    /**
     * io-ts runtime type for member entity from this data source.
     */
    get entityTypeSpec(): types.ObjectTypeSpec<Dict<types.AnyTypeSpec>, types.SourceFromTypeSpecMapping<Dict<types.AnyTypeSpec>>, any>;
    /**
     * Getter to extract static type of Shallow member entity
     *
     * This is only useful in maped types. Throws if invoked directly.
     */
    get ShallowEntityType(): ShallowEntityType<T>;
    /**
     * Getter to extract static type of member entity
     *
     * This is only useful in maped types. Throws if invoked directly.
     */
    get EntityType(): NestedEntityType<T>;
    /**
     * Getter to extract static type of the mapping used to configure the data source
     *
     * This is only useful in maped types. Throws if invoked directly.
     */
    get MappingType(): T;
    /**
     * Get the default GraphQL output type for a member entity
     */
    get defaultOutputType(): GraphQLOutputType;
    /**
     * Get the output type for the response ofa paginated response performed against this data source
     */
    get paginatedOutputType(): import("graphql").GraphQLObjectType<any, any>;
    /**
     * Get the output type for the response of a paginated query (for shallow entities) performed against this data source
     */
    get paginatedShallowOutputType(): import("graphql").GraphQLObjectType<any, any>;
    /**
     * Get the default GraphQL input type for a shallow member entity (excludes associations)
     */
    get defaultShallowInputType(): GraphQLInputType;
    /**
     * Get the default GraphQL output type for a shallow member entity (excludes associations)
     */
    get defaultShallowOutputType(): GraphQLOutputType;
    get defaultIdOutputType(): GraphQLOutputType;
    /**
     * Maps member entities (what the application interacts with) to rows (in the format the persistence layer expects)
     */
    mapEntitiesToRows(entities: ShallowEntityType<T>[]): Dict[];
    /**
     * Reverse map the rows obtained from the data source (the persistence layer) to member entities (what the application interacts with)
     */
    mapRowsToEntities(rows: Dict[], storeParams: StoreQueryParams<MappedDataSource<T>>): Promise<any[]>;
    /**
     * Reverse map the rows obtained from the data source (the persistence layer) to shallow member entities
     * (what the application interacts with)
     *
     * This does not deal with mapping of associations, so is relatively cheaper than mapRowsToEntities
     */
    mapRowsToShallowEntities(rows: Dict[]): Dict<any>[];
    /**
     * Given a query (entity field name -> value mapping), translates it into a query that the persistence
     * layer can process by mapping entity field names to source column names.
     */
    mapQueryParams(whereArgs: Dict, aliasHierarchyVisitor: AliasHierarchyVisitor): Dict<any>;
}
/**
 * Used to map a relational data source using specified configuration (of type [DataSourceMapping](api:DataSourceMapping)).
 *
 * Refer the guide on [Mapping Data Sources](guide:mapping-data-sources) for detailed explanation and examples.
 *
 * @api-category PrimaryAPI
 */
export declare const mapDataSource: <T extends DataSourceMapping>(mapping: T) => MappedDataSource<T>;
export {};