Sequelize associations - special methods/mixins are not created?

As per documentation:https://sequelize.org/docs/v6/core-concepts/assocs/#special-methodsmixins-added-to-instances

When an association is defined between two models, the instances of those models gain special methods to interact with their associated counterparts.

Special methods/mixins should be available to user instance, such like user.addFriend(), user.removeFriend(), when there is an applied belongsToMany,hasMany association, but there is a problem.

import { Model, DataTypes, Optional } from "sequelize";
import sequelize from "../../sequelize";
import { UserAttributes } from "./user.def";

interface UserCreationAttributes extends Optional<UserAttributes, "userId"> { }

export class User
  extends Model<UserAttributes, UserCreationAttributes>
  implements UserAttributes {
  public userId!: number;
  public active!: boolean;
  public firstName!: string;
  public lastName!: string;
  public username!: string;
}

const instance = User.init(
  {
    userId: {
      field: "user_id",
      type: DataTypes.BIGINT,
      primaryKey: true,
      autoIncrement: true,
    },
    active: {
      field: "active",
      type: DataTypes.BOOLEAN,
      defaultValue: true,
      allowNull: false,
    },
    firstName: {
      field: "first_name",
      type: DataTypes.STRING(100),
      allowNull: false,
    },
    lastName: {
      field: "last_name",
      type: DataTypes.STRING(100),
      allowNull: false,
    },
    username: {
      field: "username",
      type: DataTypes.STRING(),
      allowNull: false,
      unique: true,
    },
  },
  {
    sequelize,
    tableName: "user",
    freezeTableName: true,

  }
);
User.belongsToMany(User, { foreignKey: 'friend_id', as: 'Friend', through: 'UserFriend' })
export { instance };

These methods are not created. By the way, the 'through' table UserFriend is created in db.

I don't know if this problem has something with typescript, or with the way of creating this self-referential association. The first thing I suspect is the problem, is the way of creating these associations, but I tried all possibilities for connecting models, and special methods were never created.

Is there any way for me to check if these methods are created, because my IDE shows me this message - Property 'addFriend' does not exist on type 'User' (clearly not created).
If anyone recognizes these types of problem, or where I can learn more about this topic and these types of problems, I'd be very grateful. Any advice will be helpful.

I have the exact same problem going on right now. I don't have a complete solution but I do have part of it. I'll say that this code contains some kind of bug, but refer you to the incomplete yet still useful docs for combining TypeScript with Sequelize to try to fix the bug.

I don't know which associations you would make in your code, but for me I have a Profile model that connects to the Account model, Housing model and Gym model, like this:

export class Profile extends Model<ProfileAttributes, ProfileCreationAttributes> implements ProfileAttributes {
    public profileId!: number;
    public acctId!: ForeignKey<Account["acctId"]>;
    public ipAddress!: string;

    public readonly createdAt!: Date;
    public readonly updatedAt!: Date;
    public readonly deletedAt!: Date;

    declare getAccount: BelongsToGetAssociationMixin<Account>;
    declare setAccount: BelongsToSetAssociationMixin<Account, number>;

    declare getHousings: HasManyGetAssociationsMixin<Housing>;
    declare addHousing: HasManyAddAssociationMixin<Housing, number>;
    declare addHousings: HasManyAddAssociationsMixin<Housing, number>;

    declare getGyms: HasManyGetAssociationsMixin<Gym>;
    declare addGym: HasManyAddAssociationMixin<Gym, number>;
    declare addGyms: HasManyAddAssociationsMixin<Gym, number>;

    public readonly Housings?: Housing[];
    public readonly Gyms?: Gym[];

    public static associations: {
        Housings: Association<Profile, Housing>;
        Gyms: Association<Profile, Gym>;
    };

    static initModel(sequelize: S): typeof Profile {
        return Profile.init(
            {
                profileId: {
                    type: DataTypes.INTEGER,
                    unique: true,
                    autoIncrement: true,
                    primaryKey: true,
                },
                ipAddress: {
                    type: DataTypes.STRING,
                    allowNull: false,
                },
            },
            {
                timestamps: true,
                sequelize: sequelize,
                paranoid: false,
            },
        );
    }
}

And the relationship between Profile, Account, Housing, and Gym are like this:

Account.hasOne(Profile, { foreignKey: "acctId", as: "profile" });
Profile.belongsTo(Account, { foreignKey: "acctId", as: "account" });

// https://sequelize.org/docs/v6/advanced-association-concepts/advanced-many-to-many/
Profile.belongsToMany(Housing, { through: "Profile_Housings",  as: "housings" });
Housing.belongsToMany(Profile, { through: "Profile_Housings",  as: "profile" });

Profile.belongsToMany(Gym, { through: "Profile_Gyms", as: "gyms" });
Gym.belongsToMany(Profile, { through: "Profile_Gyms", as: "profile" });

Profile.hasMany(Feedback, { foreignKey: "profileId", as: "their_feedback" });
Feedback.belongsTo(Profile, { foreignKey: "profileId", as: "feedback_from" });

Hence now I can do profile.getHousings(); and profile.addHousing(housing);

The problem is that these functions are defined in runtime while typescript is going to fail if they are not declared in compile time, this is why you need to declare their signatures in the model yourself, only the signature, the implementation is taken care of by sequelize itself. since you have a belongsToMany relation you can add the following signatures as follows in the model class

export class User
  extends Model<UserAttributes, UserCreationAttributes>
  implements UserAttributes {
  public userId!: number;
  public active!: boolean;
  public firstName!: string;
  public lastName!: string;
  public username!: string;

  declare getFriends: BelongsToManyGetAssociationsMixin<User>;
  declare addFriend: BelongsToManyAddAssociationsMixin<User, number>;
  // etc...
}

see https://sequelize.org/docs/v6/other-topics/typescript/#usage