diff --git a/packages/graphql-api/codegen.yml b/packages/graphql-api/codegen.yml
index 6f447611b..7baab3ec6 100644
--- a/packages/graphql-api/codegen.yml
+++ b/packages/graphql-api/codegen.yml
@@ -7,6 +7,6 @@ generates:
       noNamespaces: true
     plugins:
       - add: /* tslint:disable */
-      - typescript-common
-      - typescript-server
+      - typescript
       - typescript-resolvers
+      - typescript-operations
\ No newline at end of file
diff --git a/packages/graphql-api/package.json b/packages/graphql-api/package.json
index 1f50dd394..ae7b5bd60 100644
--- a/packages/graphql-api/package.json
+++ b/packages/graphql-api/package.json
@@ -33,16 +33,17 @@
     "@accounts/types": "^0.19.0",
     "@gql2ts/from-schema": "1.10.1",
     "@gql2ts/types": "1.9.0",
+    "@graphql-codegen/add": "^1.6.1",
+    "@graphql-codegen/cli": "^1.6.1",
+    "@graphql-codegen/typescript": "^1.6.1",
+    "@graphql-codegen/typescript-operations": "^1.6.1",
+    "@graphql-codegen/typescript-resolvers": "^1.6.1",
+    "@graphql-codegen/typescript-type-graphql": "^1.6.1",
     "@graphql-modules/core": "0.7.10",
     "@types/jest": "24.0.18",
     "@types/request-ip": "0.0.34",
     "concurrently": "4.1.2",
     "graphql": "14.5.3",
-    "graphql-code-generator": "0.18.2",
-    "graphql-codegen-add": "0.18.2",
-    "graphql-codegen-typescript-common": "0.18.2",
-    "graphql-codegen-typescript-resolvers": "0.18.2",
-    "graphql-codegen-typescript-server": "0.18.2",
     "graphql-tools": "4.0.5",
     "jest": "24.9.0",
     "lodash": "4.17.15",
diff --git a/packages/graphql-api/src/models.ts b/packages/graphql-api/src/models.ts
index 33934612c..c7255a8f3 100644
--- a/packages/graphql-api/src/models.ts
+++ b/packages/graphql-api/src/models.ts
@@ -1,611 +1,447 @@
 /* tslint:disable */
+import { GraphQLResolveInfo } from 'graphql';
 export type Maybe<T> = T | null;
-
-export interface CreateUserInput {
-  username?: Maybe<string>;
-
-  email?: Maybe<string>;
-
-  password?: Maybe<string>;
-}
-
-export interface TwoFactorSecretKeyInput {
-  ascii?: Maybe<string>;
-
-  base32?: Maybe<string>;
-
-  hex?: Maybe<string>;
-
-  qr_code_ascii?: Maybe<string>;
-
-  qr_code_hex?: Maybe<string>;
-
-  qr_code_base32?: Maybe<string>;
-
-  google_auth_qr?: Maybe<string>;
-
-  otpauth_url?: Maybe<string>;
-}
-
-export interface AuthenticateParamsInput {
-  access_token?: Maybe<string>;
-
-  access_token_secret?: Maybe<string>;
-
-  provider?: Maybe<string>;
-
-  password?: Maybe<string>;
-
+export type RequireFields<T, K extends keyof T> = { [X in Exclude<keyof T, K>]?: T[X] } &
+  { [P in K]-?: NonNullable<T[P]> };
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string;
+  String: string;
+  Boolean: boolean;
+  Int: number;
+  Float: number;
+};
+
+export type AuthenticateParamsInput = {
+  access_token?: Maybe<Scalars['String']>;
+  access_token_secret?: Maybe<Scalars['String']>;
+  provider?: Maybe<Scalars['String']>;
+  password?: Maybe<Scalars['String']>;
   user?: Maybe<UserInput>;
+  code?: Maybe<Scalars['String']>;
+};
+
+export type CreateUserInput = {
+  username?: Maybe<Scalars['String']>;
+  email?: Maybe<Scalars['String']>;
+  password?: Maybe<Scalars['String']>;
+};
+
+export type EmailRecord = {
+  __typename?: 'EmailRecord';
+  address?: Maybe<Scalars['String']>;
+  verified?: Maybe<Scalars['Boolean']>;
+};
+
+export type ImpersonateReturn = {
+  __typename?: 'ImpersonateReturn';
+  authorized?: Maybe<Scalars['Boolean']>;
+  tokens?: Maybe<Tokens>;
+  user?: Maybe<User>;
+};
 
-  code?: Maybe<string>;
-}
-
-export interface UserInput {
-  id?: Maybe<string>;
-
-  email?: Maybe<string>;
-
-  username?: Maybe<string>;
-}
-
-// ====================================================
-// Types
-// ====================================================
-
-export interface Query {
-  twoFactorSecret?: Maybe<TwoFactorSecretKey>;
-
-  getUser?: Maybe<User>;
-}
-
-export interface TwoFactorSecretKey {
-  ascii?: Maybe<string>;
-
-  base32?: Maybe<string>;
-
-  hex?: Maybe<string>;
-
-  qr_code_ascii?: Maybe<string>;
-
-  qr_code_hex?: Maybe<string>;
-
-  qr_code_base32?: Maybe<string>;
-
-  google_auth_qr?: Maybe<string>;
-
-  otpauth_url?: Maybe<string>;
-}
-
-export interface User {
-  id: string;
-
-  emails?: Maybe<EmailRecord[]>;
-
-  username?: Maybe<string>;
-}
-
-export interface EmailRecord {
-  address?: Maybe<string>;
-
-  verified?: Maybe<boolean>;
-}
-
-export interface Mutation {
-  createUser?: Maybe<string>;
-
-  verifyEmail?: Maybe<boolean>;
+export type LoginResult = {
+  __typename?: 'LoginResult';
+  sessionId?: Maybe<Scalars['String']>;
+  tokens?: Maybe<Tokens>;
+};
 
+export type Mutation = {
+  __typename?: 'Mutation';
+  createUser?: Maybe<Scalars['ID']>;
+  verifyEmail?: Maybe<Scalars['Boolean']>;
   resetPassword?: Maybe<LoginResult>;
-
-  sendVerificationEmail?: Maybe<boolean>;
-
-  sendResetPasswordEmail?: Maybe<boolean>;
-
-  changePassword?: Maybe<boolean>;
-
-  twoFactorSet?: Maybe<boolean>;
-
-  twoFactorUnset?: Maybe<boolean>;
-
+  sendVerificationEmail?: Maybe<Scalars['Boolean']>;
+  sendResetPasswordEmail?: Maybe<Scalars['Boolean']>;
+  changePassword?: Maybe<Scalars['Boolean']>;
+  twoFactorSet?: Maybe<Scalars['Boolean']>;
+  twoFactorUnset?: Maybe<Scalars['Boolean']>;
   impersonate?: Maybe<ImpersonateReturn>;
-
   refreshTokens?: Maybe<LoginResult>;
-
-  logout?: Maybe<boolean>;
-
+  logout?: Maybe<Scalars['Boolean']>;
   authenticate?: Maybe<LoginResult>;
-}
+};
 
-export interface LoginResult {
-  sessionId?: Maybe<string>;
-
-  tokens?: Maybe<Tokens>;
-}
-
-export interface Tokens {
-  refreshToken?: Maybe<string>;
-
-  accessToken?: Maybe<string>;
-}
-
-export interface ImpersonateReturn {
-  authorized?: Maybe<boolean>;
+export type MutationCreateUserArgs = {
+  user: CreateUserInput;
+};
 
-  tokens?: Maybe<Tokens>;
+export type MutationVerifyEmailArgs = {
+  token: Scalars['String'];
+};
 
-  user?: Maybe<User>;
-}
+export type MutationResetPasswordArgs = {
+  token: Scalars['String'];
+  newPassword: Scalars['String'];
+};
 
-// ====================================================
-// Arguments
-// ====================================================
+export type MutationSendVerificationEmailArgs = {
+  email: Scalars['String'];
+};
 
-export interface CreateUserMutationArgs {
-  user: CreateUserInput;
-}
-export interface VerifyEmailMutationArgs {
-  token: string;
-}
-export interface ResetPasswordMutationArgs {
-  token: string;
+export type MutationSendResetPasswordEmailArgs = {
+  email: Scalars['String'];
+};
 
-  newPassword: string;
-}
-export interface SendVerificationEmailMutationArgs {
-  email: string;
-}
-export interface SendResetPasswordEmailMutationArgs {
-  email: string;
-}
-export interface ChangePasswordMutationArgs {
-  oldPassword: string;
+export type MutationChangePasswordArgs = {
+  oldPassword: Scalars['String'];
+  newPassword: Scalars['String'];
+};
 
-  newPassword: string;
-}
-export interface TwoFactorSetMutationArgs {
+export type MutationTwoFactorSetArgs = {
   secret: TwoFactorSecretKeyInput;
+  code: Scalars['String'];
+};
 
-  code: string;
-}
-export interface TwoFactorUnsetMutationArgs {
-  code: string;
-}
-export interface ImpersonateMutationArgs {
-  accessToken: string;
+export type MutationTwoFactorUnsetArgs = {
+  code: Scalars['String'];
+};
 
-  username: string;
-}
-export interface RefreshTokensMutationArgs {
-  accessToken: string;
+export type MutationImpersonateArgs = {
+  accessToken: Scalars['String'];
+  username: Scalars['String'];
+};
 
-  refreshToken: string;
-}
-export interface AuthenticateMutationArgs {
-  serviceName: string;
+export type MutationRefreshTokensArgs = {
+  accessToken: Scalars['String'];
+  refreshToken: Scalars['String'];
+};
 
+export type MutationAuthenticateArgs = {
+  serviceName: Scalars['String'];
   params: AuthenticateParamsInput;
-}
-
-import { GraphQLResolveInfo } from 'graphql';
+};
 
-export type Resolver<Result, Parent = {}, TContext = {}, Args = {}> = (
-  parent: Parent,
-  args: Args,
+export type Query = {
+  __typename?: 'Query';
+  twoFactorSecret?: Maybe<TwoFactorSecretKey>;
+  getUser?: Maybe<User>;
+};
+
+export type Tokens = {
+  __typename?: 'Tokens';
+  refreshToken?: Maybe<Scalars['String']>;
+  accessToken?: Maybe<Scalars['String']>;
+};
+
+export type TwoFactorSecretKey = {
+  __typename?: 'TwoFactorSecretKey';
+  ascii?: Maybe<Scalars['String']>;
+  base32?: Maybe<Scalars['String']>;
+  hex?: Maybe<Scalars['String']>;
+  qr_code_ascii?: Maybe<Scalars['String']>;
+  qr_code_hex?: Maybe<Scalars['String']>;
+  qr_code_base32?: Maybe<Scalars['String']>;
+  google_auth_qr?: Maybe<Scalars['String']>;
+  otpauth_url?: Maybe<Scalars['String']>;
+};
+
+export type TwoFactorSecretKeyInput = {
+  ascii?: Maybe<Scalars['String']>;
+  base32?: Maybe<Scalars['String']>;
+  hex?: Maybe<Scalars['String']>;
+  qr_code_ascii?: Maybe<Scalars['String']>;
+  qr_code_hex?: Maybe<Scalars['String']>;
+  qr_code_base32?: Maybe<Scalars['String']>;
+  google_auth_qr?: Maybe<Scalars['String']>;
+  otpauth_url?: Maybe<Scalars['String']>;
+};
+
+export type User = {
+  __typename?: 'User';
+  id: Scalars['ID'];
+  emails?: Maybe<Array<EmailRecord>>;
+  username?: Maybe<Scalars['String']>;
+};
+
+export type UserInput = {
+  id?: Maybe<Scalars['ID']>;
+  email?: Maybe<Scalars['String']>;
+  username?: Maybe<Scalars['String']>;
+};
+
+export type ResolverTypeWrapper<T> = Promise<T> | T;
+
+export type ResolverFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
   context: TContext,
   info: GraphQLResolveInfo
-) => Promise<Result> | Result;
-
-export interface ISubscriptionResolverObject<Result, Parent, TContext, Args> {
-  subscribe<R = Result, P = Parent>(
-    parent: P,
-    args: Args,
-    context: TContext,
-    info: GraphQLResolveInfo
-  ): AsyncIterator<R | Result> | Promise<AsyncIterator<R | Result>>;
-  resolve?<R = Result, P = Parent>(
-    parent: P,
-    args: Args,
-    context: TContext,
-    info: GraphQLResolveInfo
-  ): R | Result | Promise<R | Result>;
-}
+) => Promise<TResult> | TResult;
+
+export type StitchingResolver<TResult, TParent, TContext, TArgs> = {
+  fragment: string;
+  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
+};
 
-export type SubscriptionResolver<Result, Parent = {}, TContext = {}, Args = {}> =
-  | ((...args: any[]) => ISubscriptionResolverObject<Result, Parent, TContext, Args>)
-  | ISubscriptionResolverObject<Result, Parent, TContext, Args>;
+export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
+  | ResolverFn<TResult, TParent, TContext, TArgs>
+  | StitchingResolver<TResult, TParent, TContext, TArgs>;
 
-export type TypeResolveFn<Types, Parent = {}, TContext = {}> = (
-  parent: Parent,
+export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
   context: TContext,
   info: GraphQLResolveInfo
-) => Maybe<Types>;
+) => AsyncIterator<TResult> | Promise<AsyncIterator<TResult>>;
 
-export type NextResolverFn<T> = () => Promise<T>;
-
-export type DirectiveResolverFn<TResult, TArgs = {}, TContext = {}> = (
-  next: NextResolverFn<TResult>,
-  source: any,
+export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
   args: TArgs,
   context: TContext,
   info: GraphQLResolveInfo
 ) => TResult | Promise<TResult>;
 
-export interface QueryResolvers<TContext = {}, TypeParent = {}> {
-  twoFactorSecret?: QueryTwoFactorSecretResolver<Maybe<TwoFactorSecretKey>, TypeParent, TContext>;
-
-  getUser?: QueryGetUserResolver<Maybe<User>, TypeParent, TContext>;
-}
-
-export type QueryTwoFactorSecretResolver<
-  R = Maybe<TwoFactorSecretKey>,
-  Parent = {},
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-export type QueryGetUserResolver<R = Maybe<User>, Parent = {}, TContext = {}> = Resolver<
-  R,
-  Parent,
-  TContext
->;
-
-export interface TwoFactorSecretKeyResolvers<TContext = {}, TypeParent = TwoFactorSecretKey> {
-  ascii?: TwoFactorSecretKeyAsciiResolver<Maybe<string>, TypeParent, TContext>;
-
-  base32?: TwoFactorSecretKeyBase32Resolver<Maybe<string>, TypeParent, TContext>;
-
-  hex?: TwoFactorSecretKeyHexResolver<Maybe<string>, TypeParent, TContext>;
-
-  qr_code_ascii?: TwoFactorSecretKeyQrCodeAsciiResolver<Maybe<string>, TypeParent, TContext>;
-
-  qr_code_hex?: TwoFactorSecretKeyQrCodeHexResolver<Maybe<string>, TypeParent, TContext>;
-
-  qr_code_base32?: TwoFactorSecretKeyQrCodeBase32Resolver<Maybe<string>, TypeParent, TContext>;
-
-  google_auth_qr?: TwoFactorSecretKeyGoogleAuthQrResolver<Maybe<string>, TypeParent, TContext>;
-
-  otpauth_url?: TwoFactorSecretKeyOtpauthUrlResolver<Maybe<string>, TypeParent, TContext>;
-}
-
-export type TwoFactorSecretKeyAsciiResolver<
-  R = Maybe<string>,
-  Parent = TwoFactorSecretKey,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-export type TwoFactorSecretKeyBase32Resolver<
-  R = Maybe<string>,
-  Parent = TwoFactorSecretKey,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-export type TwoFactorSecretKeyHexResolver<
-  R = Maybe<string>,
-  Parent = TwoFactorSecretKey,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-export type TwoFactorSecretKeyQrCodeAsciiResolver<
-  R = Maybe<string>,
-  Parent = TwoFactorSecretKey,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-export type TwoFactorSecretKeyQrCodeHexResolver<
-  R = Maybe<string>,
-  Parent = TwoFactorSecretKey,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-export type TwoFactorSecretKeyQrCodeBase32Resolver<
-  R = Maybe<string>,
-  Parent = TwoFactorSecretKey,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-export type TwoFactorSecretKeyGoogleAuthQrResolver<
-  R = Maybe<string>,
-  Parent = TwoFactorSecretKey,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-export type TwoFactorSecretKeyOtpauthUrlResolver<
-  R = Maybe<string>,
-  Parent = TwoFactorSecretKey,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-
-export interface UserResolvers<TContext = {}, TypeParent = User> {
-  id?: UserIdResolver<string, TypeParent, TContext>;
-
-  emails?: UserEmailsResolver<Maybe<EmailRecord[]>, TypeParent, TContext>;
-
-  username?: UserUsernameResolver<Maybe<string>, TypeParent, TContext>;
-}
-
-export type UserIdResolver<R = string, Parent = User, TContext = {}> = Resolver<
-  R,
-  Parent,
-  TContext
->;
-export type UserEmailsResolver<R = Maybe<EmailRecord[]>, Parent = User, TContext = {}> = Resolver<
-  R,
-  Parent,
-  TContext
->;
-export type UserUsernameResolver<R = Maybe<string>, Parent = User, TContext = {}> = Resolver<
-  R,
-  Parent,
-  TContext
->;
-
-export interface EmailRecordResolvers<TContext = {}, TypeParent = EmailRecord> {
-  address?: EmailRecordAddressResolver<Maybe<string>, TypeParent, TContext>;
-
-  verified?: EmailRecordVerifiedResolver<Maybe<boolean>, TypeParent, TContext>;
-}
-
-export type EmailRecordAddressResolver<
-  R = Maybe<string>,
-  Parent = EmailRecord,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-export type EmailRecordVerifiedResolver<
-  R = Maybe<boolean>,
-  Parent = EmailRecord,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-
-export interface MutationResolvers<TContext = {}, TypeParent = {}> {
-  createUser?: MutationCreateUserResolver<Maybe<string>, TypeParent, TContext>;
-
-  verifyEmail?: MutationVerifyEmailResolver<Maybe<boolean>, TypeParent, TContext>;
-
-  resetPassword?: MutationResetPasswordResolver<Maybe<LoginResult>, TypeParent, TContext>;
-
-  sendVerificationEmail?: MutationSendVerificationEmailResolver<
-    Maybe<boolean>,
-    TypeParent,
-    TContext
-  >;
-
-  sendResetPasswordEmail?: MutationSendResetPasswordEmailResolver<
-    Maybe<boolean>,
-    TypeParent,
-    TContext
-  >;
-
-  changePassword?: MutationChangePasswordResolver<Maybe<boolean>, TypeParent, TContext>;
-
-  twoFactorSet?: MutationTwoFactorSetResolver<Maybe<boolean>, TypeParent, TContext>;
-
-  twoFactorUnset?: MutationTwoFactorUnsetResolver<Maybe<boolean>, TypeParent, TContext>;
-
-  impersonate?: MutationImpersonateResolver<Maybe<ImpersonateReturn>, TypeParent, TContext>;
-
-  refreshTokens?: MutationRefreshTokensResolver<Maybe<LoginResult>, TypeParent, TContext>;
-
-  logout?: MutationLogoutResolver<Maybe<boolean>, TypeParent, TContext>;
-
-  authenticate?: MutationAuthenticateResolver<Maybe<LoginResult>, TypeParent, TContext>;
-}
-
-export type MutationCreateUserResolver<R = Maybe<string>, Parent = {}, TContext = {}> = Resolver<
-  R,
-  Parent,
-  TContext,
-  MutationCreateUserArgs
->;
-export interface MutationCreateUserArgs {
-  user: CreateUserInput;
-}
-
-export type MutationVerifyEmailResolver<R = Maybe<boolean>, Parent = {}, TContext = {}> = Resolver<
-  R,
-  Parent,
-  TContext,
-  MutationVerifyEmailArgs
->;
-export interface MutationVerifyEmailArgs {
-  token: string;
-}
-
-export type MutationResetPasswordResolver<
-  R = Maybe<LoginResult>,
-  Parent = {},
-  TContext = {}
-> = Resolver<R, Parent, TContext, MutationResetPasswordArgs>;
-export interface MutationResetPasswordArgs {
-  token: string;
-
-  newPassword: string;
-}
-
-export type MutationSendVerificationEmailResolver<
-  R = Maybe<boolean>,
-  Parent = {},
-  TContext = {}
-> = Resolver<R, Parent, TContext, MutationSendVerificationEmailArgs>;
-export interface MutationSendVerificationEmailArgs {
-  email: string;
-}
-
-export type MutationSendResetPasswordEmailResolver<
-  R = Maybe<boolean>,
-  Parent = {},
-  TContext = {}
-> = Resolver<R, Parent, TContext, MutationSendResetPasswordEmailArgs>;
-export interface MutationSendResetPasswordEmailArgs {
-  email: string;
-}
-
-export type MutationChangePasswordResolver<
-  R = Maybe<boolean>,
-  Parent = {},
-  TContext = {}
-> = Resolver<R, Parent, TContext, MutationChangePasswordArgs>;
-export interface MutationChangePasswordArgs {
-  oldPassword: string;
-
-  newPassword: string;
-}
-
-export type MutationTwoFactorSetResolver<R = Maybe<boolean>, Parent = {}, TContext = {}> = Resolver<
-  R,
-  Parent,
+export interface SubscriptionSubscriberObject<
+  TResult,
+  TKey extends string,
+  TParent,
   TContext,
-  MutationTwoFactorSetArgs
->;
-export interface MutationTwoFactorSetArgs {
-  secret: TwoFactorSecretKeyInput;
-
-  code: string;
+  TArgs
+> {
+  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
+  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
 }
 
-export type MutationTwoFactorUnsetResolver<
-  R = Maybe<boolean>,
-  Parent = {},
-  TContext = {}
-> = Resolver<R, Parent, TContext, MutationTwoFactorUnsetArgs>;
-export interface MutationTwoFactorUnsetArgs {
-  code: string;
+export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
+  subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
+  resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
 }
 
-export type MutationImpersonateResolver<
-  R = Maybe<ImpersonateReturn>,
-  Parent = {},
-  TContext = {}
-> = Resolver<R, Parent, TContext, MutationImpersonateArgs>;
-export interface MutationImpersonateArgs {
-  accessToken: string;
-
-  username: string;
-}
+export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
+  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
+  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
 
-export type MutationRefreshTokensResolver<
-  R = Maybe<LoginResult>,
-  Parent = {},
-  TContext = {}
-> = Resolver<R, Parent, TContext, MutationRefreshTokensArgs>;
-export interface MutationRefreshTokensArgs {
-  accessToken: string;
+export type SubscriptionResolver<
+  TResult,
+  TKey extends string,
+  TParent = {},
+  TContext = {},
+  TArgs = {}
+> =
+  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
+  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
 
-  refreshToken: string;
-}
-
-export type MutationLogoutResolver<R = Maybe<boolean>, Parent = {}, TContext = {}> = Resolver<
-  R,
-  Parent,
-  TContext
->;
-export type MutationAuthenticateResolver<
-  R = Maybe<LoginResult>,
-  Parent = {},
-  TContext = {}
-> = Resolver<R, Parent, TContext, MutationAuthenticateArgs>;
-export interface MutationAuthenticateArgs {
-  serviceName: string;
-
-  params: AuthenticateParamsInput;
-}
-
-export interface LoginResultResolvers<TContext = {}, TypeParent = LoginResult> {
-  sessionId?: LoginResultSessionIdResolver<Maybe<string>, TypeParent, TContext>;
-
-  tokens?: LoginResultTokensResolver<Maybe<Tokens>, TypeParent, TContext>;
-}
-
-export type LoginResultSessionIdResolver<
-  R = Maybe<string>,
-  Parent = LoginResult,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-export type LoginResultTokensResolver<
-  R = Maybe<Tokens>,
-  Parent = LoginResult,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-
-export interface TokensResolvers<TContext = {}, TypeParent = Tokens> {
-  refreshToken?: TokensRefreshTokenResolver<Maybe<string>, TypeParent, TContext>;
-
-  accessToken?: TokensAccessTokenResolver<Maybe<string>, TypeParent, TContext>;
-}
-
-export type TokensRefreshTokenResolver<
-  R = Maybe<string>,
-  Parent = Tokens,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-export type TokensAccessTokenResolver<R = Maybe<string>, Parent = Tokens, TContext = {}> = Resolver<
-  R,
-  Parent,
-  TContext
->;
-
-export interface ImpersonateReturnResolvers<TContext = {}, TypeParent = ImpersonateReturn> {
-  authorized?: ImpersonateReturnAuthorizedResolver<Maybe<boolean>, TypeParent, TContext>;
-
-  tokens?: ImpersonateReturnTokensResolver<Maybe<Tokens>, TypeParent, TContext>;
-
-  user?: ImpersonateReturnUserResolver<Maybe<User>, TypeParent, TContext>;
-}
+export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
+  parent: TParent,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => Maybe<TTypes>;
 
-export type ImpersonateReturnAuthorizedResolver<
-  R = Maybe<boolean>,
-  Parent = ImpersonateReturn,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-export type ImpersonateReturnTokensResolver<
-  R = Maybe<Tokens>,
-  Parent = ImpersonateReturn,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-export type ImpersonateReturnUserResolver<
-  R = Maybe<User>,
-  Parent = ImpersonateReturn,
-  TContext = {}
-> = Resolver<R, Parent, TContext>;
-
-export type AuthDirectiveResolver<Result> = DirectiveResolverFn<
-  Result,
-  {},
-  {}
->; /** Directs the executor to skip this field or fragment when the `if` argument is true. */
-export type SkipDirectiveResolver<Result> = DirectiveResolverFn<Result, SkipDirectiveArgs, {}>;
-export interface SkipDirectiveArgs {
-  /** Skipped when true. */
-  if: boolean;
-}
+export type NextResolverFn<T> = () => Promise<T>;
 
-/** Directs the executor to include this field or fragment only when the `if` argument is true. */
-export type IncludeDirectiveResolver<Result> = DirectiveResolverFn<
-  Result,
-  IncludeDirectiveArgs,
-  {}
->;
-export interface IncludeDirectiveArgs {
-  /** Included when true. */
-  if: boolean;
-}
+export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
+  next: NextResolverFn<TResult>,
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => TResult | Promise<TResult>;
 
-/** Marks an element of a GraphQL schema as no longer supported. */
-export type DeprecatedDirectiveResolver<Result> = DirectiveResolverFn<
+/** Mapping between all available schema types and the resolvers types */
+export type ResolversTypes = {
+  Query: ResolverTypeWrapper<{}>;
+  TwoFactorSecretKey: ResolverTypeWrapper<TwoFactorSecretKey>;
+  String: ResolverTypeWrapper<Scalars['String']>;
+  User: ResolverTypeWrapper<User>;
+  ID: ResolverTypeWrapper<Scalars['ID']>;
+  EmailRecord: ResolverTypeWrapper<EmailRecord>;
+  Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+  Mutation: ResolverTypeWrapper<{}>;
+  CreateUserInput: CreateUserInput;
+  LoginResult: ResolverTypeWrapper<LoginResult>;
+  Tokens: ResolverTypeWrapper<Tokens>;
+  TwoFactorSecretKeyInput: TwoFactorSecretKeyInput;
+  ImpersonateReturn: ResolverTypeWrapper<ImpersonateReturn>;
+  AuthenticateParamsInput: AuthenticateParamsInput;
+  UserInput: UserInput;
+};
+
+/** Mapping between all available schema types and the resolvers parents */
+export type ResolversParentTypes = {
+  Query: {};
+  TwoFactorSecretKey: TwoFactorSecretKey;
+  String: Scalars['String'];
+  User: User;
+  ID: Scalars['ID'];
+  EmailRecord: EmailRecord;
+  Boolean: Scalars['Boolean'];
+  Mutation: {};
+  CreateUserInput: CreateUserInput;
+  LoginResult: LoginResult;
+  Tokens: Tokens;
+  TwoFactorSecretKeyInput: TwoFactorSecretKeyInput;
+  ImpersonateReturn: ImpersonateReturn;
+  AuthenticateParamsInput: AuthenticateParamsInput;
+  UserInput: UserInput;
+};
+
+export type AuthDirectiveResolver<
   Result,
-  DeprecatedDirectiveArgs,
-  {}
->;
-export interface DeprecatedDirectiveArgs {
-  /** Explains why this element was deprecated, usually also including a suggestion for how to access supported similar data. Formatted using the Markdown syntax (as specified by [CommonMark](https://commonmark.org/). */
-  reason?: string;
-}
-
-export type IResolvers<TContext = {}> = {
-  Query?: QueryResolvers<TContext>;
-  TwoFactorSecretKey?: TwoFactorSecretKeyResolvers<TContext>;
-  User?: UserResolvers<TContext>;
-  EmailRecord?: EmailRecordResolvers<TContext>;
-  Mutation?: MutationResolvers<TContext>;
-  LoginResult?: LoginResultResolvers<TContext>;
-  Tokens?: TokensResolvers<TContext>;
-  ImpersonateReturn?: ImpersonateReturnResolvers<TContext>;
-} & { [typeName: string]: never };
-
-export type IDirectiveResolvers<Result> = {
-  auth?: AuthDirectiveResolver<Result>;
-  skip?: SkipDirectiveResolver<Result>;
-  include?: IncludeDirectiveResolver<Result>;
-  deprecated?: DeprecatedDirectiveResolver<Result>;
-} & { [directiveName: string]: never };
+  Parent,
+  ContextType = any,
+  Args = {}
+> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type EmailRecordResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['EmailRecord'] = ResolversParentTypes['EmailRecord']
+> = {
+  address?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  verified?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+};
+
+export type ImpersonateReturnResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['ImpersonateReturn'] = ResolversParentTypes['ImpersonateReturn']
+> = {
+  authorized?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+  tokens?: Resolver<Maybe<ResolversTypes['Tokens']>, ParentType, ContextType>;
+  user?: Resolver<Maybe<ResolversTypes['User']>, ParentType, ContextType>;
+};
+
+export type LoginResultResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['LoginResult'] = ResolversParentTypes['LoginResult']
+> = {
+  sessionId?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  tokens?: Resolver<Maybe<ResolversTypes['Tokens']>, ParentType, ContextType>;
+};
+
+export type MutationResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']
+> = {
+  createUser?: Resolver<
+    Maybe<ResolversTypes['ID']>,
+    ParentType,
+    ContextType,
+    RequireFields<MutationCreateUserArgs, 'user'>
+  >;
+  verifyEmail?: Resolver<
+    Maybe<ResolversTypes['Boolean']>,
+    ParentType,
+    ContextType,
+    RequireFields<MutationVerifyEmailArgs, 'token'>
+  >;
+  resetPassword?: Resolver<
+    Maybe<ResolversTypes['LoginResult']>,
+    ParentType,
+    ContextType,
+    RequireFields<MutationResetPasswordArgs, 'token' | 'newPassword'>
+  >;
+  sendVerificationEmail?: Resolver<
+    Maybe<ResolversTypes['Boolean']>,
+    ParentType,
+    ContextType,
+    RequireFields<MutationSendVerificationEmailArgs, 'email'>
+  >;
+  sendResetPasswordEmail?: Resolver<
+    Maybe<ResolversTypes['Boolean']>,
+    ParentType,
+    ContextType,
+    RequireFields<MutationSendResetPasswordEmailArgs, 'email'>
+  >;
+  changePassword?: Resolver<
+    Maybe<ResolversTypes['Boolean']>,
+    ParentType,
+    ContextType,
+    RequireFields<MutationChangePasswordArgs, 'oldPassword' | 'newPassword'>
+  >;
+  twoFactorSet?: Resolver<
+    Maybe<ResolversTypes['Boolean']>,
+    ParentType,
+    ContextType,
+    RequireFields<MutationTwoFactorSetArgs, 'secret' | 'code'>
+  >;
+  twoFactorUnset?: Resolver<
+    Maybe<ResolversTypes['Boolean']>,
+    ParentType,
+    ContextType,
+    RequireFields<MutationTwoFactorUnsetArgs, 'code'>
+  >;
+  impersonate?: Resolver<
+    Maybe<ResolversTypes['ImpersonateReturn']>,
+    ParentType,
+    ContextType,
+    RequireFields<MutationImpersonateArgs, 'accessToken' | 'username'>
+  >;
+  refreshTokens?: Resolver<
+    Maybe<ResolversTypes['LoginResult']>,
+    ParentType,
+    ContextType,
+    RequireFields<MutationRefreshTokensArgs, 'accessToken' | 'refreshToken'>
+  >;
+  logout?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>;
+  authenticate?: Resolver<
+    Maybe<ResolversTypes['LoginResult']>,
+    ParentType,
+    ContextType,
+    RequireFields<MutationAuthenticateArgs, 'serviceName' | 'params'>
+  >;
+};
+
+export type QueryResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']
+> = {
+  twoFactorSecret?: Resolver<Maybe<ResolversTypes['TwoFactorSecretKey']>, ParentType, ContextType>;
+  getUser?: Resolver<Maybe<ResolversTypes['User']>, ParentType, ContextType>;
+};
+
+export type TokensResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['Tokens'] = ResolversParentTypes['Tokens']
+> = {
+  refreshToken?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  accessToken?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+};
+
+export type TwoFactorSecretKeyResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['TwoFactorSecretKey'] = ResolversParentTypes['TwoFactorSecretKey']
+> = {
+  ascii?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  base32?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  hex?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  qr_code_ascii?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  qr_code_hex?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  qr_code_base32?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  google_auth_qr?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  otpauth_url?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+};
+
+export type UserResolvers<
+  ContextType = any,
+  ParentType extends ResolversParentTypes['User'] = ResolversParentTypes['User']
+> = {
+  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+  emails?: Resolver<Maybe<Array<ResolversTypes['EmailRecord']>>, ParentType, ContextType>;
+  username?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+};
+
+export type Resolvers<ContextType = any> = {
+  EmailRecord?: EmailRecordResolvers<ContextType>;
+  ImpersonateReturn?: ImpersonateReturnResolvers<ContextType>;
+  LoginResult?: LoginResultResolvers<ContextType>;
+  Mutation?: MutationResolvers<ContextType>;
+  Query?: QueryResolvers<ContextType>;
+  Tokens?: TokensResolvers<ContextType>;
+  TwoFactorSecretKey?: TwoFactorSecretKeyResolvers<ContextType>;
+  User?: UserResolvers<ContextType>;
+};
+
+/**
+ * @deprecated
+ * Use "Resolvers" root object instead. If you wish to get "IResolvers", add "typesPrefix: I" to your config.
+ */
+export type IResolvers<ContextType = any> = Resolvers<ContextType>;
+export type DirectiveResolvers<ContextType = any> = {
+  auth?: AuthDirectiveResolver<any, any, ContextType>;
+};
+
+/**
+ * @deprecated
+ * Use "DirectiveResolvers" root object instead. If you wish to get "IDirectiveResolvers", add "typesPrefix: I" to your config.
+ */
+export type IDirectiveResolvers<ContextType = any> = DirectiveResolvers<ContextType>;
diff --git a/packages/type-graphql/.npmignore b/packages/type-graphql/.npmignore
new file mode 100755
index 000000000..e65c31dc0
--- /dev/null
+++ b/packages/type-graphql/.npmignore
@@ -0,0 +1,6 @@
+src/
+coverage/
+node_modules
+yarn.lock
+tsconfig.json
+.npmignore
\ No newline at end of file
diff --git a/packages/type-graphql/README.md b/packages/type-graphql/README.md
new file mode 100755
index 000000000..1670afa2d
--- /dev/null
+++ b/packages/type-graphql/README.md
@@ -0,0 +1,199 @@
+# @accounts/graphql-api
+
+_Schema, Resolvers and Utils for GraphQL server with JSAccounts_
+
+[![npm](https://img.shields.io/npm/v/@accounts/graphql-api.svg?maxAge=2592000)](https://www.npmjs.com/package/@accounts/graphql-api)
+![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)
+
+> This package does not requires any network interface / express in order to combine with your GraphQL - it's just a collection of GraphQL schema, resolvers and utils!
+
+## How to use this package?
+
+This package exports GraphQL schema and GraphQL resolvers, which you can extend with your existing GraphQL schema server.
+
+Start by installing it from NPM / Yarn:
+
+```bash
+// Npm
+npm install --save @accounts/server @accounts/graphql-api @graphql-modules/core
+
+// Yarn
+yarn add @accounts/server @accounts/graphql-api @graphql-modules/core
+```
+
+> This package does not create a transport or anything else, only schema and string and resolvers as object.
+
+Start by configuring your `AccountsServer` as you wish. For example, using MongoDB:
+
+```js
+import mongoose from 'mongoose'
+import AccountsServer from '@accounts/server'
+import AccountsPassword from '@accounts/password'
+import MongoDBInterface from '@accounts/mongo'
+
+const db = mongoose.connection
+
+const password = new AccountsPassword()
+
+const accountsServer = new AccountsServer({
+  {
+    db: new MongoDBInterface(db),
+    tokenSecret: 'SECRET',
+  },
+  {
+    password,
+  }
+});
+```
+
+Next, import `AccountsModule` from this package, and run it with your `AccountsServer`:
+
+```js
+import { AccountsModule } from '@accounts/graphql-api';
+
+const accountsGraphQL = AccountsModule.forRoot({
+  accountsServer,
+});
+```
+
+Now, add `accountsGraphQL.typeDefs` to your schema definition (just before using it with `makeExecutableSchema`), and merge your resolvers object with `accountsGraphQL.resolvers` by using `@graphql-tools/epoxy`, for example:
+
+```js
+import { makeExecutableSchema } from 'graphql-tools';
+import { mergeGraphQLSchemas, mergeResolvers } from '@graphql-tools/epoxy';
+
+const typeDefs = [
+  `
+  type Query {
+    myQuery: String
+  }
+
+  type Mutation {
+    myMutation: String
+  }
+
+  schema {
+      query: Query,
+      mutation: Mutation
+  }
+  `,
+  accountsGraphQL.typeDefs,
+];
+
+let myResolvers = {
+  Query: {
+    myQuery: () => 'Hello',
+  },
+  Mutation: {
+    myMutation: () => 'Hello',
+  },
+};
+
+const schema = makeExecutableSchema({
+  resolvers: mergeResolvers([accountsGraphQL.resolvers, myResolvers]),
+  typeDefs: mergeGraphQLSchemas([typeDefs]),
+});
+```
+
+The last step is to extend your `graphqlExpress` with a context middleware, that extracts the authentication token from the HTTP request, so AccountsServer will automatically validate it:
+
+```js
+app.use(
+  GRAPHQL_ROUTE,
+  bodyParser.json(),
+  graphqlExpress(request => {
+    return {
+      context: {
+        ...accountsGraphQL(request),
+        // your context
+      },
+      schema,
+    };
+  })
+);
+```
+
+## Authenticating Resolvers
+
+You can authenticate your own resolvers with `JSAccounts` authentication flow, by using `authenticated` method from this package.
+
+This method composer also extends `context` with the current authenticated user!
+
+This is an example for a protected mutation:
+
+```js
+import AccountsServer from '@accounts/server';
+import { authenticated } from '@accounts/graphql-api';
+
+export const resolver = {
+  Mutation: {
+    updateUserProfile: authenticated(AccountsServer, (rootValue, args, context) => {
+      // Write your resolver here
+      // context.user - the current authenticated user!
+    }),
+  },
+};
+```
+
+## Customization
+
+This package allow you to customize the GraphQL schema and it's resolvers.
+
+For example, some application main query called `MyQuery` or `RootQuery` instead of query, so you can customize the name, without modifying you application's schema.
+
+These are the available customizations:
+
+- `rootQueryName` (string) - The name of the root query, default: `Query`.
+- `rootMutationName` (string) - The name of the root mutation, default: `Mutation`.
+- `extend` (boolean) - whether to add `extend` before the root type declaration, default: `true`.
+- `withSchemaDefinition` (boolean): whether to add `schema { ... }` declaration to the generation schema, default: `false`.
+
+Pass a second object to `createAccountsGraphQL`, for example:
+
+Another possible customization is to modify the name of the authentication header, use it with `accountsContext` (the default is `Authorization`):
+
+```js
+const myCustomGraphQLAccounts = AccountsModule.forRoot({
+  accountsServer,
+  rootQueryName: 'RootQuery',
+  rootMutationName: 'RootMutation',
+  headerName: 'MyCustomHeader',
+});
+```
+
+## Extending `User`
+
+To extend `User` object with custom fields and logic, add your own GraphQL type definition of `User` with the prefix of `extend`, and add your fields:
+
+```graphql
+extend type User {
+  firstName: String
+  lastName: String
+}
+```
+
+And also implement a regular resolver, for the fields you added:
+
+```js
+const UserResolver = {
+  firstName: () => 'Dotan',
+  lastName: () => 'Simha',
+};
+```
+
+## Extending `User` during password creation
+
+To extend the user object during the user creation you need to extend the `CreateUserInput` type and add your fields:
+
+```graphql
+extend input CreateUserInput {
+  profile: CreateUserProfileInput!
+}
+
+input CreateUserProfileInput {
+  firstName: String!
+  lastName: String!
+}
+```
+
+The user will be saved in the db with the profile key set.
diff --git a/packages/type-graphql/codegen.yml b/packages/type-graphql/codegen.yml
new file mode 100644
index 000000000..7e2a93474
--- /dev/null
+++ b/packages/type-graphql/codegen.yml
@@ -0,0 +1,14 @@
+overwrite: true
+schema: ../graphql-api/src/schema.ts
+require: ts-node/register/transpile-only
+generates:
+  ./src/type-graphql.ts:
+    config:
+      noNamespaces: true
+      declarationType:
+        type: "abstract class"
+      decoratorName:
+        type: "InterfaceType"
+    plugins:
+      - add: /* tslint:disable */
+      - typescript-type-graphql
\ No newline at end of file
diff --git a/packages/type-graphql/package.json b/packages/type-graphql/package.json
new file mode 100644
index 000000000..ef89fcb19
--- /dev/null
+++ b/packages/type-graphql/package.json
@@ -0,0 +1,51 @@
+{
+  "name": "@accounts/type-graphql",
+  "version": "0.19.0",
+  "description": "Server side type-graphql objects for accounts",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "scripts": {
+    "clean": "rimraf lib",
+    "start": "gql-gen && tsc --watch",
+    "precompile": "yarn clean && gql-gen",
+    "compile": "tsc",
+    "testonly": "jest",
+    "coverage": "yarn testonly --coverage",
+    "prepublishOnly": "yarn compile"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "preset": "ts-jest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/accounts-js/accounts/tree/master/packages/type-graphql"
+  },
+  "author": "David Yahalomi",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/accounts-js/accounts/issues"
+  },
+  "homepage": "https://github.com/accounts-js/accounts",
+  "devDependencies": {
+    "@graphql-codegen/add": "^1.7.0",
+    "@graphql-codegen/cli": "^1.7.0",
+    "@graphql-codegen/typescript": "^1.7.0",
+    "@graphql-codegen/typescript-type-graphql": "^1.7.0",
+    "@types/jest": "24.0.18",
+    "graphql": "14.5.3",
+    "graphql-tools": "4.0.5",
+    "jest": "24.9.0"
+  },
+  "peerDependencies": {
+    "@accounts/password": "^0.9.3",
+    "@accounts/server": "^0.9.3",
+    "@accounts/types": "^0.9.3",
+    "graphql-tag": "^2.10.0",
+    "graphql-tools": "^4.0.5"
+  },
+  "dependencies": {
+    "graphql-toolkit": "^0.5.10",
+    "type-graphql": "^0.17.5"
+  }
+}
diff --git a/packages/type-graphql/src/index.ts b/packages/type-graphql/src/index.ts
new file mode 100644
index 000000000..349cc7eed
--- /dev/null
+++ b/packages/type-graphql/src/index.ts
@@ -0,0 +1 @@
+export * from './type-graphql';
diff --git a/packages/type-graphql/src/type-graphql.ts b/packages/type-graphql/src/type-graphql.ts
new file mode 100644
index 000000000..a65ea5c00
--- /dev/null
+++ b/packages/type-graphql/src/type-graphql.ts
@@ -0,0 +1,308 @@
+/* tslint:disable */
+import * as TypeGraphQL from 'type-graphql';
+export type Maybe<T> = T | null;
+type FixDecorator<T> = T;
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string;
+  String: string;
+  Boolean: boolean;
+  Int: number;
+  Float: number;
+};
+
+@TypeGraphQL.InterfaceType()
+export class User {
+  __typename?: 'User';
+
+  @TypeGraphQL.Field(type => TypeGraphQL.ID)
+  id!: Scalars['ID'];
+
+  @TypeGraphQL.Field(type => [EmailRecord], { nullable: true })
+  emails!: Maybe<Array<EmailRecord>>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  username!: Maybe<Scalars['String']>;
+}
+
+@TypeGraphQL.InterfaceType()
+export class TwoFactorSecretKey {
+  __typename?: 'TwoFactorSecretKey';
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  ascii!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  base32!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  hex!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  qr_code_ascii!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  qr_code_hex!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  qr_code_base32!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  google_auth_qr!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  otpauth_url!: Maybe<Scalars['String']>;
+}
+
+@TypeGraphQL.InterfaceType()
+export class Tokens {
+  __typename?: 'Tokens';
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  refreshToken!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  accessToken!: Maybe<Scalars['String']>;
+}
+
+@TypeGraphQL.InterfaceType()
+export class LoginResult {
+  __typename?: 'LoginResult';
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  sessionId!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => Tokens, { nullable: true })
+  tokens!: Maybe<Tokens>;
+}
+
+@TypeGraphQL.InterfaceType()
+export class ImpersonateReturn {
+  __typename?: 'ImpersonateReturn';
+
+  @TypeGraphQL.Field(type => Boolean, { nullable: true })
+  authorized!: Maybe<Scalars['Boolean']>;
+
+  @TypeGraphQL.Field(type => Tokens, { nullable: true })
+  tokens!: Maybe<Tokens>;
+
+  @TypeGraphQL.Field(type => User, { nullable: true })
+  user!: Maybe<User>;
+}
+
+@TypeGraphQL.InterfaceType()
+export class EmailRecord {
+  __typename?: 'EmailRecord';
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  address!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => Boolean, { nullable: true })
+  verified!: Maybe<Scalars['Boolean']>;
+}
+
+@TypeGraphQL.InputType()
+export class AuthenticateParamsInput {
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  access_token!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  access_token_secret!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  provider!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  password!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => UserInput, { nullable: true })
+  user!: Maybe<UserInput>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  code!: Maybe<Scalars['String']>;
+}
+
+@TypeGraphQL.InputType()
+export class CreateUserInput {
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  username!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  email!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  password!: Maybe<Scalars['String']>;
+}
+
+export class Mutation {
+  __typename?: 'Mutation';
+
+  @TypeGraphQL.Field(type => TypeGraphQL.ID, { nullable: true })
+  createUser!: Maybe<Scalars['ID']>;
+
+  @TypeGraphQL.Field(type => Boolean, { nullable: true })
+  verifyEmail!: Maybe<Scalars['Boolean']>;
+
+  @TypeGraphQL.Field(type => LoginResult, { nullable: true })
+  resetPassword!: Maybe<LoginResult>;
+
+  @TypeGraphQL.Field(type => Boolean, { nullable: true })
+  sendVerificationEmail!: Maybe<Scalars['Boolean']>;
+
+  @TypeGraphQL.Field(type => Boolean, { nullable: true })
+  sendResetPasswordEmail!: Maybe<Scalars['Boolean']>;
+
+  @TypeGraphQL.Field(type => Boolean, { nullable: true })
+  changePassword!: Maybe<Scalars['Boolean']>;
+
+  @TypeGraphQL.Field(type => Boolean, { nullable: true })
+  twoFactorSet!: Maybe<Scalars['Boolean']>;
+
+  @TypeGraphQL.Field(type => Boolean, { nullable: true })
+  twoFactorUnset!: Maybe<Scalars['Boolean']>;
+
+  @TypeGraphQL.Field(type => ImpersonateReturn, { nullable: true })
+  impersonate!: Maybe<ImpersonateReturn>;
+
+  @TypeGraphQL.Field(type => LoginResult, { nullable: true })
+  refreshTokens!: Maybe<LoginResult>;
+
+  @TypeGraphQL.Field(type => Boolean, { nullable: true })
+  logout!: Maybe<Scalars['Boolean']>;
+
+  @TypeGraphQL.Field(type => LoginResult, { nullable: true })
+  authenticate!: Maybe<LoginResult>;
+}
+
+@TypeGraphQL.ArgsType()
+export class MutationCreateUserArgs {
+  @TypeGraphQL.Field(type => CreateUserInput)
+  user!: FixDecorator<CreateUserInput>;
+}
+
+@TypeGraphQL.ArgsType()
+export class MutationVerifyEmailArgs {
+  @TypeGraphQL.Field(type => String)
+  token!: Scalars['String'];
+}
+
+@TypeGraphQL.ArgsType()
+export class MutationResetPasswordArgs {
+  @TypeGraphQL.Field(type => String)
+  token!: Scalars['String'];
+
+  @TypeGraphQL.Field(type => String)
+  newPassword!: Scalars['String'];
+}
+
+@TypeGraphQL.ArgsType()
+export class MutationSendVerificationEmailArgs {
+  @TypeGraphQL.Field(type => String)
+  email!: Scalars['String'];
+}
+
+@TypeGraphQL.ArgsType()
+export class MutationSendResetPasswordEmailArgs {
+  @TypeGraphQL.Field(type => String)
+  email!: Scalars['String'];
+}
+
+@TypeGraphQL.ArgsType()
+export class MutationChangePasswordArgs {
+  @TypeGraphQL.Field(type => String)
+  oldPassword!: Scalars['String'];
+
+  @TypeGraphQL.Field(type => String)
+  newPassword!: Scalars['String'];
+}
+
+@TypeGraphQL.ArgsType()
+export class MutationTwoFactorSetArgs {
+  @TypeGraphQL.Field(type => TwoFactorSecretKeyInput)
+  secret!: FixDecorator<TwoFactorSecretKeyInput>;
+
+  @TypeGraphQL.Field(type => String)
+  code!: Scalars['String'];
+}
+
+@TypeGraphQL.ArgsType()
+export class MutationTwoFactorUnsetArgs {
+  @TypeGraphQL.Field(type => String)
+  code!: Scalars['String'];
+}
+
+@TypeGraphQL.ArgsType()
+export class MutationImpersonateArgs {
+  @TypeGraphQL.Field(type => String)
+  accessToken!: Scalars['String'];
+
+  @TypeGraphQL.Field(type => String)
+  username!: Scalars['String'];
+}
+
+@TypeGraphQL.ArgsType()
+export class MutationRefreshTokensArgs {
+  @TypeGraphQL.Field(type => String)
+  accessToken!: Scalars['String'];
+
+  @TypeGraphQL.Field(type => String)
+  refreshToken!: Scalars['String'];
+}
+
+@TypeGraphQL.ArgsType()
+export class MutationAuthenticateArgs {
+  @TypeGraphQL.Field(type => String)
+  serviceName!: Scalars['String'];
+
+  @TypeGraphQL.Field(type => AuthenticateParamsInput)
+  params!: FixDecorator<AuthenticateParamsInput>;
+}
+
+export class Query {
+  __typename?: 'Query';
+
+  @TypeGraphQL.Field(type => TwoFactorSecretKey, { nullable: true })
+  twoFactorSecret!: Maybe<TwoFactorSecretKey>;
+
+  @TypeGraphQL.Field(type => User, { nullable: true })
+  getUser!: Maybe<User>;
+}
+
+@TypeGraphQL.InputType()
+export class TwoFactorSecretKeyInput {
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  ascii!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  base32!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  hex!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  qr_code_ascii!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  qr_code_hex!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  qr_code_base32!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  google_auth_qr!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  otpauth_url!: Maybe<Scalars['String']>;
+}
+
+@TypeGraphQL.InputType()
+export class UserInput {
+  @TypeGraphQL.Field(type => TypeGraphQL.ID, { nullable: true })
+  id!: Maybe<Scalars['ID']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  email!: Maybe<Scalars['String']>;
+
+  @TypeGraphQL.Field(type => String, { nullable: true })
+  username!: Maybe<Scalars['String']>;
+}
diff --git a/packages/type-graphql/tsconfig.json b/packages/type-graphql/tsconfig.json
new file mode 100644
index 000000000..512450c8e
--- /dev/null
+++ b/packages/type-graphql/tsconfig.json
@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./lib",
+    "noUnusedParameters": false,
+    "noUnusedLocals": false,
+    "noImplicitAny": false,
+    "experimentalDecorators": true,
+    "importHelpers": true
+  },
+  "exclude": ["node_modules", "__tests__", "lib"]
+}