More complex types...

[n8jadams]

I would love to have this project transform some graphql generated typescript types by this library and take things one step further by generating io-ts types, so I can get runtime checks.

Here is what the generated typescript looks like:

import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
export type Maybe<T> = T | null;
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;
	Date: any;
	JSON: any;
};

export type Author = {
	__typename?: 'Author';
	id: Scalars['ID'];
	/** The first name of the author. */
	firstName: Scalars['String'];
	lastName: Scalars['String'];
	posts: Array<Maybe<Post>>;
	birthday: Scalars['Date'];
};


export type AuthorFirstNameArgs = {
	format?: Maybe<AuthorNameFormat>;
};

export type AuthorPostsArgs = {
	findTitle?: Maybe<Scalars['String']>;
};


export type AuthorBirthdayArgs = {
	format?: Maybe<DateFormat>;
};

export type AuthorInput = {
	firstName: Scalars['String'];
	lastName: Scalars['String'];
	birthday: Scalars['Date'];
};

export enum AuthorNameFormat {
	Normal = 'NORMAL',
	Lowercase = 'LOWERCASE',
	Uppercase = 'UPPERCASE'
}


export enum DateFormat {
	ShortDate = 'SHORT_DATE',
	MediumDate = 'MEDIUM_DATE',
	LongDate = 'LONG_DATE',
	UnixTimestamp = 'UNIX_TIMESTAMP',
	IsoDateTime = 'ISO_DATE_TIME'
}


export type Mutation = {
	__typename?: 'Mutation';
	addPost?: Maybe<Post>;
	addAuthor?: Maybe<Author>;
};


export type MutationAddPostArgs = {
	post: PostInput;
};


export type MutationAddAuthorArgs = {
	author: AuthorInput;
};

export type Post = {
	__typename?: 'Post';
	id: Scalars['ID'];
	title: Scalars['String'];
	author: Author;
	addedDate: Scalars['Date'];
};


export type PostAddedDateArgs = {
	format?: Maybe<DateFormat>;
};

export type PostInput = {
	title: Scalars['String'];
	authorId: Scalars['ID'];
};

export type Query = {
	__typename?: 'Query';
	posts?: Maybe<Array<Maybe<Post>>>;
	authors?: Maybe<Array<Maybe<Author>>>;
	someJson?: Maybe<Scalars['JSON']>;
};



export type ResolverTypeWrapper<T> = Promise<T> | T;


export type StitchingResolver<TResult, TParent, TContext, TArgs> = {
	fragment: string;
	resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
};

export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
	| ResolverFn<TResult, TParent, TContext, TArgs>
	| StitchingResolver<TResult, TParent, TContext, TArgs>;

export type ResolverFn<TResult, TParent, TContext, TArgs> = (
	parent: TParent,
	args: TArgs,
	context: TContext,
	info: GraphQLResolveInfo
) => Promise<TResult> | TResult;

export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
	parent: TParent,
	args: TArgs,
	context: TContext,
	info: GraphQLResolveInfo
) => AsyncIterator<TResult> | Promise<AsyncIterator<TResult>>;

export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
	parent: TParent,
	args: TArgs,
	context: TContext,
	info: GraphQLResolveInfo
) => TResult | Promise<TResult>;

export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
	subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
	resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
}

export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
	subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
	resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
}

export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
	| SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
	| SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;

export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
	| ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
	| SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;

export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
	parent: TParent,
	context: TContext,
	info: GraphQLResolveInfo
) => Maybe<TTypes> | Promise<Maybe<TTypes>>;

export type isTypeOfResolverFn<T = {}> = (obj: T, info: GraphQLResolveInfo) => boolean | Promise<boolean>;

export type NextResolverFn<T> = () => Promise<T>;

export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
	next: NextResolverFn<TResult>,
	parent: TParent,
	args: TArgs,
	context: TContext,
	info: GraphQLResolveInfo
) => TResult | Promise<TResult>;

/** Mapping between all available schema types and the resolvers types */
export type ResolversTypes = {
	Query: ResolverTypeWrapper<{}>,
	Post: ResolverTypeWrapper<Post>,
	ID: ResolverTypeWrapper<Scalars['ID']>,
	String: ResolverTypeWrapper<Scalars['String']>,
	Author: ResolverTypeWrapper<Author>,
	AuthorNameFormat: AuthorNameFormat,
	DateFormat: DateFormat,
	Date: ResolverTypeWrapper<Scalars['Date']>,
	JSON: ResolverTypeWrapper<Scalars['JSON']>,
	Mutation: ResolverTypeWrapper<{}>,
	PostInput: PostInput,
	AuthorInput: AuthorInput,
	Boolean: ResolverTypeWrapper<Scalars['Boolean']>,
};

/** Mapping between all available schema types and the resolvers parents */
export type ResolversParentTypes = {
	Query: {},
	Post: Post,
	ID: Scalars['ID'],
	String: Scalars['String'],
	Author: Author,
	AuthorNameFormat: AuthorNameFormat,
	DateFormat: DateFormat,
	Date: Scalars['Date'],
	JSON: Scalars['JSON'],
	Mutation: {},
	PostInput: PostInput,
	AuthorInput: AuthorInput,
	Boolean: Scalars['Boolean'],
};

export type AuthorResolvers<ContextType = any, ParentType extends ResolversParentTypes['Author'] = ResolversParentTypes['Author']> = {
	id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>,
	firstName?: Resolver<ResolversTypes['String'], ParentType, ContextType, RequireFields<AuthorFirstNameArgs, 'format'>>,
	lastName?: Resolver<ResolversTypes['String'], ParentType, ContextType>,
	posts?: Resolver<Array<Maybe<ResolversTypes['Post']>>, ParentType, ContextType, RequireFields<AuthorPostsArgs, never>>,
	birthday?: Resolver<ResolversTypes['Date'], ParentType, ContextType, RequireFields<AuthorBirthdayArgs, 'format'>>,
	__isTypeOf?: isTypeOfResolverFn<ParentType>,
};

export interface DateScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Date'], any> {
	name: 'Date'
}

export interface JsonScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['JSON'], any> {
	name: 'JSON'
}

export type MutationResolvers<ContextType = any, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = {
	addPost?: Resolver<Maybe<ResolversTypes['Post']>, ParentType, ContextType, RequireFields<MutationAddPostArgs, 'post'>>,
	addAuthor?: Resolver<Maybe<ResolversTypes['Author']>, ParentType, ContextType, RequireFields<MutationAddAuthorArgs, 'author'>>,
};

export type PostResolvers<ContextType = any, ParentType extends ResolversParentTypes['Post'] = ResolversParentTypes['Post']> = {
	id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>,
	title?: Resolver<ResolversTypes['String'], ParentType, ContextType>,
	author?: Resolver<ResolversTypes['Author'], ParentType, ContextType>,
	addedDate?: Resolver<ResolversTypes['Date'], ParentType, ContextType, RequireFields<PostAddedDateArgs, 'format'>>,
	__isTypeOf?: isTypeOfResolverFn<ParentType>,
};

export type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
	posts?: Resolver<Maybe<Array<Maybe<ResolversTypes['Post']>>>, ParentType, ContextType>,
	authors?: Resolver<Maybe<Array<Maybe<ResolversTypes['Author']>>>, ParentType, ContextType>,
	someJson?: Resolver<Maybe<ResolversTypes['JSON']>, ParentType, ContextType>,
};

export type Resolvers<ContextType = any> = {
	Author?: AuthorResolvers<ContextType>,
	Date?: GraphQLScalarType,
	JSON?: GraphQLScalarType,
	Mutation?: MutationResolvers<ContextType>,
	Post?: PostResolvers<ContextType>,
	Query?: QueryResolvers<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>;

The error message I got over and over again wasn't really insightful on how to fix. But it did tell me to make this issue:

[io-ts-transformer info]: If you will get any problems using this transformer, please
  leave an issue on GitHub https://github.com/awerlogus/io-ts-transformer/issues with your types example

There is a lot going on in these complex types.