@earbug/db-models 0.0.40 → 0.0.42

package/dist/init-models.js

@@ -2,6 +2,7 @@
 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.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 = void 0;
 exports.initModels = initModels;
 const AccessControlPreference_1 = require("./AccessControlPreference");
 Object.defineProperty(exports, "AccessControlPreference", { enumerable: true, get: function () { return AccessControlPreference_1.AccessControlPreference; } });
@@ -203,6 +204,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);
@@ -304,6 +333,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" });
@@ -408,6 +451,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 +463,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 +487,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 +509,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 +529,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 +547,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" });
@@ -576,6 +639,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 +659,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 +687,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" });
@@ -654,6 +735,36 @@ function initModels(sequelize) {
     UserComments.hasMany(UserComments, { as: "userComments", foreignKey: "replyCommentId" });
     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,
@@ -755,5 +866,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

@@ -20,6 +20,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;
@@ -324,6 +326,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({

package/models/GuestUser.ts

@@ -2,30 +2,34 @@ import * as Sequelize from 'sequelize';
 import { DataTypes, Model, Optional } from 'sequelize';
 import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
 import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+import type { Versus, VersusId } from './Versus';
+import type { VersusCoCreator, VersusCoCreatorId } from './VersusCoCreator';
 
 export interface GuestUserAttributes {
+  jukeboxSessionId?: string;
   firstName: string;
   lastName?: string;
-  jukeboxSessionId: string;
   ipAddress?: string;
   id: string;
   createDate: Date;
   updateDate: Date;
+  versusId?: string;
 }
 
 export type GuestUserPk = "id";
 export type GuestUserId = GuestUser[GuestUserPk];
-export type GuestUserOptionalAttributes = "lastName" | "ipAddress" | "id" | "createDate" | "updateDate";
+export type GuestUserOptionalAttributes = "jukeboxSessionId" | "lastName" | "ipAddress" | "id" | "createDate" | "updateDate" | "versusId";
 export type GuestUserCreationAttributes = Optional<GuestUserAttributes, GuestUserOptionalAttributes>;
 
 export class GuestUser extends Model<GuestUserAttributes, GuestUserCreationAttributes> implements GuestUserAttributes {
+  jukeboxSessionId?: string;
   firstName!: string;
   lastName?: string;
-  jukeboxSessionId!: string;
   ipAddress?: string;
   id!: string;
   createDate!: Date;
   updateDate!: Date;
+  versusId?: string;
 
   // GuestUser hasMany JukeboxQueueEntry via trackAddedGuestUserId
   jukeboxQueueEntries!: JukeboxQueueEntry[];
@@ -39,14 +43,40 @@ export class GuestUser extends Model<GuestUserAttributes, GuestUserCreationAttri
   hasJukeboxQueueEntry!: Sequelize.HasManyHasAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
   hasJukeboxQueueEntries!: Sequelize.HasManyHasAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
   countJukeboxQueueEntries!: Sequelize.HasManyCountAssociationsMixin;
+  // GuestUser hasMany VersusCoCreator via guestUserId
+  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;
   // GuestUser belongsTo JukeboxSession via jukeboxSessionId
   jukeboxSession!: JukeboxSession;
   getJukeboxSession!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
   setJukeboxSession!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
   createJukeboxSession!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+  // GuestUser belongsTo Versus via versusId
+  versu!: Versus;
+  getVersu!: Sequelize.BelongsToGetAssociationMixin<Versus>;
+  setVersu!: Sequelize.BelongsToSetAssociationMixin<Versus, VersusId>;
+  createVersu!: Sequelize.BelongsToCreateAssociationMixin<Versus>;
 
   static initModel(sequelize: Sequelize.Sequelize): typeof GuestUser {
     return GuestUser.init({
+    jukeboxSessionId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      field: 'jukebox_session_id'
+    },
     firstName: {
       type: DataTypes.TEXT,
       allowNull: false,
@@ -57,15 +87,6 @@ export class GuestUser extends Model<GuestUserAttributes, GuestUserCreationAttri
       allowNull: true,
       field: 'last_name'
     },
-    jukeboxSessionId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'jukebox_session',
-        key: 'id'
-      },
-      field: 'jukebox_session_id'
-    },
     ipAddress: {
       type: DataTypes.TEXT,
       allowNull: true,
@@ -88,6 +109,15 @@ export class GuestUser extends Model<GuestUserAttributes, GuestUserCreationAttri
       allowNull: false,
       defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
       field: 'update_date'
+    },
+    versusId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'versus',
+        key: 'id'
+      },
+      field: 'versus_id'
     }
   }, {
     sequelize,
@@ -108,6 +138,12 @@ export class GuestUser extends Model<GuestUserAttributes, GuestUserCreationAttri
           { name: "jukebox_session_id" },
         ]
       },
+      {
+        name: "idx_guest_user_versus",
+        fields: [
+          { name: "versus_id" },
+        ]
+      },
     ]
   });
   }

package/models/JukeboxSession.ts

@@ -30,11 +30,12 @@ export interface JukeboxSessionAttributes {
   description?: string;
   jukeboxStatusId: number;
   durationMs: number;
+  pausedAt?: Date;
 }
 
 export type JukeboxSessionPk = "id";
 export type JukeboxSessionId = JukeboxSession[JukeboxSessionPk];
-export type JukeboxSessionOptionalAttributes = "trackQueue" | "stateMachineArn" | "id" | "createdAt" | "updatedAt" | "description" | "jukeboxStatusId" | "durationMs";
+export type JukeboxSessionOptionalAttributes = "trackQueue" | "stateMachineArn" | "id" | "createdAt" | "updatedAt" | "description" | "jukeboxStatusId" | "durationMs" | "pausedAt";
 export type JukeboxSessionCreationAttributes = Optional<JukeboxSessionAttributes, JukeboxSessionOptionalAttributes>;
 
 export class JukeboxSession extends Model<JukeboxSessionAttributes, JukeboxSessionCreationAttributes> implements JukeboxSessionAttributes {
@@ -50,6 +51,7 @@ export class JukeboxSession extends Model<JukeboxSessionAttributes, JukeboxSessi
   description?: string;
   jukeboxStatusId!: number;
   durationMs!: number;
+  pausedAt?: Date;
 
   // JukeboxSession belongsTo JukeboxAccessType via accessTypeId
   accessType!: JukeboxAccessType;
@@ -294,6 +296,11 @@ export class JukeboxSession extends Model<JukeboxSessionAttributes, JukeboxSessi
       allowNull: false,
       defaultValue: 0,
       field: 'duration_ms'
+    },
+    pausedAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'paused_at'
     }
   }, {
     sequelize,

package/models/PlatformAlbum.ts

@@ -17,6 +17,9 @@ import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
 import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
 import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum';
 import type { UnmatchedAlbum, UnmatchedAlbumId } from './UnmatchedAlbum';
+import type { Versus, VersusId } from './Versus';
+import type { VersusOption, VersusOptionId } from './VersusOption';
+import type { VersusPublishIssue, VersusPublishIssueId } from './VersusPublishIssue';
 
 export interface PlatformAlbumAttributes {
   platformId: number;
@@ -253,6 +256,42 @@ export class PlatformAlbum extends Model<PlatformAlbumAttributes, PlatformAlbumC
   hasUnmatchedAlbum!: Sequelize.HasManyHasAssociationMixin<UnmatchedAlbum, UnmatchedAlbumId>;
   hasUnmatchedAlbums!: Sequelize.HasManyHasAssociationsMixin<UnmatchedAlbum, UnmatchedAlbumId>;
   countUnmatchedAlbums!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformAlbum hasMany Versus via platformAlbumId
+  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;
+  // PlatformAlbum hasMany VersusOption via platformAlbumId
+  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;
+  // PlatformAlbum hasMany VersusPublishIssue via platformAlbumId
+  versusPublishIssues!: VersusPublishIssue[];
+  getVersusPublishIssues!: Sequelize.HasManyGetAssociationsMixin<VersusPublishIssue>;
+  setVersusPublishIssues!: Sequelize.HasManySetAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
+  addVersusPublishIssue!: Sequelize.HasManyAddAssociationMixin<VersusPublishIssue, VersusPublishIssueId>;
+  addVersusPublishIssues!: Sequelize.HasManyAddAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
+  createVersusPublishIssue!: Sequelize.HasManyCreateAssociationMixin<VersusPublishIssue>;
+  removeVersusPublishIssue!: Sequelize.HasManyRemoveAssociationMixin<VersusPublishIssue, VersusPublishIssueId>;
+  removeVersusPublishIssues!: Sequelize.HasManyRemoveAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
+  hasVersusPublishIssue!: Sequelize.HasManyHasAssociationMixin<VersusPublishIssue, VersusPublishIssueId>;
+  hasVersusPublishIssues!: Sequelize.HasManyHasAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
+  countVersusPublishIssues!: Sequelize.HasManyCountAssociationsMixin;
 
   static initModel(sequelize: Sequelize.Sequelize): typeof PlatformAlbum {
     return PlatformAlbum.init({