import { GraphQLSchema, GraphQLError } from 'graphql';
import DataLoader from 'dataloader';
import { PubSub } from 'graphql-subscriptions';
import type { Context } from '../context.js';
import type { WebSocket } from 'ws';
export interface GraphQLOptions {
    schema: string;
    resolvers?: Record<string, any>;
    endpoint?: string;
    subscriptionsEndpoint?: string;
    playground?: boolean;
    introspection?: boolean;
    dataLoaders?: Record<string, () => DataLoader<any, any>>;
    context?: (ctx: Context) => Record<string, any>;
    formatError?: (error: GraphQLError) => any;
    validationRules?: any[];
    requireAuth?: boolean;
    allowedOrigins?: string[];
    maxQueryDepth?: number;
    maxQueryComplexity?: number;
    rateLimit?: {
        windowMs: number;
        maxQueries: number;
    };
    disablePlaygroundInProduction?: boolean;
    sanitizeInputs?: boolean;
}
export interface GraphQLContext extends Context {
    dataLoaders: Record<string, DataLoader<any, any>>;
    pubsub: PubSub;
}
export interface SubscriptionContext {
    pubsub: PubSub;
    connection: WebSocket;
    context: Record<string, any>;
}
declare class DataLoaderFactory {
    private loaders;
    createLoader<T, K>(name: string, batchFn: (keys: readonly K[]) => Promise<T[]>, options?: DataLoader.Options<K, T>): DataLoader<K, T>;
    getLoader(name: string): DataLoader<any, any> | undefined;
    clearAll(): void;
    primeAll(key: any, value: any): void;
}
declare class GraphQLSchemaBuilder {
    private typeDefs;
    private resolvers;
    private dataLoaderFactory;
    addTypeDefs(typeDefs: string): GraphQLSchemaBuilder;
    addResolvers(resolvers: Record<string, any>): GraphQLSchemaBuilder;
    addDataLoader<T, K>(name: string, batchFn: (keys: readonly K[]) => Promise<T[]>, options?: DataLoader.Options<K, T>): GraphQLSchemaBuilder;
    generateResolvers(dataSources: Record<string, any>): GraphQLSchemaBuilder;
    build(): {
        schema: GraphQLSchema;
        resolvers: Record<string, any>;
        dataLoaders: DataLoaderFactory;
    };
}
declare class TypeGenerator {
    static generateTypes(schema: GraphQLSchema, outputPath?: string): string;
    private static schemaToTypes;
}
declare class SubscriptionManager {
    private pubsub;
    private subscriptions;
    subscribe(topic: string, callback: (payload: any) => void): Promise<number>;
    unsubscribe(subId: number): Promise<void>;
    publish(topic: string, payload: any): Promise<void>;
    handleWebSocketSubscription(connection: WebSocket, context: SubscriptionContext): void;
}
export declare function graphqlPlugin(options: GraphQLOptions): (ctx: Context, next: () => Promise<any>) => Promise<any>;
export declare function createDataLoader<T, K>(batchFn: (keys: readonly K[]) => Promise<T[]>, options?: DataLoader.Options<K, T>): () => DataLoader<K, T>;
export { GraphQLSchemaBuilder, TypeGenerator, SubscriptionManager, DataLoaderFactory };
export { graphqlPlugin as graphql };
export declare function createLoaderResolver<T, K>(loaderName: string, keyFn: (parent: any, args: any, context: GraphQLContext) => K): (parent: any, args: any, context: GraphQLContext) => Promise<any>;
export declare function createBatchResolver<T>(loaderName: string, keyFn: (args: any, context: GraphQLContext) => any[]): (parent: any, args: any, context: GraphQLContext) => Promise<any>;
//# sourceMappingURL=graphql.d.ts.map