@earbug/db-models 0.0.41 → 0.0.43

package/dist/UserAbuseReports.d.ts

@@ -0,0 +1,70 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+import type { RadioShow, RadioShowId } from './RadioShow';
+import type { RadioShowMedia, RadioShowMediaId } from './RadioShowMedia';
+import type { UserComments, UserCommentsId } from './UserComments';
+import type { UserMessages, UserMessagesId } from './UserMessages';
+export interface UserAbuseReportsAttributes {
+    reporterUserId: string;
+    jukeboxId?: string;
+    jukeboxChatMessageId?: string;
+    radioShowId?: string;
+    radioShowMediaId?: string;
+    playlistId?: string;
+    versusThemeTextId?: string;
+    commentId?: string;
+    directMessageId?: string;
+    id: string;
+    reportDate: Date;
+    updateDate: Date;
+}
+export type UserAbuseReportsPk = "id";
+export type UserAbuseReportsId = UserAbuseReports[UserAbuseReportsPk];
+export type UserAbuseReportsOptionalAttributes = "jukeboxId" | "jukeboxChatMessageId" | "radioShowId" | "radioShowMediaId" | "playlistId" | "versusThemeTextId" | "commentId" | "directMessageId" | "id" | "reportDate" | "updateDate";
+export type UserAbuseReportsCreationAttributes = Optional<UserAbuseReportsAttributes, UserAbuseReportsOptionalAttributes>;
+export declare class UserAbuseReports extends Model<UserAbuseReportsAttributes, UserAbuseReportsCreationAttributes> implements UserAbuseReportsAttributes {
+    reporterUserId: string;
+    jukeboxId?: string;
+    jukeboxChatMessageId?: string;
+    radioShowId?: string;
+    radioShowMediaId?: string;
+    playlistId?: string;
+    versusThemeTextId?: string;
+    commentId?: string;
+    directMessageId?: string;
+    id: string;
+    reportDate: Date;
+    updateDate: Date;
+    reporterUser: AppUser;
+    getReporterUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setReporterUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createReporterUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    jukebox: JukeboxSession;
+    getJukebox: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+    setJukebox: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    createJukebox: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+    playlist: PlatformUserPlaylist;
+    getPlaylist: Sequelize.BelongsToGetAssociationMixin<PlatformUserPlaylist>;
+    setPlaylist: Sequelize.BelongsToSetAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    createPlaylist: Sequelize.BelongsToCreateAssociationMixin<PlatformUserPlaylist>;
+    radioShow: RadioShow;
+    getRadioShow: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
+    setRadioShow: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
+    createRadioShow: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+    radioShowMedium: RadioShowMedia;
+    getRadioShowMedium: Sequelize.BelongsToGetAssociationMixin<RadioShowMedia>;
+    setRadioShowMedium: Sequelize.BelongsToSetAssociationMixin<RadioShowMedia, RadioShowMediaId>;
+    createRadioShowMedium: Sequelize.BelongsToCreateAssociationMixin<RadioShowMedia>;
+    comment: UserComments;
+    getComment: Sequelize.BelongsToGetAssociationMixin<UserComments>;
+    setComment: Sequelize.BelongsToSetAssociationMixin<UserComments, UserCommentsId>;
+    createComment: Sequelize.BelongsToCreateAssociationMixin<UserComments>;
+    directMessage: UserMessages;
+    getDirectMessage: Sequelize.BelongsToGetAssociationMixin<UserMessages>;
+    setDirectMessage: Sequelize.BelongsToSetAssociationMixin<UserMessages, UserMessagesId>;
+    createDirectMessage: Sequelize.BelongsToCreateAssociationMixin<UserMessages>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UserAbuseReports;
+}

package/dist/UserAbuseReports.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAbuseReports = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class UserAbuseReports extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return UserAbuseReports.init({
+            reporterUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                field: 'reporter_user_id'
+            },
+            jukeboxId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'jukebox_session',
+                    key: 'id'
+                },
+                field: 'jukebox_id'
+            },
+            jukeboxChatMessageId: {
+                type: sequelize_1.DataTypes.STRING(50),
+                allowNull: true,
+                field: 'jukebox_chat_message_id'
+            },
+            radioShowId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'radio_show',
+                    key: 'id'
+                },
+                field: 'radio_show_id'
+            },
+            radioShowMediaId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'radio_show_media',
+                    key: 'id'
+                },
+                field: 'radio_show_media_id'
+            },
+            playlistId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'platform_user_playlist',
+                    key: 'id'
+                },
+                field: 'playlist_id'
+            },
+            versusThemeTextId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                field: 'versus_theme_text_id'
+            },
+            commentId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'user_comments',
+                    key: 'id'
+                },
+                field: 'comment_id'
+            },
+            directMessageId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'user_messages',
+                    key: 'id'
+                },
+                field: 'direct_message_id'
+            },
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            reportDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'report_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            }
+        }, {
+            sequelize,
+            tableName: 'user_abuse_reports',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "idx_user_abuse_reports_comment",
+                    fields: [
+                        { name: "comment_id" },
+                    ]
+                },
+                {
+                    name: "idx_user_abuse_reports_direct_message",
+                    fields: [
+                        { name: "direct_message_id" },
+                    ]
+                },
+                {
+                    name: "idx_user_abuse_reports_jukebox",
+                    fields: [
+                        { name: "jukebox_id" },
+                    ]
+                },
+                {
+                    name: "idx_user_abuse_reports_playlist",
+                    fields: [
+                        { name: "playlist_id" },
+                    ]
+                },
+                {
+                    name: "idx_user_abuse_reports_radio_show",
+                    fields: [
+                        { name: "radio_show_id" },
+                    ]
+                },
+                {
+                    name: "idx_user_abuse_reports_radio_show_media",
+                    fields: [
+                        { name: "radio_show_media_id" },
+                    ]
+                },
+                {
+                    name: "idx_user_abuse_reports_reporter",
+                    fields: [
+                        { name: "reporter_user_id" },
+                    ]
+                },
+                {
+                    name: "user_abuse_reports_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.UserAbuseReports = UserAbuseReports;

package/dist/UserComments.d.ts

@@ -4,6 +4,7 @@ import type { AppUser, AppUserId } from './AppUser';
 import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
 import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
 import type { RadioShow, RadioShowId } from './RadioShow';
+import type { UserAbuseReports, UserAbuseReportsId } from './UserAbuseReports';
 export interface UserCommentsAttributes {
     appUserId: string;
     jukeboxId?: string;
@@ -55,6 +56,17 @@ export declare class UserComments extends Model<UserCommentsAttributes, UserComm
     getRadioShow: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
     setRadioShow: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
     createRadioShow: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+    userAbuseReports: UserAbuseReports[];
+    getUserAbuseReports: Sequelize.HasManyGetAssociationsMixin<UserAbuseReports>;
+    setUserAbuseReports: Sequelize.HasManySetAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+    addUserAbuseReport: Sequelize.HasManyAddAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+    addUserAbuseReports: Sequelize.HasManyAddAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+    createUserAbuseReport: Sequelize.HasManyCreateAssociationMixin<UserAbuseReports>;
+    removeUserAbuseReport: Sequelize.HasManyRemoveAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+    removeUserAbuseReports: Sequelize.HasManyRemoveAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+    hasUserAbuseReport: Sequelize.HasManyHasAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+    hasUserAbuseReports: Sequelize.HasManyHasAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+    countUserAbuseReports: Sequelize.HasManyCountAssociationsMixin;
     replyComment: UserComments;
     getReplyComment: Sequelize.BelongsToGetAssociationMixin<UserComments>;
     setReplyComment: Sequelize.BelongsToSetAssociationMixin<UserComments, UserCommentsId>;

package/dist/UserMessages.d.ts

@@ -1,6 +1,7 @@
 import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
 import type { AppUser, AppUserId } from './AppUser';
+import type { UserAbuseReports, UserAbuseReportsId } from './UserAbuseReports';
 export interface UserMessagesAttributes {
     senderId: string;
     recipientId: string;
@@ -38,6 +39,17 @@ export declare class UserMessages extends Model<UserMessagesAttributes, UserMess
     getSender: Sequelize.BelongsToGetAssociationMixin<AppUser>;
     setSender: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
     createSender: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    userAbuseReports: UserAbuseReports[];
+    getUserAbuseReports: Sequelize.HasManyGetAssociationsMixin<UserAbuseReports>;
+    setUserAbuseReports: Sequelize.HasManySetAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+    addUserAbuseReport: Sequelize.HasManyAddAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+    addUserAbuseReports: Sequelize.HasManyAddAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+    createUserAbuseReport: Sequelize.HasManyCreateAssociationMixin<UserAbuseReports>;
+    removeUserAbuseReport: Sequelize.HasManyRemoveAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+    removeUserAbuseReports: Sequelize.HasManyRemoveAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+    hasUserAbuseReport: Sequelize.HasManyHasAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+    hasUserAbuseReports: Sequelize.HasManyHasAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+    countUserAbuseReports: Sequelize.HasManyCountAssociationsMixin;
     replyMessage: UserMessages;
     getReplyMessage: Sequelize.BelongsToGetAssociationMixin<UserMessages>;
     setReplyMessage: Sequelize.BelongsToSetAssociationMixin<UserMessages, UserMessagesId>;

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;
+}