In my drizzle schema, I have two tables, users and payment_history, when I try to reference the id of payment_history, it throws a type error Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions.. users table and payment_history table have a one to many relation where one user can have many payments. These are my schema definition:
users:

export const users = pgTable("users",{
   id: varchar("id").primaryKey().unique().notNull(),
   phone_number: varchar("phone_number", {length: 13 }).unique().notNull(), 
   subscribed: boolean("subscribed").default(false),
   on_trial: boolean("onTrial").default(false),
   trial_start: timestamp("trial_start"),
   trial_end: timestamp("trial_end"),
   plan_id: integer("plan_id").references(()=>plan.id, { onDelete: "cascade" }), //fk to plan.id
// this is going to be the last payment id from the payment history table
   last_payment_id: varchar("last_payment_id").references(() => payment_history.id, { onDelete: "cascade" }),
   last_payment_timestamp: timestamp("last_payment_timestamp"), // going to be the last payment timestamp from the payment history table
   created_at: timestamp("created_at").defaultNow(),
   agreement_to_terms: boolean("agreement_to_terms").default(false),
   sms_permission: boolean("sms_permission").default(false),
   user_type: user_type("user_type"),
   has_onboarded: boolean("has_onboarded").default(false).notNull(),
})

payment_history:

export const payment_history = pgTable("payment_history",{
   id: varchar("id").primaryKey().unique().notNull(),
   order_id: varchar("order_id").notNull(),
   amount: integer("amount"),
   signature: varchar("signature"),
   plan_id: integer("plan_id").references(()=>plan.id, { onDelete: "cascade" }), //fk to plan.id
   date_of_payment: timestamp("date_of_payment"),
   user_id: varchar("user_id").references(() => users.id, { onDelete: "cascade" }), //fk to users.id
})

and these are the table relations:
users:

export const userRelation = relations(users, ({ one, many }) => ({
   business: many(business_detail),
   individual: many(individual_detail),
   payment_history: many(payment_history),
   // last_payment: one(payment_history, { 
   //    fields: [users.last_payment_id],
   //    references: [payment_history.id],
   // }),
   plan: one(plan, {
      fields: [users.plan_id],
      references: [plan.id],
   }),
   device_information: one(device_information, {
      fields: [users.id],
      references: [device_information.user_id],
   }),
   document_details: many(document_details),
   credit_trans: many(credit_trans),
}))

payment_history:

export const paymentHistoryRelations = relations(payment_history, ({ one, many }) => ({
   user: one(users, {
      fields: [payment_history.user_id],
      references: [users.id],
   }),
   last_payment: one(users, {    
      fields: [payment_history.user_id],
      references: [users.last_payment_id],
   }),
   plan: one(plan, {
      fields: [payment_history.plan_id],
      references: [plan.id],
   }),
}))

I thought it was a circular dependancy issue after I added another relation definition for the payment field like this:

export const paymentHistoryRelations = relations(payment_history, ({ one, many }) => ({
   user: one(users, {
      fields: [payment_history.user_id],
      references: [users.id],
   }),
   last_payment: one(users, {    
      fields: [payment_history.user_id],
      references: [users.last_payment_id],
   }),
...
}))

and

export const userRelation = relations(users, ({ one, many }) => ({
...
   payment_history: many(payment_history),
   last_payment: one(payment_history, { 
      fields: [users.last_payment_id],
      references: [payment_history.id],
   }),
...
}))