import * as graphql from "graphql";
import { cmp } from "@glide/soql";
import { Omit } from "utility-types";
import { Maybe } from "./helpers";
export declare type Definition<T extends keyof DefinitionTypes = "Schema"> = DefinitionTypes[T];
export declare type Operator = "assign" | Exclude<keyof typeof cmp, "prototype">;
export interface DefinitionTypes {
    readonly Directive: DirectiveDefinition;
    readonly Field: FieldDefinition;
    readonly Operation: OperationDefinition;
    readonly Parameter: ParameterDefinition;
    readonly Schema: SchemaDefinition;
    readonly Type: TypeDefinition;
}
export interface DirectiveDefinition {
    description?: string;
    locations: graphql.DirectiveLocationEnum[];
    params?: {
        [name: string]: Omit<graphql.GraphQLArgumentConfig, "astNode">;
    };
}
export interface FieldDefinition {
    description?: string;
    primaryKey: boolean;
    required: boolean;
    source: string;
    type: string;
}
export interface OperationDefinition {
    description?: string;
    params: {
        [name: string]: ParameterDefinition;
    };
    type: string;
}
export interface ParameterDefinition {
    operator: Operator;
    references: string;
}
export interface ScalarDefinition<I, E> {
    description?: string;
    fromLiteral(node: graphql.ValueNode, variables?: any): Maybe<I>;
    fromValue(external: E): I;
    toValue(internal: I): E;
}
export interface SchemaDefinition {
    mutations: {
        [name: string]: OperationDefinition;
    };
    queries: {
        [name: string]: OperationDefinition;
    };
    types: {
        [name: string]: TypeDefinition;
    };
}
export interface TypeDefinition {
    description?: string;
    fields: {
        [name: string]: FieldDefinition;
    };
    table: string;
}
export interface Scope {
    [name: string]: graphql.GraphQLNamedType;
}
export declare function directive(name: string, definition: DirectiveDefinition): graphql.GraphQLDirective;
export declare function operation(scope: Scope, schema: SchemaDefinition, definition: OperationDefinition): {
    args: import("./helpers").Table<{
        description: string | undefined;
        type: graphql.GraphQLNamedType;
    }>;
    description: string | undefined;
    resolve: import("./resolver").Resolver;
    type: graphql.GraphQLObjectType<any, any, {
        [key: string]: any;
    }>;
};
export declare function parameter(scope: Scope, type: TypeDefinition, definition: ParameterDefinition): {
    description: string | undefined;
    type: graphql.GraphQLNamedType;
};
export declare function scalar<I, E = string>(name: string, definition: ScalarDefinition<I, E>): graphql.GraphQLScalarType;
export declare function type(name: string, scope: Scope, definition: TypeDefinition): graphql.GraphQLObjectType<object, any, {
    [key: string]: any;
}>;