Refresh token type error

[min-stelland]

I am getting this error:

Type '({ token, account }: { token: JWT; user: User | AdapterUser; account: Account | null; profile?: Profile | undefined; trigger?: "signIn" | "signUp" | "update" | undefined; isNewUser?: boolean | undefined; session?: any; }) => Promise<...>' is not assignable to type '(params: { token: JWT; user: User | AdapterUser; account: Account | null; profile?: Profile | undefined; trigger?: "signIn" | "signUp" | "update" | undefined; isNewUser?: boolean | undefined; session?: any; }) => Awaitable<...>'.
  Type 'Promise<JWT | { access_token: string | undefined; expires_at: number | undefined; refresh_token: string | undefined; error?: "RefreshTokenError" | undefined; name?: string | null | undefined; ... 5 more ...; jti?: string | undefined; }>' is not assignable to type 'Awaitable<JWT | null>'.
    Type 'Promise<JWT | { access_token: string | undefined; expires_at: number | undefined; refresh_token: string | undefined; error?: "RefreshTokenError" | undefined; name?: string | null | undefined; ... 5 more ...; jti?: string | undefined; }>' is missing the following properties from type 'JWT': access_token, expires_at

Here is my code (copied from the auth.js documentation on refresh token rotation: https://authjs.dev/guides/refresh-token-rotation)

import NextAuth, { type User } from "next-auth"
import type { JWT } from "next-auth/jwt"

import Google from "next-auth/providers/google"

export const { handlers, auth } = NextAuth({
    providers: [
        Google({
            // Google requires "offline" access_type to provide a `refresh_token`
            authorization: { params: { access_type: "offline", prompt: "consent" } },
        }),
    ],
    callbacks: {
        async jwt({ token, account }) {
            if (account) {
                // First-time login, save the `access_token`, its expiry and the `refresh_token`
                return {
                    ...token,
                    access_token: account.access_token,
                    expires_at: account.expires_at,
                    refresh_token: account.refresh_token,
                }
            } else if (Date.now() < token.expires_at * 1000) {
                // Subsequent logins, but the `access_token` is still valid
                return token
            } else {
                // Subsequent logins, but the `access_token` has expired, try to refresh it
                if (!token.refresh_token) throw new TypeError("Missing refresh_token")

                try {
                    // The `token_endpoint` can be found in the provider's documentation. Or if they support OIDC,
                    // at their `/.well-known/openid-configuration` endpoint.
                    // i.e. https://accounts.google.com/.well-known/openid-configuration
                    const response = await fetch("https://oauth2.googleapis.com/token", {
                        method: "POST",
                        body: new URLSearchParams({
                            client_id: process.env.AUTH_GOOGLE_ID!,
                            client_secret: process.env.AUTH_GOOGLE_SECRET!,
                            grant_type: "refresh_token",
                            refresh_token: token.refresh_token!,
                        }),
                    })

                    const tokensOrError = await response.json()

                    if (!response.ok) throw tokensOrError

                    const newTokens = tokensOrError as {
                        access_token: string
                        expires_in: number
                        refresh_token?: string
                    }

                    token.access_token = newTokens.access_token
                    token.expires_at = Math.floor(
                        Date.now() / 1000 + newTokens.expires_in
                    )
                    // Some providers only issue refresh tokens once, so preserve if we did not get a new one
                    if (newTokens.refresh_token)
                        token.refresh_token = newTokens.refresh_token
                    return token
                } catch (error) {
                    console.error("Error refreshing access_token", error)
                    // If we fail to refresh the token, return an error so we can handle it on the page
                    token.error = "RefreshTokenError"
                    return token
                }
            }
        },
        async session({ session, token }) {
            session.error = token.error
            return session
        },
    },
})

and in my types/next-auth.d.ts file

import NextAuth from "next-auth"
import {User} from "@/components/Types"

declare module "next-auth" {
  /**
   * Returned by `useSession`, `getSession` and received as a prop on the `SessionProvider` React Context
   */
  interface Session {
    user: User,
    accessToken: string,
    token: string,
    provider: string,
    error?: "RefreshTokenError"
  }
}

declare module "next-auth/jwt" {
  interface JWT {
    access_token: string
    expires_at: number
    refresh_token?: string
    error?: "RefreshTokenError"
  }
}

Please help with the error.