@earbug/db-models 0.0.41 → 0.0.43

package/models/init-models.ts

@@ -181,6 +181,8 @@ import { UnmatchedAlbum as _UnmatchedAlbum } from "./UnmatchedAlbum";
 import type { UnmatchedAlbumAttributes, UnmatchedAlbumCreationAttributes } from "./UnmatchedAlbum";
 import { UnmatchedArtist as _UnmatchedArtist } from "./UnmatchedArtist";
 import type { UnmatchedArtistAttributes, UnmatchedArtistCreationAttributes } from "./UnmatchedArtist";
+import { UserAbuseReports as _UserAbuseReports } from "./UserAbuseReports";
+import type { UserAbuseReportsAttributes, UserAbuseReportsCreationAttributes } from "./UserAbuseReports";
 import { UserAffinity as _UserAffinity } from "./UserAffinity";
 import type { UserAffinityAttributes, UserAffinityCreationAttributes } from "./UserAffinity";
 import { UserArtistAffinity as _UserArtistAffinity } from "./UserArtistAffinity";
@@ -199,6 +201,34 @@ import { UserLikes as _UserLikes } from "./UserLikes";
 import type { UserLikesAttributes, UserLikesCreationAttributes } from "./UserLikes";
 import { UserMessages as _UserMessages } from "./UserMessages";
 import type { UserMessagesAttributes, UserMessagesCreationAttributes } from "./UserMessages";
+import { Versus as _Versus } from "./Versus";
+import type { VersusAttributes, VersusCreationAttributes } from "./Versus";
+import { VersusAccessType as _VersusAccessType } from "./VersusAccessType";
+import type { VersusAccessTypeAttributes, VersusAccessTypeCreationAttributes } from "./VersusAccessType";
+import { VersusCoCreator as _VersusCoCreator } from "./VersusCoCreator";
+import type { VersusCoCreatorAttributes, VersusCoCreatorCreationAttributes } from "./VersusCoCreator";
+import { VersusCreatorScope as _VersusCreatorScope } from "./VersusCreatorScope";
+import type { VersusCreatorScopeAttributes, VersusCreatorScopeCreationAttributes } from "./VersusCreatorScope";
+import { VersusEndMode as _VersusEndMode } from "./VersusEndMode";
+import type { VersusEndModeAttributes, VersusEndModeCreationAttributes } from "./VersusEndMode";
+import { VersusEndTimerDuration as _VersusEndTimerDuration } from "./VersusEndTimerDuration";
+import type { VersusEndTimerDurationAttributes, VersusEndTimerDurationCreationAttributes } from "./VersusEndTimerDuration";
+import { VersusEndVoteThreshold as _VersusEndVoteThreshold } from "./VersusEndVoteThreshold";
+import type { VersusEndVoteThresholdAttributes, VersusEndVoteThresholdCreationAttributes } from "./VersusEndVoteThreshold";
+import { VersusEntityKind as _VersusEntityKind } from "./VersusEntityKind";
+import type { VersusEntityKindAttributes, VersusEntityKindCreationAttributes } from "./VersusEntityKind";
+import { VersusOption as _VersusOption } from "./VersusOption";
+import type { VersusOptionAttributes, VersusOptionCreationAttributes } from "./VersusOption";
+import { VersusPublishIssue as _VersusPublishIssue } from "./VersusPublishIssue";
+import type { VersusPublishIssueAttributes, VersusPublishIssueCreationAttributes } from "./VersusPublishIssue";
+import { VersusQuestion as _VersusQuestion } from "./VersusQuestion";
+import type { VersusQuestionAttributes, VersusQuestionCreationAttributes } from "./VersusQuestion";
+import { VersusQuestionVariableType as _VersusQuestionVariableType } from "./VersusQuestionVariableType";
+import type { VersusQuestionVariableTypeAttributes, VersusQuestionVariableTypeCreationAttributes } from "./VersusQuestionVariableType";
+import { VersusVotingListType as _VersusVotingListType } from "./VersusVotingListType";
+import type { VersusVotingListTypeAttributes, VersusVotingListTypeCreationAttributes } from "./VersusVotingListType";
+import { VersusVotingMode as _VersusVotingMode } from "./VersusVotingMode";
+import type { VersusVotingModeAttributes, VersusVotingModeCreationAttributes } from "./VersusVotingMode";
 
 export {
   _AccessControlPreference as AccessControlPreference,
@@ -292,6 +322,7 @@ export {
   _TrackDeletionReason as TrackDeletionReason,
   _UnmatchedAlbum as UnmatchedAlbum,
   _UnmatchedArtist as UnmatchedArtist,
+  _UserAbuseReports as UserAbuseReports,
   _UserAffinity as UserAffinity,
   _UserArtistAffinity as UserArtistAffinity,
   _UserBookmarks as UserBookmarks,
@@ -301,6 +332,20 @@ export {
   _UserGenreAffinity as UserGenreAffinity,
   _UserLikes as UserLikes,
   _UserMessages as UserMessages,
+  _Versus as Versus,
+  _VersusAccessType as VersusAccessType,
+  _VersusCoCreator as VersusCoCreator,
+  _VersusCreatorScope as VersusCreatorScope,
+  _VersusEndMode as VersusEndMode,
+  _VersusEndTimerDuration as VersusEndTimerDuration,
+  _VersusEndVoteThreshold as VersusEndVoteThreshold,
+  _VersusEntityKind as VersusEntityKind,
+  _VersusOption as VersusOption,
+  _VersusPublishIssue as VersusPublishIssue,
+  _VersusQuestion as VersusQuestion,
+  _VersusQuestionVariableType as VersusQuestionVariableType,
+  _VersusVotingListType as VersusVotingListType,
+  _VersusVotingMode as VersusVotingMode,
 };
 
 export type {
@@ -486,6 +531,8 @@ export type {
   UnmatchedAlbumCreationAttributes,
   UnmatchedArtistAttributes,
   UnmatchedArtistCreationAttributes,
+  UserAbuseReportsAttributes,
+  UserAbuseReportsCreationAttributes,
   UserAffinityAttributes,
   UserAffinityCreationAttributes,
   UserArtistAffinityAttributes,
@@ -504,6 +551,34 @@ export type {
   UserLikesCreationAttributes,
   UserMessagesAttributes,
   UserMessagesCreationAttributes,
+  VersusAttributes,
+  VersusCreationAttributes,
+  VersusAccessTypeAttributes,
+  VersusAccessTypeCreationAttributes,
+  VersusCoCreatorAttributes,
+  VersusCoCreatorCreationAttributes,
+  VersusCreatorScopeAttributes,
+  VersusCreatorScopeCreationAttributes,
+  VersusEndModeAttributes,
+  VersusEndModeCreationAttributes,
+  VersusEndTimerDurationAttributes,
+  VersusEndTimerDurationCreationAttributes,
+  VersusEndVoteThresholdAttributes,
+  VersusEndVoteThresholdCreationAttributes,
+  VersusEntityKindAttributes,
+  VersusEntityKindCreationAttributes,
+  VersusOptionAttributes,
+  VersusOptionCreationAttributes,
+  VersusPublishIssueAttributes,
+  VersusPublishIssueCreationAttributes,
+  VersusQuestionAttributes,
+  VersusQuestionCreationAttributes,
+  VersusQuestionVariableTypeAttributes,
+  VersusQuestionVariableTypeCreationAttributes,
+  VersusVotingListTypeAttributes,
+  VersusVotingListTypeCreationAttributes,
+  VersusVotingModeAttributes,
+  VersusVotingModeCreationAttributes,
 };
 
 export function initModels(sequelize: Sequelize) {
@@ -598,6 +673,7 @@ export function initModels(sequelize: Sequelize) {
   const TrackDeletionReason = _TrackDeletionReason.initModel(sequelize);
   const UnmatchedAlbum = _UnmatchedAlbum.initModel(sequelize);
   const UnmatchedArtist = _UnmatchedArtist.initModel(sequelize);
+  const UserAbuseReports = _UserAbuseReports.initModel(sequelize);
   const UserAffinity = _UserAffinity.initModel(sequelize);
   const UserArtistAffinity = _UserArtistAffinity.initModel(sequelize);
   const UserBookmarks = _UserBookmarks.initModel(sequelize);
@@ -607,6 +683,20 @@ export function initModels(sequelize: Sequelize) {
   const UserGenreAffinity = _UserGenreAffinity.initModel(sequelize);
   const UserLikes = _UserLikes.initModel(sequelize);
   const UserMessages = _UserMessages.initModel(sequelize);
+  const Versus = _Versus.initModel(sequelize);
+  const VersusAccessType = _VersusAccessType.initModel(sequelize);
+  const VersusCoCreator = _VersusCoCreator.initModel(sequelize);
+  const VersusCreatorScope = _VersusCreatorScope.initModel(sequelize);
+  const VersusEndMode = _VersusEndMode.initModel(sequelize);
+  const VersusEndTimerDuration = _VersusEndTimerDuration.initModel(sequelize);
+  const VersusEndVoteThreshold = _VersusEndVoteThreshold.initModel(sequelize);
+  const VersusEntityKind = _VersusEntityKind.initModel(sequelize);
+  const VersusOption = _VersusOption.initModel(sequelize);
+  const VersusPublishIssue = _VersusPublishIssue.initModel(sequelize);
+  const VersusQuestion = _VersusQuestion.initModel(sequelize);
+  const VersusQuestionVariableType = _VersusQuestionVariableType.initModel(sequelize);
+  const VersusVotingListType = _VersusVotingListType.initModel(sequelize);
+  const VersusVotingMode = _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" });
@@ -692,6 +782,8 @@ export function initModels(sequelize: 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"});
@@ -712,6 +804,10 @@ export function initModels(sequelize: 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"});
@@ -720,6 +816,10 @@ export function initModels(sequelize: 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"});
@@ -740,6 +840,10 @@ export function initModels(sequelize: 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"});
@@ -758,6 +862,8 @@ export function initModels(sequelize: 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"});
@@ -776,6 +882,10 @@ export function initModels(sequelize: 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"});
@@ -790,6 +900,8 @@ export function initModels(sequelize: 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"});
@@ -812,6 +924,8 @@ export function initModels(sequelize: 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"});
@@ -880,6 +994,12 @@ export function initModels(sequelize: 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"});
@@ -894,6 +1014,12 @@ export function initModels(sequelize: 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"});
@@ -916,6 +1042,12 @@ export function initModels(sequelize: 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"});
@@ -924,6 +1056,8 @@ export function initModels(sequelize: 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"});
@@ -940,12 +1074,16 @@ export function initModels(sequelize: 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"});
@@ -954,10 +1092,44 @@ export function initModels(sequelize: 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,
@@ -1051,6 +1223,7 @@ export function initModels(sequelize: Sequelize) {
     TrackDeletionReason: TrackDeletionReason,
     UnmatchedAlbum: UnmatchedAlbum,
     UnmatchedArtist: UnmatchedArtist,
+    UserAbuseReports: UserAbuseReports,
     UserAffinity: UserAffinity,
     UserArtistAffinity: UserArtistAffinity,
     UserBookmarks: UserBookmarks,
@@ -1060,5 +1233,19 @@ export function initModels(sequelize: 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@earbug/db-models",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {