db.query error with relation

const singleMatch = await db.query.matches.findMany({
        where: eq(matches.matchID, 'g123245'),
        with: {
          matchDetails: true,
        },
      });

export const matchesRelations = relations(matches, ({ one, many }) => ({
  matchDetails: one(matchesDetails, {
    fields: [matchesDetails.matchID],
    references: [matchesDetails.matchID],
  }),
}));

export const matchesRelations = relations(matches, ({ one, many }) => ({
  matchDetails: one(matchesDetails, {
    fields: [matchesDetails.matchID],
    references: [matches.matchID],
  }),
}));

Type 'MySqlVarChar<{ tableName: "_matches"; enumValues: [string, ...string[]]; name: "matchID"; data: string; driverParam: string | number; hasDefault: false; notNull: true; }>' is not assignable to type 'AnyColumn<{ tableName: "matchDetails"; }>'.
The types of '.config.tableName' are incompatible between these types.
Type '"_matches"' is not assignable to type '"_matchDetails"'.ts(2322)

export const matchesRelations = relations(matches, ({ one, many }) => ({
  matchesDetails: one(matches, {
    fields: [matchesDetails.matchID],
    references: [matches.matchID],
  }),
}));

import * as schema from "./db/schema"
const db = drizzle(connection, { schema });

const { matches, matchesDetails } = schema

const db = drizzle(connection, { schema });
const { matches, matchesDetails } = schema;

await migrate(db, { migrationsFolder: './migrations-folder' });

Argument of type 'MySql2Database<typeof import("/Users/paulcanning/Programming/Work/rds-test/db/schema")>' is not assignable to parameter of type 'MySql2Database'.
The types of '_.schema' are incompatible between these types.
Type 'ExtractTablesWithRelations<typeof import("/Users/paulcanning/Programming/Work/rds-test/db/schema")> | undefined' is not assignable to type 'ExtractTablesWithRelations<Record<string, never>> | undefined'.
Type 'ExtractTablesWithRelations<typeof import("/Users/paulcanning/Programming/Work/rds-test/db/schema")>' is not assignable to type 'ExtractTablesWithRelations<Record<string, never>>'.ts(2345)

export const matchesRelations = relations(matches, ({ one }) => ({
  matchesDetails: one(matches, {
    fields: [matches.matchID],
    references: [matches.matchID],
  }),
}));

export const matchesRelations = relations(matches, ({ one }) => ({
  matchesDetails: one(matches, {
    fields: [matches.matchID],
    references: [matchesDetails.matchID],
  }),
}));

Type 'MySqlVarChar<{ tableName: "_matchDetails"; name: "matchID"; data: string; driverParam: string | number; enumValues: [string, ...string[]]; notNull: false; hasDefault: false; }>' is not assignable to type 'AnyColumn<{ tableName: "matches"; }>'.
The types of '.config.tableName' are incompatible between these types.
Type '"_matchDetails"' is not assignable to type '"_matches"'.ts(2322)

import { pgTable, serial, text, integer, jsonb } from 'drizzle-orm/pg-core';
import { relations } from 'drizzle-orm';
 
export const users = pgTable('users', {
    id: serial('id').primaryKey(),
    name: text('name'),
});
 
export const usersRelations = relations(users, ({ one, many }) => ({
    profileInfo: one(users, {
        fields: [profileInfo.userId],
        references: [users.id],
    }),
}));
 
export const profileInfo = pgTable('profile_info', {
    id: serial('id').primaryKey(),
    userId: integer("user_id").references(() => users.id),
    metadata: jsonb("metadata"),
});

export const usersRelations = relations(users, ({ one, many }) => ({
    // You need to do one not to user, but to another table you want to connect
    profileInfo: one(profileInfo, {
        fields: [users.id],
        references: [profileInfo.u],
    }),
}));

export const matchesRelations = relations(matches, ({ one }) => ({
  matchesDetails: one(matchesDetails, {
    fields: [matches.matchID],
    references: [matchesDetails.matchID],
  }),
}));

export const matches = mysqlTable("_matches", {
  id: bigint("matchID", { mode: "number" }).primaryKey().autoincrement(),
  competitionID: int("competitionID"),
  seasonID: int("sessionID"),
  kickOffUTC: datetime("kickOffUTC"),
  groupName: varchar("groupName", { length: 20 }),
  matchDay: varchar("matchDay", { length: 20 }),
  matchType: varchar("matchType", { length: 20 }),
  leg: varchar("leg", { length: 20 }),
  matchWinnerID: varchar("matchWinnerID", { length: 20 }),
  gameWinnerID: varchar("gameWinnerID", { length: 20 }),
  gameWinnerType: varchar("gameWinnerType", { length: 20 }),
  legWinnerTypeID: varchar("legWinnerTypeID", { length: 20 }),
  period: varchar("period", { length: 20 }),
  roundNumber: varchar("roundNumber", { length: 20 }),
  roundType: varchar("roundType", { length: 20 }),
  venue: varchar("venue", { length: 20 }),
  venueCity: varchar("venueCity", { length: 20 }),
  refereeName: varchar("refereeName", { length: 20 }),
  homeTeamID: varchar("homeTeamID", { length: 20 }),
  awayTeamID: varchar("awayTeamID", { length: 20 }),
  createAt: timestamp("createdAt"),
  updatedAt: timestamp("updatedAt"),
});

export const matchesDetails = mysqlTable("_matchDetails", {
  id: bigint("id", { mode: "number" }).primaryKey().autoincrement(),
  matchID: bigint("matchID", { mode: "number" }).references(() => matches.id),
  kickOffUTC: datetime("kickOffUTC"),
  period: varchar("period", { length: 20 }),
  weather: varchar("weather", { length: 50 }),
  attendance: int("attendance"),
  awayAttendance: int("awayAttendance"),
  winner: varchar("winner", { length: 20 }),
  resultType: varchar("resultType", { length: 50 }),
  refereeName: varchar("refereeName", { length: 50 }),
  matchTime: int("matchTime"),
  createdAt: timestamp("createdAt"),
  updatedAt: timestamp("updatedAt"),
});

export const matchesRelations = relations(matches, ({ one }) => ({
  matchesDetails: one(matchesDetails, {
    fields: [matches.id],
    references: [matchesDetails.matchID],
  }),
}));