@earbug/db-models 0.0.41 → 0.0.42

package/dist/AppUser.d.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;
     firstName: string;
@@ -297,6 +299,28 @@ export declare class AppUser extends Model<AppUserAttributes, AppUserCreationAtt
     hasSenderUserMessage: Sequelize.HasManyHasAssociationMixin<UserMessages, UserMessagesId>;
     hasSenderUserMessages: Sequelize.HasManyHasAssociationsMixin<UserMessages, UserMessagesId>;
     countSenderUserMessages: Sequelize.HasManyCountAssociationsMixin;
+    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;
+    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;
     state: State;
     getState: Sequelize.BelongsToGetAssociationMixin<State>;
     setState: Sequelize.BelongsToSetAssociationMixin<State, StateId>;

package/dist/CanonAlbum.d.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;
     asciiName: string;
@@ -115,5 +117,27 @@ export declare class CanonAlbum extends Model<CanonAlbumAttributes, CanonAlbumCr
     hasPlatformAlbumIdPlatformAlbum: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
     hasPlatformAlbumIdPlatformAlbums: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
     countPlatformAlbumIdPlatformAlbums: Sequelize.BelongsToManyCountAssociationsMixin;
+    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;
+    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;
 }

package/dist/CanonArtist.d.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;
     asciiName: string;
@@ -193,5 +195,27 @@ export declare class CanonArtist extends Model<CanonArtistAttributes, CanonArtis
     hasUserArtistAffinity: Sequelize.HasManyHasAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
     hasUserArtistAffinities: Sequelize.HasManyHasAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
     countUserArtistAffinities: Sequelize.HasManyCountAssociationsMixin;
+    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;
+    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;
 }

package/dist/CanonGenre.d.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;
     asciiName: string;
@@ -177,5 +178,16 @@ export declare class CanonGenre extends Model<CanonGenreAttributes, CanonGenreCr
     hasUserGenreAffinity: Sequelize.HasManyHasAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
     hasUserGenreAffinities: Sequelize.HasManyHasAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
     countUserGenreAffinities: Sequelize.HasManyCountAssociationsMixin;
+    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;
 }

package/dist/CanonTrack.d.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;
     asciiName: string;
@@ -121,5 +123,27 @@ export declare class CanonTrack extends Model<CanonTrackAttributes, CanonTrackCr
     hasRadioShowPlacement: Sequelize.HasManyHasAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
     hasRadioShowPlacements: Sequelize.HasManyHasAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
     countRadioShowPlacements: Sequelize.HasManyCountAssociationsMixin;
+    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;
+    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;
 }

package/dist/GuestUser.d.ts

@@ -2,27 +2,31 @@ import * as Sequelize from 'sequelize';
 import { 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 declare 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;
     jukeboxQueueEntries: JukeboxQueueEntry[];
     getJukeboxQueueEntries: Sequelize.HasManyGetAssociationsMixin<JukeboxQueueEntry>;
     setJukeboxQueueEntries: Sequelize.HasManySetAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
@@ -34,9 +38,24 @@ export declare class GuestUser extends Model<GuestUserAttributes, GuestUserCreat
     hasJukeboxQueueEntry: Sequelize.HasManyHasAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
     hasJukeboxQueueEntries: Sequelize.HasManyHasAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
     countJukeboxQueueEntries: Sequelize.HasManyCountAssociationsMixin;
+    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;
     jukeboxSession: JukeboxSession;
     getJukeboxSession: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
     setJukeboxSession: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
     createJukeboxSession: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+    versu: Versus;
+    getVersu: Sequelize.BelongsToGetAssociationMixin<Versus>;
+    setVersu: Sequelize.BelongsToSetAssociationMixin<Versus, VersusId>;
+    createVersu: Sequelize.BelongsToCreateAssociationMixin<Versus>;
     static initModel(sequelize: Sequelize.Sequelize): typeof GuestUser;
 }

package/dist/GuestUser.js

@@ -29,6 +29,15 @@ const sequelize_1 = require("sequelize");
 class GuestUser extends sequelize_1.Model {
     static initModel(sequelize) {
         return GuestUser.init({
+            jukeboxSessionId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'jukebox_session',
+                    key: 'id'
+                },
+                field: 'jukebox_session_id'
+            },
             firstName: {
                 type: sequelize_1.DataTypes.TEXT,
                 allowNull: false,
@@ -39,15 +48,6 @@ class GuestUser extends sequelize_1.Model {
                 allowNull: true,
                 field: 'last_name'
             },
-            jukeboxSessionId: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'jukebox_session',
-                    key: 'id'
-                },
-                field: 'jukebox_session_id'
-            },
             ipAddress: {
                 type: sequelize_1.DataTypes.TEXT,
                 allowNull: true,
@@ -70,6 +70,15 @@ class GuestUser extends sequelize_1.Model {
                 allowNull: false,
                 defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
                 field: 'update_date'
+            },
+            versusId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'versus',
+                    key: 'id'
+                },
+                field: 'versus_id'
             }
         }, {
             sequelize,
@@ -90,6 +99,12 @@ class GuestUser extends sequelize_1.Model {
                         { name: "jukebox_session_id" },
                     ]
                 },
+                {
+                    name: "idx_guest_user_versus",
+                    fields: [
+                        { name: "versus_id" },
+                    ]
+                },
             ]
         });
     }

package/dist/PlatformAlbum.d.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;
     externalAlbumId: string;
@@ -232,5 +235,38 @@ export declare class PlatformAlbum extends Model<PlatformAlbumAttributes, Platfo
     hasUnmatchedAlbum: Sequelize.HasManyHasAssociationMixin<UnmatchedAlbum, UnmatchedAlbumId>;
     hasUnmatchedAlbums: Sequelize.HasManyHasAssociationsMixin<UnmatchedAlbum, UnmatchedAlbumId>;
     countUnmatchedAlbums: Sequelize.HasManyCountAssociationsMixin;
+    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;
+    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;
+    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;
 }

package/dist/PlatformArtist.d.ts

@@ -15,6 +15,9 @@ import type { PlatformArtistGenreRelation, PlatformArtistGenreRelationId } from
 import type { PlatformArtistTrackRelation, PlatformArtistTrackRelationId } from './PlatformArtistTrackRelation';
 import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
 import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { Versus, VersusId } from './Versus';
+import type { VersusOption, VersusOptionId } from './VersusOption';
+import type { VersusPublishIssue, VersusPublishIssueId } from './VersusPublishIssue';
 export interface PlatformArtistAttributes {
     externalArtistId: string;
     platformId: number;
@@ -204,5 +207,38 @@ export declare class PlatformArtist extends Model<PlatformArtistAttributes, Plat
     hasPlatformTrackIdPlatformTrackPlatformArtistTrackRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
     hasPlatformTrackIdPlatformTrackPlatformArtistTrackRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
     countPlatformTrackIdPlatformTrackPlatformArtistTrackRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    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;
+    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;
+    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 PlatformArtist;
 }

package/dist/PlatformTrack.d.ts

@@ -12,6 +12,9 @@ import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
 import type { PlatformTrackGenreRelation, PlatformTrackGenreRelationId } from './PlatformTrackGenreRelation';
 import type { PlatformUserAlbumTrack, PlatformUserAlbumTrackId } from './PlatformUserAlbumTrack';
 import type { PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId } from './PlatformUserPlaylistTrack';
+import type { Versus, VersusId } from './Versus';
+import type { VersusOption, VersusOptionId } from './VersusOption';
+import type { VersusPublishIssue, VersusPublishIssueId } from './VersusPublishIssue';
 export interface PlatformTrackAttributes {
     platformId: number;
     externalTrackId: string;
@@ -172,5 +175,38 @@ export declare class PlatformTrack extends Model<PlatformTrackAttributes, Platfo
     hasPlatformUserPlaylistTrack: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
     hasPlatformUserPlaylistTracks: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
     countPlatformUserPlaylistTracks: Sequelize.HasManyCountAssociationsMixin;
+    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;
+    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;
+    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 PlatformTrack;
 }

package/dist/Versus.d.ts

@@ -0,0 +1,182 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { GuestUser, GuestUserId } from './GuestUser';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { VersusAccessType, VersusAccessTypeId } from './VersusAccessType';
+import type { VersusCoCreator, VersusCoCreatorId } from './VersusCoCreator';
+import type { VersusCreatorScope, VersusCreatorScopeId } from './VersusCreatorScope';
+import type { VersusEndMode, VersusEndModeId } from './VersusEndMode';
+import type { VersusEndTimerDuration, VersusEndTimerDurationId } from './VersusEndTimerDuration';
+import type { VersusEndVoteThreshold, VersusEndVoteThresholdId } from './VersusEndVoteThreshold';
+import type { VersusOption, VersusOptionId } from './VersusOption';
+import type { VersusPublishIssue, VersusPublishIssueId } from './VersusPublishIssue';
+import type { VersusQuestion, VersusQuestionId } from './VersusQuestion';
+import type { VersusVotingMode, VersusVotingModeId } from './VersusVotingMode';
+export interface VersusAttributes {
+    versusQuestionId: string;
+    canonTrackId?: string;
+    platformTrackId?: string;
+    canonAlbumId?: string;
+    platformAlbumId?: string;
+    canonArtistId?: string;
+    platformArtistId?: string;
+    canonGenreId?: string;
+    themeText?: string;
+    versusAccessTypeId: number;
+    versusCreatorScopeId: number;
+    versusVotingModeId: number;
+    versusEndModeId: number;
+    versusEndVoteThresholdId?: number;
+    versusEndTimerDurationId?: number;
+    startsAt?: Date;
+    endsAt?: Date;
+    creatorUserId: string;
+    publishedAt?: Date;
+    id: string;
+    publishRequested: boolean;
+    deleted: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type VersusPk = "id";
+export type VersusId = Versus[VersusPk];
+export type VersusOptionalAttributes = "canonTrackId" | "platformTrackId" | "canonAlbumId" | "platformAlbumId" | "canonArtistId" | "platformArtistId" | "canonGenreId" | "themeText" | "versusEndVoteThresholdId" | "versusEndTimerDurationId" | "startsAt" | "endsAt" | "publishedAt" | "id" | "createdAt" | "updatedAt";
+export type VersusCreationAttributes = Optional<VersusAttributes, VersusOptionalAttributes>;
+export declare class Versus extends Model<VersusAttributes, VersusCreationAttributes> implements VersusAttributes {
+    versusQuestionId: string;
+    canonTrackId?: string;
+    platformTrackId?: string;
+    canonAlbumId?: string;
+    platformAlbumId?: string;
+    canonArtistId?: string;
+    platformArtistId?: string;
+    canonGenreId?: string;
+    themeText?: string;
+    versusAccessTypeId: number;
+    versusCreatorScopeId: number;
+    versusVotingModeId: number;
+    versusEndModeId: number;
+    versusEndVoteThresholdId?: number;
+    versusEndTimerDurationId?: number;
+    startsAt?: Date;
+    endsAt?: Date;
+    creatorUserId: string;
+    publishedAt?: Date;
+    id: string;
+    publishRequested: boolean;
+    deleted: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    creatorUser: AppUser;
+    getCreatorUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setCreatorUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createCreatorUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    canonAlbum: CanonAlbum;
+    getCanonAlbum: Sequelize.BelongsToGetAssociationMixin<CanonAlbum>;
+    setCanonAlbum: Sequelize.BelongsToSetAssociationMixin<CanonAlbum, CanonAlbumId>;
+    createCanonAlbum: Sequelize.BelongsToCreateAssociationMixin<CanonAlbum>;
+    canonArtist: CanonArtist;
+    getCanonArtist: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+    setCanonArtist: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+    createCanonArtist: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+    canonGenre: CanonGenre;
+    getCanonGenre: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+    setCanonGenre: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+    createCanonGenre: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+    canonTrack: CanonTrack;
+    getCanonTrack: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
+    setCanonTrack: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
+    createCanonTrack: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+    platformAlbum: PlatformAlbum;
+    getPlatformAlbum: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+    setPlatformAlbum: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    createPlatformAlbum: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+    platformArtist: PlatformArtist;
+    getPlatformArtist: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+    setPlatformArtist: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+    createPlatformArtist: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+    platformTrack: PlatformTrack;
+    getPlatformTrack: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+    setPlatformTrack: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrack: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+    guestUsers: GuestUser[];
+    getGuestUsers: Sequelize.HasManyGetAssociationsMixin<GuestUser>;
+    setGuestUsers: Sequelize.HasManySetAssociationsMixin<GuestUser, GuestUserId>;
+    addGuestUser: Sequelize.HasManyAddAssociationMixin<GuestUser, GuestUserId>;
+    addGuestUsers: Sequelize.HasManyAddAssociationsMixin<GuestUser, GuestUserId>;
+    createGuestUser: Sequelize.HasManyCreateAssociationMixin<GuestUser>;
+    removeGuestUser: Sequelize.HasManyRemoveAssociationMixin<GuestUser, GuestUserId>;
+    removeGuestUsers: Sequelize.HasManyRemoveAssociationsMixin<GuestUser, GuestUserId>;
+    hasGuestUser: Sequelize.HasManyHasAssociationMixin<GuestUser, GuestUserId>;
+    hasGuestUsers: Sequelize.HasManyHasAssociationsMixin<GuestUser, GuestUserId>;
+    countGuestUsers: Sequelize.HasManyCountAssociationsMixin;
+    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;
+    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;
+    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;
+    versusAccessType: VersusAccessType;
+    getVersusAccessType: Sequelize.BelongsToGetAssociationMixin<VersusAccessType>;
+    setVersusAccessType: Sequelize.BelongsToSetAssociationMixin<VersusAccessType, VersusAccessTypeId>;
+    createVersusAccessType: Sequelize.BelongsToCreateAssociationMixin<VersusAccessType>;
+    versusCreatorScope: VersusCreatorScope;
+    getVersusCreatorScope: Sequelize.BelongsToGetAssociationMixin<VersusCreatorScope>;
+    setVersusCreatorScope: Sequelize.BelongsToSetAssociationMixin<VersusCreatorScope, VersusCreatorScopeId>;
+    createVersusCreatorScope: Sequelize.BelongsToCreateAssociationMixin<VersusCreatorScope>;
+    versusEndMode: VersusEndMode;
+    getVersusEndMode: Sequelize.BelongsToGetAssociationMixin<VersusEndMode>;
+    setVersusEndMode: Sequelize.BelongsToSetAssociationMixin<VersusEndMode, VersusEndModeId>;
+    createVersusEndMode: Sequelize.BelongsToCreateAssociationMixin<VersusEndMode>;
+    versusEndTimerDuration: VersusEndTimerDuration;
+    getVersusEndTimerDuration: Sequelize.BelongsToGetAssociationMixin<VersusEndTimerDuration>;
+    setVersusEndTimerDuration: Sequelize.BelongsToSetAssociationMixin<VersusEndTimerDuration, VersusEndTimerDurationId>;
+    createVersusEndTimerDuration: Sequelize.BelongsToCreateAssociationMixin<VersusEndTimerDuration>;
+    versusEndVoteThreshold: VersusEndVoteThreshold;
+    getVersusEndVoteThreshold: Sequelize.BelongsToGetAssociationMixin<VersusEndVoteThreshold>;
+    setVersusEndVoteThreshold: Sequelize.BelongsToSetAssociationMixin<VersusEndVoteThreshold, VersusEndVoteThresholdId>;
+    createVersusEndVoteThreshold: Sequelize.BelongsToCreateAssociationMixin<VersusEndVoteThreshold>;
+    versusQuestion: VersusQuestion;
+    getVersusQuestion: Sequelize.BelongsToGetAssociationMixin<VersusQuestion>;
+    setVersusQuestion: Sequelize.BelongsToSetAssociationMixin<VersusQuestion, VersusQuestionId>;
+    createVersusQuestion: Sequelize.BelongsToCreateAssociationMixin<VersusQuestion>;
+    versusVotingMode: VersusVotingMode;
+    getVersusVotingMode: Sequelize.BelongsToGetAssociationMixin<VersusVotingMode>;
+    setVersusVotingMode: Sequelize.BelongsToSetAssociationMixin<VersusVotingMode, VersusVotingModeId>;
+    createVersusVotingMode: Sequelize.BelongsToCreateAssociationMixin<VersusVotingMode>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof Versus;
+}