const generateRootTypes: (schema: GraphQLSchema) => string = schema => filterAndJoinArray(
   [
     interfaceBuilder(
       generateInterfaceName('GraphQLResponseRoot'),
       gID([
         formatInput('data', !optionsInput.legacy, generateRootDataName(schema)),
         formatInput('errors', !optionsInput.legacy, wrapList(generateInterfaceName('GraphQLResponseError')))
       ])
     ),
     interfaceBuilder(
       generateInterfaceName('GraphQLResponseError'),
       gID([
         '/** Required for all errors */',
         formatInput('message', false, TYPE_MAP.String),
         formatInput('locations', !optionsInput.legacy, wrapList(generateInterfaceName('GraphQLResponseErrorLocation'))),
         `/** 7.2.2 says 'GraphQL servers may provide additional entries to error' */`,
         formatInput('[propName: string]', false, TYPE_MAP.__DEFAULT),
       ])
     ),
     interfaceBuilder(
       generateInterfaceName('GraphQLResponseErrorLocation'),
       gID([
         formatInput('line', false, TYPE_MAP.Int),
         formatInput('column', false, TYPE_MAP.Int),
       ])
     )
   ],
   '\n\n'
 );

 const joinOutputs: (output: IOutputJoinInput) => IFromQueryReturnValue = output => {
   const { variables, additionalTypes, interface: iface } = output;
   const result: string = postProcessor(filterAndJoinArray([variables, ...additionalTypes, iface], '\n\n'));
   return {
     ...output,
     result
   };
 };

  const generateArgumentDeclaration: ArgumentToDefinition = (arg, supportsNullability) => {
    const resolved: ResolvedInterfaceValue = resolveInterfaceName(arg.type, false);

    return filterAndJoinArray([
      generateDocumentation(buildDocumentation(arg)),
      formatInput(arg.name, !resolved.isNonNull, typePrinter(resolved, supportsNullability))
    ]);
  };

export const DEFAULT_ENUM_FORMATTER: EnumFormatter = (values, documentationGenerator) => `{
  ${filterAndJoinArray(
    values.map(value => filterAndJoinArray([
      documentationGenerator(buildDocumentation(value)),
      `${value.name} = '${value.name}'`
    ])),
    ',\n'
  )}
}`;

export const DEFAULT_DOCUMENTATION_GENERATOR: GenerateDocumentation = ({ description, tags = [] }) => {
  if (!description && !tags.length) {
    return '';
  }
  const arr: Array<string | undefined> = [
    fixDescriptionDocblock(description),
    ...tags.map(({ tag, value }) => `@${tag} ${JSON.stringify(value)}`)
  ];
  return `
  /**
   * ${filterAndJoinArray(arr, '\n   * ')}
   */`;
};

  const typeToInterface: TypeToInterface = (type, ignoredTypes, supportsNullability) => {
    if (isScalar(type)) {
      return null;
    }

    if (isUnion(type)) {
      return generateAbstractTypeDeclaration(type, ignoredTypes);
    }

    if (isEnum(type)) {
      return generateEnumDeclaration(type.description, type.name, type.getValues());
    }

    const isInput: boolean = type instanceof GraphQLInputObjectType;
    const f1: GraphQLInputFieldMap | GraphQLFieldMap<any, any> = type.getFields();
    const f: Array<GraphQLField<any, any> | GraphQLInputField> = Object.keys(f1).map(k => f1[k]);

    const filteredFields: Array<GraphQLField<any, any> | GraphQLInputField> = f.filter(field => filterField(field, ignoredTypes));

    const fields: string[] = filteredFields
      .map(field => [generateDocumentation(buildDocumentation(field)), fieldToDefinition(field, isInput, supportsNullability)])
      .reduce((acc, val) => [...acc, ...val], [])
      .filter(Boolean);

    const interfaceDeclaration: string = generateInterfaceName(type.name);
    let additionalInfo: string = '';

    if (isAbstractType(type)) {
      additionalInfo = generateAbstractTypeDeclaration(type, ignoredTypes);
    }

    return filterAndJoinArray(
      [
        generateInterfaceDeclaration(type, interfaceDeclaration, fields, additionalInfo, isInput),
        ...filteredFields.map(field => generateArgumentsDeclaration(field, type.name, supportsNullability))
      ],
      '\n\n'
    );
  };

  const typesToInterfaces: (schema: GraphQLSchema, options: Partial<IInternalOptions>) => string = (schema, options) => {
    const ignoredTypes: Set<string> = new Set(options.ignoredTypes);
    const supportsNullability: boolean = !options.legacy;
    const types: { [typeName: string]: GraphQLNamedType } = schema.getTypeMap();
    const typeArr: GraphQLNamedType[] = Object.keys(types).map(k => types[k]);

    const typeInterfaces: string[] =
      typeArr
        .filter(type => !type.name.startsWith('__'))  // remove introspection types
        .filter(type =>                               // remove ignored types
          !ignoredTypes.has(type.name)
        )
        .map(type =>                                  // convert to interface
          typeToInterface(type, ignoredTypes, supportsNullability)!
        );

    return filterAndJoinArray(
      [
        generateRootTypes(schema),
        ...typeInterfaces
      ],
      '\n\n'
    );
  };

export const interfaceExtendListToString: (extensions: string[]) => string = exts => {
  if (!exts.length) { return ''; }
  return ` extends ${filterAndJoinArray(exts, ', ')}`;
};