import { ClassType } from 'class-transformer/ClassTransformer';
import { GraphQLResolveInfo } from 'graphql';
import { BaseEntity, FindConditions, FindManyOptions, JoinOptions, ObjectLiteral } from 'typeorm';
import { AbstractCategoryEntity } from '../base';
import { CursoredPageable, PageInfo, PageRequest } from '../core/helpers';
import type { DataLoaderFunction, DefaultRegisteredLoaders, GraphqlContext } from '../dataloader';
import { CategoryInputQuery, CursoredRequestInput, ExclusiveQueryConditionInput, RelationQueryConditionInput, TimeConditionInput } from './input';
interface ResolveFindOptionsType<Entity extends BaseEntity> {
    cls: ClassType<Entity>;
    pageRequest?: PageRequest;
    select?: (keyof Entity)[] | string[];
    info?: GraphQLResolveInfo;
    where?: FindConditions<Entity>[] | FindConditions<Entity> | ObjectLiteral | string;
    join?: JoinOptions;
    relationPath?: string;
    selectionPath?: string;
    relations?: boolean | {
        relations?: string[];
        disableMixedMap?: boolean;
    };
    timeCondition?: TimeConditionInput;
    cache?: boolean | number | {
        id: any;
        milliseconds: number;
    };
    order?: {
        [P in keyof Entity]?: 'ASC' | 'DESC' | 1 | -1;
    };
}
interface ResolveCategoryOptionsType<Entity extends BaseEntity> {
    categoryRef?: keyof Entity;
    categoryCls: ClassType<AbstractCategoryEntity>;
    query: CategoryInputQuery;
}
declare type BaseResolveProperty<Entity extends BaseEntity> = {
    cls: ClassType<Entity>;
    instance: Entity;
    key: keyof Entity;
    cache?: boolean | number;
};
declare type BaseResolvePropertyWithMapper<Entity extends BaseEntity, RelationEntity extends BaseEntity, MixedRelationEntity> = {
    cls: ClassType<Entity>;
    instance: Entity;
    key: keyof Entity;
    cache?: boolean | number;
    mapper: (item: RelationEntity) => MixedRelationEntity | Promise<MixedRelationEntity>;
};
declare type ResolvePropertyByTarget<RelationEntity extends BaseEntity> = {
    targetCls: ClassType<RelationEntity>;
};
declare type ResolvePropertyByLoader<RelationEntity extends BaseEntity> = {
    loader: DataLoaderFunction<RelationEntity>;
};
export declare class GraphqlHelper {
    static resolveOrder<Entity extends BaseEntity>(cls: ClassType<Entity>, pageRequest: PageRequest): {
        [P in keyof Entity]?: 'ASC' | 'DESC' | 1 | -1;
    };
    static handlePagedDefaultQueryRequest<Entity extends BaseEntity, DataLoaders extends DefaultRegisteredLoaders = DefaultRegisteredLoaders, MixedEntity = any>({ cls, query, where, ctx, loader, pageRequest, mapper, info, relationPath, }: {
        cls: ClassType<Entity>;
        query: ExclusiveQueryConditionInput;
        where?: FindConditions<Entity>[] | FindConditions<Entity> | ObjectLiteral | string;
        relationPath?: string;
        info?: GraphQLResolveInfo;
        ctx?: GraphqlContext<DataLoaders>;
        loader?: (loaders: DataLoaders) => DataLoaderFunction<Entity>;
        pageRequest: PageRequest;
        mapper?: (item: Entity) => Promise<MixedEntity>;
    }): Promise<PageInfo & {
        items: any[];
        total: number;
    }>;
    static handleDefaultQueryRequest<Entity extends BaseEntity, DataLoaders extends DefaultRegisteredLoaders, MixedEntity>(opts: {
        cls: ClassType<Entity>;
        categoryCls?: ClassType<AbstractCategoryEntity>;
        query: ExclusiveQueryConditionInput;
        relationPath?: string;
        info?: GraphQLResolveInfo;
        where?: FindConditions<Entity>[] | FindConditions<Entity> | ObjectLiteral | string;
        ctx?: GraphqlContext<DataLoaders>;
        pageInfo?: PageInfo;
        loader?: (loaders: DataLoaders) => DataLoaderFunction<Entity>;
        mapper?: (item: Entity) => MixedEntity | Promise<MixedEntity>;
    }): Promise<MixedEntity[]>;
    static handleDefaultQueryRequest<Entity extends BaseEntity, DataLoaders extends DefaultRegisteredLoaders>(opts: {
        cls: ClassType<Entity>;
        categoryCls?: ClassType<AbstractCategoryEntity>;
        query: ExclusiveQueryConditionInput;
        relationPath?: string;
        info?: GraphQLResolveInfo;
        where?: FindConditions<Entity>[] | FindConditions<Entity> | ObjectLiteral | string;
        ctx?: GraphqlContext<DataLoaders>;
        pageInfo?: PageInfo;
        loader?: (loaders: DataLoaders) => DataLoaderFunction<Entity>;
    }): Promise<Entity[]>;
    /**
     * @param cls
     * @param info
     * @param select
     * @param pageRequest
     * @param where
     * @param relationPath
     * @param categoryRef 类型的引用字段，默认为 category
     * @param categoryCls
     * @param query
     * @param timeCondition
     * @param cache 所有用户敏感的数据都应该关闭 cache，默认 true
     */
    static genericFindOptions<Entity extends BaseEntity>(opts: ResolveFindOptionsType<Entity>): Promise<FindManyOptions<Entity>>;
    static genericFindOptions<Entity extends BaseEntity>(opts: ResolveFindOptionsType<Entity> & ResolveCategoryOptionsType<Entity>): Promise<FindManyOptions<Entity>>;
    static resolveProperty_DO_NOT_USE<Entity extends BaseEntity, RelationEntity extends BaseEntity>(opts: BaseResolveProperty<Entity> & (ResolvePropertyByLoader<RelationEntity> | ResolvePropertyByTarget<RelationEntity>)): Promise<RelationEntity>;
    static resolveProperties<Entity extends BaseEntity, RelationEntity extends BaseEntity>(opts: BaseResolveProperty<Entity> & (ResolvePropertyByLoader<RelationEntity> | ResolvePropertyByTarget<RelationEntity>)): Promise<RelationEntity[]>;
    static resolveProperties<Entity extends BaseEntity, RelationEntity extends BaseEntity, MixedRelationEntity extends {
        origin: RelationEntity;
    } = {
        origin: RelationEntity;
    }>(opts: BaseResolvePropertyWithMapper<Entity, RelationEntity, MixedRelationEntity> & (ResolvePropertyByLoader<RelationEntity> | ResolvePropertyByTarget<RelationEntity>)): Promise<MixedRelationEntity[]>;
    static pagedResult<Entity>({ pageRequest, items, total, }: {
        pageRequest: PageRequest;
        items: Entity[];
        total: number;
    }): Promise<PageInfo & {
        items: Entity[];
        total: number;
    }>;
    static pagedResult<Entity, MixedEntity>({ pageRequest, items, total, mapper, }: {
        pageRequest: PageRequest;
        items: Entity[];
        total: number;
        mapper: (item: Entity) => MixedEntity | Promise<MixedEntity>;
    }): Promise<PageInfo & {
        items: MixedEntity[];
        total: number;
    }>;
    static resolveMixedRelation<Entity extends BaseEntity, RelationEntity extends BaseEntity>({ origin, query, targetCls, where, }: {
        origin: Entity;
        query: RelationQueryConditionInput;
        targetCls: ClassType<RelationEntity>;
        where: FindConditions<RelationEntity>;
    }): Promise<{
        count: number;
        items: RelationEntity[];
    }>;
    static handleCursoredQueryRequest<Entity extends BaseEntity>({ cls, cursoredRequest, where, }: {
        cls: ClassType<Entity>;
        cursoredRequest: CursoredRequestInput;
        where?: FindConditions<Entity>[] | FindConditions<Entity> | ObjectLiteral | string;
    }): Promise<CursoredPageable<Entity>>;
}
export {};