@earbug/db-models 0.0.62 → 0.0.63

package/models/JukeboxSession.ts

@@ -0,0 +1,334 @@
+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 {
+  id: string;
+  typeId: number;
+  accessTypeId: number;
+  terminationConditionId: number;
+  jukeboxQueueModeId: number;
+  createdAt: Date;
+  updatedAt: Date;
+  jukeboxStatusId: number;
+  trackQueue?: string[];
+  description?: string;
+  stateMachineArn?: string;
+  durationMs: number;
+  pausedAt?: Date;
+}
+
+export type JukeboxSessionPk = "id";
+export type JukeboxSessionId = JukeboxSession[JukeboxSessionPk];
+export type JukeboxSessionOptionalAttributes = "id" | "createdAt" | "updatedAt" | "jukeboxStatusId" | "trackQueue" | "description" | "stateMachineArn" | "durationMs" | "pausedAt";
+export type JukeboxSessionCreationAttributes = Optional<JukeboxSessionAttributes, JukeboxSessionOptionalAttributes>;
+
+export class JukeboxSession extends Model<JukeboxSessionAttributes, JukeboxSessionCreationAttributes> implements JukeboxSessionAttributes {
+  id!: string;
+  typeId!: number;
+  accessTypeId!: number;
+  terminationConditionId!: number;
+  jukeboxQueueModeId!: number;
+  createdAt!: Date;
+  updatedAt!: Date;
+  jukeboxStatusId!: number;
+  trackQueue?: string[];
+  description?: string;
+  stateMachineArn?: string;
+  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({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    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'
+    },
+    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'
+    },
+    jukeboxStatusId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      references: {
+        model: 'jukebox_status',
+        key: 'id'
+      },
+      field: 'jukebox_status_id'
+    },
+    trackQueue: {
+      type: DataTypes.ARRAY(DataTypes.TEXT),
+      allowNull: true,
+      field: 'track_queue'
+    },
+    description: {
+      type: DataTypes.STRING(512),
+      allowNull: true
+    },
+    stateMachineArn: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      field: 'state_machine_arn'
+    },
+    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

@@ -0,0 +1,136 @@
+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 {
+  id: string;
+  jukeboxSessionId: string;
+  canonArtistId: string;
+  affinityTierId: number;
+  rank: number;
+  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 {
+  id!: string;
+  jukeboxSessionId!: string;
+  canonArtistId!: string;
+  affinityTierId!: number;
+  rank!: number;
+  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({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    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
+    },
+    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

@@ -0,0 +1,136 @@
+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 {
+  id: string;
+  jukeboxSessionId: string;
+  canonGenreId: string;
+  affinityTierId: number;
+  rank: number;
+  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 {
+  id!: string;
+  jukeboxSessionId!: string;
+  canonGenreId!: string;
+  affinityTierId!: number;
+  rank!: number;
+  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({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    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
+    },
+    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

@@ -0,0 +1,58 @@
+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" },
+        ]
+      },
+    ]
+  });
+  }
+}