diff --git a/examples/starwars.ts b/examples/starwars.ts
index 26acd50..81cdcc7 100644
--- a/examples/starwars.ts
+++ b/examples/starwars.ts
@@ -1,4 +1,4 @@
-import type { Interface } from '../src';
+import type { InterfaceType } from '../src';
 import type { Connection, ConnectionArguments, Edge } from '../src/relay';
 import { buildGraphQLSchema, Gql } from '../src';
 import {
@@ -10,7 +10,7 @@ import express = require('express');
 import graphqlHTTP = require('express-graphql');
 
 declare module '../src/types' {
-  interface Context {
+  interface GqlContext {
     contextContent: string;
   }
 }
@@ -154,7 +154,7 @@ const episodeEnum = Gql.Enum({
   ],
 });
 
-const characterInterface: Interface<ICharacter | null> =
+const characterInterface: InterfaceType<ICharacter | null> =
   Gql.InterfaceType<ICharacter>({
     name: 'Character',
     interfaces: [],
diff --git a/src/build.ts b/src/build.ts
index e88e0dd..3af9a0a 100644
--- a/src/build.ts
+++ b/src/build.ts
@@ -6,11 +6,11 @@ import {
   AllType,
   DefaultArgument,
   Argument,
-  SubscriptionObject,
+  SubscriptionObjectType,
   ArgMap,
-  Context,
-  Union,
-  Interface,
+  GqlContext,
+  UnionType,
+  InterfaceType,
 } from './types';
 
 export function buildGraphQLSchema<RootSrc>(
@@ -64,13 +64,13 @@ export function toGraphQLArgs<T>(
 }
 
 export function toGraphQLSubscriptionObject<RootSrc>(
-  subscriptionObj: SubscriptionObject<RootSrc>,
+  subscriptionObj: SubscriptionObjectType<RootSrc>,
   typeMap: Map<AllType, graphql.GraphQLType>
 ): graphql.GraphQLObjectType {
   return new graphql.GraphQLObjectType({
     name: subscriptionObj.name,
     fields: () => {
-      const gqlFieldConfig: graphql.GraphQLFieldConfigMap<RootSrc, Context> =
+      const gqlFieldConfig: graphql.GraphQLFieldConfigMap<RootSrc, GqlContext> =
         {};
 
       subscriptionObj.fields().forEach((field) => {
@@ -190,7 +190,7 @@ export function toGraphQLOutputType<Src>(
         isTypeOf: t.isTypeOf,
         fields: () => {
           const fields = t.fieldsFn();
-          const gqlFieldConfig: graphql.GraphQLFieldConfigMap<Src, Context> =
+          const gqlFieldConfig: graphql.GraphQLFieldConfigMap<Src, GqlContext> =
             {};
 
           fields.forEach((field) => {
@@ -231,7 +231,7 @@ export function toGraphQLOutputType<Src>(
                 src,
                 ctx,
                 info,
-                ourType as Union<any> | Interface<any>
+                ourType as UnionType<any> | InterfaceType<any>
               );
             }
           : undefined,
@@ -245,7 +245,7 @@ export function toGraphQLOutputType<Src>(
         description: t.description,
         fields: () => {
           const fields = t.fieldsFn();
-          const result: graphql.GraphQLFieldConfigMap<Src, Context> = {};
+          const result: graphql.GraphQLFieldConfigMap<Src, GqlContext> = {};
 
           fields.forEach((field) => {
             result[field.name] = {
@@ -275,7 +275,7 @@ export function toGraphQLOutputType<Src>(
                 src,
                 ctx,
                 info,
-                ourType as Union<any> | Interface<any>
+                ourType as UnionType<any> | InterfaceType<any>
               );
             }
           : undefined,
diff --git a/src/define.ts b/src/define.ts
index c2bf2c4..252d909 100644
--- a/src/define.ts
+++ b/src/define.ts
@@ -1,12 +1,12 @@
 import * as graphql from 'graphql';
 import {
-  Scalar,
-  Enum,
+  ScalarType,
+  EnumType,
   EnumValue,
   ObjectType,
-  InputObject,
-  Interface,
-  Union,
+  InputObjectType,
+  InterfaceType,
+  UnionType,
   InputType,
   OutputType,
   ArgMap,
@@ -17,9 +17,9 @@ import {
   Argument,
   InputFieldMap,
   SubscriptionField,
-  SubscriptionObject,
+  SubscriptionObjectType,
   PromiseOrValue,
-  Context,
+  GqlContext,
 } from './types';
 
 type ExtensionsMap = {
@@ -35,7 +35,7 @@ type ResolvePartialMandatory<Src, Arg, Out> = {
   resolve: (
     src: Src,
     args: TOfArgMap<ArgMap<Arg>>,
-    ctx: Context,
+    ctx: GqlContext,
     info: graphql.GraphQLResolveInfo
   ) => PromiseOrValue<Out>;
 };
@@ -44,14 +44,14 @@ type ResolvePartialOptional<Src, Arg, Out> = {
   resolve?: (
     src: Src,
     args: TOfArgMap<ArgMap<Arg>>,
-    ctx: Context,
+    ctx: GqlContext,
     info: graphql.GraphQLResolveInfo
   ) => PromiseOrValue<Out>;
 };
 
 function builtInScalar<Src>(
   builtInType: graphql.GraphQLScalarType
-): Scalar<Src | null> {
+): ScalarType<Src | null> {
   return {
     kind: 'Scalar',
     builtInType,
@@ -59,22 +59,22 @@ function builtInScalar<Src>(
 }
 
 export namespace Gql {
-  export const String: Scalar<string | null | undefined> =
+  export const String: ScalarType<string | null | undefined> =
     builtInScalar<string>(graphql.GraphQLString);
-  export const Int: Scalar<number | null | undefined> = builtInScalar<number>(
+  export const Int: ScalarType<number | null | undefined> = builtInScalar<number>(
     graphql.GraphQLInt
   );
-  export const Float: Scalar<number | null | undefined> = builtInScalar<number>(
+  export const Float: ScalarType<number | null | undefined> = builtInScalar<number>(
     graphql.GraphQLFloat
   );
-  export const Boolean: Scalar<boolean | null | undefined> =
+  export const Boolean: ScalarType<boolean | null | undefined> =
     builtInScalar<boolean>(graphql.GraphQLBoolean);
 
-  export const ID: Scalar<string | null | undefined> = builtInScalar<string>(
+  export const ID: ScalarType<string | null | undefined> = builtInScalar<string>(
     graphql.GraphQLID
   );
 
-  export function ScalarType<Src>({
+  export function Scalar<Src>({
     name,
     description,
     serialize,
@@ -86,7 +86,7 @@ export namespace Gql {
     serialize: (src: Src) => any | null;
     parseValue?: (value: unknown) => Src | null;
     parseLiteral?: (value: graphql.ValueNode) => Src | null;
-  }): Scalar<Src | null> {
+  }): ScalarType<Src | null> {
     return {
       kind: 'Scalar',
       graphqlTypeConfig: {
@@ -107,7 +107,7 @@ export namespace Gql {
     name: string;
     description?: string;
     values: Array<EnumValue<Src>>;
-  }): Enum<Src | null> {
+  }): EnumType<Src | null> {
     return {
       kind: 'Enum',
       name,
@@ -210,13 +210,13 @@ export namespace Gql {
   }: {
     name: string;
     description?: string;
-    interfaces?: Array<Interface<any>>;
+    interfaces?: Array<InterfaceType<any>>;
     fields: (
       self: OutputType<Src | null>
     ) => [Field<Src, any, {}>, ...Field<Src, any, {}>[]];
     isTypeOf?: (
       src: any,
-      ctx: Context,
+      ctx: GqlContext,
       info: graphql.GraphQLResolveInfo
     ) => boolean;
     extensions?: ExtensionsMap['objectType'] extends undefined
@@ -245,8 +245,8 @@ export namespace Gql {
     name: string;
     description?: string;
     fields: (self: InputType<Src | null>) => InputFieldMap<Src>;
-  }): InputObject<Src | null> {
-    let inputObj: InputObject<Src | null> = {
+  }): InputObjectType<Src | null> {
+    let inputObj: InputObjectType<Src | null> = {
       kind: 'InputObject',
       name,
       description,
@@ -267,14 +267,14 @@ export namespace Gql {
     description?: string;
     types: Array<ObjectType<any>> | (() => Array<ObjectType<any>>);
     resolveType: (src: Src) => string;
-  }): Union<Src | null> {
+  }): UnionType<Src | null> {
     return {
       kind: 'Union',
       name,
       description,
       types,
       resolveType,
-    } as Union<Src | null>;
+    } as UnionType<Src | null>;
   }
 
   export function InterfaceType<Src>({
@@ -285,10 +285,10 @@ export namespace Gql {
   }: {
     name: string;
     description?: string;
-    interfaces?: Array<Interface<any>> | (() => Array<Interface<any>>);
-    fields: (self: Interface<Src | null>) => Array<AbstractField<any>>;
-  }): Interface<Src | null> {
-    const obj: Interface<Src | null> = {
+    interfaces?: Array<InterfaceType<any>> | (() => Array<InterfaceType<any>>);
+    fields: (self: InterfaceType<Src | null>) => Array<AbstractField<any>>;
+  }): InterfaceType<Src | null> {
+    const obj: InterfaceType<Src | null> = {
       kind: 'Interface',
       name,
       description,
@@ -388,7 +388,7 @@ export namespace Gql {
     subscribe: (
       src: RootSrc,
       args: TOfArgMap<ArgMap<Arg>>,
-      ctx: Context,
+      ctx: GqlContext,
       info: graphql.GraphQLResolveInfo
     ) => PromiseOrValue<AsyncIterableIterator<Out>>;
   }): SubscriptionField<RootSrc, Arg, Out> {
@@ -413,7 +413,7 @@ export namespace Gql {
       SubscriptionField<Src, any, any>,
       ...SubscriptionField<Src, any, any>[]
     ];
-  }): SubscriptionObject<Src> {
+  }): SubscriptionObjectType<Src> {
     return {
       kind: 'SubscriptionObject',
       name,
diff --git a/src/relay.ts b/src/relay.ts
index 373026e..1eb6db9 100644
--- a/src/relay.ts
+++ b/src/relay.ts
@@ -1,9 +1,9 @@
 import type {
   Field,
-  Interface,
+  InterfaceType,
   Argument,
   TOfArgMap,
-  Context,
+  GqlContext,
   ObjectType,
 } from './types';
 import { Gql } from './define';
@@ -14,7 +14,7 @@ import { GraphQLResolveInfo } from 'graphql';
 
 export type ConnectionConfig<T> = {
   name?: string;
-  nodeType: ObjectType<T | null> | Interface<T | null>;
+  nodeType: ObjectType<T | null> | InterfaceType<T | null>;
   edgeFields?: () => Array<Field<Edge<T>, any, any>>;
   connectionFields?: () => Array<Field<Connection<T>, any, any>>;
 };
@@ -58,7 +58,7 @@ export type RelayConnectionDefinitions<T> = {
 export function nodeDefinitions<Src>(
   idFetcher: (
     id: string,
-    context: Context,
+    context: GqlContext,
     info: GraphQLResolveInfo
   ) => Promise<Src> | Src
 ) {
diff --git a/src/types.ts b/src/types.ts
index 486fd7a..cdff205 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -3,24 +3,24 @@ import * as graphql from 'graphql';
 export type PromiseOrValue<T> = Promise<T> | T;
 type Maybe<T> = T | null | undefined;
 
-export interface Context {}
+export interface GqlContext {}
 
 export type OutputType<Src> =
-  | Scalar<Src>
-  | Enum<Src>
+  | ScalarType<Src>
+  | EnumType<Src>
   | ObjectType<Src>
-  | Union<Src>
-  | Interface<Src>
-  | ListType<Src>
-  | NonNullType<Src>;
+  | UnionType<Src>
+  | InterfaceType<Src>
+  | ListOutput<Src>
+  | NonNullOutput<Src>;
 
-interface ListType<Src> extends List<OutputType<Src>> {}
-interface NonNullType<Src> extends NonNull<OutputType<Src>> {}
+interface ListOutput<Src> extends List<OutputType<Src>> {}
+interface NonNullOutput<Src> extends NonNull<OutputType<Src>> {}
 
 export type InputType<Src> =
-  | Scalar<Src>
-  | Enum<Src>
-  | InputObject<Src>
+  | ScalarType<Src>
+  | EnumType<Src>
+  | InputObjectType<Src>
   | ListInputType<Src>
   | NonNullInputType<Src>;
 
@@ -29,7 +29,7 @@ interface NonNullInputType<Src> extends NonNullInput<InputType<Src>> {}
 
 export type AllType = OutputType<any> | InputType<any>;
 
-export type Scalar<Src> =
+export type ScalarType<Src> =
   | {
       kind: 'Scalar';
       graphqlTypeConfig: graphql.GraphQLScalarTypeConfig<Src, unknown>;
@@ -39,7 +39,7 @@ export type Scalar<Src> =
       builtInType: graphql.GraphQLScalarType;
     };
 
-export type Enum<Src> = {
+export type EnumType<Src> = {
   kind: 'Enum';
   name: string;
   description?: string;
@@ -113,7 +113,7 @@ export type Field<Src, Out, TArg extends object = {}> = {
   resolve?: (
     src: Src,
     args: TOfArgMap<ArgMap<TArg>>,
-    ctx: Context,
+    ctx: GqlContext,
     info: graphql.GraphQLResolveInfo
   ) => Out | Promise<Out>;
   extensions?: Record<string, any>;
@@ -133,11 +133,11 @@ export type ObjectType<Src> = {
   name: string;
   description?: string;
   deprecationReason?: string;
-  interfaces: Array<Interface<any>> | (() => Array<Interface<any>>);
+  interfaces: Array<InterfaceType<any>> | (() => Array<InterfaceType<any>>);
   fieldsFn: () => Array<Field<Src, any, any>>;
   isTypeOf?: (
     src: any,
-    ctx: Context,
+    ctx: GqlContext,
     info: graphql.GraphQLResolveInfo
   ) => boolean | Promise<boolean>;
   extensions?: Record<string, any>;
@@ -153,7 +153,7 @@ export type InputFieldMap<T> = {
   [K in keyof T]: InputField<T[K]>;
 };
 
-export type InputObject<Src> = {
+export type InputObjectType<Src> = {
   kind: 'InputObject';
   name: string;
   description?: string;
@@ -162,21 +162,21 @@ export type InputObject<Src> = {
 
 export type ResolveType<Src> = (
   src: Src,
-  ctx: Context,
+  ctx: GqlContext,
   info: graphql.GraphQLResolveInfo,
-  abstractType: Union<Src> | Interface<Src>
+  abstractType: UnionType<Src> | InterfaceType<Src>
 ) => PromiseOrValue<string | undefined>;
 
-export type Interface<Src> = {
+export type InterfaceType<Src> = {
   kind: 'Interface';
   name: string;
   description?: string;
-  interfaces: Array<Interface<any>> | (() => Array<Interface<any>>);
+  interfaces: Array<InterfaceType<any>> | (() => Array<InterfaceType<any>>);
   fieldsFn: () => Array<AbstractField<any>>;
   resolveType?: ResolveType<Src>;
 };
 
-export type Union<Src> = {
+export type UnionType<Src> = {
   kind: 'Union';
   name: string;
   description?: string;
@@ -184,7 +184,7 @@ export type Union<Src> = {
   resolveType: ResolveType<Src>;
 };
 
-export type SubscriptionObject<RootSrc> = {
+export type SubscriptionObjectType<RootSrc> = {
   kind: 'SubscriptionObject';
   name: string;
   fields: () => Array<SubscriptionField<RootSrc, any, any>>;
@@ -200,13 +200,13 @@ export type SubscriptionField<RootSrc, TArg, Out> = {
   subscribe: (
     source: RootSrc,
     args: TOfArgMap<ArgMap<TArg>>,
-    ctx: Context,
+    ctx: GqlContext,
     info: graphql.GraphQLResolveInfo
   ) => PromiseOrValue<AsyncIterableIterator<Out>>;
   resolve: (
     source: Out,
     args: TOfArgMap<ArgMap<TArg>>,
-    ctx: Context,
+    ctx: GqlContext,
     info: graphql.GraphQLResolveInfo
   ) => PromiseOrValue<Out>;
 };
@@ -214,7 +214,7 @@ export type SubscriptionField<RootSrc, TArg, Out> = {
 export type Schema<RootSrc = undefined> = {
   query: ObjectType<RootSrc>;
   mutation?: ObjectType<RootSrc>;
-  subscription?: SubscriptionObject<RootSrc>;
+  subscription?: SubscriptionObjectType<RootSrc>;
   types?: ObjectType<any>[];
   directives?: graphql.GraphQLDirective[];
 };
diff --git a/test/simple.spec.ts b/test/simple.spec.ts
index b0da7e1..6b220a0 100644
--- a/test/simple.spec.ts
+++ b/test/simple.spec.ts
@@ -1,11 +1,11 @@
 import { execute, parse, printSchema, subscribe } from 'graphql';
 import * as relay from '../src/relay';
 import { Gql } from '../src/define';
-import { Interface } from '../src/types';
+import { InterfaceType } from '../src/types';
 import { buildGraphQLSchema } from '../src/build';
 
 declare module '../src/types' {
-  interface Context {
+  interface GqlContext {
     contextContent: string;
   }
 }
@@ -153,7 +153,7 @@ test('can build a schema', async () => {
     ],
   });
 
-  const characterInterface: Interface<Character | null> =
+  const characterInterface: InterfaceType<Character | null> =
     Gql.InterfaceType<Character>({
       name: 'Character',
       interfaces: [],