import { DirectiveLocation, OperationDefinitionNode } from 'graphql';
import { FieldOptions } from './decorators';
import { HookRegister } from './hook-manager';
import { AdminUIFilterType, BackendProvider, CreateOrUpdateHookParams, DeleteManyHookParams, FieldMetadata, Filter, GetTypeFunction, ReadHookParams, Resolver, Sort } from './types';
export type EntityHookFunctionCreateOrUpdate<G = unknown> = (params: CreateOrUpdateHookParams<G>) => Promise<Partial<G>> | Partial<G>;
export type EntityHookFunctionDelete<G = unknown> = (params: DeleteManyHookParams<G>) => Promise<Partial<G>> | Partial<G>;
export type EntityHookFunctionRead<G = unknown> = (params: ReadHookParams<G>) => Promise<Partial<G>> | Partial<G>;
export interface HookRegistration<G> {
    [HookRegister.BEFORE_CREATE]?: EntityHookFunctionCreateOrUpdate<G>[];
    [HookRegister.AFTER_CREATE]?: EntityHookFunctionCreateOrUpdate<G>[];
    [HookRegister.BEFORE_UPDATE]?: EntityHookFunctionCreateOrUpdate<G>[];
    [HookRegister.AFTER_UPDATE]?: EntityHookFunctionCreateOrUpdate<G>[];
    [HookRegister.BEFORE_DELETE]?: EntityHookFunctionDelete<G>[];
    [HookRegister.AFTER_DELETE]?: EntityHookFunctionDelete<G>[];
    [HookRegister.BEFORE_READ]?: EntityHookFunctionRead<G>[];
    [HookRegister.AFTER_READ]?: EntityHookFunctionRead<G>[];
}
export interface EntityMetadata<G = unknown, D = unknown> {
    type: 'entity';
    name: string;
    description?: string;
    plural: string;
    target: {
        new (...args: any[]): G;
    };
    provider?: BackendProvider<D>;
    fields: {
        [key: string]: FieldMetadata<G, D>;
    };
    directives?: Record<string, unknown>;
    hooks?: HookRegistration<G>;
    primaryKeyField?: keyof G;
    apiOptions?: {
        clientGeneratedPrimaryKeys?: boolean;
        excludeFromBuiltInOperations?: boolean;
        excludeFromBuiltInWriteOperations?: boolean;
        excludeFromFiltering?: boolean;
        excludeFromTracing?: boolean;
        namespaceForFederation?: boolean;
        resolvableViaFederation?: boolean;
        excludeFromFederation?: boolean;
    };
    adminUIOptions?: {
        defaultFilter?: Filter<G>;
        defaultSort?: Partial<Record<keyof G, Sort>>;
        exportPageSize?: number;
        hideInSideBar?: boolean;
        hideInFilterBar?: boolean;
        hideInDetailForm?: boolean;
        summaryField?: Extract<keyof G, string>;
        readonly?: boolean;
        fieldForDetailPanelNavigationId?: Extract<keyof G, string>;
        filterType?: AdminUIFilterType;
    };
    graphweaverInternalOptions?: {
        ignoreReservedEntityNames?: boolean;
    };
}
export declare function isInputMetadata<G = unknown, D = unknown>(value: unknown): value is InputTypeMetadata<G, D>;
export declare function isEntityMetadata<G = unknown, D = unknown>(value: unknown): value is EntityMetadata<G, D>;
export interface EnumMetadata<TEnum extends object> {
    type: 'enum';
    target: object;
    name: string;
    description?: string;
    valuesConfig?: EnumValuesConfig<TEnum>;
}
export declare function isEnumMetadata<TEnum extends object>(value: unknown): value is EnumMetadata<TEnum>;
export type EnumValuesConfig<TEnum extends object> = Partial<Record<keyof TEnum, {
    description?: string;
    deprecationReason?: string;
}>>;
export interface InputTypeMetadata<G = unknown, D = unknown> {
    type: 'inputType';
    name: string;
    description?: string;
    fields: {
        [key: string]: FieldMetadata<G, D>;
    };
    target: G;
}
export type CollectEnumInformationArgs<TEnum extends object> = Omit<EnumMetadata<TEnum>, 'type'>;
export type CollectEntityInformationArgs<G = unknown, D = unknown> = Omit<EntityMetadata<G, D>, 'type' | 'fields'>;
export type CollectInputTypeInformationArgs<G = unknown, D = unknown> = Omit<InputTypeMetadata<G, D>, 'type' | 'fields'>;
export interface ArgMetadata {
    type: GetTypeFunction;
    description?: string;
    defaultValue?: unknown;
    deprecationReason?: string;
    nullable?: boolean;
}
export declare function isArgMetadata(value: unknown): value is ArgMetadata;
export interface ArgsMetadata {
    [key: string]: ArgMetadata | GetTypeFunction;
}
export interface DirectiveMetadata {
    name: string;
    type: 'directive';
    description?: string;
    args?: ArgsMetadata;
    isRepeatable?: boolean;
    locations: DirectiveLocation[];
}
export type CollectDirectiveTypeInformationArgs = Omit<DirectiveMetadata, 'type'>;
export declare function isUnionMetadata(value: unknown): value is UnionMetadata;
export interface UnionMetadata {
    name: string;
    type: 'union';
    target: object;
    description?: string;
    getTypes: GetTypeFunction;
}
type VariableValues = {
    [name: string]: any;
};
export type CollectUnionTypeInformationArgs = Omit<UnionMetadata, 'type' | 'target'>;
export interface LogOnDidResolveOperationParams {
    ast: OperationDefinitionNode;
    variables: VariableValues | undefined;
}
export interface LogOnDidResolveOperationResponse {
    query: string;
    variables: VariableValues | undefined;
}
export interface AdditionalOperationInformation {
    name: string;
    getType: () => any;
    resolver: Resolver;
    directives?: Record<string, unknown>;
    args?: ArgsMetadata;
    description?: string;
    /**
     * Optional function to override the default logging of the operation.
     * This allows you to change the log message, perhaps to obfuscate sensitive data, or to add additional context.
     * This log gets printed at `didResolveOperation` of the Apollo lifecycle.
     * For more information of the lifecycle see https://www.apollographql.com/docs/apollo-server/integrations/plugins-event-reference#didresolveoperation
     * @param params The query as AST and the variables as an object
     * @returns the query and variables to log. Internally Graphweaver does something like `logger.info(logOnDidResolveOperation(params))`
     */
    logOnDidResolveOperation?: (params: Readonly<LogOnDidResolveOperationParams>) => LogOnDidResolveOperationResponse;
}
export type MetadataType = EntityMetadata<any, any> | EnumMetadata<any> | InputTypeMetadata<any, any> | DirectiveMetadata | UnionMetadata;
declare class Metadata {
    private metadataByType;
    private nameLookupCache;
    private typeByDataEntityLookup;
    private additionalQueriesLookup;
    private additionalMutationsLookup;
    private entityDecoratorCallLog;
    federationSubgraphName?: string;
    private ensureNameLookupCachePopulated;
    collectEntityInformation<G = unknown, D = unknown>(args: CollectEntityInformationArgs<G, D>): void;
    collectProviderInformationForEntity<G = unknown, D = unknown>(args: {
        provider: BackendProvider<D>;
        target: any;
    }): void;
    collectFieldInformation<G = unknown, D = unknown>(args: FieldOptions & Pick<FieldMetadata<G, D>, 'target' | 'name' | 'getType' | 'relationshipInfo'>): void;
    collectEnumInformation<TEnum extends object>(args: CollectEnumInformationArgs<TEnum>): void;
    collectInputTypeInformation<G = unknown, D = unknown>(args: CollectInputTypeInformationArgs<G, D>): void;
    collectDirectiveTypeInformation(args: CollectDirectiveTypeInformationArgs): void;
    collectUnionTypeInformation(args: CollectUnionTypeInformationArgs): {};
    entities(): Generator<EntityMetadata<any, any>, void, unknown>;
    entityNames(): Generator<string, void, unknown>;
    enums(): Generator<EnumMetadata<any>, void, unknown>;
    inputTypes(): Generator<InputTypeMetadata<any, any>, void, unknown>;
    additionalQueries(): Generator<AdditionalOperationInformation, void, unknown>;
    additionalMutations(): Generator<AdditionalOperationInformation, void, unknown>;
    directives(): Generator<DirectiveMetadata, void, unknown>;
    hasName(name: string): boolean;
    getTypeForName(name: string): MetadataType | undefined;
    metadataForType(type: unknown): MetadataType | undefined;
    hasEntity(type: unknown): boolean;
    hasEnum(type: unknown): boolean;
    hasInputType(type: unknown): boolean;
    getEntityMetadataByDataEntity<G = unknown, D = unknown>(dataEntityClass: unknown): EntityMetadata<G, D> | undefined;
    get typeCounts(): {
        entity: number;
        enum: number;
        inputType: number;
        directive: number;
        union: number;
    };
    getEntityByName<G = unknown, D = unknown>(name: string): EntityMetadata<G, D> | undefined;
    getEnumByName<TEnum extends object = object>(name: string): EnumMetadata<TEnum> | undefined;
    getInputTypeByName(name: string): InputTypeMetadata<any, any> | undefined;
    getAdditionalQueryByName(name: string): AdditionalOperationInformation | undefined;
    getAdditionalMutationByName(name: string): AdditionalOperationInformation | undefined;
    nameForObjectType(type: unknown): string | undefined;
    primaryKeyFieldForEntity(entity: EntityMetadata<any, any>): string;
    fieldMetadataForFilterKey(entity: EntityMetadata<any, any>, filterKey: string): FieldMetadata<any, any> | undefined;
    addQuery(args: AdditionalOperationInformation & {
        intentionalOverride?: boolean;
    }): void;
    addMutation(args: AdditionalOperationInformation & {
        intentionalOverride?: boolean;
    }): void;
    federationNameForEntity(entity: EntityMetadata<any, any>): string;
    federationNameForGraphQLTypeName(name: string): string;
    clear(): void;
    readonly validateEntities: () => void;
}
export declare const graphweaverMetadata: Metadata;
export {};