@earbug/db-models 0.0.59 → 0.0.62

package/models/JukeboxSession.ts

@@ -1,334 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { GuestUser, GuestUserId } from './GuestUser';
-import type { JukeboxAccessType, JukeboxAccessTypeId } from './JukeboxAccessType';
-import type { JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId } from './JukeboxCanonGenreRelation';
-import type { JukeboxInvite, JukeboxInviteId } from './JukeboxInvite';
-import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
-import type { JukeboxQueueMode, JukeboxQueueModeId } from './JukeboxQueueMode';
-import type { JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId } from './JukeboxSessionArtistAffinity';
-import type { JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId } from './JukeboxSessionGenreAffinity';
-import type { JukeboxStatus, JukeboxStatusId } from './JukeboxStatus';
-import type { JukeboxTerminationCondition, JukeboxTerminationConditionId } from './JukeboxTerminationCondition';
-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';
-
-export interface JukeboxSessionAttributes {
-  typeId: number;
-  accessTypeId: number;
-  terminationConditionId: number;
-  jukeboxQueueModeId: number;
-  trackQueue?: string[];
-  stateMachineArn?: string;
-  id: string;
-  createdAt: Date;
-  updatedAt: Date;
-  description?: string;
-  jukeboxStatusId: number;
-  durationMs: number;
-  pausedAt?: Date;
-}
-
-export type JukeboxSessionPk = "id";
-export type JukeboxSessionId = JukeboxSession[JukeboxSessionPk];
-export type JukeboxSessionOptionalAttributes = "trackQueue" | "stateMachineArn" | "id" | "createdAt" | "updatedAt" | "description" | "jukeboxStatusId" | "durationMs" | "pausedAt";
-export type JukeboxSessionCreationAttributes = Optional<JukeboxSessionAttributes, JukeboxSessionOptionalAttributes>;
-
-export class JukeboxSession extends Model<JukeboxSessionAttributes, JukeboxSessionCreationAttributes> implements JukeboxSessionAttributes {
-  typeId!: number;
-  accessTypeId!: number;
-  terminationConditionId!: number;
-  jukeboxQueueModeId!: number;
-  trackQueue?: string[];
-  stateMachineArn?: string;
-  id!: string;
-  createdAt!: Date;
-  updatedAt!: Date;
-  description?: string;
-  jukeboxStatusId!: number;
-  durationMs!: number;
-  pausedAt?: Date;
-
-  // JukeboxSession belongsTo JukeboxAccessType via accessTypeId
-  accessType!: JukeboxAccessType;
-  getAccessType!: Sequelize.BelongsToGetAssociationMixin<JukeboxAccessType>;
-  setAccessType!: Sequelize.BelongsToSetAssociationMixin<JukeboxAccessType, JukeboxAccessTypeId>;
-  createAccessType!: Sequelize.BelongsToCreateAssociationMixin<JukeboxAccessType>;
-  // JukeboxSession belongsTo JukeboxQueueMode via jukeboxQueueModeId
-  jukeboxQueueMode!: JukeboxQueueMode;
-  getJukeboxQueueMode!: Sequelize.BelongsToGetAssociationMixin<JukeboxQueueMode>;
-  setJukeboxQueueMode!: Sequelize.BelongsToSetAssociationMixin<JukeboxQueueMode, JukeboxQueueModeId>;
-  createJukeboxQueueMode!: Sequelize.BelongsToCreateAssociationMixin<JukeboxQueueMode>;
-  // JukeboxSession hasMany GuestUser via jukeboxSessionId
-  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;
-  // JukeboxSession hasMany JukeboxCanonGenreRelation via jukeboxSessionId
-  jukeboxCanonGenreRelations!: JukeboxCanonGenreRelation[];
-  getJukeboxCanonGenreRelations!: Sequelize.HasManyGetAssociationsMixin<JukeboxCanonGenreRelation>;
-  setJukeboxCanonGenreRelations!: Sequelize.HasManySetAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
-  addJukeboxCanonGenreRelation!: Sequelize.HasManyAddAssociationMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
-  addJukeboxCanonGenreRelations!: Sequelize.HasManyAddAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
-  createJukeboxCanonGenreRelation!: Sequelize.HasManyCreateAssociationMixin<JukeboxCanonGenreRelation>;
-  removeJukeboxCanonGenreRelation!: Sequelize.HasManyRemoveAssociationMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
-  removeJukeboxCanonGenreRelations!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
-  hasJukeboxCanonGenreRelation!: Sequelize.HasManyHasAssociationMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
-  hasJukeboxCanonGenreRelations!: Sequelize.HasManyHasAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
-  countJukeboxCanonGenreRelations!: Sequelize.HasManyCountAssociationsMixin;
-  // JukeboxSession hasMany JukeboxInvite via jukeboxSessionId
-  jukeboxInvites!: JukeboxInvite[];
-  getJukeboxInvites!: Sequelize.HasManyGetAssociationsMixin<JukeboxInvite>;
-  setJukeboxInvites!: Sequelize.HasManySetAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
-  addJukeboxInvite!: Sequelize.HasManyAddAssociationMixin<JukeboxInvite, JukeboxInviteId>;
-  addJukeboxInvites!: Sequelize.HasManyAddAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
-  createJukeboxInvite!: Sequelize.HasManyCreateAssociationMixin<JukeboxInvite>;
-  removeJukeboxInvite!: Sequelize.HasManyRemoveAssociationMixin<JukeboxInvite, JukeboxInviteId>;
-  removeJukeboxInvites!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
-  hasJukeboxInvite!: Sequelize.HasManyHasAssociationMixin<JukeboxInvite, JukeboxInviteId>;
-  hasJukeboxInvites!: Sequelize.HasManyHasAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
-  countJukeboxInvites!: Sequelize.HasManyCountAssociationsMixin;
-  // JukeboxSession hasMany JukeboxQueueEntry via jukeboxSessionId
-  jukeboxQueueEntries!: JukeboxQueueEntry[];
-  getJukeboxQueueEntries!: Sequelize.HasManyGetAssociationsMixin<JukeboxQueueEntry>;
-  setJukeboxQueueEntries!: Sequelize.HasManySetAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
-  addJukeboxQueueEntry!: Sequelize.HasManyAddAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
-  addJukeboxQueueEntries!: Sequelize.HasManyAddAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
-  createJukeboxQueueEntry!: Sequelize.HasManyCreateAssociationMixin<JukeboxQueueEntry>;
-  removeJukeboxQueueEntry!: Sequelize.HasManyRemoveAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
-  removeJukeboxQueueEntries!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
-  hasJukeboxQueueEntry!: Sequelize.HasManyHasAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
-  hasJukeboxQueueEntries!: Sequelize.HasManyHasAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
-  countJukeboxQueueEntries!: Sequelize.HasManyCountAssociationsMixin;
-  // JukeboxSession hasMany JukeboxSessionArtistAffinity via jukeboxSessionId
-  jukeboxSessionArtistAffinities!: JukeboxSessionArtistAffinity[];
-  getJukeboxSessionArtistAffinities!: Sequelize.HasManyGetAssociationsMixin<JukeboxSessionArtistAffinity>;
-  setJukeboxSessionArtistAffinities!: Sequelize.HasManySetAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
-  addJukeboxSessionArtistAffinity!: Sequelize.HasManyAddAssociationMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
-  addJukeboxSessionArtistAffinities!: Sequelize.HasManyAddAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
-  createJukeboxSessionArtistAffinity!: Sequelize.HasManyCreateAssociationMixin<JukeboxSessionArtistAffinity>;
-  removeJukeboxSessionArtistAffinity!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
-  removeJukeboxSessionArtistAffinities!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
-  hasJukeboxSessionArtistAffinity!: Sequelize.HasManyHasAssociationMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
-  hasJukeboxSessionArtistAffinities!: Sequelize.HasManyHasAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
-  countJukeboxSessionArtistAffinities!: Sequelize.HasManyCountAssociationsMixin;
-  // JukeboxSession hasMany JukeboxSessionGenreAffinity via jukeboxSessionId
-  jukeboxSessionGenreAffinities!: JukeboxSessionGenreAffinity[];
-  getJukeboxSessionGenreAffinities!: Sequelize.HasManyGetAssociationsMixin<JukeboxSessionGenreAffinity>;
-  setJukeboxSessionGenreAffinities!: Sequelize.HasManySetAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
-  addJukeboxSessionGenreAffinity!: Sequelize.HasManyAddAssociationMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
-  addJukeboxSessionGenreAffinities!: Sequelize.HasManyAddAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
-  createJukeboxSessionGenreAffinity!: Sequelize.HasManyCreateAssociationMixin<JukeboxSessionGenreAffinity>;
-  removeJukeboxSessionGenreAffinity!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
-  removeJukeboxSessionGenreAffinities!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
-  hasJukeboxSessionGenreAffinity!: Sequelize.HasManyHasAssociationMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
-  hasJukeboxSessionGenreAffinities!: Sequelize.HasManyHasAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
-  countJukeboxSessionGenreAffinities!: Sequelize.HasManyCountAssociationsMixin;
-  // JukeboxSession hasMany JukeboxUser via jukeboxSessionId
-  jukeboxUsers!: JukeboxUser[];
-  getJukeboxUsers!: Sequelize.HasManyGetAssociationsMixin<JukeboxUser>;
-  setJukeboxUsers!: Sequelize.HasManySetAssociationsMixin<JukeboxUser, JukeboxUserId>;
-  addJukeboxUser!: Sequelize.HasManyAddAssociationMixin<JukeboxUser, JukeboxUserId>;
-  addJukeboxUsers!: Sequelize.HasManyAddAssociationsMixin<JukeboxUser, JukeboxUserId>;
-  createJukeboxUser!: Sequelize.HasManyCreateAssociationMixin<JukeboxUser>;
-  removeJukeboxUser!: Sequelize.HasManyRemoveAssociationMixin<JukeboxUser, JukeboxUserId>;
-  removeJukeboxUsers!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxUser, JukeboxUserId>;
-  hasJukeboxUser!: Sequelize.HasManyHasAssociationMixin<JukeboxUser, JukeboxUserId>;
-  hasJukeboxUsers!: Sequelize.HasManyHasAssociationsMixin<JukeboxUser, JukeboxUserId>;
-  countJukeboxUsers!: Sequelize.HasManyCountAssociationsMixin;
-  // JukeboxSession hasMany Notification via jukeboxSessionId
-  notifications!: Notification[];
-  getNotifications!: Sequelize.HasManyGetAssociationsMixin<Notification>;
-  setNotifications!: Sequelize.HasManySetAssociationsMixin<Notification, NotificationId>;
-  addNotification!: Sequelize.HasManyAddAssociationMixin<Notification, NotificationId>;
-  addNotifications!: Sequelize.HasManyAddAssociationsMixin<Notification, NotificationId>;
-  createNotification!: Sequelize.HasManyCreateAssociationMixin<Notification>;
-  removeNotification!: Sequelize.HasManyRemoveAssociationMixin<Notification, NotificationId>;
-  removeNotifications!: Sequelize.HasManyRemoveAssociationsMixin<Notification, NotificationId>;
-  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>;
-  setUserBookmarks!: Sequelize.HasManySetAssociationsMixin<UserBookmarks, UserBookmarksId>;
-  addUserBookmark!: Sequelize.HasManyAddAssociationMixin<UserBookmarks, UserBookmarksId>;
-  addUserBookmarks!: Sequelize.HasManyAddAssociationsMixin<UserBookmarks, UserBookmarksId>;
-  createUserBookmark!: Sequelize.HasManyCreateAssociationMixin<UserBookmarks>;
-  removeUserBookmark!: Sequelize.HasManyRemoveAssociationMixin<UserBookmarks, UserBookmarksId>;
-  removeUserBookmarks!: Sequelize.HasManyRemoveAssociationsMixin<UserBookmarks, UserBookmarksId>;
-  hasUserBookmark!: Sequelize.HasManyHasAssociationMixin<UserBookmarks, UserBookmarksId>;
-  hasUserBookmarks!: Sequelize.HasManyHasAssociationsMixin<UserBookmarks, UserBookmarksId>;
-  countUserBookmarks!: Sequelize.HasManyCountAssociationsMixin;
-  // JukeboxSession hasMany UserComments via jukeboxId
-  userComments!: UserComments[];
-  getUserComments!: Sequelize.HasManyGetAssociationsMixin<UserComments>;
-  setUserComments!: Sequelize.HasManySetAssociationsMixin<UserComments, UserCommentsId>;
-  addUserComment!: Sequelize.HasManyAddAssociationMixin<UserComments, UserCommentsId>;
-  addUserComments!: Sequelize.HasManyAddAssociationsMixin<UserComments, UserCommentsId>;
-  createUserComment!: Sequelize.HasManyCreateAssociationMixin<UserComments>;
-  removeUserComment!: Sequelize.HasManyRemoveAssociationMixin<UserComments, UserCommentsId>;
-  removeUserComments!: Sequelize.HasManyRemoveAssociationsMixin<UserComments, UserCommentsId>;
-  hasUserComment!: Sequelize.HasManyHasAssociationMixin<UserComments, UserCommentsId>;
-  hasUserComments!: Sequelize.HasManyHasAssociationsMixin<UserComments, UserCommentsId>;
-  countUserComments!: Sequelize.HasManyCountAssociationsMixin;
-  // JukeboxSession hasMany UserLikes via jukeboxId
-  userLikes!: UserLikes[];
-  getUserLikes!: Sequelize.HasManyGetAssociationsMixin<UserLikes>;
-  setUserLikes!: Sequelize.HasManySetAssociationsMixin<UserLikes, UserLikesId>;
-  addUserLike!: Sequelize.HasManyAddAssociationMixin<UserLikes, UserLikesId>;
-  addUserLikes!: Sequelize.HasManyAddAssociationsMixin<UserLikes, UserLikesId>;
-  createUserLike!: Sequelize.HasManyCreateAssociationMixin<UserLikes>;
-  removeUserLike!: Sequelize.HasManyRemoveAssociationMixin<UserLikes, UserLikesId>;
-  removeUserLikes!: Sequelize.HasManyRemoveAssociationsMixin<UserLikes, UserLikesId>;
-  hasUserLike!: Sequelize.HasManyHasAssociationMixin<UserLikes, UserLikesId>;
-  hasUserLikes!: Sequelize.HasManyHasAssociationsMixin<UserLikes, UserLikesId>;
-  countUserLikes!: Sequelize.HasManyCountAssociationsMixin;
-  // JukeboxSession belongsTo JukeboxStatus via jukeboxStatusId
-  jukeboxStatus!: JukeboxStatus;
-  getJukeboxStatus!: Sequelize.BelongsToGetAssociationMixin<JukeboxStatus>;
-  setJukeboxStatus!: Sequelize.BelongsToSetAssociationMixin<JukeboxStatus, JukeboxStatusId>;
-  createJukeboxStatus!: Sequelize.BelongsToCreateAssociationMixin<JukeboxStatus>;
-  // JukeboxSession belongsTo JukeboxTerminationCondition via terminationConditionId
-  terminationCondition!: JukeboxTerminationCondition;
-  getTerminationCondition!: Sequelize.BelongsToGetAssociationMixin<JukeboxTerminationCondition>;
-  setTerminationCondition!: Sequelize.BelongsToSetAssociationMixin<JukeboxTerminationCondition, JukeboxTerminationConditionId>;
-  createTerminationCondition!: Sequelize.BelongsToCreateAssociationMixin<JukeboxTerminationCondition>;
-  // JukeboxSession belongsTo JukeboxType via typeId
-  type!: JukeboxType;
-  getType!: Sequelize.BelongsToGetAssociationMixin<JukeboxType>;
-  setType!: Sequelize.BelongsToSetAssociationMixin<JukeboxType, JukeboxTypeId>;
-  createType!: Sequelize.BelongsToCreateAssociationMixin<JukeboxType>;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxSession {
-    return JukeboxSession.init({
-    typeId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      references: {
-        model: 'jukebox_type',
-        key: 'id'
-      },
-      field: 'type_id'
-    },
-    accessTypeId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      references: {
-        model: 'jukebox_access_type',
-        key: 'id'
-      },
-      field: 'access_type_id'
-    },
-    terminationConditionId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      references: {
-        model: 'jukebox_termination_condition',
-        key: 'id'
-      },
-      field: 'termination_condition_id'
-    },
-    jukeboxQueueModeId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      references: {
-        model: 'jukebox_queue_mode',
-        key: 'id'
-      },
-      field: 'jukebox_queue_mode_id'
-    },
-    trackQueue: {
-      type: DataTypes.ARRAY(DataTypes.TEXT),
-      allowNull: true,
-      field: 'track_queue'
-    },
-    stateMachineArn: {
-      type: DataTypes.STRING(255),
-      allowNull: true,
-      field: 'state_machine_arn'
-    },
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: DataTypes.UUIDV4,
-      primaryKey: true
-    },
-    createdAt: {
-      type: DataTypes.DATE,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
-      field: 'created_at'
-    },
-    updatedAt: {
-      type: DataTypes.DATE,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
-      field: 'updated_at'
-    },
-    description: {
-      type: DataTypes.STRING(512),
-      allowNull: true
-    },
-    jukeboxStatusId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      defaultValue: 0,
-      references: {
-        model: 'jukebox_status',
-        key: 'id'
-      },
-      field: 'jukebox_status_id'
-    },
-    durationMs: {
-      type: DataTypes.INTEGER,
-      allowNull: false,
-      defaultValue: 0,
-      field: 'duration_ms'
-    },
-    pausedAt: {
-      type: DataTypes.DATE,
-      allowNull: true,
-      field: 'paused_at'
-    }
-  }, {
-    sequelize,
-    tableName: 'jukebox_session',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "jukebox_session_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/JukeboxSessionArtistAffinity.ts

@@ -1,136 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { AffinityTier, AffinityTierId } from './AffinityTier';
-import type { CanonArtist, CanonArtistId } from './CanonArtist';
-import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
-
-export interface JukeboxSessionArtistAffinityAttributes {
-  jukeboxSessionId: string;
-  canonArtistId: string;
-  affinityTierId: number;
-  rank: number;
-  id: string;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-export type JukeboxSessionArtistAffinityPk = "id";
-export type JukeboxSessionArtistAffinityId = JukeboxSessionArtistAffinity[JukeboxSessionArtistAffinityPk];
-export type JukeboxSessionArtistAffinityOptionalAttributes = "id" | "createdAt" | "updatedAt";
-export type JukeboxSessionArtistAffinityCreationAttributes = Optional<JukeboxSessionArtistAffinityAttributes, JukeboxSessionArtistAffinityOptionalAttributes>;
-
-export class JukeboxSessionArtistAffinity extends Model<JukeboxSessionArtistAffinityAttributes, JukeboxSessionArtistAffinityCreationAttributes> implements JukeboxSessionArtistAffinityAttributes {
-  jukeboxSessionId!: string;
-  canonArtistId!: string;
-  affinityTierId!: number;
-  rank!: number;
-  id!: string;
-  createdAt!: Date;
-  updatedAt!: Date;
-
-  // JukeboxSessionArtistAffinity belongsTo AffinityTier via affinityTierId
-  affinityTier!: AffinityTier;
-  getAffinityTier!: Sequelize.BelongsToGetAssociationMixin<AffinityTier>;
-  setAffinityTier!: Sequelize.BelongsToSetAssociationMixin<AffinityTier, AffinityTierId>;
-  createAffinityTier!: Sequelize.BelongsToCreateAssociationMixin<AffinityTier>;
-  // JukeboxSessionArtistAffinity belongsTo CanonArtist via canonArtistId
-  canonArtist!: CanonArtist;
-  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
-  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
-  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
-  // JukeboxSessionArtistAffinity belongsTo JukeboxSession via jukeboxSessionId
-  jukeboxSession!: JukeboxSession;
-  getJukeboxSession!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
-  setJukeboxSession!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
-  createJukeboxSession!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxSessionArtistAffinity {
-    return JukeboxSessionArtistAffinity.init({
-    jukeboxSessionId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'jukebox_session',
-        key: 'id'
-      },
-      unique: "jukebox_session_artist_affinity_jukebox_session_id_canon_artist",
-      field: 'jukebox_session_id'
-    },
-    canonArtistId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'canon_artist',
-        key: 'id'
-      },
-      unique: "jukebox_session_artist_affinity_jukebox_session_id_canon_artist",
-      field: 'canon_artist_id'
-    },
-    affinityTierId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      references: {
-        model: 'affinity_tier',
-        key: 'id'
-      },
-      field: 'affinity_tier_id'
-    },
-    rank: {
-      type: DataTypes.INTEGER,
-      allowNull: false
-    },
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: DataTypes.UUIDV4,
-      primaryKey: true
-    },
-    createdAt: {
-      type: DataTypes.DATE,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
-      field: 'created_at'
-    },
-    updatedAt: {
-      type: DataTypes.DATE,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
-      field: 'updated_at'
-    }
-  }, {
-    sequelize,
-    tableName: 'jukebox_session_artist_affinity',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "idx_jukebox_session_artist_affinity_artist",
-        fields: [
-          { name: "canon_artist_id" },
-        ]
-      },
-      {
-        name: "idx_jukebox_session_artist_affinity_session",
-        fields: [
-          { name: "jukebox_session_id" },
-        ]
-      },
-      {
-        name: "jukebox_session_artist_affinity_jukebox_session_id_canon_artist",
-        unique: true,
-        fields: [
-          { name: "jukebox_session_id" },
-          { name: "canon_artist_id" },
-        ]
-      },
-      {
-        name: "jukebox_session_artist_affinity_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/JukeboxSessionGenreAffinity.ts

@@ -1,136 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { AffinityTier, AffinityTierId } from './AffinityTier';
-import type { CanonGenre, CanonGenreId } from './CanonGenre';
-import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
-
-export interface JukeboxSessionGenreAffinityAttributes {
-  jukeboxSessionId: string;
-  canonGenreId: string;
-  affinityTierId: number;
-  rank: number;
-  id: string;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-export type JukeboxSessionGenreAffinityPk = "id";
-export type JukeboxSessionGenreAffinityId = JukeboxSessionGenreAffinity[JukeboxSessionGenreAffinityPk];
-export type JukeboxSessionGenreAffinityOptionalAttributes = "id" | "createdAt" | "updatedAt";
-export type JukeboxSessionGenreAffinityCreationAttributes = Optional<JukeboxSessionGenreAffinityAttributes, JukeboxSessionGenreAffinityOptionalAttributes>;
-
-export class JukeboxSessionGenreAffinity extends Model<JukeboxSessionGenreAffinityAttributes, JukeboxSessionGenreAffinityCreationAttributes> implements JukeboxSessionGenreAffinityAttributes {
-  jukeboxSessionId!: string;
-  canonGenreId!: string;
-  affinityTierId!: number;
-  rank!: number;
-  id!: string;
-  createdAt!: Date;
-  updatedAt!: Date;
-
-  // JukeboxSessionGenreAffinity belongsTo AffinityTier via affinityTierId
-  affinityTier!: AffinityTier;
-  getAffinityTier!: Sequelize.BelongsToGetAssociationMixin<AffinityTier>;
-  setAffinityTier!: Sequelize.BelongsToSetAssociationMixin<AffinityTier, AffinityTierId>;
-  createAffinityTier!: Sequelize.BelongsToCreateAssociationMixin<AffinityTier>;
-  // JukeboxSessionGenreAffinity belongsTo CanonGenre via canonGenreId
-  canonGenre!: CanonGenre;
-  getCanonGenre!: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
-  setCanonGenre!: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
-  createCanonGenre!: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
-  // JukeboxSessionGenreAffinity belongsTo JukeboxSession via jukeboxSessionId
-  jukeboxSession!: JukeboxSession;
-  getJukeboxSession!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
-  setJukeboxSession!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
-  createJukeboxSession!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxSessionGenreAffinity {
-    return JukeboxSessionGenreAffinity.init({
-    jukeboxSessionId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'jukebox_session',
-        key: 'id'
-      },
-      unique: "jukebox_session_genre_affinity_jukebox_session_id_canon_genre_i",
-      field: 'jukebox_session_id'
-    },
-    canonGenreId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'canon_genre',
-        key: 'id'
-      },
-      unique: "jukebox_session_genre_affinity_jukebox_session_id_canon_genre_i",
-      field: 'canon_genre_id'
-    },
-    affinityTierId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      references: {
-        model: 'affinity_tier',
-        key: 'id'
-      },
-      field: 'affinity_tier_id'
-    },
-    rank: {
-      type: DataTypes.INTEGER,
-      allowNull: false
-    },
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: DataTypes.UUIDV4,
-      primaryKey: true
-    },
-    createdAt: {
-      type: DataTypes.DATE,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
-      field: 'created_at'
-    },
-    updatedAt: {
-      type: DataTypes.DATE,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
-      field: 'updated_at'
-    }
-  }, {
-    sequelize,
-    tableName: 'jukebox_session_genre_affinity',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "idx_jukebox_session_genre_affinity_genre",
-        fields: [
-          { name: "canon_genre_id" },
-        ]
-      },
-      {
-        name: "idx_jukebox_session_genre_affinity_session",
-        fields: [
-          { name: "jukebox_session_id" },
-        ]
-      },
-      {
-        name: "jukebox_session_genre_affinity_jukebox_session_id_canon_genre_i",
-        unique: true,
-        fields: [
-          { name: "jukebox_session_id" },
-          { name: "canon_genre_id" },
-        ]
-      },
-      {
-        name: "jukebox_session_genre_affinity_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/JukeboxStatus.ts

@@ -1,58 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
-
-export interface JukeboxStatusAttributes {
-  id: number;
-  description: string;
-}
-
-export type JukeboxStatusPk = "id";
-export type JukeboxStatusId = JukeboxStatus[JukeboxStatusPk];
-export type JukeboxStatusCreationAttributes = JukeboxStatusAttributes;
-
-export class JukeboxStatus extends Model<JukeboxStatusAttributes, JukeboxStatusCreationAttributes> implements JukeboxStatusAttributes {
-  id!: number;
-  description!: string;
-
-  // JukeboxStatus hasMany JukeboxSession via jukeboxStatusId
-  jukeboxSessions!: JukeboxSession[];
-  getJukeboxSessions!: Sequelize.HasManyGetAssociationsMixin<JukeboxSession>;
-  setJukeboxSessions!: Sequelize.HasManySetAssociationsMixin<JukeboxSession, JukeboxSessionId>;
-  addJukeboxSession!: Sequelize.HasManyAddAssociationMixin<JukeboxSession, JukeboxSessionId>;
-  addJukeboxSessions!: Sequelize.HasManyAddAssociationsMixin<JukeboxSession, JukeboxSessionId>;
-  createJukeboxSession!: Sequelize.HasManyCreateAssociationMixin<JukeboxSession>;
-  removeJukeboxSession!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSession, JukeboxSessionId>;
-  removeJukeboxSessions!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSession, JukeboxSessionId>;
-  hasJukeboxSession!: Sequelize.HasManyHasAssociationMixin<JukeboxSession, JukeboxSessionId>;
-  hasJukeboxSessions!: Sequelize.HasManyHasAssociationsMixin<JukeboxSession, JukeboxSessionId>;
-  countJukeboxSessions!: Sequelize.HasManyCountAssociationsMixin;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxStatus {
-    return JukeboxStatus.init({
-    id: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      primaryKey: true
-    },
-    description: {
-      type: DataTypes.STRING(255),
-      allowNull: false
-    }
-  }, {
-    sequelize,
-    tableName: 'jukebox_status',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "jukebox_status_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}