import { BaseContext as ApolloBaseContext, ApolloServerPlugin } from '@apollo/server';
import { Span, Tracer } from '@opentelemetry/api';
import { GraphQLResolveInfo, GraphQLScalarType, Source } from 'graphql';
import { ResolveTree } from 'graphql-parse-resolve-info';
import { ComplexityEstimator } from 'graphql-query-complexity';
import { CellFormatOptions, DetailPanelInputComponent, DetailPanelInputComponentOption } from './decorators';
import { EntityMetadata } from './metadata';
export type { Instrumentation } from '@opentelemetry/instrumentation';
export type { GraphQLResolveInfo } from 'graphql';
export type { FieldsByTypeName, ResolveTree } from 'graphql-parse-resolve-info';
export type BaseContext = object;
export declare const ID: GraphQLScalarType<string, string>;
export interface TraceOptions {
    span: Span;
    tracer: Tracer;
}
export declare enum Sort {
    ASC = "ASC",
    DESC = "DESC"
}
export type OrderByOptions = Record<string, Sort>;
export type PaginationOptions = {
    orderBy: OrderByOptions;
    offset: number;
    limit: number;
};
export type BaseOperator = 'ne' | 'notnull' | 'null';
export type ArrayOperator = 'in' | 'nin';
export type StringOperator = 'like' | 'ilike';
export type NumericOperator = 'gt' | 'gte' | 'lt' | 'lte';
export type FilterWithOperators<G> = {
    [K in keyof G as G[K] extends string ? `${K & string}_${BaseOperator | ArrayOperator | StringOperator}` : G[K] extends number | bigint | Date ? `${K & string}_${BaseOperator | ArrayOperator | NumericOperator}` : `${K & string}_${BaseOperator | ArrayOperator}`]?: FilterValue<G[K]>;
};
export type FilterValue<T> = T | T[];
export type FilterEntity<G> = {
    [K in keyof G]?: G[K] extends (...args: any[]) => Promise<infer C> ? Filter<C> : G[K] extends Promise<infer C> ? Filter<C> : Partial<G[K]>;
};
export type FilterTopLevelProperties<G> = {
    _and?: Filter<G>[];
    _or?: Filter<G>[];
    _not?: Filter<G>[];
};
export declare const isTopLevelFilterProperty: (key: string) => boolean;
export type Filter<G> = FilterEntity<G> & FilterTopLevelProperties<G> & FilterWithOperators<G>;
export interface GraphQLArgs<G> {
    items?: Partial<G>[];
    filter?: Filter<G>;
    pagination?: PaginationOptions;
}
export declare enum AggregationType {
    COUNT = "COUNT"
}
export interface AggregationResult {
    count?: number;
}
export interface BackendProvider<D> {
    readonly backendId: string;
    readonly backendDisplayName?: string;
    entityType?: new () => D;
    find(filter: Filter<D>, pagination?: PaginationOptions, entityMetadata?: EntityMetadata): Promise<D[]>;
    findOne(filter: Filter<D>, entityMetadata?: EntityMetadata): Promise<D | null>;
    findByRelatedId(entity: {
        new (): D;
    }, relatedField: string, relatedIds: readonly string[], filter?: Filter<D>): Promise<D[]>;
    updateOne(id: string | number, updateArgs: Partial<D>): Promise<D>;
    updateMany(entities: Partial<D>[]): Promise<D[]>;
    createOne(entity: Partial<D>): Promise<D>;
    createMany(entities: Partial<D>[]): Promise<D[]>;
    createTraces?(entities: Partial<D>[]): Promise<D[]>;
    createOrUpdateMany(entities: Partial<D>[]): Promise<D[]>;
    deleteOne(filter: Filter<D>): Promise<boolean>;
    deleteMany?(filter: Filter<D>): Promise<boolean>;
    withTransaction?: <T>(callback: () => Promise<T>) => Promise<T>;
    foreignKeyForRelationshipField?(field: FieldMetadata<any, D>, dataEntity: D): string | number;
    readonly maxDataLoaderBatchSize?: number;
    aggregate?(filter: Filter<D> | undefined, requestedAggregations: Set<AggregationType>): Promise<AggregationResult>;
    backendProviderConfig?: BackendProviderConfig;
    /**
     * @deprecated The method should not be used and will be removed in the future. Use `apolloPluginManager.addPlugin` instead.
     */
    apolloPlugins?: ApolloServerPlugin<ApolloBaseContext>[];
}
export interface HookParams<G, TContext = BaseContext> {
    context: TContext;
    transactional: boolean;
    fields?: ResolveTree;
    entities?: (G | null)[];
    deleted?: boolean;
}
export interface CreateOrUpdateHookParams<G, TContext = BaseContext> extends HookParams<G, TContext> {
    args: {
        items: Partial<G>[];
    };
}
export interface ReadHookParams<G, TContext = BaseContext> extends HookParams<G, TContext> {
    args: {
        filter?: Filter<G>;
        pagination?: PaginationOptions;
    };
    isAggregate?: boolean;
}
export interface DeleteHookParams<G, TContext = BaseContext> extends HookParams<G, TContext> {
    args: {
        filter: Filter<G>;
    };
}
export interface DeleteManyHookParams<G, TContext = BaseContext> extends HookParams<G, TContext> {
    args: {
        filter: Filter<G>;
    };
}
export declare enum AdminUIFilterType {
    DATE_TIME_RANGE = "DATE_TIME_RANGE",
    DATE_RANGE = "DATE_RANGE",
    ENUM = "ENUM",
    /** Default for numbers - shows simple numeric input */
    NUMERIC = "NUMERIC",
    /** Shows a range to filter by a range from and to a number. */
    NUMERIC_RANGE = "NUMERIC_RANGE",
    RELATIONSHIP = "RELATIONSHIP",
    TEXT = "TEXT",
    BOOLEAN = "BOOLEAN",
    DROP_DOWN_TEXT = "DROP_DOWN_TEXT"
}
export type AdminUIEntitySettings<G> = {
    defaultFilter?: Filter<G>;
    hideFromDisplay?: boolean;
    hideFromFilterBar?: boolean;
};
export type AdminUISettingsType<G> = {
    fields?: {
        [x: string]: {
            hideFromDisplay?: boolean;
            hideFromFilterBar?: boolean;
        };
    };
    entity?: AdminUIEntitySettings<G>;
};
export declare enum RelationshipType {
    MANY_TO_ONE = "MANY_TO_ONE",
    MANY_TO_MANY = "MANY_TO_MANY",
    ONE_TO_MANY = "ONE_TO_MANY"
}
export interface BackendProviderConfig {
    filter?: boolean;
    pagination?: boolean;
    orderBy?: boolean;
    supportedAggregationTypes?: Set<AggregationType>;
    idListLoadingMethod?: 'find' | 'findOne';
    supportsPseudoCursorPagination?: boolean;
}
export type Constructor<T extends object, Arguments extends unknown[] = any[]> = new (...arguments_: Arguments) => T;
export type ClassType<T extends object = object, Arguments extends unknown[] = any[]> = Constructor<T, Arguments> & {
    prototype: T;
};
export type TypeValue = ClassType | GraphQLScalarType | Function | object | symbol;
export type GetTypeFunction = (type?: void) => TypeValue;
export type Complexity = ComplexityEstimator | number;
export interface FieldMetadata<G = unknown, D = unknown> {
    adminUIOptions?: {
        hideInTable?: boolean;
        hideInFilterBar?: boolean;
        hideInDetailForm?: boolean;
        readonly?: boolean;
        fieldForDetailPanelNavigationId?: boolean;
        filterType?: AdminUIFilterType;
        filterOptions?: Record<string, unknown>;
        detailPanelInputComponent?: DetailPanelInputComponentOption | DetailPanelInputComponent;
        format?: CellFormatOptions;
        relationshipBehaviour?: 'load' | 'count';
    };
    apiOptions?: {
        requiredForCreate?: boolean;
        requiredForUpdate?: boolean;
        excludeFromBuiltInWriteOperations?: boolean;
    };
    target: {
        new (...args: any[]): G;
    };
    name: string;
    getType: GetTypeFunction;
    relationshipInfo?: {
        relatedField?: string;
        id?: string | bigint | ((dataEntity: D) => string | number | bigint | undefined);
    };
    description?: string;
    deprecationReason?: string;
    complexity?: Complexity;
    defaultValue?: any;
    readonly?: boolean;
    nullable?: boolean | 'items' | 'itemsAndList';
    excludeFromFilterType?: boolean;
    additionalInformation?: Record<string, unknown>;
    directives?: Record<string, any>;
}
export type AuthChecker<TContextType extends object = object, TRoleType = string> = (context: TContextType, roles: TRoleType[]) => boolean | Promise<boolean>;
export type ResolverOptions<TArgs = any, TContext = BaseContext, TSource = Source> = {
    source: TSource;
    args: TArgs;
    context: TContext;
    fields: ResolveTree;
    info: GraphQLResolveInfo;
    trace?: TraceOptions;
};
export type Resolver<TArgs = any, TContext = BaseContext, TResult = unknown> = ({ args, context, fields, trace, }: ResolverOptions<TArgs, TContext>) => Promise<TResult>;
export declare enum GraphweaverRequestEvent {
    OnRequest = "ON_REQUEST"
}
export type GraphweaverPluginNextFunction<T = unknown> = (event: GraphweaverRequestEvent, next: GraphweaverPluginNextFunction<T>) => Promise<T>;
export type GraphweaverPlugin<T = unknown> = {
    name: string;
    event: GraphweaverRequestEvent;
    next: GraphweaverPluginNextFunction<T>;
};