import type { GraphQLFieldExtensions, GraphQLObjectTypeConfig, GraphQLResolveInfo, GraphQLUnionTypeConfig, GraphQLArgumentConfig, GraphQLInputFieldConfig, GraphQLScalarTypeConfig, FieldDefinitionNode } from "graphql";
import { GArg, GEnumType, GEnumTypeConfig, GEnumValueConfig, GField, GInputObjectType, GInputObjectTypeConfig, GInputType, GInterfaceField, GInterfaceType, GInterfaceTypeConfig, GList, GNonNull, GNullableInputType, GNullableType, GObjectType, GOutputType, GScalarType, GType, GUnionType, InferValueFromOutputType, InferValueFromArgs, InferValueFromInputType } from "./types.js";
type SomeTypeThatIsntARecordOfArgs = string;
type ImpliedResolver<Args extends {
    [Key in keyof Args]: GArg<GInputType>;
}, Type extends GOutputType<Context>, Context> = InferValueFromOutputType<Type> | ((args: InferValueFromArgs<Args>, context: Context, info: GraphQLResolveInfo) => InferValueFromOutputType<Type>);
type Maybe<T> = T | null | undefined;
type FieldFuncArgs<Source, Args extends {
    [Key in keyof Args]: GArg<GInputType>;
}, Type extends GOutputType<Context>, Context> = {
    args?: Args;
    type: Type;
    description?: Maybe<string>;
    deprecationReason?: Maybe<string>;
    extensions?: Maybe<Readonly<GraphQLFieldExtensions<Source, Context>>>;
    astNode?: Maybe<FieldDefinitionNode>;
};
/** @deprecated */
export type InterfaceToInterfaceFields<Interface extends GInterfaceType<any, any, any>> = Interface extends GInterfaceType<any, infer Fields, any> ? Fields : never;
type InterfaceFieldsToOutputFields<Source, Context, Fields extends {
    [key: string]: GInterfaceField<any, any, any>;
}> = {
    [Key in keyof Fields]: Fields[Key] extends GInterfaceField<infer Args, infer OutputType, any> ? GField<Source, Args, OutputType, Key extends keyof Source ? Source[Key] : unknown, Context> : never;
};
/** @deprecated */
export type _InterfacesToOutputFields<Source, Context, Interfaces extends readonly GInterfaceType<Source, any, Context>[]> = InterfacesToOutputFields<Source, Context, Interfaces>;
export type { _InterfacesToOutputFields as InterfacesToOutputFields };
type InterfacesToOutputFields<Source, Context, Interfaces extends readonly GInterfaceType<Source, any, any>[]> = MergeTuple<{
    [Key in keyof Interfaces]: Interfaces[Key] extends GInterfaceType<Source, infer Fields, any> ? InterfaceFieldsToOutputFields<Source, Context, Fields> : never;
}, {}>;
export type InterfacesToInterfaceFields<Interfaces extends readonly GInterfaceType<any, any, any>[]> = MergeTuple<{
    [Key in keyof Interfaces]: Interfaces[Key] extends GInterfaceType<any, infer Fields, any> ? Fields : never;
}, {}>;
type MergeTuple<T, Merged> = T extends readonly [infer U, ...infer Rest] ? MergeTuple<Rest, Merged & U> : Merged;
export type GWithContext<Context> = {
    /**
     * Creates a GraphQL object type.
     *
     * Note this is an **output** type, if you want an input object, use
     * `g.inputObject`.
     *
     * When calling `g.object`, you must provide a type parameter that is the
     * source of the object type. The source is what you receive as the first
     * argument of resolvers on this type and what you must return from resolvers
     * of fields that return this type.
     *
     * ```ts
     * const Person = g.object<{ name: string }>()({
     *   name: "Person",
     *   fields: {
     *     name: g.field({ type: g.String }),
     *   },
     * });
     * // ==
     * graphql`
     *   type Person {
     *     name: String
     *   }
     * `;
     * ```
     *
     * ## Writing resolvers
     *
     * To do anything other than just return a field from the source type, you
     * need to provide a resolver.
     *
     * Note: TypeScript will force you to provide a resolve function if the field
     * in the source type and the GraphQL field don't match
     *
     * ```ts
     * const Person = g.object<{ name: string }>()({
     *   name: "Person",
     *   fields: {
     *     name: g.field({ type: g.String }),
     *     excitedName: g.field({
     *       type: g.String,
     *       resolve(source, args, context, info) {
     *         return `${source.name}!`;
     *       },
     *     }),
     *   },
     * });
     * ```
     *
     * ## Circularity
     *
     * GraphQL types will often contain references to themselves and to make
     * TypeScript allow that, you need have an explicit type annotation of
     * `g<typeof g.object<Source>>` along with making `fields` a function that
     * returns the object.
     *
     * ```ts
     * type PersonSource = { name: string; friends: PersonSource[] };
     *
     * const Person: g<typeof g.object<PersonSource>> =
     *   g.object<PersonSource>()({
     *     name: "Person",
     *     fields: () => ({
     *       name: g.field({ type: g.String }),
     *       friends: g.field({ type: g.list(Person) }),
     *     }),
     *   });
     * ```
     */
    object: <Source>(youOnlyNeedToPassATypeParameterToThisFunctionYouPassTheActualRuntimeArgsOnTheResultOfThisFunction?: {
        youOnlyNeedToPassATypeParameterToThisFunctionYouPassTheActualRuntimeArgsOnTheResultOfThisFunction: true;
    }) => <Fields extends {
        [Key in keyof Fields]: GField<Source, any, any, Key extends keyof Source ? Source[Key] : unknown, Context>;
    } & InterfaceFieldsToOutputFields<Source, Context, InterfacesToInterfaceFields<Interfaces>>, const Interfaces extends readonly GInterfaceType<Source, any, Context>[] = []>(config: {
        fields: Fields | (() => Fields);
        interfaces?: [...Interfaces];
    } & Omit<GraphQLObjectTypeConfig<Source, Context>, "fields" | "interfaces">) => GObjectType<Source, Context>;
    /**
     * Create a GraphQL union type.
     *
     * A union type represents an object that could be one of a list of types.
     * Note it is similar to an {@link GInterfaceType interface type} except that a
     * union doesn't imply having a common set of fields among the member types.
     *
     * ```ts
     * const A = g.object<{ __typename: "A" }>()({
     *   name: "A",
     *   fields: {
     *     something: g.field({ type: g.String }),
     *   },
     * });
     * const B = g.object<{ __typename: "B" }>()({
     *   name: "B",
     *   fields: {
     *     differentThing: g.field({ type: g.String }),
     *   },
     * });
     * const AOrB = g.union({
     *   name: "AOrB",
     *   types: [A, B],
     * });
     * ```
     */
    union: <Type extends GObjectType<any, Context>>(config: Flatten<Omit<GraphQLUnionTypeConfig<Type extends GObjectType<infer Source, Context> ? Source : never, Context>, "types"> & {
        types: readonly Type[] | (() => readonly Type[]);
    }>) => GUnionType<Type extends GObjectType<infer Source, Context> ? Source : never, Context>;
    /**
     * Creates a GraphQL field.
     *
     * These will generally be passed directly to the `fields` object in a
     * `g.object` call.
     *
     * ```ts
     * const Something = g.object<{ thing: string }>()({
     *   name: "Something",
     *   fields: {
     *     thing: g.field({ type: g.String }),
     *   },
     * });
     * ```
     */
    field: <Source, Type extends GOutputType<Context>, Resolve, Args extends {
        [Key in keyof Args]: GArg<GInputType>;
    } = {}>(field: FieldFuncArgs<Source, Args, Type, Context> & (Resolve extends {} ? {
        resolve: ((source: Source, args: InferValueFromArgs<SomeTypeThatIsntARecordOfArgs extends Args ? {} : Args>, context: Context, info: GraphQLResolveInfo) => InferValueFromOutputType<Type>) & Resolve;
    } : {
        resolve?: ((source: Source, args: InferValueFromArgs<SomeTypeThatIsntARecordOfArgs extends Args ? {} : Args>, context: Context, info: GraphQLResolveInfo) => InferValueFromOutputType<Type>) & Resolve;
    })) => GField<Source, Args, Type, Resolve extends {} ? unknown : ImpliedResolver<Args, Type, Context>, Context>;
    /**
     * A helper to declare fields while providing the source type a single time
     * rather than in every resolver.
     *
     * ```ts
     * const nodeFields = g.fields<{ id: string }>()({
     *   id: g.field({ type: g.ID }),
     *   relatedIds: g.field({
     *     type: g.list(g.ID),
     *     resolve(source) {
     *       return loadRelatedIds(source.id);
     *     },
     *   }),
     *   otherRelatedIds: g.field({
     *     type: g.list(g.ID),
     *     resolve(source) {
     *       return loadOtherRelatedIds(source.id);
     *     },
     *   }),
     * });
     *
     * const Person = g.object<{
     *   id: string;
     *   name: string;
     * }>()({
     *   name: "Person",
     *   fields: {
     *     ...nodeFields,
     *     name: g.field({ type: g.String }),
     *   },
     * });
     * ```
     */
    fields: <Source>(youOnlyNeedToPassATypeParameterToThisFunctionYouPassTheActualRuntimeArgsOnTheResultOfThisFunction?: {
        youOnlyNeedToPassATypeParameterToThisFunctionYouPassTheActualRuntimeArgsOnTheResultOfThisFunction: true;
    }) => <Fields extends Record<string, GField<Source, any, GOutputType<Context>, any, Context>> & {
        [Key in keyof Source]?: GField<Source, any, GOutputType<Context>, Source[Key], Context>;
    }>(fields: Fields) => Fields;
    /**
     * Creates a GraphQL interface field.
     *
     * These will generally be passed directly to the `fields` object in a
     * {@link g.interface} call. Interfaces fields are similar to
     * {@link GField regular fields} except that they **don't define how the field
     * is resolved**.
     *
     * ```ts
     * const Entity = g.interface()({
     *   name: "Entity",
     *   fields: {
     *     name: g.interfaceField({ type: g.String }),
     *   },
     * });
     * ```
     *
     * Note that {@link GField regular fields} are assignable to
     * {@link GInterfaceField interface fields} but the opposite is not true. This
     * means that you can use a regular field in an
     * {@link GInterfaceType interface type}.
     */
    interfaceField: <Args extends {
        [Key in keyof Args]: GArg<GInputType>;
    }, Type extends GOutputType<Context>>(field: GInterfaceField<Args, Type, Context>) => GInterfaceField<Args, Type, Context>;
    /**
     * Creates a GraphQL interface type that can be implemented by other GraphQL
     * object and interface types.
     *
     * ```ts
     * const Entity = g.interface()({
     *   name: "Entity",
     *   fields: {
     *     name: g.interfaceField({ type: g.String }),
     *   },
     * });
     *
     * type PersonSource = { __typename: "Person"; name: string };
     *
     * const Person = g.object<PersonSource>()({
     *   name: "Person",
     *   interfaces: [Entity],
     *   fields: {
     *     name: g.field({ type: g.String }),
     *   },
     * });
     *
     * type OrganisationSource = {
     *   __typename: "Organisation";
     *   name: string;
     * };
     *
     * const Organisation = g.object<OrganisationSource>()({
     *   name: "Organisation",
     *   interfaces: [Entity],
     *   fields: {
     *     name: g.field({ type: g.String }),
     *   },
     * });
     * ```
     *
     * ## Resolving Types
     *
     * When using GraphQL interface and union types, there needs to a way to
     * determine which concrete object type has been returned from a resolver.
     * With `graphql-js` and `@graphql-ts/schema`, this is done with `isTypeOf` on
     * object types and `resolveType` on interface and union types. Note
     * `@graphql-ts/schema` **does not aim to strictly type the implementation of
     * `resolveType` and `isTypeOf`**. If you don't provide `resolveType` or
     * `isTypeOf`, a `__typename` property on the source type will be used, if
     * that fails, an error will be thrown at runtime.
     *
     * ## Fields vs Interface Fields
     *
     * You might have noticed that `g.interfaceField` was used instead of
     * `g.field` for the fields on the interfaces. This is because **interfaces
     * aren't defining implementation of fields** which means that fields on an
     * interface don't need define resolvers.
     *
     * ## Sharing field implementations
     *
     * Even though interfaces don't contain field implementations, you may still
     * want to share field implementations between interface implementations. You
     * can use `g.fields` to do that. See `g.fields` for more information about
     * why you should use `g.fields` instead of just defining an object the fields
     * and spreading that.
     *
     * ```ts
     * const nodeFields = g.fields<{ id: string }>({
     *   id: g.field({ type: g.ID }),
     * });
     *
     * const Node = g.field({
     *   name: "Node",
     *   fields: nodeFields,
     * });
     *
     * const Person = g.object<{
     *   __typename: "Person";
     *   id: string;
     *   name: string;
     * }>()({
     *   name: "Person",
     *   interfaces: [Node],
     *   fields: {
     *     ...nodeFields,
     *     name: g.field({ type: g.String }),
     *   },
     * });
     * ```
     */
    interface: <Source>(youOnlyNeedToPassATypeParameterToThisFunctionYouPassTheActualRuntimeArgsOnTheResultOfThisFunction?: {
        youOnlyNeedToPassATypeParameterToThisFunctionYouPassTheActualRuntimeArgsOnTheResultOfThisFunction: true;
    }) => <Fields extends {
        [Key in keyof Fields]: GInterfaceField<any, GOutputType<Context>, Context>;
    } & InterfacesToInterfaceFields<Interfaces>, const Interfaces extends readonly GInterfaceType<Source, any, Context>[] = []>(config: GInterfaceTypeConfig<Source, Fields, Interfaces, Context>) => GInterfaceType<Source, Fields, Context>;
    /**
     * A shorthand to easily create {@link GEnumValueConfig enum values} to pass to
     * {@link g.enum}.
     *
     * If you need to set a `description` or `deprecationReason` for an enum
     * variant, you should pass values directly to `g.enum` without using
     * `g.enumValues`.
     *
     * ```ts
     * const MyEnum = g.enum({
     *   name: "MyEnum",
     *   values: g.enumValues(["a", "b"]),
     * });
     * ```
     *
     * ```ts
     * const values = g.enumValues(["a", "b"]);
     *
     * assertDeepEqual(values, {
     *   a: { value: "a" },
     *   b: { value: "b" },
     * });
     * ```
     */
    enumValues: <const Values extends readonly string[]>(values: readonly [...Values]) => {
        [Key in Values[number]]: GEnumValueConfig<Key>;
    };
    /**
     * Creates an {@link GEnumType enum type} with a number of
     * {@link GEnumValueConfig enum values}.
     *
     * ```ts
     * const MyEnum = g.enum({
     *   name: "MyEnum",
     *   values: g.enumValues(["a", "b"]),
     * });
     * // ==
     * graphql`
     *   enum MyEnum {
     *     a
     *     b
     *   }
     * `;
     * ```
     *
     * ```ts
     * const MyEnum = g.enum({
     *   name: "MyEnum",
     *   description: "My enum does things",
     *   values: {
     *     something: {
     *       description: "something something",
     *       value: "something",
     *     },
     *     thing: {
     *       description: "thing thing",
     *       deprecationReason: "something should be used instead of thing",
     *       value: "thing",
     *     },
     *   },
     * });
     * // ==
     * graphql`
     *   """
     *   My enum does things
     *   """
     *   enum MyEnum {
     *     """
     *     something something
     *     """
     *     something
     *     """
     *     thing thing
     *     """
     *     thing @\deprecated(reason: "something should be used instead of thing")
     *   }
     * `;)
     * ```
     */
    enum: <const Values extends Record<string, unknown>>(config: GEnumTypeConfig<Values>) => GEnumType<Values>;
    /**
     * Creates a {@link GArg GraphQL argument}.
     *
     * Args can can be used as arguments on output fields:
     *
     * ```ts
     * g.field({
     *   type: g.String,
     *   args: {
     *     something: g.arg({ type: g.String }),
     *   },
     *   resolve(source, { something }) {
     *     return something || somethingElse;
     *   },
     * });
     * // ==
     * graphql`(something: String): String`;
     * ```
     *
     * Or as fields on input objects:
     *
     * ```ts
     * const Something = g.inputObject({
     *   name: "Something",
     *   fields: {
     *     something: g.arg({ type: g.String }),
     *   },
     * });
     * // ==
     * graphql`
     *   input Something {
     *     something: String
     *   }
     * `;
     * ```
     */
    arg: <Type extends GInputType, DefaultValue extends InferValueFromInputType<Type> | undefined = undefined>(arg: Flatten<{
        type: Type;
    } & Omit<GraphQLInputFieldConfig & GraphQLArgumentConfig, "type" | "defaultValue">> & (undefined extends DefaultValue ? {
        defaultValue?: DefaultValue;
    } : {
        defaultValue: DefaultValue;
    })) => GArg<Type, DefaultValue extends undefined ? false : true>;
    /**
     * Creates an {@link GInputObjectType input object type}
     *
     * ```ts
     * const Something = g.inputObject({
     *   name: "Something",
     *   fields: {
     *     something: g.arg({ type: g.String }),
     *   },
     * });
     * // ==
     * graphql`
     *   input Something {
     *     something: String
     *   }
     * `;
     * ```
     *
     * ### Handling circular objects
     *
     * Circular input objects require explicitly specifying the fields on the
     * object in the type because of TypeScript's limits with circularity.
     *
     * ```ts
     * import { GInputObjectType } from "@graphql-ts/schema";
     *
     * type SomethingInputType = GInputObjectType<{
     *   something: g<typeof g.arg<SomethingInputType>>;
     * }>;
     * const Something: SomethingInputType = g.inputObject({
     *   name: "Something",
     *   fields: () => ({
     *     something: g.arg({ type: Something }),
     *   }),
     * });
     * ```
     *
     * You can specify all of your non-circular fields outside of the fields
     * object and then use `typeof` to get the type to avoid writing the
     * non-circular fields as types again.
     *
     * ```ts
     * import { GInputObjectType } from "@graphql-ts/schema";
     *
     * const nonCircularFields = {
     *   thing: g.arg({ type: g.String }),
     * };
     * type SomethingInputType = GInputObjectType<
     *   typeof nonCircularFields & {
     *     something: g<typeof g.arg<SomethingInputType>>;
     *   }
     * >;
     * const Something: SomethingInputType = g.inputObject({
     *   name: "Something",
     *   fields: () => ({
     *     ...nonCircularFields,
     *     something: g.arg({ type: Something }),
     *   }),
     * });
     * ```
     */
    inputObject: <Fields extends {
        [key: string]: IsOneOf extends true ? GArg<GNullableInputType, false> : GArg<GInputType>;
    }, IsOneOf extends boolean = false>(config: GInputObjectTypeConfig<Fields, IsOneOf>) => GInputObjectType<Fields, IsOneOf>;
    /**
     * Wraps any GraphQL type in a {@link GList list type}.
     *
     * ```ts
     * const stringListType = g.list(g.String);
     * // ==
     * graphql`[String]`;
     * ```
     *
     * When used as an input type, you will recieve an array of the inner type.
     *
     * ```ts
     * g.field({
     *   type: g.String,
     *   args: { thing: g.arg({ type: g.list(g.String) }) },
     *   resolve(source, { thing }) {
     *     const theThing: undefined | null | Array<string | null> = thing;
     *     return "";
     *   },
     * });
     * ```
     *
     * When used as an output type, you can return an iterable of the inner type
     * that also matches `typeof val === 'object'` so for example, you'll probably
     * return an Array most of the time but you could also return a Set you
     * couldn't return a string though, even though a string is an iterable, it
     * doesn't match `typeof val === 'object'`.
     *
     * ```ts
     * g.field({
     *   type: g.list(g.String),
     *   resolve() {
     *     return [""];
     *   },
     * });
     * ```
     *
     * ```ts
     * g.field({
     *   type: g.list(g.String),
     *   resolve() {
     *     return new Set([""]);
     *   },
     * });
     * ```
     *
     * ```ts
     * g.field({
     *   type: g.list(g.String),
     *   resolve() {
     *     // this will not be allowed
     *     return "some things";
     *   },
     * });
     * ```
     */
    list: <Of extends GType<any>>(of: Of) => GList<Of>;
    /**
     * Wraps a {@link GNullableType nullable type} with a
     * {@link GNonNull non-nullable type}.
     *
     * Types in GraphQL are always nullable by default so if you want to enforce
     * that a type must always be there, you can use the non-null type.
     *
     * ```ts
     * const nonNullableString = g.nonNull(g.String);
     * // ==
     * graphql`String!`;
     * ```
     *
     * When using a non-null type as an input type, your resolver will never
     * recieve null and consumers of your GraphQL API **must** provide a value for
     * it unless you provide a default value.
     *
     * ```ts
     * g.field({
     *   args: {
     *     someNonNullAndRequiredArg: g.arg({
     *       type: g.nonNull(g.String),
     *     }),
     *     someNonNullButOptionalArg: g.arg({
     *       type: g.nonNull(g.String),
     *       defaultValue: "some default",
     *     }),
     *   },
     *   type: g.String,
     *   resolve(source, args) {
     *     // both of these will always be a string
     *     args.someNonNullAndRequiredArg;
     *     args.someNonNullButOptionalArg;
     *
     *     return "";
     *   },
     * });
     * // ==
     * graphql`
     *   fieldName(
     *     someNonNullAndRequiredArg: String!
     *     someNonNullButOptionalArg: String! = "some default"
     *   ): String
     * `;
     * ```
     *
     * When using a non-null type as an output type, your resolver must never
     * return null. If you do return null(which unless you do
     * type-casting/ts-ignore/etc. `@graphql-ts/schema` will not let you do)
     * graphql-js will return an error to consumers of your GraphQL API.
     *
     * Non-null types should be used very carefully on output types. If you have
     * to do a fallible operation like a network request or etc. to get the value,
     * it probably shouldn't be non-null. If you make a field non-null and doing
     * the fallible operation fails, consumers of your GraphQL API will be unable
     * to see any of the other fields on the object that the non-null field was
     * on. For example, an id on some type is a good candidate for being non-null
     * because if you have the item, you will already have the id so getting the
     * id will never fail but fetching a related item from a database would be
     * fallible so even if it will never be null in the success case, you should
     * make it nullable.
     *
     * ```ts
     * g.field({
     *   type: g.nonNull(g.String),
     *   resolve(source, args) {
     *     return "something";
     *   },
     * });
     * // ==
     * graphql`
     *   fieldName: String!
     * `;
     * ```
     *
     * If you try to wrap another non-null type in a non-null type again, you will
     * get a type error.
     *
     * ```ts
     * // Argument of type 'NonNullType<ScalarType<string>>'
     * // is not assignable to parameter of type 'NullableType'.
     * g.nonNull(g.nonNull(g.String));
     * ```
     */
    nonNull: <Of extends GNullableType<any>>(of: Of) => GNonNull<Of>;
    /**
     * Creates a {@link GScalarType scalar type}.
     *
     * ```ts
     * const BigInt = g.scalar({
     *   name: "BigInt",
     *   serialize(value) {
     *     if (typeof value !== "bigint")
     *       throw new GraphQLError(
     *         `unexpected value provided to BigInt scalar: ${value}`
     *       );
     *     return value.toString();
     *   },
     *   parseLiteral(value) {
     *     if (value.kind !== "StringValue")
     *       throw new GraphQLError("BigInt only accepts values as strings");
     *     return globalThis.BigInt(value.value);
     *   },
     *   parseValue(value) {
     *     if (typeof value === "bigint") return value;
     *     if (typeof value !== "string")
     *       throw new GraphQLError("BigInt only accepts values as strings");
     *     return globalThis.BigInt(value);
     *   },
     * });
     * // for fields on output types
     * g.field({ type: someScalar });
     *
     * // for args on output fields or fields on input types
     * g.arg({ type: someScalar });
     * ```
     *
     * Note, while graphql-js allows you to express scalar types like the `ID`
     * type which accepts integers and strings as both input values and return
     * values from resolvers which are transformed into strings before calling
     * resolvers and returning the query respectively, the type you use should be
     * `string` for `ID` since that is what it is transformed into.
     * `@graphql-ts/schema` doesn't currently express the coercion of scalars, you
     * should instead convert values to the canonical form yourself before
     * returning from resolvers.
     */
    scalar: <Internal, External = Internal>(config: GraphQLScalarTypeConfig<Internal, External>) => GScalarType<Internal, External>;
    ID: GScalarType<string>;
    String: GScalarType<string>;
    Float: GScalarType<number>;
    Int: GScalarType<number>;
    Boolean: GScalarType<boolean>;
};
/**
 * The `gWithContext` function accepts a `Context` type parameter which binds
 * the returned functions so they can be used to compose GraphQL types into a
 * GraphQL schema.
 *
 * A simple schema with only a query type looks like this:
 *
 * ```ts
 * import { gWithContext } from "@graphql-ts/schema";
 * import { GraphQLSchema, graphql } from "graphql";
 *
 * type Context = {};
 *
 * const g = gWithContext<Context>();
 * type g<T> = gWithContext.infer<T>;
 *
 * const Query = g.object()({
 *   name: "Query",
 *   fields: {
 *     hello: g.field({
 *       type: g.String,
 *       resolve() {
 *         return "Hello!";
 *       },
 *     }),
 *   },
 * });
 *
 * const schema = new GraphQLSchema({
 *   query: Query,
 * });
 *
 * graphql({
 *   source: `
 *       query {
 *         hello
 *       }
 *     `,
 *   schema,
 * }).then((result) => {
 *   console.log(result);
 * });
 * ```
 *
 * You can use pass the `schema` to `ApolloServer` and other GraphQL servers.
 *
 * You can also create a more advanced schema with other object types, circular
 * types, args, and mutations. See {@link GWithContext} for what the other
 * functions on `g` do.
 *
 * ```ts
 * import { gWithContext } from "@graphql-ts/schema";
 * import { GraphQLSchema, graphql } from "graphql";
 * import { deepEqual } from "node:assert";
 *
 * type Context = {
 *   todos: Map<string, TodoItem>;
 * };
 *
 * const g = gWithContext<Context>();
 * type g<T> = gWithContext.infer<T>;
 *
 * type TodoItem = {
 *   id: string;
 *   title: string;
 *   relatedTodos: string[];
 * };
 *
 * const Todo: g<typeof g.object<TodoItem>> = g.object<TodoItem>()({
 *   name: "Todo",
 *   fields: () => ({
 *     id: g.field({ type: g.nonNull(g.ID) }),
 *     title: g.field({ type: g.nonNull(g.String) }),
 *     relatedTodos: g.field({
 *       type: g.list(Todo),
 *       resolve(source, _args, context) {
 *         return source.relatedTodos
 *           .map((id) => context.todos.get(id))
 *           .filter((todo) => todo !== undefined);
 *       },
 *     }),
 *   }),
 * });
 *
 * const Query = g.object()({
 *   name: "Query",
 *   fields: {
 *     todos: g.field({
 *       type: g.list(Todo),
 *       resolve(_source, _args, context) {
 *         return context.todos.values();
 *       },
 *     }),
 *   },
 * });
 *
 * const Mutation = g.object()({
 *   name: "Mutation",
 *   fields: {
 *     createTodo: g.field({
 *       args: {
 *         title: g.arg({ type: g.nonNull(g.String) }),
 *         relatedTodos: g.arg({
 *           type: g.nonNull(g.list(g.nonNull(g.ID))),
 *           defaultValue: [],
 *         }),
 *       },
 *       type: Todo,
 *       resolve(_source, { title, relatedTodos }, context) {
 *         const todo = { title, relatedTodos, id: crypto.randomUUID() };
 *         context.todos.set(todo.id, todo);
 *         return todo;
 *       },
 *     }),
 *   },
 * });
 *
 * const schema = new GraphQLSchema({
 *   query: Query,
 *   mutation: Mutation,
 * });
 *
 * (async () => {
 *   const contextValue: Context = { todos: new Map() };
 *   {
 *     const result = await graphql({
 *       source: `
 *         query {
 *           todos {
 *             title
 *           }
 *         }
 *       `,
 *       schema,
 *       contextValue,
 *     });
 *     deepEqual(result, { data: { todos: [] } });
 *   }
 *
 *   {
 *     const result = await graphql({
 *       source: `
 *         mutation {
 *           createTodo(title: "Try graphql-ts") {
 *             title
 *           }
 *         }
 *       `,
 *       schema,
 *       contextValue,
 *     });
 *     deepEqual(result, {
 *       data: { createTodo: { title: "Try graphql-ts" } },
 *     });
 *   }
 *   {
 *     const result = await graphql({
 *       source: `
 *         query {
 *           todos {
 *             title
 *           }
 *         }
 *       `,
 *       schema,
 *       contextValue,
 *     });
 *     deepEqual(result, {
 *       data: { todos: [{ title: "Try graphql-ts" }] },
 *     });
 *   }
 * })();
 * ```
 */
export declare function gWithContext<Context>(): GWithContext<Context>;
export declare namespace gWithContext {
    /**
     * The `gWithContext.infer` type is useful particularly when defining circular
     * types to resolve errors from TypeScript because of the circularity.
     *
     * We recommend aliasing `gWithContext.infer` to your `g` like this to make it
     * easier to use:
     *
     * ```ts
     * import { gWithContext } from "@graphql-ts/schema";
     * type Context = {};
     *
     * const g = gWithContext<Context>();
     * type g<T> = gWithContext.infer<T>;
     *
     * type PersonSource = { name: string; friends: PersonSource[] };
     *
     * const Person: g<typeof g.object<PersonSource>> =
     *   g.object<PersonSource>()({
     *     name: "Person",
     *     fields: () => ({
     *       name: g.field({ type: g.String }),
     *       friends: g.field({ type: g.list(Person) }),
     *     }),
     *   });
     * ```
     */
    type infer<T> = T extends () => (args: any) => infer R ? R : T extends (args: any) => infer R ? R : never;
}
type Flatten<T> = {
    [Key in keyof T]: T[Key];
} & {};
//# sourceMappingURL=output.d.ts.map