import RoomType from './chat/room_type.js';
import ChatRight from './chat/rights.js';
import ChatUserRight from './chat/user_rights.js';
import ChatUser from './chat/user.js';
import Room from './chat/room.js';
import User from './community/user.js';
import UserParam from './community/user_param.js';
import UserParamType from './type/user_param.js';
import UserRightType from './type/user_right.js';
import UserRight from './community/user_right.js';
import SettingsType from './type/settings.js';
import UserParamValue from './type/user_param_value.js';
import InterestType from './type/interest.js';
import InterestTranslationType from './type/interest_translation.js';
import Interest from './community/interest.js';
import UserParamVisibilityType from './type/user_param_visibility.js';
import UserParamVisibility from './community/user_param_visibility.js';
import Folder from './community/folder.js';
import Image from './community/image.js';
import ImageVisibilityType from './type/image_visibility.js';
import ImageVisibilityUser from './community/image_visibility_user.js';
import FolderImageVisibility from './community/folder_image_visibility.js';
import ImageImageVisibility from './community/image_image_visibility.js';
import FolderVisibilityUser from './community/folder_visibility_user.js';
import GuestbookEntry from './community/guestbook.js';
import Forum from './forum/forum.js';
import Title from './forum/title.js';
import Message from './forum/message.js';
import MessageImage from './forum/message_image.js';
import MessageHistory from './forum/message_history.js';
import TitleHistory from './forum/title_history.js';
import ForumPermission from './forum/forum_permission.js';
import ForumUserPermission from './forum/forum_user_permission.js';
import ForumForumPermission from './forum/forum_forum_permission.js';
import Friendship from './community/friendship.js';
import FalukantUser from './falukant/data/user.js';
import RegionType from './falukant/type/region.js';
import RegionData from './falukant/data/region.js';
import FalukantCharacter from './falukant/data/character.js';
import FalukantPredefineFirstname from './falukant/predefine/firstname.js';
import FalukantPredefineLastname from './falukant/predefine/lastname.js';
import FalukantStock from './falukant/data/stock.js';
import FalukantStockType from './falukant/type/stock.js';
import Knowledge from './falukant/data/product_knowledge.js';
import ProductType from './falukant/type/product.js';
import TitleOfNobility from './falukant/type/title_of_nobility.js';
import TitleRequirement from './falukant/type/title_requirement.js';
import Branch from './falukant/data/branch.js';
import BranchType from './falukant/type/branch.js';
import Production from './falukant/data/production.js';
import Inventory from './falukant/data/inventory.js';
import BuyableStock from './falukant/data/buyable_stock.js';
import MoneyFlow from './falukant/log/moneyflow.js';
import Director from './falukant/data/director.js';
import DirectorProposal from './falukant/data/director_proposal.js';
import TownProductWorth from './falukant/data/town_product_worth.js';
import DayProduction from './falukant/log/dayproduction.js';
import DaySell from './falukant/log/daysell.js';
import MarriageProposal from './falukant/data/marriage_proposal.js';
import Notification from './falukant/log/notification.js';
import CharacterTrait from './falukant/type/character_trait.js';
import FalukantCharacterTrait from './falukant/data/falukant_character_trait.js';
import Mood from './falukant/type/mood.js';
import PromotionalGift from './falukant/type/promotional_gift.js';
import PromotionalGiftCharacterTrait from './falukant/predefine/promotional_gift_character_trait.js';
import PromotionalGiftMood from './falukant/predefine/promotional_gift_mood.js';
import RelationshipType from './falukant/type/relationship.js';
import Relationship from './falukant/data/relationship.js';
import PromotionalGiftLog from './falukant/log/promotional_gift.js';
import HouseType from './falukant/type/house.js';
import BuyableHouse from './falukant/data/buyable_house.js';
import UserHouse from './falukant/data/user_house.js';
import PartyType from './falukant/type/party.js';
import Party from './falukant/data/party.js';
import MusicType from './falukant/type/music.js';
import BanquetteType from './falukant/type/banquette.js';
import PartyInvitedNobility from './falukant/data/partyInvitedNobility.js';
import ChildRelation from './falukant/data/child_relation.js';
import Learning from './falukant/data/learning.js';
import LearnRecipient from './falukant/type/learn_recipient.js';
import Credit from './falukant/data/credit.js';
import DebtorsPrism from './falukant/data/debtors_prism.js';
import HealthActivity from './falukant/log/health_activity.js';
import Election from './falukant/data/election.js';
import ElectionResult from './falukant/data/election_result.js';
import Candidate from './falukant/data/candidate.js';
import Vote from './falukant/data/vote.js';
import PoliticalOfficeType from './falukant/type/political_office_type.js';
import PoliticalOffice from './falukant/data/political_office.js';
import PoliticalOfficeBenefit from './falukant/predefine/political_office_benefit.js';
import PoliticalOfficeBenefitType from './falukant/type/political_office_benefit_type.js';
import PoliticalOfficeRequirement from './falukant/predefine/political_office_prerequisite.js';
import PoliticalOfficePrerequisite from './falukant/predefine/political_office_prerequisite.js';
import PoliticalOfficeHistory from './falukant/log/political_office_history.js';
import ElectionHistory from './falukant/log/election_history.js';
import Underground from './falukant/data/underground.js';
import UndergroundType from './falukant/type/underground.js';
import VehicleType from './falukant/type/vehicle.js';
import Vehicle from './falukant/data/vehicle.js';
import Transport from './falukant/data/transport.js';
import RegionDistance from './falukant/data/region_distance.js';
import WeatherType from './falukant/type/weather.js';
import Weather from './falukant/data/weather.js';
import ProductWeatherEffect from './falukant/type/product_weather_effect.js';
import Blog from './community/blog.js';
import BlogPost from './community/blog_post.js';
import Campaign from './match3/campaign.js';
import Match3Level from './match3/level.js';
import Objective from './match3/objective.js';
import UserProgress from './match3/userProgress.js';
import UserLevelProgress from './match3/userLevelProgress.js';
import TaxiGameState from './taxi/taxiGameState.js';
import TaxiLevelStats from './taxi/taxiLevelStats.js';
import TaxiMapType from './taxi/taxiMapType.js';
import TaxiMap from './taxi/taxiMap.js';
import TaxiMapTile from './taxi/taxiMapTile.js';
import TaxiMapTileHouse from './taxi/taxiMapTileHouse.js';
import TaxiStreetName from './taxi/taxiStreetName.js';
import TaxiMapTileStreet from './taxi/taxiMapTileStreet.js';
import TaxiHighscore from './minigames/taxiHighscore.js';

export default function setupAssociations() {
  // RoomType 1:n Room
  RoomType.hasMany(Room, { foreignKey: 'roomTypeId', as: 'rooms' });
  Room.belongsTo(RoomType, { foreignKey: 'roomTypeId', as: 'roomType' });
  // ChatUser <-> ChatRight n:m
  ChatUser.belongsToMany(ChatRight, {
    through: ChatUserRight,
    foreignKey: 'chat_user_id',
    otherKey: 'chat_right_id',
    as: 'rights',
  });
  ChatRight.belongsToMany(ChatUser, {
    through: ChatUserRight,
    foreignKey: 'chat_right_id',
    otherKey: 'chat_user_id',
    as: 'users',
  });
  // ChatUser zu FalukantUser
  ChatUser.belongsTo(FalukantUser, { foreignKey: 'falukant_user_id', as: 'falukantUser' });
  FalukantUser.hasOne(ChatUser, { foreignKey: 'falukant_user_id', as: 'chatUser' });
  // Chat Room associations
  Room.belongsTo(User, { foreignKey: 'owner_id', as: 'owner' });
  User.hasMany(Room, { foreignKey: 'owner_id', as: 'ownedRooms' });

  Room.belongsTo(UserParamValue, { foreignKey: 'gender_restriction_id', as: 'genderRestriction' });
  UserParamValue.hasMany(Room, { foreignKey: 'gender_restriction_id', as: 'roomsWithGenderRestriction' });
  // UserParam related associations
  SettingsType.hasMany(UserParamType, { foreignKey: 'settingsId', as: 'user_param_types' });
  UserParamType.belongsTo(SettingsType, { foreignKey: 'settingsId', as: 'settings_type' });

  UserParamType.hasMany(UserParam, { foreignKey: 'paramTypeId', as: 'user_params' });
  UserParam.belongsTo(UserParamType, { foreignKey: 'paramTypeId', as: 'paramType' });

  User.hasMany(UserParam, { foreignKey: 'userId', as: 'user_params' });
  UserParam.belongsTo(User, { foreignKey: 'userId', as: 'user' });

  UserParamValue.belongsTo(UserParamType, { foreignKey: 'userParamTypeId', as: 'user_param_value_type' });
  UserParamType.hasMany(UserParamValue, { foreignKey: 'userParamTypeId', as: 'user_param_type_value' });

  UserRight.belongsTo(User, { foreignKey: 'userId', as: 'user_with_rights' });
  UserRight.belongsTo(UserRightType, { foreignKey: 'rightTypeId', as: 'rightType' });
  UserRightType.hasMany(UserRight, { foreignKey: 'rightTypeId', as: 'user_rights' });

  UserParam.hasMany(UserParamVisibility, { foreignKey: 'param_id', as: 'param_visibilities' });
  UserParamVisibility.belongsTo(UserParam, { foreignKey: 'param_id', as: 'param' });

  UserParamVisibility.belongsTo(UserParamVisibilityType, { foreignKey: 'visibility', as: 'visibility_type' });
  UserParamVisibilityType.hasMany(UserParamVisibility, { foreignKey: 'visibility', as: 'user_param_visibilities' });

  // Interest related associations
  InterestType.hasMany(InterestTranslationType, { foreignKey: 'interestsId', as: 'interest_translations' });
  InterestTranslationType.belongsTo(InterestType, { foreignKey: 'interestsId', as: 'interest_translations' });

  InterestType.hasMany(Interest, { foreignKey: 'userinterestId', as: 'user_interest_type' });
  User.hasMany(Interest, { foreignKey: 'userId', as: 'user_interests' });
  Interest.belongsTo(InterestType, { foreignKey: 'userinterestId', as: 'interest_type' });
  Interest.belongsTo(User, { foreignKey: 'userId', as: 'interest_owner' });

  // Folder and Image related associations
  Folder.belongsTo(User, { foreignKey: 'userId' });
  User.hasMany(Folder, { foreignKey: 'userId' });

  Folder.belongsTo(Folder, { foreignKey: 'parentId', as: 'parent' });
  Folder.hasMany(Folder, { foreignKey: 'parentId', as: 'children' });

  Image.belongsTo(Folder, { foreignKey: 'folderId' });
  Folder.hasMany(Image, { foreignKey: 'folderId' });

  Image.belongsTo(User, { foreignKey: 'userId' });
  User.hasMany(Image, { foreignKey: 'userId' });

  // Image visibility associations
  Folder.belongsToMany(ImageVisibilityType, {
    through: FolderImageVisibility,
    foreignKey: 'folderId',
    otherKey: 'visibilityTypeId'
  });
  ImageVisibilityType.belongsToMany(Folder, {
    through: FolderImageVisibility,
    foreignKey: 'visibilityTypeId',
    otherKey: 'folderId'
  });

  Image.belongsToMany(ImageVisibilityType, {
    through: ImageImageVisibility,
    foreignKey: 'imageId',
    otherKey: 'visibilityTypeId'
  });
  ImageVisibilityType.belongsToMany(Image, {
    through: ImageImageVisibility,
    foreignKey: 'visibilityTypeId',
    otherKey: 'imageId'
  });

  Folder.belongsToMany(ImageVisibilityUser, {
    through: FolderVisibilityUser,
    foreignKey: 'folderId',
    otherKey: 'visibilityUserId'
  });
  ImageVisibilityUser.belongsToMany(Folder, {
    through: FolderVisibilityUser,
    foreignKey: 'visibilityUserId',
    otherKey: 'folderId'
  });

  // Guestbook related associations
  User.hasMany(GuestbookEntry, { foreignKey: 'recipientId', as: 'receivedEntries' });
  User.hasMany(GuestbookEntry, { foreignKey: 'senderId', as: 'sentEntries' });
  GuestbookEntry.belongsTo(User, { foreignKey: 'recipientId', as: 'recipient' });
  GuestbookEntry.belongsTo(User, { foreignKey: 'senderId', as: 'sender' });

  // Forum related associations
  Forum.hasMany(Title, { foreignKey: 'forumId' });
  Title.belongsTo(Forum, { foreignKey: 'forumId' });

  Title.belongsTo(User, { foreignKey: 'createdBy', as: 'createdByUser' });
  User.hasMany(Title, { foreignKey: 'createdBy', as: 'titles' });

  Title.hasMany(Message, { foreignKey: 'titleId', as: 'messages' });
  Message.belongsTo(Title, { foreignKey: 'titleId', as: 'title' });

  Message.belongsTo(User, { foreignKey: 'createdBy', as: 'lastMessageUser' });
  User.hasMany(Message, { foreignKey: 'createdBy', as: 'userMessages' });

  Message.hasMany(MessageImage, { foreignKey: 'messageId' });
  MessageImage.belongsTo(Message, { foreignKey: 'messageId' });

  Message.hasMany(MessageHistory, { foreignKey: 'messageId' });
  MessageHistory.belongsTo(Message, { foreignKey: 'messageId' });

  Title.hasMany(TitleHistory, { foreignKey: 'titleId' });
  TitleHistory.belongsTo(Title, { foreignKey: 'titleId' });

  // Forum permissions associations
  Forum.hasMany(ForumUserPermission, { foreignKey: 'forumId', as: 'userPermissions' });
  ForumUserPermission.belongsTo(Forum, { foreignKey: 'forumId' });

  User.hasMany(ForumUserPermission, { foreignKey: 'userId', as: 'userPermissions' });
  ForumUserPermission.belongsTo(User, { foreignKey: 'userId' });

  Forum.belongsToMany(ForumPermission, {
    through: ForumForumPermission,
    foreignKey: 'forumId',
    as: 'associatedPermissions'
  });

  ForumPermission.belongsToMany(Forum, {
    through: ForumForumPermission,
    foreignKey: 'permissionId',
    as: 'forums'
  });

  ForumPermission.hasMany(ForumUserPermission, { foreignKey: 'permissionId' });
  ForumUserPermission.belongsTo(ForumPermission, { foreignKey: 'permissionId' });

  Friendship.belongsTo(User, { foreignKey: 'user1Id', as: 'friendSender' });
  Friendship.belongsTo(User, { foreignKey: 'user2Id', as: 'friendReceiver' });
  User.hasMany(Friendship, { foreignKey: 'user1Id', as: 'friendSender' });
  User.hasMany(Friendship, { foreignKey: 'user2Id', as: 'friendReceiver' });

  User.hasMany(FalukantUser, { foreignKey: 'userId', as: 'falukantData' });
  FalukantUser.belongsTo(User, { foreignKey: 'userId', as: 'user' });

  RegionType.hasMany(RegionType, { foreignKey: 'parentId', as: 'children' });
  RegionType.belongsTo(RegionType, { foreignKey: 'parentId', as: 'parent' });

  RegionData.hasMany(RegionData, { foreignKey: 'parentId', as: 'children' });
  RegionData.belongsTo(RegionData, { foreignKey: 'parentId', as: 'parent' });

  RegionData.belongsTo(RegionType, { foreignKey: 'regionTypeId', as: 'regionType' });
  RegionType.hasMany(RegionData, { foreignKey: 'regionTypeId', as: 'regions' });

  Weather.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
  RegionData.hasOne(Weather, { foreignKey: 'regionId', as: 'weather' });

  Weather.belongsTo(WeatherType, { foreignKey: 'weatherTypeId', as: 'weatherType' });
  WeatherType.hasMany(Weather, { foreignKey: 'weatherTypeId', as: 'weathers' });

  ProductWeatherEffect.belongsTo(ProductType, { foreignKey: 'productId', as: 'product' });
  ProductType.hasMany(ProductWeatherEffect, { foreignKey: 'productId', as: 'weatherEffects' });

  ProductWeatherEffect.belongsTo(WeatherType, { foreignKey: 'weatherTypeId', as: 'weatherType' });
  WeatherType.hasMany(ProductWeatherEffect, { foreignKey: 'weatherTypeId', as: 'productEffects' });

  Production.belongsTo(WeatherType, { foreignKey: 'weatherTypeId', as: 'weatherType' });
  WeatherType.hasMany(Production, { foreignKey: 'weatherTypeId', as: 'productions' });

  FalukantUser.belongsTo(RegionData, { foreignKey: 'mainBranchRegionId', as: 'mainBranchRegion' });
  RegionData.hasMany(FalukantUser, { foreignKey: 'mainBranchRegionId', as: 'users' });

  FalukantCharacter.belongsTo(FalukantUser, { foreignKey: 'userId', as: 'user' });
  FalukantUser.hasOne(FalukantCharacter, { foreignKey: 'userId', as: 'character' });

  FalukantCharacter.belongsTo(FalukantPredefineFirstname, { foreignKey: 'firstName', as: 'definedFirstName' });
  FalukantPredefineFirstname.hasMany(FalukantCharacter, { foreignKey: 'firstName', as: 'charactersWithFirstName' });

  FalukantCharacter.belongsTo(FalukantPredefineLastname, { foreignKey: 'lastName', as: 'definedLastName' });
  FalukantPredefineLastname.hasMany(FalukantCharacter, { foreignKey: 'lastName', as: 'charactersWithLastName' });

  FalukantCharacter.belongsTo(TitleOfNobility, { foreignKey: 'titleOfNobility', as: 'nobleTitle' });
  TitleOfNobility.hasMany(FalukantCharacter, { foreignKey: 'titleOfNobility', as: 'charactersWithNobleTitle' });

  FalukantCharacter.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
  RegionData.hasMany(FalukantCharacter, { foreignKey: 'regionId', as: 'charactersInRegion' });

  FalukantStock.belongsTo(FalukantStockType, { foreignKey: 'stockTypeId', as: 'stockType' });
  FalukantStockType.hasMany(FalukantStock, { foreignKey: 'stockTypeId', as: 'stocks' });

  Knowledge.belongsTo(ProductType, { foreignKey: 'productId', as: 'productType' });
  ProductType.hasMany(Knowledge, { foreignKey: 'productId', as: 'knowledges' });

  Knowledge.belongsTo(FalukantCharacter, { foreignKey: 'characterId', as: 'character' });
  FalukantCharacter.hasMany(Knowledge, { foreignKey: 'characterId', as: 'knowledges' });

  TitleRequirement.belongsTo(TitleOfNobility, { foreignKey: 'titleId', as: 'title' });
  TitleOfNobility.hasMany(TitleRequirement, { foreignKey: 'titleId', as: 'requirements' });

  Branch.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
  RegionData.hasMany(Branch, { foreignKey: 'regionId', as: 'branches' });

  Branch.belongsTo(FalukantUser, { foreignKey: 'falukantUserId', as: 'user' });
  FalukantUser.hasMany(Branch, { foreignKey: 'falukantUserId', as: 'branches' });

  Branch.belongsTo(BranchType, { foreignKey: 'branchTypeId', as: 'branchType' });
  BranchType.hasMany(Branch, { foreignKey: 'branchTypeId', as: 'branches' });

  Production.belongsTo(Branch, { foreignKey: 'branchId', as: 'branch' });
  Branch.hasMany(Production, { foreignKey: 'branchId', as: 'productions' });

  Production.belongsTo(ProductType, { foreignKey: 'productId', as: 'productType' });
  ProductType.hasMany(Production, { foreignKey: 'productId', as: 'productions' });

  Inventory.belongsTo(FalukantStock, { foreignKey: 'stockId', as: 'stock' });
  FalukantStock.hasMany(Inventory, { foreignKey: 'stockId', as: 'inventories' });

  Inventory.belongsTo(ProductType, { foreignKey: 'productId', as: 'productType' });
  ProductType.hasMany(Inventory, { foreignKey: 'productId', as: 'inventories' });

  BuyableStock.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
  RegionData.hasMany(BuyableStock, { foreignKey: 'regionId', as: 'buyableStocks' });

  Branch.hasMany(FalukantStock, { foreignKey: 'branchId', as: 'stocks' });
  FalukantStock.belongsTo(Branch, { foreignKey: 'branchId', as: 'branch' });

  MoneyFlow.belongsTo(FalukantUser, { foreignKey: 'falukantUserId', as: 'user' });
  FalukantUser.hasMany(MoneyFlow, { foreignKey: 'falukantUserId', as: 'flows' });

  BuyableStock.belongsTo(FalukantStockType, { foreignKey: 'stockTypeId', as: 'stockType' });
  FalukantStockType.hasMany(BuyableStock, { foreignKey: 'stockTypeId', as: 'buyableStocks' });

  Director.belongsTo(FalukantUser, { foreignKey: 'employerUserId', as: 'user' });
  FalukantUser.hasMany(Director, { foreignKey: 'employerUserId', as: 'directors' });

  Director.belongsTo(FalukantCharacter, { foreignKey: 'directorCharacterId', as: 'character' });
  FalukantCharacter.hasMany(Director, { foreignKey: 'directorCharacterId', as: 'directors' });

  DirectorProposal.belongsTo(FalukantUser, { foreignKey: 'employerUserId', as: 'user' });
  FalukantUser.hasMany(DirectorProposal, { foreignKey: 'employerUserId', as: 'directorProposals' });

  DirectorProposal.belongsTo(FalukantCharacter, { foreignKey: 'directorCharacterId', as: 'character' });
  FalukantCharacter.hasMany(DirectorProposal, { foreignKey: 'directorCharacterId', as: 'directorProposals' });

  TownProductWorth.belongsTo(ProductType, { foreignKey: 'productId', as: 'productType' });
  ProductType.hasMany(TownProductWorth, { foreignKey: 'productId', as: 'townProductWorths' });

  TownProductWorth.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
  RegionData.hasMany(TownProductWorth, { foreignKey: 'regionId', as: 'townProductWorths' });

  DayProduction.belongsTo(ProductType, { foreignKey: 'productId', as: 'productType' });
  ProductType.hasMany(DayProduction, { foreignKey: 'productId', as: 'dayProductions' });

  DayProduction.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
  RegionData.hasMany(DayProduction, { foreignKey: 'regionId', as: 'dayProductions' });

  DayProduction.belongsTo(FalukantUser, { foreignKey: 'producerId', as: 'user' });
  FalukantUser.hasMany(DayProduction, { foreignKey: 'producerId', as: 'dayProductions' });

  DaySell.belongsTo(ProductType, { foreignKey: 'productId', as: 'productType' });
  ProductType.hasMany(DaySell, { foreignKey: 'productId', as: 'daySells' });

  DaySell.belongsTo(RegionData, { foreignKey: 'regionId', as: 'region' });
  RegionData.hasMany(DaySell, { foreignKey: 'regionId', as: 'daySells' });

  DaySell.belongsTo(FalukantUser, { foreignKey: 'sellerId', as: 'user' });
  FalukantUser.hasMany(DaySell, { foreignKey: 'sellerId', as: 'daySells' });

  Notification.belongsTo(FalukantUser, { foreignKey: 'userId', as: 'user' });
  FalukantUser.hasMany(Notification, { foreignKey: 'userId', as: 'notifications' });

  MarriageProposal.belongsTo(FalukantCharacter, { foreignKey: 'requesterCharacterId', as: 'requesterCharacter', });
  FalukantCharacter.hasMany(MarriageProposal, { foreignKey: 'requesterCharacterId', as: 'initiatedProposals' });

  MarriageProposal.belongsTo(FalukantCharacter, { foreignKey: 'proposedCharacterId', as: 'proposedCharacter', });
  FalukantCharacter.hasMany(MarriageProposal, { foreignKey: 'proposedCharacterId', as: 'receivedProposals' });

  FalukantCharacter.belongsToMany(CharacterTrait, { through: FalukantCharacterTrait, foreignKey: 'character_id', as: 'traits', });
  CharacterTrait.belongsToMany(FalukantCharacter, { through: FalukantCharacterTrait, foreignKey: 'trait_id', as: 'characters', });

  Mood.hasMany(FalukantCharacter, { foreignKey: 'mood_id', as: 'moods' });
  FalukantCharacter.belongsTo(Mood, { foreignKey: 'mood_id', as: 'mood' });

  PromotionalGift.belongsToMany(CharacterTrait, { through: PromotionalGiftCharacterTrait, foreignKey: 'gift_id', as: 'traits', });
  CharacterTrait.belongsToMany(PromotionalGift, { through: PromotionalGiftCharacterTrait, foreignKey: 'trait_id', as: 'gifts', });

  PromotionalGift.belongsToMany(Mood, { through: PromotionalGiftMood, foreignKey: 'gift_id', as: 'moods', });
  Mood.belongsToMany(PromotionalGift, { through: PromotionalGiftMood, foreignKey: 'mood_id', as: 'gifts', });

  Relationship.belongsTo(RelationshipType, { foreignKey: 'relationshipTypeId', as: 'relationshipType' });
  RelationshipType.hasMany(Relationship, { foreignKey: 'relationshipTypeId', as: 'relationships' });

  Relationship.belongsTo(FalukantCharacter, { foreignKey: 'character1Id', as: 'character1', });
  Relationship.belongsTo(FalukantCharacter, { foreignKey: 'character2Id', as: 'character2', });
  FalukantCharacter.hasMany(Relationship, { foreignKey: 'character1Id', as: 'relationshipsAsCharacter1', });
  FalukantCharacter.hasMany(Relationship, { foreignKey: 'character2Id', as: 'relationshipsAsCharacter2', });

  PromotionalGiftLog.belongsTo(PromotionalGift, { foreignKey: 'giftId', as: 'gift' });
  PromotionalGift.hasMany(PromotionalGiftLog, { foreignKey: 'giftId', as: 'logs' });

  PromotionalGiftLog.belongsTo(FalukantCharacter, { foreignKey: 'senderCharacterId', as: 'character' });
  FalukantCharacter.hasMany(PromotionalGiftLog, { foreignKey: 'senderCharacterId', as: 'logs' });

  PromotionalGiftLog.belongsTo(FalukantCharacter, { foreignKey: 'recipientCharacterId', as: 'recipient' });
  FalukantCharacter.hasMany(PromotionalGiftLog, { foreignKey: 'recipientCharacterId', as: 'giftlogs' });

  // Vehicles & Transports

  VehicleType.hasMany(Vehicle, {
    foreignKey: 'vehicleTypeId',
    as: 'vehicles',
  });
  Vehicle.belongsTo(VehicleType, {
    foreignKey: 'vehicleTypeId',
    as: 'type',
  });

  FalukantUser.hasMany(Vehicle, {
    foreignKey: 'falukantUserId',
    as: 'vehicles',
  });
  Vehicle.belongsTo(FalukantUser, {
    foreignKey: 'falukantUserId',
    as: 'owner',
  });

  RegionData.hasMany(Vehicle, {
    foreignKey: 'regionId',
    as: 'vehicles',
  });
  Vehicle.belongsTo(RegionData, {
    foreignKey: 'regionId',
    as: 'region',
  });

  // Region distances
  RegionData.hasMany(RegionDistance, {
    foreignKey: 'sourceRegionId',
    as: 'distancesFrom',
  });
  RegionData.hasMany(RegionDistance, {
    foreignKey: 'targetRegionId',
    as: 'distancesTo',
  });
  RegionDistance.belongsTo(RegionData, {
    foreignKey: 'sourceRegionId',
    as: 'sourceRegion',
  });
  RegionDistance.belongsTo(RegionData, {
    foreignKey: 'targetRegionId',
    as: 'targetRegion',
  });

  Transport.belongsTo(RegionData, {
    foreignKey: 'sourceRegionId',
    as: 'sourceRegion',
  });
  Transport.belongsTo(RegionData, {
    foreignKey: 'targetRegionId',
    as: 'targetRegion',
  });

  RegionData.hasMany(Transport, {
    foreignKey: 'sourceRegionId',
    as: 'outgoingTransports',
  });
  RegionData.hasMany(Transport, {
    foreignKey: 'targetRegionId',
    as: 'incomingTransports',
  });

  Transport.belongsTo(ProductType, {
    foreignKey: 'productId',
    as: 'productType',
  });
  ProductType.hasMany(Transport, {
    foreignKey: 'productId',
    as: 'transports',
  });

  Transport.belongsTo(Vehicle, {
    foreignKey: 'vehicleId',
    as: 'vehicle',
  });
  Vehicle.hasMany(Transport, {
    foreignKey: 'vehicleId',
    as: 'transports',
  });

  PromotionalGift.hasMany(PromotionalGiftCharacterTrait, { foreignKey: 'gift_id', as: 'characterTraits' });
  PromotionalGift.hasMany(PromotionalGiftMood, { foreignKey: 'gift_id', as: 'promotionalgiftmoods' });

  PromotionalGiftCharacterTrait.belongsTo(PromotionalGift, { foreignKey: 'gift_id', as: 'promotionalgiftcharactertrait' });
  PromotionalGiftMood.belongsTo(PromotionalGift, { foreignKey: 'gift_id', as: 'promotionalgiftcharactermood' });

  HouseType.hasMany(BuyableHouse, { foreignKey: 'houseTypeId', as: 'buyableHouses' });
  BuyableHouse.belongsTo(HouseType, { foreignKey: 'houseTypeId', as: 'houseType' });

  HouseType.hasMany(UserHouse, { foreignKey: 'houseTypeId', as: 'userHouses' });
  UserHouse.belongsTo(HouseType, { foreignKey: 'houseTypeId', as: 'houseType' });

  FalukantUser.hasOne(UserHouse, { foreignKey: 'userId', as: 'userHouse' });
  UserHouse.belongsTo(FalukantUser, { foreignKey: 'userId', as: 'houseUser' });

  TitleOfNobility.hasMany(HouseType, { foreignKey: 'minimumNobleTitle', as: 'houseTypes' });
  HouseType.belongsTo(TitleOfNobility, { foreignKey: 'minimumNobleTitle', as: 'titleOfNobility' });

  PartyType.hasMany(Party, { foreignKey: 'partyTypeId', as: 'parties' });
  Party.belongsTo(PartyType, { foreignKey: 'partyTypeId', as: 'partyType' });

  MusicType.hasMany(Party, { foreignKey: 'musicTypeId', as: 'parties' });
  Party.belongsTo(MusicType, { foreignKey: 'musicTypeId', as: 'musicType' });

  BanquetteType.hasMany(Party, { foreignKey: 'banquetteTypeId', as: 'parties' });
  Party.belongsTo(BanquetteType, { foreignKey: 'banquetteTypeId', as: 'banquetteType' });

  FalukantUser.hasMany(Party, { foreignKey: 'falukantUserId', as: 'parties' });
  Party.belongsTo(FalukantUser, { foreignKey: 'falukantUserId', as: 'partyUser' });

  Party.belongsToMany(TitleOfNobility, {
    through: PartyInvitedNobility,
    foreignKey: 'party_id',
    otherKey: 'title_of_nobility_id',
    as: 'invitedNobilities',
  });
  TitleOfNobility.belongsToMany(Party, {
    through: PartyInvitedNobility,
    foreignKey: 'title_of_nobility_id',
    otherKey: 'party_id',
    as: 'partiesInvitedTo',
  });

  ChildRelation.belongsTo(FalukantCharacter, {
    foreignKey: 'fatherCharacterId',
    as: 'father'
  });
  FalukantCharacter.hasMany(ChildRelation, {
    foreignKey: 'fatherCharacterId',
    as: 'childrenFather'
  });

  ChildRelation.belongsTo(FalukantCharacter, {
    foreignKey: 'motherCharacterId',
    as: 'mother'
  });
  FalukantCharacter.hasMany(ChildRelation, {
    foreignKey: 'motherCharacterId',
    as: 'childrenMother'
  });

  ChildRelation.belongsTo(FalukantCharacter, {
    foreignKey: 'childCharacterId',
    as: 'child'
  });
  FalukantCharacter.hasMany(ChildRelation, {
    foreignKey: 'childCharacterId',
    as: 'parentRelations'
  });

  Learning.belongsTo(LearnRecipient, {
    foreignKey: 'learningRecipientId',
    as: 'recipient',
    constraints: false
  }
  );

  LearnRecipient.hasMany(Learning, {
    foreignKey: 'learningRecipientId',
    as: 'learnings',
    constraints: false
  });

  Learning.belongsTo(FalukantUser, {
    foreignKey: 'associatedFalukantUserId',
    as: 'learner',
    constraints: false
  }
  );

  FalukantUser.hasMany(Learning, {
    foreignKey: 'associatedFalukantUserId',
    as: 'learnings',
    constraints: false
  });

  Learning.belongsTo(ProductType, {
    foreignKey: 'productId',
    as: 'productType',
    constraints: false
  });

  ProductType.hasMany(Learning, {
    foreignKey: 'productId',
    as: 'learnings',
    constraints: false
  });

  Learning.belongsTo(FalukantCharacter, {
    foreignKey: 'associatedLearningCharacterId',
    as: 'learningCharacter',
    constraints: false
  });

  FalukantCharacter.hasMany(Learning, {
    foreignKey: 'associatedLearningCharacterId',
    as: 'learningsCharacter',
    constraints: false
  });

  FalukantUser.hasMany(Credit, {
    foreignKey: 'falukantUserId',
    as: 'credits'
  });
  Credit.belongsTo(FalukantUser, {
    foreignKey: 'falukantUserId',
    as: 'user'
  });

  FalukantCharacter.hasMany(DebtorsPrism, {
    foreignKey: 'character_id',
    as: 'debtorsPrisms'
  });
  DebtorsPrism.belongsTo(FalukantCharacter, {
    foreignKey: 'character_id',
    as: 'character'
  });

  HealthActivity.belongsTo(FalukantCharacter, {
    foreignKey: 'character_id',
    as: 'character'
  });
  FalukantCharacter.hasMany(HealthActivity, {
    foreignKey: 'character_id',
    as: 'healthActivities'
  });

  // — Political Offices —

  // predefine requirements for office
  PoliticalOfficeRequirement.belongsTo(PoliticalOfficeType, {
    foreignKey: 'officeTypeId',
    as: 'officeType'
  });
  PoliticalOfficeType.hasMany(PoliticalOfficeRequirement, {
    foreignKey: 'officeTypeId',
    as: 'requirements'
  });

  // predefine benefits for office
  PoliticalOfficeBenefit.belongsTo(
    PoliticalOfficeBenefitType,
    { foreignKey: 'benefitTypeId', as: 'benefitDefinition' }
  );
  PoliticalOfficeBenefitType.hasMany(
    PoliticalOfficeBenefit,
    { foreignKey: 'benefitTypeId', as: 'benefitDefinitions' }
  );

  // tie benefits back to office type
  PoliticalOfficeBenefit.belongsTo(PoliticalOfficeType, {
    foreignKey: 'officeTypeId',
    as: 'officeType'
  });
  PoliticalOfficeType.hasMany(PoliticalOfficeBenefit, {
    foreignKey: 'officeTypeId',
    as: 'benefits'
  });

  // actual office holdings
  PoliticalOffice.belongsTo(PoliticalOfficeType, {
    foreignKey: 'officeTypeId',
    as: 'type'
  });
  PoliticalOfficeType.hasMany(PoliticalOffice, {
    foreignKey: 'officeTypeId',
    as: 'offices'
  });

  PoliticalOffice.belongsTo(FalukantCharacter, {
    foreignKey: 'characterId',
    as: 'holder'
  });
  FalukantCharacter.hasOne(PoliticalOffice, {
    foreignKey: 'characterId',
    as: 'heldOffice'
  });

  // elections
  Election.belongsTo(PoliticalOfficeType, {
    foreignKey: 'officeTypeId',
    as: 'officeType'
  });
  PoliticalOfficeType.hasMany(Election, {
    foreignKey: 'officeTypeId',
    as: 'elections'
  });

  Election.belongsTo(RegionData, {
    foreignKey: 'regionId',
    as: 'region'
  });

  RegionData.hasMany(Election, {
    foreignKey: 'regionId',
    as: 'elections'
  });

  // candidates in an election
  Candidate.belongsTo(Election, {
    foreignKey: 'electionId',
    as: 'election'
  });
  Election.hasMany(Candidate, {
    foreignKey: 'electionId',
    as: 'candidates'
  });

  Candidate.belongsTo(FalukantCharacter, {
    foreignKey: 'characterId',
    as: 'character'
  });
  FalukantCharacter.hasMany(Candidate, {
    foreignKey: 'characterId',
    as: 'candidacies'
  });

  // votes cast
  Vote.belongsTo(Election, {
    foreignKey: 'electionId',
    as: 'election'
  });
  Election.hasMany(Vote, {
    foreignKey: 'electionId',
    as: 'votes'
  });

  Vote.belongsTo(Candidate, {
    foreignKey: 'candidateId',
    as: 'candidate'
  });
  Candidate.hasMany(Vote, {
    foreignKey: 'candidateId',
    as: 'votes'
  });

  Vote.belongsTo(FalukantCharacter, {
    foreignKey: 'voterCharacterId',
    as: 'voter'
  });
  FalukantCharacter.hasMany(Vote, {
    foreignKey: 'voterCharacterId',
    as: 'votesCast'
  });

  // election results
  ElectionResult.belongsTo(Election, {
    foreignKey: 'electionId',
    as: 'election'
  });
  Election.hasMany(ElectionResult, {
    foreignKey: 'electionId',
    as: 'results'
  });

  ElectionResult.belongsTo(Candidate, {
    foreignKey: 'candidateId',
    as: 'candidate'
  });
  Candidate.hasMany(ElectionResult, {
    foreignKey: 'candidateId',
    as: 'results'
  });

  PoliticalOffice.belongsTo(RegionData, {
    foreignKey: 'regionId',
    as: 'region'
  });
  RegionData.hasMany(PoliticalOffice, {
    foreignKey: 'regionId',
    as: 'offices'
  });

  PoliticalOfficePrerequisite.belongsTo(PoliticalOfficeType, {
    foreignKey: 'office_type_id',
    as: 'officeTypePrerequisite',
  });

  PoliticalOfficeType.hasMany(PoliticalOfficePrerequisite, {
    foreignKey: 'office_type_id',
    as: 'prerequisites',
  });

  PoliticalOfficeHistory.belongsTo(PoliticalOfficeType, {
    foreignKey: 'officeTypeId',
    as: 'officeTypeHistory',
  });

  PoliticalOfficeType.hasMany(PoliticalOfficeHistory, {
    foreignKey: 'officeTypeId',
    as: 'history',
  });

  FalukantCharacter.hasMany(PoliticalOfficeHistory, {
    foreignKey: 'characterId',
    as: 'officeHistories',
  });
  PoliticalOfficeHistory.belongsTo(FalukantCharacter, {
    foreignKey: 'characterId',
    as: 'character',
  });

  ElectionHistory.belongsTo(PoliticalOfficeType, {
    foreignKey: 'officeTypeId',
    as: 'officeTypeHistory',
  });

  PoliticalOfficeType.hasMany(ElectionHistory, {
    foreignKey: 'officeTypeId',
    as: 'electionHistory',
  }
  );

  Underground.belongsTo(UndergroundType, {
    foreignKey: 'undergroundTypeId',
    as: 'undergroundType'
  });
  UndergroundType.hasMany(Underground, {
    foreignKey: 'undergroundTypeId',
    as: 'undergrounds'
  });

  // 2) Täter (performer)
  Underground.belongsTo(FalukantCharacter, {
    foreignKey: 'performerId',
    as: 'performer'
  });
  FalukantCharacter.hasMany(Underground, {
    foreignKey: 'performerId',
    as: 'performedUndergrounds'
  });

  // 3) Opfer (victim)
  Underground.belongsTo(FalukantCharacter, {
    foreignKey: 'victimId',
    as: 'victim'
  });
  FalukantCharacter.hasMany(Underground, {
    foreignKey: 'victimId',
    as: 'victimUndergrounds'
  });

  // Blog associations
  Blog.belongsTo(User, { foreignKey: 'user_id', as: 'owner' });
  User.hasMany(Blog, { foreignKey: 'user_id', as: 'blogs' });
  BlogPost.belongsTo(Blog, { foreignKey: 'blog_id', as: 'blog' });
  Blog.hasMany(BlogPost, { foreignKey: 'blog_id', as: 'posts' });
  BlogPost.belongsTo(User, { foreignKey: 'user_id', as: 'author' });
  User.hasMany(BlogPost, { foreignKey: 'user_id', as: 'blogPosts' });

  // Match3 Campaign & Levels
  Campaign.hasMany(Match3Level, { foreignKey: 'campaignId', as: 'levels' });
  Match3Level.belongsTo(Campaign, { foreignKey: 'campaignId', as: 'campaign' });
  Match3Level.hasMany(Objective, { foreignKey: 'levelId', as: 'objectives' });
  Objective.belongsTo(Match3Level, { foreignKey: 'levelId', as: 'level' });
  // User progress tracking
  Campaign.hasMany(UserProgress, { foreignKey: 'campaignId', as: 'userProgressEntries' });
  UserProgress.belongsTo(Campaign, { foreignKey: 'campaignId', as: 'campaign' });
  UserProgress.hasMany(UserLevelProgress, { foreignKey: 'userProgressId', as: 'levelProgress' });
  UserLevelProgress.belongsTo(UserProgress, { foreignKey: 'userProgressId', as: 'userProgress' });
  Match3Level.hasMany(UserLevelProgress, { foreignKey: 'levelId', as: 'userLevelProgress' });
  UserLevelProgress.belongsTo(Match3Level, { foreignKey: 'levelId', as: 'level' });

  // Taxi Game associations
  TaxiGameState.belongsTo(User, { foreignKey: 'userId', as: 'user' });
  User.hasOne(TaxiGameState, { foreignKey: 'userId', as: 'taxiGameState' });
  
  TaxiLevelStats.belongsTo(User, { foreignKey: 'userId', as: 'user' });
  User.hasMany(TaxiLevelStats, { foreignKey: 'userId', as: 'taxiLevelStats' });
  
  // Taxi Map associations
  TaxiMap.belongsTo(TaxiMapType, { foreignKey: 'mapTypeId', as: 'mapType' });
  TaxiMapType.hasMany(TaxiMap, { foreignKey: 'mapTypeId', as: 'maps' });
  
  // Tiles
  TaxiMap.hasMany(TaxiMapTile, { foreignKey: 'mapId', as: 'tiles' });
  TaxiMapTile.belongsTo(TaxiMap, { foreignKey: 'mapId', as: 'map' });

  // Street name models
  TaxiMapTileStreet.belongsTo(TaxiMap, { foreignKey: 'map_id', as: 'map' });
  TaxiMap.hasMany(TaxiMapTileStreet, { foreignKey: 'map_id', as: 'tileStreets' });
  
  TaxiMapTileStreet.belongsTo(TaxiStreetName, { foreignKey: 'street_name_h_id', as: 'streetNameH' });
  TaxiMapTileStreet.belongsTo(TaxiStreetName, { foreignKey: 'street_name_v_id', as: 'streetNameV' });

  // Houses per tile (one row per corner)
  TaxiMap.hasMany(TaxiMapTileHouse, { foreignKey: 'map_id', as: 'tileHouses' });
  TaxiMapTileHouse.belongsTo(TaxiMap, { foreignKey: 'map_id', as: 'map' });

  // Taxi Highscore associations
  TaxiHighscore.belongsTo(User, { foreignKey: 'userId', as: 'user' });
  User.hasMany(TaxiHighscore, { foreignKey: 'userId', as: 'taxiHighscores' });
  
  TaxiHighscore.belongsTo(TaxiMap, { foreignKey: 'mapId', as: 'map' });
  TaxiMap.hasMany(TaxiHighscore, { foreignKey: 'mapId', as: 'highscores' });
}

