@earbug/db-models 0.0.41 → 0.0.42

package/models/init-models.ts

@@ -199,6 +199,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,
@@ -301,6 +329,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 {
@@ -504,6 +546,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) {
@@ -607,6 +677,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" });
@@ -712,6 +796,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 +808,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 +832,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 +854,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 +874,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 +892,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"});
@@ -880,6 +984,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 +1004,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 +1032,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"});
@@ -958,6 +1080,36 @@ export function initModels(sequelize: 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,
@@ -1060,5 +1212,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.42",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {