@earbug/db-models 0.0.41 → 0.0.43

package/dist/init-models.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KnexMigrations = exports.JukeboxUserType = exports.JukeboxUser = exports.JukeboxType = exports.JukeboxTerminationCondition = exports.JukeboxStatus = exports.JukeboxSessionGenreAffinity = exports.JukeboxSessionArtistAffinity = exports.JukeboxSession = exports.JukeboxQueueMode = exports.JukeboxQueueEntry = exports.JukeboxInvite = exports.JukeboxCanonGenreRelation = exports.JukeboxAccessType = exports.GuestUser = exports.FeedContentType = exports.FeedConfig = exports.ExternalReference = exports.ConfigParam = exports.CanonTrack = exports.CanonToPlatformTrackRelation = exports.CanonToPlatformGenreRelation = exports.CanonToPlatformArtistRelation = exports.CanonToPlatformAlbumRelation = exports.CanonMemberExternalReferenceRelation = exports.CanonMember = exports.CanonLabelExternalReferenceRelation = exports.CanonLabel = exports.CanonGenreExternalReferenceRelation = exports.CanonGenre = exports.CanonArtistTrackRelation = exports.CanonArtistMemberRelation = exports.CanonArtistImageHarvested = exports.CanonArtistGenreRelation = exports.CanonArtistExternalReferenceRelation = exports.CanonArtistAlbumRelation = exports.CanonArtist = exports.CanonAlbumTrackRelation = exports.CanonAlbumLabelRelation = exports.CanonAlbumImageHarvested = exports.CanonAlbumGenreRelation = exports.CanonAlbumExternalReferenceRelation = exports.CanonAlbum = exports.AppUserPlatformRelation = exports.AppUserFollowRelation = exports.AppUserDevice = exports.AppUser = exports.AffinityTier = exports.AffinityRelationshipType = exports.AccessControlPreference = void 0;
-exports.UserMessages = exports.UserLikes = exports.UserGenreAffinity = exports.UserEngagementFactor = exports.UserContacts = exports.UserComments = exports.UserBookmarks = exports.UserArtistAffinity = exports.UserAffinity = exports.UnmatchedArtist = exports.UnmatchedAlbum = exports.TrackDeletionReason = exports.State = exports.RadioShowPublishRequests = exports.RadioShowPlacement = exports.RadioShowMedia = exports.RadioShowGenres = exports.RadioShow = exports.PlaybackStatusType = exports.PlaybackStatus = exports.PlatformUserPlaylistTrack = exports.PlatformUserPlaylistGenreAffinity = exports.PlatformUserPlaylistArtistAffinity = exports.PlatformUserPlaylist = exports.PlatformUserAlbumTrack = exports.PlatformUserAlbum = exports.PlatformTrackGenreRelation = exports.PlatformTrack = exports.PlatformGenre = exports.PlatformArtistTrackRelation = exports.PlatformArtistGenreRelation = exports.PlatformArtistAlbumRelation = exports.PlatformArtist = exports.PlatformAlbumTrackRelation = exports.PlatformAlbumGenreRelation = exports.PlatformAlbum = exports.Platform = exports.PauseStatusType = exports.NotificationType = exports.Notification = exports.NewsSite = exports.NewsPlatform = exports.NewsArticle = exports.MetricsEvent = exports.MetricsDaily = exports.MerchType = exports.MerchPlatform = exports.MerchOrchestration = exports.MerchItem = exports.KnexMigrationsLock = void 0;
+exports.UserLikes = exports.UserGenreAffinity = exports.UserEngagementFactor = exports.UserContacts = exports.UserComments = exports.UserBookmarks = exports.UserArtistAffinity = exports.UserAffinity = exports.UserAbuseReports = exports.UnmatchedArtist = exports.UnmatchedAlbum = exports.TrackDeletionReason = exports.State = exports.RadioShowPublishRequests = exports.RadioShowPlacement = exports.RadioShowMedia = exports.RadioShowGenres = exports.RadioShow = exports.PlaybackStatusType = exports.PlaybackStatus = exports.PlatformUserPlaylistTrack = exports.PlatformUserPlaylistGenreAffinity = exports.PlatformUserPlaylistArtistAffinity = exports.PlatformUserPlaylist = exports.PlatformUserAlbumTrack = exports.PlatformUserAlbum = exports.PlatformTrackGenreRelation = exports.PlatformTrack = exports.PlatformGenre = exports.PlatformArtistTrackRelation = exports.PlatformArtistGenreRelation = exports.PlatformArtistAlbumRelation = exports.PlatformArtist = exports.PlatformAlbumTrackRelation = exports.PlatformAlbumGenreRelation = exports.PlatformAlbum = exports.Platform = exports.PauseStatusType = exports.NotificationType = exports.Notification = exports.NewsSite = exports.NewsPlatform = exports.NewsArticle = exports.MetricsEvent = exports.MetricsDaily = exports.MerchType = exports.MerchPlatform = exports.MerchOrchestration = exports.MerchItem = exports.KnexMigrationsLock = void 0;
+exports.VersusVotingMode = exports.VersusVotingListType = exports.VersusQuestionVariableType = exports.VersusQuestion = exports.VersusPublishIssue = exports.VersusOption = exports.VersusEntityKind = exports.VersusEndVoteThreshold = exports.VersusEndTimerDuration = exports.VersusEndMode = exports.VersusCreatorScope = exports.VersusCoCreator = exports.VersusAccessType = exports.Versus = exports.UserMessages = void 0;
 exports.initModels = initModels;
 const AccessControlPreference_1 = require("./AccessControlPreference");
 Object.defineProperty(exports, "AccessControlPreference", { enumerable: true, get: function () { return AccessControlPreference_1.AccessControlPreference; } });
@@ -185,6 +186,8 @@ const UnmatchedAlbum_1 = require("./UnmatchedAlbum");
 Object.defineProperty(exports, "UnmatchedAlbum", { enumerable: true, get: function () { return UnmatchedAlbum_1.UnmatchedAlbum; } });
 const UnmatchedArtist_1 = require("./UnmatchedArtist");
 Object.defineProperty(exports, "UnmatchedArtist", { enumerable: true, get: function () { return UnmatchedArtist_1.UnmatchedArtist; } });
+const UserAbuseReports_1 = require("./UserAbuseReports");
+Object.defineProperty(exports, "UserAbuseReports", { enumerable: true, get: function () { return UserAbuseReports_1.UserAbuseReports; } });
 const UserAffinity_1 = require("./UserAffinity");
 Object.defineProperty(exports, "UserAffinity", { enumerable: true, get: function () { return UserAffinity_1.UserAffinity; } });
 const UserArtistAffinity_1 = require("./UserArtistAffinity");
@@ -203,6 +206,34 @@ const UserLikes_1 = require("./UserLikes");
 Object.defineProperty(exports, "UserLikes", { enumerable: true, get: function () { return UserLikes_1.UserLikes; } });
 const UserMessages_1 = require("./UserMessages");
 Object.defineProperty(exports, "UserMessages", { enumerable: true, get: function () { return UserMessages_1.UserMessages; } });
+const Versus_1 = require("./Versus");
+Object.defineProperty(exports, "Versus", { enumerable: true, get: function () { return Versus_1.Versus; } });
+const VersusAccessType_1 = require("./VersusAccessType");
+Object.defineProperty(exports, "VersusAccessType", { enumerable: true, get: function () { return VersusAccessType_1.VersusAccessType; } });
+const VersusCoCreator_1 = require("./VersusCoCreator");
+Object.defineProperty(exports, "VersusCoCreator", { enumerable: true, get: function () { return VersusCoCreator_1.VersusCoCreator; } });
+const VersusCreatorScope_1 = require("./VersusCreatorScope");
+Object.defineProperty(exports, "VersusCreatorScope", { enumerable: true, get: function () { return VersusCreatorScope_1.VersusCreatorScope; } });
+const VersusEndMode_1 = require("./VersusEndMode");
+Object.defineProperty(exports, "VersusEndMode", { enumerable: true, get: function () { return VersusEndMode_1.VersusEndMode; } });
+const VersusEndTimerDuration_1 = require("./VersusEndTimerDuration");
+Object.defineProperty(exports, "VersusEndTimerDuration", { enumerable: true, get: function () { return VersusEndTimerDuration_1.VersusEndTimerDuration; } });
+const VersusEndVoteThreshold_1 = require("./VersusEndVoteThreshold");
+Object.defineProperty(exports, "VersusEndVoteThreshold", { enumerable: true, get: function () { return VersusEndVoteThreshold_1.VersusEndVoteThreshold; } });
+const VersusEntityKind_1 = require("./VersusEntityKind");
+Object.defineProperty(exports, "VersusEntityKind", { enumerable: true, get: function () { return VersusEntityKind_1.VersusEntityKind; } });
+const VersusOption_1 = require("./VersusOption");
+Object.defineProperty(exports, "VersusOption", { enumerable: true, get: function () { return VersusOption_1.VersusOption; } });
+const VersusPublishIssue_1 = require("./VersusPublishIssue");
+Object.defineProperty(exports, "VersusPublishIssue", { enumerable: true, get: function () { return VersusPublishIssue_1.VersusPublishIssue; } });
+const VersusQuestion_1 = require("./VersusQuestion");
+Object.defineProperty(exports, "VersusQuestion", { enumerable: true, get: function () { return VersusQuestion_1.VersusQuestion; } });
+const VersusQuestionVariableType_1 = require("./VersusQuestionVariableType");
+Object.defineProperty(exports, "VersusQuestionVariableType", { enumerable: true, get: function () { return VersusQuestionVariableType_1.VersusQuestionVariableType; } });
+const VersusVotingListType_1 = require("./VersusVotingListType");
+Object.defineProperty(exports, "VersusVotingListType", { enumerable: true, get: function () { return VersusVotingListType_1.VersusVotingListType; } });
+const VersusVotingMode_1 = require("./VersusVotingMode");
+Object.defineProperty(exports, "VersusVotingMode", { enumerable: true, get: function () { return VersusVotingMode_1.VersusVotingMode; } });
 function initModels(sequelize) {
     const AccessControlPreference = AccessControlPreference_1.AccessControlPreference.initModel(sequelize);
     const AffinityRelationshipType = AffinityRelationshipType_1.AffinityRelationshipType.initModel(sequelize);
@@ -295,6 +326,7 @@ function initModels(sequelize) {
     const TrackDeletionReason = TrackDeletionReason_1.TrackDeletionReason.initModel(sequelize);
     const UnmatchedAlbum = UnmatchedAlbum_1.UnmatchedAlbum.initModel(sequelize);
     const UnmatchedArtist = UnmatchedArtist_1.UnmatchedArtist.initModel(sequelize);
+    const UserAbuseReports = UserAbuseReports_1.UserAbuseReports.initModel(sequelize);
     const UserAffinity = UserAffinity_1.UserAffinity.initModel(sequelize);
     const UserArtistAffinity = UserArtistAffinity_1.UserArtistAffinity.initModel(sequelize);
     const UserBookmarks = UserBookmarks_1.UserBookmarks.initModel(sequelize);
@@ -304,6 +336,20 @@ function initModels(sequelize) {
     const UserGenreAffinity = UserGenreAffinity_1.UserGenreAffinity.initModel(sequelize);
     const UserLikes = UserLikes_1.UserLikes.initModel(sequelize);
     const UserMessages = UserMessages_1.UserMessages.initModel(sequelize);
+    const Versus = Versus_1.Versus.initModel(sequelize);
+    const VersusAccessType = VersusAccessType_1.VersusAccessType.initModel(sequelize);
+    const VersusCoCreator = VersusCoCreator_1.VersusCoCreator.initModel(sequelize);
+    const VersusCreatorScope = VersusCreatorScope_1.VersusCreatorScope.initModel(sequelize);
+    const VersusEndMode = VersusEndMode_1.VersusEndMode.initModel(sequelize);
+    const VersusEndTimerDuration = VersusEndTimerDuration_1.VersusEndTimerDuration.initModel(sequelize);
+    const VersusEndVoteThreshold = VersusEndVoteThreshold_1.VersusEndVoteThreshold.initModel(sequelize);
+    const VersusEntityKind = VersusEntityKind_1.VersusEntityKind.initModel(sequelize);
+    const VersusOption = VersusOption_1.VersusOption.initModel(sequelize);
+    const VersusPublishIssue = VersusPublishIssue_1.VersusPublishIssue.initModel(sequelize);
+    const VersusQuestion = VersusQuestion_1.VersusQuestion.initModel(sequelize);
+    const VersusQuestionVariableType = VersusQuestionVariableType_1.VersusQuestionVariableType.initModel(sequelize);
+    const VersusVotingListType = VersusVotingListType_1.VersusVotingListType.initModel(sequelize);
+    const VersusVotingMode = VersusVotingMode_1.VersusVotingMode.initModel(sequelize);
     CanonAlbum.belongsToMany(CanonTrack, { as: 'canonTrackIdCanonTracks', through: CanonAlbumTrackRelation, foreignKey: "canonAlbumId", otherKey: "canonTrackId" });
     CanonAlbum.belongsToMany(ExternalReference, { as: 'externalReferenceIdExternalReferences', through: CanonAlbumExternalReferenceRelation, foreignKey: "canonAlbumId", otherKey: "externalReferenceId" });
     CanonAlbum.belongsToMany(PlatformAlbum, { as: 'platformAlbumIdPlatformAlbums', through: CanonToPlatformAlbumRelation, foreignKey: "canonAlbumId", otherKey: "platformAlbumId" });
@@ -388,6 +434,8 @@ function initModels(sequelize) {
     AppUser.hasMany(PlatformUserPlaylist, { as: "platformUserPlaylists", foreignKey: "appUserId" });
     RadioShow.belongsTo(AppUser, { as: "creatorUser", foreignKey: "creatorUserId" });
     AppUser.hasMany(RadioShow, { as: "radioShows", foreignKey: "creatorUserId" });
+    UserAbuseReports.belongsTo(AppUser, { as: "reporterUser", foreignKey: "reporterUserId" });
+    AppUser.hasMany(UserAbuseReports, { as: "userAbuseReports", foreignKey: "reporterUserId" });
     UserAffinity.belongsTo(AppUser, { as: "user", foreignKey: "userId" });
     AppUser.hasMany(UserAffinity, { as: "userAffinities", foreignKey: "userId" });
     UserArtistAffinity.belongsTo(AppUser, { as: "user", foreignKey: "userId" });
@@ -408,6 +456,10 @@ function initModels(sequelize) {
     AppUser.hasMany(UserMessages, { as: "userMessages", foreignKey: "recipientId" });
     UserMessages.belongsTo(AppUser, { as: "sender", foreignKey: "senderId" });
     AppUser.hasMany(UserMessages, { as: "senderUserMessages", foreignKey: "senderId" });
+    Versus.belongsTo(AppUser, { as: "creatorUser", foreignKey: "creatorUserId" });
+    AppUser.hasMany(Versus, { as: "versus", foreignKey: "creatorUserId" });
+    VersusCoCreator.belongsTo(AppUser, { as: "appUser", foreignKey: "appUserId" });
+    AppUser.hasMany(VersusCoCreator, { as: "versusCoCreators", foreignKey: "appUserId" });
     CanonAlbumExternalReferenceRelation.belongsTo(CanonAlbum, { as: "canonAlbum", foreignKey: "canonAlbumId" });
     CanonAlbum.hasMany(CanonAlbumExternalReferenceRelation, { as: "canonAlbumExternalReferenceRelations", foreignKey: "canonAlbumId" });
     CanonAlbumImageHarvested.belongsTo(CanonAlbum, { as: "canonAlbum", foreignKey: "canonAlbumId" });
@@ -416,6 +468,10 @@ function initModels(sequelize) {
     CanonAlbum.hasMany(CanonAlbumTrackRelation, { as: "canonAlbumTrackRelations", foreignKey: "canonAlbumId" });
     CanonToPlatformAlbumRelation.belongsTo(CanonAlbum, { as: "canonAlbum", foreignKey: "canonAlbumId" });
     CanonAlbum.hasMany(CanonToPlatformAlbumRelation, { as: "canonToPlatformAlbumRelations", foreignKey: "canonAlbumId" });
+    Versus.belongsTo(CanonAlbum, { as: "canonAlbum", foreignKey: "canonAlbumId" });
+    CanonAlbum.hasMany(Versus, { as: "versus", foreignKey: "canonAlbumId" });
+    VersusOption.belongsTo(CanonAlbum, { as: "canonAlbum", foreignKey: "canonAlbumId" });
+    CanonAlbum.hasMany(VersusOption, { as: "versusOptions", foreignKey: "canonAlbumId" });
     CanonArtistAlbumRelation.belongsTo(CanonArtist, { as: "canonArtist", foreignKey: "canonArtistId" });
     CanonArtist.hasMany(CanonArtistAlbumRelation, { as: "canonArtistAlbumRelations", foreignKey: "canonArtistId" });
     CanonArtistImageHarvested.belongsTo(CanonArtist, { as: "canonArtist", foreignKey: "canonArtistId" });
@@ -436,6 +492,10 @@ function initModels(sequelize) {
     CanonArtist.hasMany(PlatformUserPlaylistArtistAffinity, { as: "platformUserPlaylistArtistAffinities", foreignKey: "canonArtistId" });
     UserArtistAffinity.belongsTo(CanonArtist, { as: "canonArtist", foreignKey: "canonArtistId" });
     CanonArtist.hasMany(UserArtistAffinity, { as: "userArtistAffinities", foreignKey: "canonArtistId" });
+    Versus.belongsTo(CanonArtist, { as: "canonArtist", foreignKey: "canonArtistId" });
+    CanonArtist.hasMany(Versus, { as: "versus", foreignKey: "canonArtistId" });
+    VersusOption.belongsTo(CanonArtist, { as: "canonArtist", foreignKey: "canonArtistId" });
+    CanonArtist.hasMany(VersusOption, { as: "versusOptions", foreignKey: "canonArtistId" });
     CanonAlbumGenreRelation.belongsTo(CanonGenre, { as: "canonGenre", foreignKey: "canonGenreId" });
     CanonGenre.hasMany(CanonAlbumGenreRelation, { as: "canonAlbumGenreRelations", foreignKey: "canonGenreId" });
     CanonArtistGenreRelation.belongsTo(CanonGenre, { as: "canonGenre", foreignKey: "canonGenreId" });
@@ -454,6 +514,8 @@ function initModels(sequelize) {
     CanonGenre.hasMany(RadioShowGenres, { as: "radioShowGenres", foreignKey: "canonGenreId" });
     UserGenreAffinity.belongsTo(CanonGenre, { as: "canonGenre", foreignKey: "canonGenreId" });
     CanonGenre.hasMany(UserGenreAffinity, { as: "userGenreAffinities", foreignKey: "canonGenreId" });
+    Versus.belongsTo(CanonGenre, { as: "canonGenre", foreignKey: "canonGenreId" });
+    CanonGenre.hasMany(Versus, { as: "versus", foreignKey: "canonGenreId" });
     CanonAlbumLabelRelation.belongsTo(CanonLabel, { as: "canonLabel", foreignKey: "canonLabelId" });
     CanonLabel.hasMany(CanonAlbumLabelRelation, { as: "canonAlbumLabelRelations", foreignKey: "canonLabelId" });
     CanonLabelExternalReferenceRelation.belongsTo(CanonLabel, { as: "canonLabel", foreignKey: "canonLabelId" });
@@ -472,6 +534,10 @@ function initModels(sequelize) {
     CanonTrack.hasMany(JukeboxQueueEntry, { as: "jukeboxQueueEntries", foreignKey: "trackId" });
     RadioShowPlacement.belongsTo(CanonTrack, { as: "canonTrack", foreignKey: "canonTrackId" });
     CanonTrack.hasMany(RadioShowPlacement, { as: "radioShowPlacements", foreignKey: "canonTrackId" });
+    Versus.belongsTo(CanonTrack, { as: "canonTrack", foreignKey: "canonTrackId" });
+    CanonTrack.hasMany(Versus, { as: "versus", foreignKey: "canonTrackId" });
+    VersusOption.belongsTo(CanonTrack, { as: "canonTrack", foreignKey: "canonTrackId" });
+    CanonTrack.hasMany(VersusOption, { as: "versusOptions", foreignKey: "canonTrackId" });
     CanonAlbumExternalReferenceRelation.belongsTo(ExternalReference, { as: "externalReference", foreignKey: "externalReferenceId" });
     ExternalReference.hasMany(CanonAlbumExternalReferenceRelation, { as: "canonAlbumExternalReferenceRelations", foreignKey: "externalReferenceId" });
     CanonArtistExternalReferenceRelation.belongsTo(ExternalReference, { as: "externalReference", foreignKey: "externalReferenceId" });
@@ -486,6 +552,8 @@ function initModels(sequelize) {
     FeedContentType.hasMany(UserEngagementFactor, { as: "userEngagementFactors", foreignKey: "contentTypeId" });
     JukeboxQueueEntry.belongsTo(GuestUser, { as: "trackAddedGuestUser", foreignKey: "trackAddedGuestUserId" });
     GuestUser.hasMany(JukeboxQueueEntry, { as: "jukeboxQueueEntries", foreignKey: "trackAddedGuestUserId" });
+    VersusCoCreator.belongsTo(GuestUser, { as: "guestUser", foreignKey: "guestUserId" });
+    GuestUser.hasMany(VersusCoCreator, { as: "versusCoCreators", foreignKey: "guestUserId" });
     JukeboxSession.belongsTo(JukeboxAccessType, { as: "accessType", foreignKey: "accessTypeId" });
     JukeboxAccessType.hasMany(JukeboxSession, { as: "jukeboxSessions", foreignKey: "accessTypeId" });
     JukeboxUser.belongsTo(JukeboxQueueEntry, { as: "pausedQueueEntry", foreignKey: "pausedQueueEntryId" });
@@ -508,6 +576,8 @@ function initModels(sequelize) {
     JukeboxSession.hasMany(JukeboxUser, { as: "jukeboxUsers", foreignKey: "jukeboxSessionId" });
     Notification.belongsTo(JukeboxSession, { as: "jukeboxSession", foreignKey: "jukeboxSessionId" });
     JukeboxSession.hasMany(Notification, { as: "notifications", foreignKey: "jukeboxSessionId" });
+    UserAbuseReports.belongsTo(JukeboxSession, { as: "jukebox", foreignKey: "jukeboxId" });
+    JukeboxSession.hasMany(UserAbuseReports, { as: "userAbuseReports", foreignKey: "jukeboxId" });
     UserBookmarks.belongsTo(JukeboxSession, { as: "jukebox", foreignKey: "jukeboxId" });
     JukeboxSession.hasMany(UserBookmarks, { as: "userBookmarks", foreignKey: "jukeboxId" });
     UserComments.belongsTo(JukeboxSession, { as: "jukebox", foreignKey: "jukeboxId" });
@@ -576,6 +646,12 @@ function initModels(sequelize) {
     PlatformAlbum.hasMany(PlatformUserAlbum, { as: "platformUserAlbums", foreignKey: "platformAlbumId" });
     UnmatchedAlbum.belongsTo(PlatformAlbum, { as: "platformAlbum", foreignKey: "platformAlbumId" });
     PlatformAlbum.hasMany(UnmatchedAlbum, { as: "unmatchedAlbums", foreignKey: "platformAlbumId" });
+    Versus.belongsTo(PlatformAlbum, { as: "platformAlbum", foreignKey: "platformAlbumId" });
+    PlatformAlbum.hasMany(Versus, { as: "versus", foreignKey: "platformAlbumId" });
+    VersusOption.belongsTo(PlatformAlbum, { as: "platformAlbum", foreignKey: "platformAlbumId" });
+    PlatformAlbum.hasMany(VersusOption, { as: "versusOptions", foreignKey: "platformAlbumId" });
+    VersusPublishIssue.belongsTo(PlatformAlbum, { as: "platformAlbum", foreignKey: "platformAlbumId" });
+    PlatformAlbum.hasMany(VersusPublishIssue, { as: "versusPublishIssues", foreignKey: "platformAlbumId" });
     CanonArtistExternalReferenceRelation.belongsTo(PlatformArtist, { as: "canonArtist", foreignKey: "canonArtistId" });
     PlatformArtist.hasMany(CanonArtistExternalReferenceRelation, { as: "canonArtistExternalReferenceRelations", foreignKey: "canonArtistId" });
     CanonArtistGenreRelation.belongsTo(PlatformArtist, { as: "canonArtist", foreignKey: "canonArtistId" });
@@ -590,6 +666,12 @@ function initModels(sequelize) {
     PlatformArtist.hasMany(PlatformArtistGenreRelation, { as: "platformArtistGenreRelations", foreignKey: "platformArtistId" });
     PlatformArtistTrackRelation.belongsTo(PlatformArtist, { as: "platformArtist", foreignKey: "platformArtistId" });
     PlatformArtist.hasMany(PlatformArtistTrackRelation, { as: "platformArtistTrackRelations", foreignKey: "platformArtistId" });
+    Versus.belongsTo(PlatformArtist, { as: "platformArtist", foreignKey: "platformArtistId" });
+    PlatformArtist.hasMany(Versus, { as: "versus", foreignKey: "platformArtistId" });
+    VersusOption.belongsTo(PlatformArtist, { as: "platformArtist", foreignKey: "platformArtistId" });
+    PlatformArtist.hasMany(VersusOption, { as: "versusOptions", foreignKey: "platformArtistId" });
+    VersusPublishIssue.belongsTo(PlatformArtist, { as: "platformArtist", foreignKey: "platformArtistId" });
+    PlatformArtist.hasMany(VersusPublishIssue, { as: "versusPublishIssues", foreignKey: "platformArtistId" });
     CanonToPlatformGenreRelation.belongsTo(PlatformGenre, { as: "platformGenre", foreignKey: "platformGenreId" });
     PlatformGenre.hasMany(CanonToPlatformGenreRelation, { as: "canonToPlatformGenreRelations", foreignKey: "platformGenreId" });
     PlatformAlbumGenreRelation.belongsTo(PlatformGenre, { as: "platformGenre", foreignKey: "platformGenreId" });
@@ -612,6 +694,12 @@ function initModels(sequelize) {
     PlatformTrack.hasMany(PlatformUserAlbumTrack, { as: "platformUserAlbumTracks", foreignKey: "platformTrackId" });
     PlatformUserPlaylistTrack.belongsTo(PlatformTrack, { as: "platformTrack", foreignKey: "platformTrackId" });
     PlatformTrack.hasMany(PlatformUserPlaylistTrack, { as: "platformUserPlaylistTracks", foreignKey: "platformTrackId" });
+    Versus.belongsTo(PlatformTrack, { as: "platformTrack", foreignKey: "platformTrackId" });
+    PlatformTrack.hasMany(Versus, { as: "versus", foreignKey: "platformTrackId" });
+    VersusOption.belongsTo(PlatformTrack, { as: "platformTrack", foreignKey: "platformTrackId" });
+    PlatformTrack.hasMany(VersusOption, { as: "versusOptions", foreignKey: "platformTrackId" });
+    VersusPublishIssue.belongsTo(PlatformTrack, { as: "platformTrack", foreignKey: "platformTrackId" });
+    PlatformTrack.hasMany(VersusPublishIssue, { as: "versusPublishIssues", foreignKey: "platformTrackId" });
     PlatformUserAlbumTrack.belongsTo(PlatformUserAlbum, { as: "platformUserAlbum", foreignKey: "platformUserAlbumId" });
     PlatformUserAlbum.hasMany(PlatformUserAlbumTrack, { as: "platformUserAlbumTracks", foreignKey: "platformUserAlbumId" });
     PlatformUserPlaylistArtistAffinity.belongsTo(PlatformUserPlaylist, { as: "platformUserPlaylist", foreignKey: "platformUserPlaylistId" });
@@ -620,6 +708,8 @@ function initModels(sequelize) {
     PlatformUserPlaylist.hasMany(PlatformUserPlaylistGenreAffinity, { as: "platformUserPlaylistGenreAffinities", foreignKey: "platformUserPlaylistId" });
     PlatformUserPlaylistTrack.belongsTo(PlatformUserPlaylist, { as: "platformUserPlaylist", foreignKey: "platformUserPlaylistId" });
     PlatformUserPlaylist.hasMany(PlatformUserPlaylistTrack, { as: "platformUserPlaylistTracks", foreignKey: "platformUserPlaylistId" });
+    UserAbuseReports.belongsTo(PlatformUserPlaylist, { as: "playlist", foreignKey: "playlistId" });
+    PlatformUserPlaylist.hasMany(UserAbuseReports, { as: "userAbuseReports", foreignKey: "playlistId" });
     UserBookmarks.belongsTo(PlatformUserPlaylist, { as: "playlist", foreignKey: "playlistId" });
     PlatformUserPlaylist.hasMany(UserBookmarks, { as: "userBookmarks", foreignKey: "playlistId" });
     UserComments.belongsTo(PlatformUserPlaylist, { as: "playlist", foreignKey: "playlistId" });
@@ -636,12 +726,16 @@ function initModels(sequelize) {
     RadioShow.hasMany(RadioShowPlacement, { as: "radioShowPlacements", foreignKey: "radioShowId" });
     RadioShowPublishRequests.belongsTo(RadioShow, { as: "radioShow", foreignKey: "radioShowId" });
     RadioShow.hasMany(RadioShowPublishRequests, { as: "radioShowPublishRequests", foreignKey: "radioShowId" });
+    UserAbuseReports.belongsTo(RadioShow, { as: "radioShow", foreignKey: "radioShowId" });
+    RadioShow.hasMany(UserAbuseReports, { as: "userAbuseReports", foreignKey: "radioShowId" });
     UserBookmarks.belongsTo(RadioShow, { as: "radioShow", foreignKey: "radioShowId" });
     RadioShow.hasMany(UserBookmarks, { as: "userBookmarks", foreignKey: "radioShowId" });
     UserComments.belongsTo(RadioShow, { as: "radioShow", foreignKey: "radioShowId" });
     RadioShow.hasMany(UserComments, { as: "userComments", foreignKey: "radioShowId" });
     UserLikes.belongsTo(RadioShow, { as: "radioShow", foreignKey: "radioShowId" });
     RadioShow.hasMany(UserLikes, { as: "userLikes", foreignKey: "radioShowId" });
+    UserAbuseReports.belongsTo(RadioShowMedia, { as: "radioShowMedium", foreignKey: "radioShowMediaId" });
+    RadioShowMedia.hasMany(UserAbuseReports, { as: "userAbuseReports", foreignKey: "radioShowMediaId" });
     AppUser.belongsTo(State, { as: "state", foreignKey: "stateId" });
     State.hasMany(AppUser, { as: "appUsers", foreignKey: "stateId" });
     PlatformUserPlaylist.belongsTo(State, { as: "state", foreignKey: "stateId" });
@@ -650,10 +744,44 @@ function initModels(sequelize) {
     State.hasMany(PlatformUserPlaylistTrack, { as: "platformUserPlaylistTracks", foreignKey: "stateId" });
     JukeboxQueueEntry.belongsTo(TrackDeletionReason, { as: "trackDeletionReason", foreignKey: "trackDeletionReasonId" });
     TrackDeletionReason.hasMany(JukeboxQueueEntry, { as: "jukeboxQueueEntries", foreignKey: "trackDeletionReasonId" });
+    UserAbuseReports.belongsTo(UserComments, { as: "comment", foreignKey: "commentId" });
+    UserComments.hasMany(UserAbuseReports, { as: "userAbuseReports", foreignKey: "commentId" });
     UserComments.belongsTo(UserComments, { as: "replyComment", foreignKey: "replyCommentId" });
     UserComments.hasMany(UserComments, { as: "userComments", foreignKey: "replyCommentId" });
+    UserAbuseReports.belongsTo(UserMessages, { as: "directMessage", foreignKey: "directMessageId" });
+    UserMessages.hasMany(UserAbuseReports, { as: "userAbuseReports", foreignKey: "directMessageId" });
     UserMessages.belongsTo(UserMessages, { as: "replyMessage", foreignKey: "replyMessageId" });
     UserMessages.hasMany(UserMessages, { as: "userMessages", foreignKey: "replyMessageId" });
+    GuestUser.belongsTo(Versus, { as: "versu", foreignKey: "versusId" });
+    Versus.hasMany(GuestUser, { as: "guestUsers", foreignKey: "versusId" });
+    VersusCoCreator.belongsTo(Versus, { as: "versu", foreignKey: "versusId" });
+    Versus.hasMany(VersusCoCreator, { as: "versusCoCreators", foreignKey: "versusId" });
+    VersusOption.belongsTo(Versus, { as: "versu", foreignKey: "versusId" });
+    Versus.hasMany(VersusOption, { as: "versusOptions", foreignKey: "versusId" });
+    VersusPublishIssue.belongsTo(Versus, { as: "versu", foreignKey: "versusId" });
+    Versus.hasMany(VersusPublishIssue, { as: "versusPublishIssues", foreignKey: "versusId" });
+    Versus.belongsTo(VersusAccessType, { as: "versusAccessType", foreignKey: "versusAccessTypeId" });
+    VersusAccessType.hasMany(Versus, { as: "versus", foreignKey: "versusAccessTypeId" });
+    Versus.belongsTo(VersusCreatorScope, { as: "versusCreatorScope", foreignKey: "versusCreatorScopeId" });
+    VersusCreatorScope.hasMany(Versus, { as: "versus", foreignKey: "versusCreatorScopeId" });
+    Versus.belongsTo(VersusEndMode, { as: "versusEndMode", foreignKey: "versusEndModeId" });
+    VersusEndMode.hasMany(Versus, { as: "versus", foreignKey: "versusEndModeId" });
+    Versus.belongsTo(VersusEndTimerDuration, { as: "versusEndTimerDuration", foreignKey: "versusEndTimerDurationId" });
+    VersusEndTimerDuration.hasMany(Versus, { as: "versus", foreignKey: "versusEndTimerDurationId" });
+    Versus.belongsTo(VersusEndVoteThreshold, { as: "versusEndVoteThreshold", foreignKey: "versusEndVoteThresholdId" });
+    VersusEndVoteThreshold.hasMany(Versus, { as: "versus", foreignKey: "versusEndVoteThresholdId" });
+    VersusOption.belongsTo(VersusEntityKind, { as: "entityKind", foreignKey: "entityKindId" });
+    VersusEntityKind.hasMany(VersusOption, { as: "versusOptions", foreignKey: "entityKindId" });
+    VersusPublishIssue.belongsTo(VersusEntityKind, { as: "entityKind", foreignKey: "entityKindId" });
+    VersusEntityKind.hasMany(VersusPublishIssue, { as: "versusPublishIssues", foreignKey: "entityKindId" });
+    Versus.belongsTo(VersusQuestion, { as: "versusQuestion", foreignKey: "versusQuestionId" });
+    VersusQuestion.hasMany(Versus, { as: "versus", foreignKey: "versusQuestionId" });
+    VersusQuestion.belongsTo(VersusQuestionVariableType, { as: "questionVariableType", foreignKey: "questionVariableTypeId" });
+    VersusQuestionVariableType.hasMany(VersusQuestion, { as: "versusQuestions", foreignKey: "questionVariableTypeId" });
+    VersusQuestion.belongsTo(VersusVotingListType, { as: "votingListType", foreignKey: "votingListTypeId" });
+    VersusVotingListType.hasMany(VersusQuestion, { as: "versusQuestions", foreignKey: "votingListTypeId" });
+    Versus.belongsTo(VersusVotingMode, { as: "versusVotingMode", foreignKey: "versusVotingModeId" });
+    VersusVotingMode.hasMany(Versus, { as: "versus", foreignKey: "versusVotingModeId" });
     return {
         AccessControlPreference: AccessControlPreference,
         AffinityRelationshipType: AffinityRelationshipType,
@@ -746,6 +874,7 @@ function initModels(sequelize) {
         TrackDeletionReason: TrackDeletionReason,
         UnmatchedAlbum: UnmatchedAlbum,
         UnmatchedArtist: UnmatchedArtist,
+        UserAbuseReports: UserAbuseReports,
         UserAffinity: UserAffinity,
         UserArtistAffinity: UserArtistAffinity,
         UserBookmarks: UserBookmarks,
@@ -755,5 +884,19 @@ function initModels(sequelize) {
         UserGenreAffinity: UserGenreAffinity,
         UserLikes: UserLikes,
         UserMessages: UserMessages,
+        Versus: Versus,
+        VersusAccessType: VersusAccessType,
+        VersusCoCreator: VersusCoCreator,
+        VersusCreatorScope: VersusCreatorScope,
+        VersusEndMode: VersusEndMode,
+        VersusEndTimerDuration: VersusEndTimerDuration,
+        VersusEndVoteThreshold: VersusEndVoteThreshold,
+        VersusEntityKind: VersusEntityKind,
+        VersusOption: VersusOption,
+        VersusPublishIssue: VersusPublishIssue,
+        VersusQuestion: VersusQuestion,
+        VersusQuestionVariableType: VersusQuestionVariableType,
+        VersusVotingListType: VersusVotingListType,
+        VersusVotingMode: VersusVotingMode,
     };
 }

package/models/AppUser.ts

@@ -11,6 +11,7 @@ import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum
 import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
 import type { RadioShow, RadioShowId } from './RadioShow';
 import type { State, StateId } from './State';
+import type { UserAbuseReports, UserAbuseReportsId } from './UserAbuseReports';
 import type { UserAffinity, UserAffinityId } from './UserAffinity';
 import type { UserArtistAffinity, UserArtistAffinityId } from './UserArtistAffinity';
 import type { UserBookmarks, UserBookmarksId } from './UserBookmarks';
@@ -20,6 +21,8 @@ import type { UserEngagementFactor, UserEngagementFactorId } from './UserEngagem
 import type { UserGenreAffinity, UserGenreAffinityId } from './UserGenreAffinity';
 import type { UserLikes, UserLikesId } from './UserLikes';
 import type { UserMessages, UserMessagesId } from './UserMessages';
+import type { Versus, VersusId } from './Versus';
+import type { VersusCoCreator, VersusCoCreatorId } from './VersusCoCreator';
 
 export interface AppUserAttributes {
   email: string;
@@ -204,6 +207,18 @@ export class AppUser extends Model<AppUserAttributes, AppUserCreationAttributes>
   hasRadioShow!: Sequelize.HasManyHasAssociationMixin<RadioShow, RadioShowId>;
   hasRadioShows!: Sequelize.HasManyHasAssociationsMixin<RadioShow, RadioShowId>;
   countRadioShows!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany UserAbuseReports via reporterUserId
+  userAbuseReports!: UserAbuseReports[];
+  getUserAbuseReports!: Sequelize.HasManyGetAssociationsMixin<UserAbuseReports>;
+  setUserAbuseReports!: Sequelize.HasManySetAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  addUserAbuseReport!: Sequelize.HasManyAddAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  addUserAbuseReports!: Sequelize.HasManyAddAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  createUserAbuseReport!: Sequelize.HasManyCreateAssociationMixin<UserAbuseReports>;
+  removeUserAbuseReport!: Sequelize.HasManyRemoveAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  removeUserAbuseReports!: Sequelize.HasManyRemoveAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  hasUserAbuseReport!: Sequelize.HasManyHasAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  hasUserAbuseReports!: Sequelize.HasManyHasAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  countUserAbuseReports!: Sequelize.HasManyCountAssociationsMixin;
   // AppUser hasMany UserAffinity via userId
   userAffinities!: UserAffinity[];
   getUserAffinities!: Sequelize.HasManyGetAssociationsMixin<UserAffinity>;
@@ -324,6 +339,30 @@ export class AppUser extends Model<AppUserAttributes, AppUserCreationAttributes>
   hasSenderUserMessage!: Sequelize.HasManyHasAssociationMixin<UserMessages, UserMessagesId>;
   hasSenderUserMessages!: Sequelize.HasManyHasAssociationsMixin<UserMessages, UserMessagesId>;
   countSenderUserMessages!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany Versus via creatorUserId
+  versus!: Versus[];
+  getVersus!: Sequelize.HasManyGetAssociationsMixin<Versus>;
+  setVersus!: Sequelize.HasManySetAssociationsMixin<Versus, VersusId>;
+  addVersu!: Sequelize.HasManyAddAssociationMixin<Versus, VersusId>;
+  addVersus!: Sequelize.HasManyAddAssociationsMixin<Versus, VersusId>;
+  createVersu!: Sequelize.HasManyCreateAssociationMixin<Versus>;
+  removeVersu!: Sequelize.HasManyRemoveAssociationMixin<Versus, VersusId>;
+  removeVersus!: Sequelize.HasManyRemoveAssociationsMixin<Versus, VersusId>;
+  hasVersu!: Sequelize.HasManyHasAssociationMixin<Versus, VersusId>;
+  hasVersus!: Sequelize.HasManyHasAssociationsMixin<Versus, VersusId>;
+  countVersus!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany VersusCoCreator via appUserId
+  versusCoCreators!: VersusCoCreator[];
+  getVersusCoCreators!: Sequelize.HasManyGetAssociationsMixin<VersusCoCreator>;
+  setVersusCoCreators!: Sequelize.HasManySetAssociationsMixin<VersusCoCreator, VersusCoCreatorId>;
+  addVersusCoCreator!: Sequelize.HasManyAddAssociationMixin<VersusCoCreator, VersusCoCreatorId>;
+  addVersusCoCreators!: Sequelize.HasManyAddAssociationsMixin<VersusCoCreator, VersusCoCreatorId>;
+  createVersusCoCreator!: Sequelize.HasManyCreateAssociationMixin<VersusCoCreator>;
+  removeVersusCoCreator!: Sequelize.HasManyRemoveAssociationMixin<VersusCoCreator, VersusCoCreatorId>;
+  removeVersusCoCreators!: Sequelize.HasManyRemoveAssociationsMixin<VersusCoCreator, VersusCoCreatorId>;
+  hasVersusCoCreator!: Sequelize.HasManyHasAssociationMixin<VersusCoCreator, VersusCoCreatorId>;
+  hasVersusCoCreators!: Sequelize.HasManyHasAssociationsMixin<VersusCoCreator, VersusCoCreatorId>;
+  countVersusCoCreators!: Sequelize.HasManyCountAssociationsMixin;
   // AppUser belongsTo State via stateId
   state!: State;
   getState!: Sequelize.BelongsToGetAssociationMixin<State>;

package/models/CanonAlbum.ts

@@ -7,6 +7,8 @@ import type { CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId } fro
 import type { CanonTrack, CanonTrackId } from './CanonTrack';
 import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
 import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { Versus, VersusId } from './Versus';
+import type { VersusOption, VersusOptionId } from './VersusOption';
 
 export interface CanonAlbumAttributes {
   name: string;
@@ -126,6 +128,30 @@ export class CanonAlbum extends Model<CanonAlbumAttributes, CanonAlbumCreationAt
   hasPlatformAlbumIdPlatformAlbum!: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
   hasPlatformAlbumIdPlatformAlbums!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
   countPlatformAlbumIdPlatformAlbums!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonAlbum hasMany Versus via canonAlbumId
+  versus!: Versus[];
+  getVersus!: Sequelize.HasManyGetAssociationsMixin<Versus>;
+  setVersus!: Sequelize.HasManySetAssociationsMixin<Versus, VersusId>;
+  addVersu!: Sequelize.HasManyAddAssociationMixin<Versus, VersusId>;
+  addVersus!: Sequelize.HasManyAddAssociationsMixin<Versus, VersusId>;
+  createVersu!: Sequelize.HasManyCreateAssociationMixin<Versus>;
+  removeVersu!: Sequelize.HasManyRemoveAssociationMixin<Versus, VersusId>;
+  removeVersus!: Sequelize.HasManyRemoveAssociationsMixin<Versus, VersusId>;
+  hasVersu!: Sequelize.HasManyHasAssociationMixin<Versus, VersusId>;
+  hasVersus!: Sequelize.HasManyHasAssociationsMixin<Versus, VersusId>;
+  countVersus!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonAlbum hasMany VersusOption via canonAlbumId
+  versusOptions!: VersusOption[];
+  getVersusOptions!: Sequelize.HasManyGetAssociationsMixin<VersusOption>;
+  setVersusOptions!: Sequelize.HasManySetAssociationsMixin<VersusOption, VersusOptionId>;
+  addVersusOption!: Sequelize.HasManyAddAssociationMixin<VersusOption, VersusOptionId>;
+  addVersusOptions!: Sequelize.HasManyAddAssociationsMixin<VersusOption, VersusOptionId>;
+  createVersusOption!: Sequelize.HasManyCreateAssociationMixin<VersusOption>;
+  removeVersusOption!: Sequelize.HasManyRemoveAssociationMixin<VersusOption, VersusOptionId>;
+  removeVersusOptions!: Sequelize.HasManyRemoveAssociationsMixin<VersusOption, VersusOptionId>;
+  hasVersusOption!: Sequelize.HasManyHasAssociationMixin<VersusOption, VersusOptionId>;
+  hasVersusOptions!: Sequelize.HasManyHasAssociationsMixin<VersusOption, VersusOptionId>;
+  countVersusOptions!: Sequelize.HasManyCountAssociationsMixin;
 
   static initModel(sequelize: Sequelize.Sequelize): typeof CanonAlbum {
     return CanonAlbum.init({

package/models/CanonArtist.ts

@@ -13,6 +13,8 @@ import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
 import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
 import type { PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId } from './PlatformUserPlaylistArtistAffinity';
 import type { UserArtistAffinity, UserArtistAffinityId } from './UserArtistAffinity';
+import type { Versus, VersusId } from './Versus';
+import type { VersusOption, VersusOptionId } from './VersusOption';
 
 export interface CanonArtistAttributes {
   name: string;
@@ -210,6 +212,30 @@ export class CanonArtist extends Model<CanonArtistAttributes, CanonArtistCreatio
   hasUserArtistAffinity!: Sequelize.HasManyHasAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
   hasUserArtistAffinities!: Sequelize.HasManyHasAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
   countUserArtistAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonArtist hasMany Versus via canonArtistId
+  versus!: Versus[];
+  getVersus!: Sequelize.HasManyGetAssociationsMixin<Versus>;
+  setVersus!: Sequelize.HasManySetAssociationsMixin<Versus, VersusId>;
+  addVersu!: Sequelize.HasManyAddAssociationMixin<Versus, VersusId>;
+  addVersus!: Sequelize.HasManyAddAssociationsMixin<Versus, VersusId>;
+  createVersu!: Sequelize.HasManyCreateAssociationMixin<Versus>;
+  removeVersu!: Sequelize.HasManyRemoveAssociationMixin<Versus, VersusId>;
+  removeVersus!: Sequelize.HasManyRemoveAssociationsMixin<Versus, VersusId>;
+  hasVersu!: Sequelize.HasManyHasAssociationMixin<Versus, VersusId>;
+  hasVersus!: Sequelize.HasManyHasAssociationsMixin<Versus, VersusId>;
+  countVersus!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonArtist hasMany VersusOption via canonArtistId
+  versusOptions!: VersusOption[];
+  getVersusOptions!: Sequelize.HasManyGetAssociationsMixin<VersusOption>;
+  setVersusOptions!: Sequelize.HasManySetAssociationsMixin<VersusOption, VersusOptionId>;
+  addVersusOption!: Sequelize.HasManyAddAssociationMixin<VersusOption, VersusOptionId>;
+  addVersusOptions!: Sequelize.HasManyAddAssociationsMixin<VersusOption, VersusOptionId>;
+  createVersusOption!: Sequelize.HasManyCreateAssociationMixin<VersusOption>;
+  removeVersusOption!: Sequelize.HasManyRemoveAssociationMixin<VersusOption, VersusOptionId>;
+  removeVersusOptions!: Sequelize.HasManyRemoveAssociationsMixin<VersusOption, VersusOptionId>;
+  hasVersusOption!: Sequelize.HasManyHasAssociationMixin<VersusOption, VersusOptionId>;
+  hasVersusOptions!: Sequelize.HasManyHasAssociationsMixin<VersusOption, VersusOptionId>;
+  countVersusOptions!: Sequelize.HasManyCountAssociationsMixin;
 
   static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtist {
     return CanonArtist.init({

package/models/CanonGenre.ts

@@ -13,6 +13,7 @@ import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
 import type { PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId } from './PlatformUserPlaylistGenreAffinity';
 import type { RadioShowGenres, RadioShowGenresId } from './RadioShowGenres';
 import type { UserGenreAffinity, UserGenreAffinityId } from './UserGenreAffinity';
+import type { Versus, VersusId } from './Versus';
 
 export interface CanonGenreAttributes {
   name: string;
@@ -194,6 +195,18 @@ export class CanonGenre extends Model<CanonGenreAttributes, CanonGenreCreationAt
   hasUserGenreAffinity!: Sequelize.HasManyHasAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
   hasUserGenreAffinities!: Sequelize.HasManyHasAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
   countUserGenreAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonGenre hasMany Versus via canonGenreId
+  versus!: Versus[];
+  getVersus!: Sequelize.HasManyGetAssociationsMixin<Versus>;
+  setVersus!: Sequelize.HasManySetAssociationsMixin<Versus, VersusId>;
+  addVersu!: Sequelize.HasManyAddAssociationMixin<Versus, VersusId>;
+  addVersus!: Sequelize.HasManyAddAssociationsMixin<Versus, VersusId>;
+  createVersu!: Sequelize.HasManyCreateAssociationMixin<Versus>;
+  removeVersu!: Sequelize.HasManyRemoveAssociationMixin<Versus, VersusId>;
+  removeVersus!: Sequelize.HasManyRemoveAssociationsMixin<Versus, VersusId>;
+  hasVersu!: Sequelize.HasManyHasAssociationMixin<Versus, VersusId>;
+  hasVersus!: Sequelize.HasManyHasAssociationsMixin<Versus, VersusId>;
+  countVersus!: Sequelize.HasManyCountAssociationsMixin;
 
   static initModel(sequelize: Sequelize.Sequelize): typeof CanonGenre {
     return CanonGenre.init({

package/models/CanonTrack.ts

@@ -8,6 +8,8 @@ import type { CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId } fro
 import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
 import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
 import type { RadioShowPlacement, RadioShowPlacementId } from './RadioShowPlacement';
+import type { Versus, VersusId } from './Versus';
+import type { VersusOption, VersusOptionId } from './VersusOption';
 
 export interface CanonTrackAttributes {
   name: string;
@@ -133,6 +135,30 @@ export class CanonTrack extends Model<CanonTrackAttributes, CanonTrackCreationAt
   hasRadioShowPlacement!: Sequelize.HasManyHasAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
   hasRadioShowPlacements!: Sequelize.HasManyHasAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
   countRadioShowPlacements!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonTrack hasMany Versus via canonTrackId
+  versus!: Versus[];
+  getVersus!: Sequelize.HasManyGetAssociationsMixin<Versus>;
+  setVersus!: Sequelize.HasManySetAssociationsMixin<Versus, VersusId>;
+  addVersu!: Sequelize.HasManyAddAssociationMixin<Versus, VersusId>;
+  addVersus!: Sequelize.HasManyAddAssociationsMixin<Versus, VersusId>;
+  createVersu!: Sequelize.HasManyCreateAssociationMixin<Versus>;
+  removeVersu!: Sequelize.HasManyRemoveAssociationMixin<Versus, VersusId>;
+  removeVersus!: Sequelize.HasManyRemoveAssociationsMixin<Versus, VersusId>;
+  hasVersu!: Sequelize.HasManyHasAssociationMixin<Versus, VersusId>;
+  hasVersus!: Sequelize.HasManyHasAssociationsMixin<Versus, VersusId>;
+  countVersus!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonTrack hasMany VersusOption via canonTrackId
+  versusOptions!: VersusOption[];
+  getVersusOptions!: Sequelize.HasManyGetAssociationsMixin<VersusOption>;
+  setVersusOptions!: Sequelize.HasManySetAssociationsMixin<VersusOption, VersusOptionId>;
+  addVersusOption!: Sequelize.HasManyAddAssociationMixin<VersusOption, VersusOptionId>;
+  addVersusOptions!: Sequelize.HasManyAddAssociationsMixin<VersusOption, VersusOptionId>;
+  createVersusOption!: Sequelize.HasManyCreateAssociationMixin<VersusOption>;
+  removeVersusOption!: Sequelize.HasManyRemoveAssociationMixin<VersusOption, VersusOptionId>;
+  removeVersusOptions!: Sequelize.HasManyRemoveAssociationsMixin<VersusOption, VersusOptionId>;
+  hasVersusOption!: Sequelize.HasManyHasAssociationMixin<VersusOption, VersusOptionId>;
+  hasVersusOptions!: Sequelize.HasManyHasAssociationsMixin<VersusOption, VersusOptionId>;
+  countVersusOptions!: Sequelize.HasManyCountAssociationsMixin;
 
   static initModel(sequelize: Sequelize.Sequelize): typeof CanonTrack {
     return CanonTrack.init({