import { DirectiveNode, DocumentNode, EnumTypeDefinitionNode, FieldDefinitionNode, InputObjectTypeDefinitionNode, InputValueDefinitionNode, Location, NamedTypeNode, ObjectTypeDefinitionNode, StringValueNode, TypeNode } from 'graphql';
import { DirectiveWrapper } from '../utils/directive-wrapper';
export declare class GenericFieldWrapper {
    type: TypeNode;
    readonly directives: DirectiveWrapper[];
    loc?: Location;
    name: string;
    constructor(field: FieldDefinitionNode | InputValueDefinitionNode);
    isList: () => boolean;
    isNonNullable: () => boolean;
    makeNullable: () => boolean;
    makeNonNullable: () => boolean;
    wrapListType: () => GenericFieldWrapper;
    unWrapListType: () => boolean;
    private isListType;
    getBaseType: () => NamedTypeNode;
    getTypeName: () => string;
    isScalar: () => boolean;
}
export declare class InputFieldWrapper extends GenericFieldWrapper {
    protected field: InputValueDefinitionNode;
    readonly argumenets?: InputValueDefinitionNode[];
    readonly description?: StringValueNode;
    type: TypeNode;
    readonly name: string;
    readonly loc?: Location;
    constructor(field: InputValueDefinitionNode);
    serialize: () => InputValueDefinitionNode;
    static fromField: (name: string, field: FieldDefinitionNode, parent: ObjectTypeDefinitionNode, document: DocumentNode) => InputFieldWrapper;
    static create: (name: string, type: string, isNullable?: boolean, isList?: boolean) => InputFieldWrapper;
}
export declare class FieldWrapper extends GenericFieldWrapper {
    readonly argumenets?: InputValueDefinitionNode[];
    readonly description?: StringValueNode;
    readonly loc?: Location;
    constructor(field: FieldDefinitionNode);
    serialize: () => FieldDefinitionNode;
    static create: (name: string, type: string, isNullable?: boolean, isList?: boolean) => FieldWrapper;
}
export declare class ObjectDefinitionWrapper {
    private node;
    readonly directives?: DirectiveWrapper[];
    readonly fields: FieldWrapper[];
    readonly name: string;
    constructor(node: ObjectTypeDefinitionNode);
    serialize: () => ObjectTypeDefinitionNode;
    hasField: (name: string) => boolean;
    getField: (name: string) => FieldWrapper;
    addField: (field: FieldWrapper) => void;
    removeField: (field: FieldWrapper) => void;
    static create: (name: string, fields?: FieldDefinitionNode[], directives?: DirectiveNode[]) => ObjectDefinitionWrapper;
}
export declare class InputObjectDefinitionWrapper {
    private node;
    readonly directives?: DirectiveWrapper[];
    readonly fields: InputFieldWrapper[];
    readonly name: string;
    constructor(node: InputObjectTypeDefinitionNode);
    serialize: () => InputObjectTypeDefinitionNode;
    hasField: (name: string) => boolean;
    getField: (name: string) => InputFieldWrapper;
    addField: (field: InputFieldWrapper) => void;
    removeField: (field: InputFieldWrapper) => void;
    static create: (name: string, fields?: InputValueDefinitionNode[], directives?: DirectiveNode[]) => InputObjectDefinitionWrapper;
    static fromObject: (name: string, def: ObjectTypeDefinitionNode, document: DocumentNode) => InputObjectDefinitionWrapper;
}
export declare class EnumWrapper {
    private node;
    readonly name: string;
    values: string[];
    directives: DirectiveWrapper[];
    constructor(node: EnumTypeDefinitionNode);
    addValue: (value: string) => void;
    serialize: () => EnumTypeDefinitionNode;
    static create: (name: string, values?: string[]) => EnumWrapper;
}
//# sourceMappingURL=object-definition-wrapper.d.ts.map