"Import type" preset with "typescript-resolvers" doesn't work well

**Describe the bug**

I made types with prefix "T". but when I generated resolver types, It doesn't have "T" prefix.

## codegen

```yml
overwrite: true
schema: "src/schema/**/*.type.gql"
documents: "src/schema/**/*.document.gql"
config:
typesPrefix: T
enumPrefix: false
namingConvention:
enumValues: keep
generates:
src/generated/type.ts:
plugins:
- "typescript"
- "typescript-operations"
src/generated/resolver.ts:
preset: "import-types"
presetConfig:
typesPath: "generated/type"
plugins:
- "typescript-resolvers"
config:
useIndexSignature: true
```

### gql files

`test.document.gql`
```gql
type User {
id: String!
name: String!
}

type Query {
getUser: User
}
```

`test.type.gql`
```gql
type User {
id: String!
name: String!
}

type Query {
getUser: User
}
```

### generated files

`type.ts`
```ts
export type Maybe = T | null;
export type Exact = { [K in keyof T]: T[K] };
/** 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 TUser = {
__typename?: 'User';
id: Scalars['String'];
name: Scalars['String'];
};

export type TQuery = {
__typename?: 'Query';
getUser?: Maybe;
};

export type TGetUserQueryVariables = Exact<{ [key: string]: never; }>;

export type TGetUserQuery = (
{ __typename?: 'Query' }
& { getUser?: Maybe<(
{ __typename?: 'User' }
& Pick
)> }
);
```

`resolver.ts`
```ts
import * as Types from 'generated/type';

import { GraphQLResolveInfo } from 'graphql';
export type WithIndex = TObject & Record;
export type ResolversObject = WithIndex;

export type ResolverTypeWrapper = Promise | T;

export type LegacyStitchingResolver = {
fragment: string;
resolve: ResolverFn;
};

export type NewStitchingResolver = {
selectionSet: string;
resolve: ResolverFn;
};
export type StitchingResolver = LegacyStitchingResolver | NewStitchingResolver;
export type Resolver =
| ResolverFn
| StitchingResolver;

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

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

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

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

export interface SubscriptionResolverObject {
subscribe: SubscriptionSubscribeFn;
resolve: SubscriptionResolveFn;
}

export type SubscriptionObject =
| SubscriptionSubscriberObject
| SubscriptionResolverObject;

export type SubscriptionResolver =
| ((...args: any[]) => SubscriptionObject)
| SubscriptionObject;

export type TypeResolveFn = (
parent: TParent,
context: TContext,
info: GraphQLResolveInfo
) => Types.Maybe | Promise>;

export type IsTypeOfResolverFn = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise;

export type NextResolverFn = () => Promise;

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

/** Mapping between all available schema types and the resolvers types */
export type TResolversTypes = ResolversObject<{
User: ResolverTypeWrapper; // <=========== this should be a `TUser`
String: ResolverTypeWrapper;
Query: ResolverTypeWrapper<{}>;
Boolean: ResolverTypeWrapper;
}>;

/** Mapping between all available schema types and the resolvers parents */
export type TResolversParentTypes = ResolversObject<{
User: Types.User; // <=========== this should be a `TUser`
String: Types.Scalars['String'];
Query: {};
Boolean: Types.Scalars['Boolean'];
}>;

export type TUserResolvers = ResolversObject<{
id?: Resolver;
name?: Resolver;
__isTypeOf?: IsTypeOfResolverFn;
}>;

export type TQueryResolvers = ResolversObject<{
getUser?: Resolver, ParentType, ContextType>;
}>;

export type TResolvers = ResolversObject<{
User?: TUserResolvers;
Query?: TQueryResolvers;
}>;
```

**To Reproduce**
Steps to reproduce the behavior:

https://github.com/Jonir227/graphql-codegen-import-type-bug

```
npm run grqphql
```

Start with the reproduction repository linked in the issue and run its documented npm command. Compare the generated type.ts and resolver.ts outputs, focusing on the User mapping and the expected TUser references. Done means the import-types preset with typesPrefix: T generates resolver types that consistently reference the prefixed type.

Written by the indexing model from the issue text.