import { ProvidenType } from "../graphq-compose-typescript";
import { EnumTypeComposer, InputTypeComposer, Resolver, ObjectTypeComposer } from "graphql-compose";
import { ComposerInstanceCreator } from "./composer-creator";
import { GraphQLEnumType, GraphQLInterfaceType, GraphQLList, GraphQLObjectType, GraphQLScalarType, GraphQLUnionType } from "graphql";
declare class QueueItem<C extends ObjectTypeComposer | InputTypeComposer | EnumTypeComposer> {
    classType: ProvidenTypeSingular;
    composer: C;
    solved: boolean;
    constructor(classType: ProvidenTypeSingular, composer: C);
}
export declare class InputTypeQueueItem extends QueueItem<InputTypeComposer> {
    static create(classType: ProvidenTypeSingular, composer: InputTypeComposer): InputTypeQueueItem;
}
export declare class OutputTypeQueueItem extends QueueItem<ObjectTypeComposer> {
    static create(classType: ProvidenTypeSingular, composer: ObjectTypeComposer): OutputTypeQueueItem;
}
export interface QueueItemFactory<C extends ObjectTypeComposer | InputTypeComposer> {
    create(constructor: ProvidenTypeSingular, composer: C): QueueItem<C>;
}
export declare type ProvidenTypeSingular = Exclude<ProvidenType, Array<any> | EnumTypeComposer | GraphQLList<any> | GraphQLScalarType | GraphQLEnumType | GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType | Resolver>;
export declare class BaseQueue<C extends ObjectTypeComposer | InputTypeComposer> {
    protected instanceCreator: ComposerInstanceCreator<C>;
    protected queueItemFactory: QueueItemFactory<C>;
    constructor(instanceCreator: ComposerInstanceCreator<C>, queueItemFactory: QueueItemFactory<C>);
    protected queue: Map<ProvidenTypeSingular, QueueItem<C>>;
    add(type: ProvidenTypeSingular): C;
    has(type: ProvidenTypeSingular): boolean;
    markSolved(type: ProvidenTypeSingular): void;
    hasUnresolved(): boolean;
    iterateUnsolved(): IterableIterator<QueueItem<any>>;
}
export declare class Queue {
    protected input: BaseQueue<InputTypeComposer>;
    protected output: BaseQueue<ObjectTypeComposer>;
    constructor(input: BaseQueue<InputTypeComposer>, output: BaseQueue<ObjectTypeComposer>);
    markSolved(type: ProvidenTypeSingular): void;
    markInputSolved(type: ProvidenTypeSingular): void;
    iterateUnsolved(): IterableIterator<QueueItem<any>>;
    protected hasUnresolved(): boolean;
}
export {};