@earbug/db-models 0.0.41 → 0.0.43

package/models/GuestUser.ts

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

package/models/JukeboxSession.ts

@@ -13,6 +13,7 @@ import type { JukeboxTerminationCondition, JukeboxTerminationConditionId } from
 import type { JukeboxType, JukeboxTypeId } from './JukeboxType';
 import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
 import type { Notification, NotificationId } from './Notification';
+import type { UserAbuseReports, UserAbuseReportsId } from './UserAbuseReports';
 import type { UserBookmarks, UserBookmarksId } from './UserBookmarks';
 import type { UserComments, UserCommentsId } from './UserComments';
 import type { UserLikes, UserLikesId } from './UserLikes';
@@ -159,6 +160,18 @@ export class JukeboxSession extends Model<JukeboxSessionAttributes, JukeboxSessi
   hasNotification!: Sequelize.HasManyHasAssociationMixin<Notification, NotificationId>;
   hasNotifications!: Sequelize.HasManyHasAssociationsMixin<Notification, NotificationId>;
   countNotifications!: Sequelize.HasManyCountAssociationsMixin;
+  // JukeboxSession hasMany UserAbuseReports via jukeboxId
+  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;
   // JukeboxSession hasMany UserBookmarks via jukeboxId
   userBookmarks!: UserBookmarks[];
   getUserBookmarks!: Sequelize.HasManyGetAssociationsMixin<UserBookmarks>;

package/models/PlatformAlbum.ts

@@ -17,6 +17,9 @@ import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
 import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
 import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum';
 import type { UnmatchedAlbum, UnmatchedAlbumId } from './UnmatchedAlbum';
+import type { Versus, VersusId } from './Versus';
+import type { VersusOption, VersusOptionId } from './VersusOption';
+import type { VersusPublishIssue, VersusPublishIssueId } from './VersusPublishIssue';
 
 export interface PlatformAlbumAttributes {
   platformId: number;
@@ -253,6 +256,42 @@ export class PlatformAlbum extends Model<PlatformAlbumAttributes, PlatformAlbumC
   hasUnmatchedAlbum!: Sequelize.HasManyHasAssociationMixin<UnmatchedAlbum, UnmatchedAlbumId>;
   hasUnmatchedAlbums!: Sequelize.HasManyHasAssociationsMixin<UnmatchedAlbum, UnmatchedAlbumId>;
   countUnmatchedAlbums!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformAlbum hasMany Versus via platformAlbumId
+  versus!: Versus[];
+  getVersus!: Sequelize.HasManyGetAssociationsMixin<Versus>;
+  setVersus!: Sequelize.HasManySetAssociationsMixin<Versus, VersusId>;
+  addVersu!: Sequelize.HasManyAddAssociationMixin<Versus, VersusId>;
+  addVersus!: Sequelize.HasManyAddAssociationsMixin<Versus, VersusId>;
+  createVersu!: Sequelize.HasManyCreateAssociationMixin<Versus>;
+  removeVersu!: Sequelize.HasManyRemoveAssociationMixin<Versus, VersusId>;
+  removeVersus!: Sequelize.HasManyRemoveAssociationsMixin<Versus, VersusId>;
+  hasVersu!: Sequelize.HasManyHasAssociationMixin<Versus, VersusId>;
+  hasVersus!: Sequelize.HasManyHasAssociationsMixin<Versus, VersusId>;
+  countVersus!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformAlbum hasMany VersusOption via platformAlbumId
+  versusOptions!: VersusOption[];
+  getVersusOptions!: Sequelize.HasManyGetAssociationsMixin<VersusOption>;
+  setVersusOptions!: Sequelize.HasManySetAssociationsMixin<VersusOption, VersusOptionId>;
+  addVersusOption!: Sequelize.HasManyAddAssociationMixin<VersusOption, VersusOptionId>;
+  addVersusOptions!: Sequelize.HasManyAddAssociationsMixin<VersusOption, VersusOptionId>;
+  createVersusOption!: Sequelize.HasManyCreateAssociationMixin<VersusOption>;
+  removeVersusOption!: Sequelize.HasManyRemoveAssociationMixin<VersusOption, VersusOptionId>;
+  removeVersusOptions!: Sequelize.HasManyRemoveAssociationsMixin<VersusOption, VersusOptionId>;
+  hasVersusOption!: Sequelize.HasManyHasAssociationMixin<VersusOption, VersusOptionId>;
+  hasVersusOptions!: Sequelize.HasManyHasAssociationsMixin<VersusOption, VersusOptionId>;
+  countVersusOptions!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformAlbum hasMany VersusPublishIssue via platformAlbumId
+  versusPublishIssues!: VersusPublishIssue[];
+  getVersusPublishIssues!: Sequelize.HasManyGetAssociationsMixin<VersusPublishIssue>;
+  setVersusPublishIssues!: Sequelize.HasManySetAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
+  addVersusPublishIssue!: Sequelize.HasManyAddAssociationMixin<VersusPublishIssue, VersusPublishIssueId>;
+  addVersusPublishIssues!: Sequelize.HasManyAddAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
+  createVersusPublishIssue!: Sequelize.HasManyCreateAssociationMixin<VersusPublishIssue>;
+  removeVersusPublishIssue!: Sequelize.HasManyRemoveAssociationMixin<VersusPublishIssue, VersusPublishIssueId>;
+  removeVersusPublishIssues!: Sequelize.HasManyRemoveAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
+  hasVersusPublishIssue!: Sequelize.HasManyHasAssociationMixin<VersusPublishIssue, VersusPublishIssueId>;
+  hasVersusPublishIssues!: Sequelize.HasManyHasAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
+  countVersusPublishIssues!: Sequelize.HasManyCountAssociationsMixin;
 
   static initModel(sequelize: Sequelize.Sequelize): typeof PlatformAlbum {
     return PlatformAlbum.init({

package/models/PlatformArtist.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;
@@ -223,6 +226,42 @@ export class PlatformArtist extends Model<PlatformArtistAttributes, PlatformArti
   hasPlatformTrackIdPlatformTrackPlatformArtistTrackRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
   hasPlatformTrackIdPlatformTrackPlatformArtistTrackRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
   countPlatformTrackIdPlatformTrackPlatformArtistTrackRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformArtist hasMany Versus via platformArtistId
+  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;
+  // PlatformArtist hasMany VersusOption via platformArtistId
+  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;
+  // PlatformArtist hasMany VersusPublishIssue via platformArtistId
+  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 {
     return PlatformArtist.init({

package/models/PlatformTrack.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;
@@ -188,6 +191,42 @@ export class PlatformTrack extends Model<PlatformTrackAttributes, PlatformTrackC
   hasPlatformUserPlaylistTrack!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
   hasPlatformUserPlaylistTracks!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
   countPlatformUserPlaylistTracks!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformTrack hasMany Versus via platformTrackId
+  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;
+  // PlatformTrack hasMany VersusOption via platformTrackId
+  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;
+  // PlatformTrack hasMany VersusPublishIssue via platformTrackId
+  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 {
     return PlatformTrack.init({

package/models/PlatformUserPlaylist.ts

@@ -6,6 +6,7 @@ import type { PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffi
 import type { PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId } from './PlatformUserPlaylistGenreAffinity';
 import type { PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId } from './PlatformUserPlaylistTrack';
 import type { State, StateId } from './State';
+import type { UserAbuseReports, UserAbuseReportsId } from './UserAbuseReports';
 import type { UserBookmarks, UserBookmarksId } from './UserBookmarks';
 import type { UserComments, UserCommentsId } from './UserComments';
 import type { UserLikes, UserLikesId } from './UserLikes';
@@ -92,6 +93,18 @@ export class PlatformUserPlaylist extends Model<PlatformUserPlaylistAttributes,
   hasPlatformUserPlaylistTrack!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
   hasPlatformUserPlaylistTracks!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
   countPlatformUserPlaylistTracks!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformUserPlaylist hasMany UserAbuseReports via playlistId
+  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;
   // PlatformUserPlaylist hasMany UserBookmarks via playlistId
   userBookmarks!: UserBookmarks[];
   getUserBookmarks!: Sequelize.HasManyGetAssociationsMixin<UserBookmarks>;

package/models/RadioShow.ts

@@ -5,6 +5,7 @@ import type { RadioShowGenres, RadioShowGenresId } from './RadioShowGenres';
 import type { RadioShowMedia, RadioShowMediaId } from './RadioShowMedia';
 import type { RadioShowPlacement, RadioShowPlacementId } from './RadioShowPlacement';
 import type { RadioShowPublishRequests, RadioShowPublishRequestsId } from './RadioShowPublishRequests';
+import type { UserAbuseReports, UserAbuseReportsId } from './UserAbuseReports';
 import type { UserBookmarks, UserBookmarksId } from './UserBookmarks';
 import type { UserComments, UserCommentsId } from './UserComments';
 import type { UserLikes, UserLikesId } from './UserLikes';
@@ -88,6 +89,18 @@ export class RadioShow extends Model<RadioShowAttributes, RadioShowCreationAttri
   hasRadioShowPublishRequest!: Sequelize.HasManyHasAssociationMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
   hasRadioShowPublishRequests!: Sequelize.HasManyHasAssociationsMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
   countRadioShowPublishRequests!: Sequelize.HasManyCountAssociationsMixin;
+  // RadioShow hasMany UserAbuseReports via radioShowId
+  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;
   // RadioShow hasMany UserBookmarks via radioShowId
   userBookmarks!: UserBookmarks[];
   getUserBookmarks!: Sequelize.HasManyGetAssociationsMixin<UserBookmarks>;

package/models/RadioShowMedia.ts

@@ -1,6 +1,7 @@
 import * as Sequelize from 'sequelize';
 import { DataTypes, Model, Optional } from 'sequelize';
 import type { RadioShow, RadioShowId } from './RadioShow';
+import type { UserAbuseReports, UserAbuseReportsId } from './UserAbuseReports';
 
 export interface RadioShowMediaAttributes {
   radioShowId: string;
@@ -51,6 +52,18 @@ export class RadioShowMedia extends Model<RadioShowMediaAttributes, RadioShowMed
   getRadioShow!: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
   setRadioShow!: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
   createRadioShow!: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+  // RadioShowMedia hasMany UserAbuseReports via radioShowMediaId
+  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;
 
   static initModel(sequelize: Sequelize.Sequelize): typeof RadioShowMedia {
     return RadioShowMedia.init({

package/models/UserAbuseReports.ts

@@ -0,0 +1,232 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, 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 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;
+
+  // UserAbuseReports belongsTo AppUser via reporterUserId
+  reporterUser!: AppUser;
+  getReporterUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setReporterUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createReporterUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // UserAbuseReports belongsTo JukeboxSession via jukeboxId
+  jukebox!: JukeboxSession;
+  getJukebox!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+  setJukebox!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  createJukebox!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+  // UserAbuseReports belongsTo PlatformUserPlaylist via playlistId
+  playlist!: PlatformUserPlaylist;
+  getPlaylist!: Sequelize.BelongsToGetAssociationMixin<PlatformUserPlaylist>;
+  setPlaylist!: Sequelize.BelongsToSetAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  createPlaylist!: Sequelize.BelongsToCreateAssociationMixin<PlatformUserPlaylist>;
+  // UserAbuseReports belongsTo RadioShow via radioShowId
+  radioShow!: RadioShow;
+  getRadioShow!: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
+  setRadioShow!: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
+  createRadioShow!: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+  // UserAbuseReports belongsTo RadioShowMedia via radioShowMediaId
+  radioShowMedium!: RadioShowMedia;
+  getRadioShowMedium!: Sequelize.BelongsToGetAssociationMixin<RadioShowMedia>;
+  setRadioShowMedium!: Sequelize.BelongsToSetAssociationMixin<RadioShowMedia, RadioShowMediaId>;
+  createRadioShowMedium!: Sequelize.BelongsToCreateAssociationMixin<RadioShowMedia>;
+  // UserAbuseReports belongsTo UserComments via commentId
+  comment!: UserComments;
+  getComment!: Sequelize.BelongsToGetAssociationMixin<UserComments>;
+  setComment!: Sequelize.BelongsToSetAssociationMixin<UserComments, UserCommentsId>;
+  createComment!: Sequelize.BelongsToCreateAssociationMixin<UserComments>;
+  // UserAbuseReports belongsTo UserMessages via directMessageId
+  directMessage!: UserMessages;
+  getDirectMessage!: Sequelize.BelongsToGetAssociationMixin<UserMessages>;
+  setDirectMessage!: Sequelize.BelongsToSetAssociationMixin<UserMessages, UserMessagesId>;
+  createDirectMessage!: Sequelize.BelongsToCreateAssociationMixin<UserMessages>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof UserAbuseReports {
+    return UserAbuseReports.init({
+    reporterUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'reporter_user_id'
+    },
+    jukeboxId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      field: 'jukebox_id'
+    },
+    jukeboxChatMessageId: {
+      type: DataTypes.STRING(50),
+      allowNull: true,
+      field: 'jukebox_chat_message_id'
+    },
+    radioShowId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'radio_show',
+        key: 'id'
+      },
+      field: 'radio_show_id'
+    },
+    radioShowMediaId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'radio_show_media',
+        key: 'id'
+      },
+      field: 'radio_show_media_id'
+    },
+    playlistId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'platform_user_playlist',
+        key: 'id'
+      },
+      field: 'playlist_id'
+    },
+    versusThemeTextId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      field: 'versus_theme_text_id'
+    },
+    commentId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'user_comments',
+        key: 'id'
+      },
+      field: 'comment_id'
+    },
+    directMessageId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'user_messages',
+        key: 'id'
+      },
+      field: 'direct_message_id'
+    },
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    reportDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'report_date'
+    },
+    updateDate: {
+      type: 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" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/UserComments.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;
@@ -63,6 +64,18 @@ export class UserComments extends Model<UserCommentsAttributes, UserCommentsCrea
   getRadioShow!: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
   setRadioShow!: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
   createRadioShow!: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+  // UserComments hasMany UserAbuseReports via commentId
+  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;
   // UserComments belongsTo UserComments via replyCommentId
   replyComment!: UserComments;
   getReplyComment!: Sequelize.BelongsToGetAssociationMixin<UserComments>;