Codegen using client present, how to make generated types not use type indexing

[adminnz]

I have this codegen.ts

import { CodegenConfig } from '@graphql-codegen/cli'
import * as fs from 'fs'
import * as path from 'path'
import { loadSchemaSync } from '@graphql-tools/load'
import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader'

function generateConnections() {
  try {
    const schemaPath = path.resolve(__dirname, './src/schema.graphql')
    const schema = loadSchemaSync(schemaPath, {
      loaders: [new GraphQLFileLoader()],
    })
    const connectionNames = Object.keys(schema.getTypeMap())
      .filter((typeName) => typeName.endsWith('Connection'))
      .map((typeName) => {
        const baseName = typeName.replace('Connection', '')
        return baseName.charAt(0).toLowerCase() + baseName.slice(1)
      })

    const outputPath = path.resolve(__dirname, './src/__generated__/field-names.ts')
    const fileContent = `export const fieldNames = ${JSON.stringify(connectionNames, null, 2)};`
    fs.writeFileSync(outputPath, fileContent)

    console.log(`[Success] Field names written to ${outputPath}`)
  } catch (error) {
    console.error('[Failed] Error extracting field names:', error)
  }
}

const config: CodegenConfig = {
  schema: 'src/schema.graphql',
  documents: ['src/**/*.{ts,tsx}'],
  generates: {
    './src/__generated__/': {
      preset: 'client',
      config: {
        type: 'interface',
        input: 'interface',
      },
      presetConfig: {
        gqlTagName: 'gql',
      },
    },
  },
  hooks: {
    afterAllFileWrite: [generateConnections],
  },
  debug: true,
  verbose: true,
  overwrite: true,
  ignoreNoDocuments: true,
}

export default config

With these packages installed:

 "@graphql-codegen/cli": "^6.0.0",
    "@graphql-codegen/client-preset": "^5.1.0",
    "@graphql-codegen/typescript-react-apollo": "^4.3.3",
    "@graphql-typed-document-node/core": "^3.2.0",

When it generates types, they come out using type indexing.

export type Coordinate = {
  __typename: 'Coordinate';
  x: Scalars['Int']['output']; // type indexing, instead of just x: number
  y: Scalars['Int']['output']; // type indexing, instead of just x: number
};

This is okay in theory, but I've encountered a bug with typescript where if the type has Maybe<> used, then all the fields/properties that follow in that type will not be type resolved properly.
See related Bug in Typescript github

As a workaround to this problem, I want all scalar types to be generated as the actual type. For example the above Coordinate type would be:

export type Coordinate = {
  __typename: 'Coordinate';
  x: number
  y: number
};

But i cannot seam to find a way to achieve this.