@earbug/db-models 0.0.1

package/models/JukeboxInvite.ts

@@ -0,0 +1,113 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+
+export interface JukeboxInviteAttributes {
+  id: string;
+  jukeboxSessionId: string;
+  inviterUserId: string;
+  invitedUserId?: string;
+  email?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type JukeboxInvitePk = "id";
+export type JukeboxInviteId = JukeboxInvite[JukeboxInvitePk];
+export type JukeboxInviteOptionalAttributes = "id" | "invitedUserId" | "email" | "createdAt" | "updatedAt";
+export type JukeboxInviteCreationAttributes = Optional<JukeboxInviteAttributes, JukeboxInviteOptionalAttributes>;
+
+export class JukeboxInvite extends Model<JukeboxInviteAttributes, JukeboxInviteCreationAttributes> implements JukeboxInviteAttributes {
+  id!: string;
+  jukeboxSessionId!: string;
+  inviterUserId!: string;
+  invitedUserId?: string;
+  email?: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+
+  // JukeboxInvite belongsTo AppUser via invitedUserId
+  invitedUser!: AppUser;
+  getInvitedUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setInvitedUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createInvitedUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // JukeboxInvite belongsTo AppUser via inviterUserId
+  inviterUser!: AppUser;
+  getInviterUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setInviterUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createInviterUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // JukeboxInvite 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 JukeboxInvite {
+    return JukeboxInvite.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    jukeboxSessionId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      field: 'jukebox_session_id'
+    },
+    inviterUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'inviter_user_id'
+    },
+    invitedUserId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'invited_user_id'
+    },
+    email: {
+      type: DataTypes.TEXT,
+      allowNull: 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_invite',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_invite_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxQueueEntry.ts

@@ -0,0 +1,195 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+import type { PlaybackStatus, PlaybackStatusId } from './PlaybackStatus';
+import type { TrackDeletionReason, TrackDeletionReasonId } from './TrackDeletionReason';
+
+export interface JukeboxQueueEntryAttributes {
+  id: string;
+  jukeboxSessionId: string;
+  trackId: string;
+  playbackPriority?: number;
+  trackAddedUserId: string;
+  createdAt: Date;
+  updatedAt: Date;
+  setOrder: number;
+  trackDeletionReasonId: number;
+  playbackStatusTypeId: number;
+  playbackStarted?: Date;
+  trackThumbsUp?: string[];
+  trackThumbsDown?: string[];
+}
+
+export type JukeboxQueueEntryPk = "id";
+export type JukeboxQueueEntryId = JukeboxQueueEntry[JukeboxQueueEntryPk];
+export type JukeboxQueueEntryOptionalAttributes = "id" | "playbackPriority" | "createdAt" | "updatedAt" | "setOrder" | "trackDeletionReasonId" | "playbackStatusTypeId" | "playbackStarted" | "trackThumbsUp" | "trackThumbsDown";
+export type JukeboxQueueEntryCreationAttributes = Optional<JukeboxQueueEntryAttributes, JukeboxQueueEntryOptionalAttributes>;
+
+export class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes, JukeboxQueueEntryCreationAttributes> implements JukeboxQueueEntryAttributes {
+  id!: string;
+  jukeboxSessionId!: string;
+  trackId!: string;
+  playbackPriority?: number;
+  trackAddedUserId!: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+  setOrder!: number;
+  trackDeletionReasonId!: number;
+  playbackStatusTypeId!: number;
+  playbackStarted?: Date;
+  trackThumbsUp?: string[];
+  trackThumbsDown?: string[];
+
+  // JukeboxQueueEntry belongsTo AppUser via trackAddedUserId
+  trackAddedUser!: AppUser;
+  getTrackAddedUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setTrackAddedUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createTrackAddedUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // JukeboxQueueEntry belongsTo CanonTrack via trackId
+  track!: CanonTrack;
+  getTrack!: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
+  setTrack!: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
+  createTrack!: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+  // JukeboxQueueEntry hasMany JukeboxUser via pausedQueueEntryId
+  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;
+  // JukeboxQueueEntry belongsTo JukeboxSession via jukeboxSessionId
+  jukeboxSession!: JukeboxSession;
+  getJukeboxSession!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+  setJukeboxSession!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+  // JukeboxQueueEntry belongsTo PlaybackStatus via playbackStatusTypeId
+  playbackStatusType!: PlaybackStatus;
+  getPlaybackStatusType!: Sequelize.BelongsToGetAssociationMixin<PlaybackStatus>;
+  setPlaybackStatusType!: Sequelize.BelongsToSetAssociationMixin<PlaybackStatus, PlaybackStatusId>;
+  createPlaybackStatusType!: Sequelize.BelongsToCreateAssociationMixin<PlaybackStatus>;
+  // JukeboxQueueEntry belongsTo TrackDeletionReason via trackDeletionReasonId
+  trackDeletionReason!: TrackDeletionReason;
+  getTrackDeletionReason!: Sequelize.BelongsToGetAssociationMixin<TrackDeletionReason>;
+  setTrackDeletionReason!: Sequelize.BelongsToSetAssociationMixin<TrackDeletionReason, TrackDeletionReasonId>;
+  createTrackDeletionReason!: Sequelize.BelongsToCreateAssociationMixin<TrackDeletionReason>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxQueueEntry {
+    return JukeboxQueueEntry.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    jukeboxSessionId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      field: 'jukebox_session_id'
+    },
+    trackId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'canon_track',
+        key: 'id'
+      },
+      field: 'track_id'
+    },
+    playbackPriority: {
+      type: DataTypes.DECIMAL,
+      allowNull: true,
+      field: 'playback_priority'
+    },
+    trackAddedUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'track_added_user_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'
+    },
+    setOrder: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      defaultValue: 1,
+      field: 'set_order'
+    },
+    trackDeletionReasonId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      references: {
+        model: 'track_deletion_reason',
+        key: 'id'
+      },
+      field: 'track_deletion_reason_id'
+    },
+    playbackStatusTypeId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      references: {
+        model: 'playback_status',
+        key: 'id'
+      },
+      field: 'playback_status_type_id'
+    },
+    playbackStarted: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'playback_started'
+    },
+    trackThumbsUp: {
+      type: DataTypes.ARRAY(DataTypes.UUID),
+      allowNull: true,
+      defaultValue: ["ARRAY[]"],
+      field: 'track_thumbs_up'
+    },
+    trackThumbsDown: {
+      type: DataTypes.ARRAY(DataTypes.UUID),
+      allowNull: true,
+      defaultValue: ["ARRAY[]"],
+      field: 'track_thumbs_down'
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_queue_entry',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_queue_entry_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxQueueMode.ts

@@ -0,0 +1,60 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+
+export interface JukeboxQueueModeAttributes {
+  id: number;
+  description: string;
+}
+
+export type JukeboxQueueModePk = "id";
+export type JukeboxQueueModeId = JukeboxQueueMode[JukeboxQueueModePk];
+export type JukeboxQueueModeCreationAttributes = JukeboxQueueModeAttributes;
+
+export class JukeboxQueueMode extends Model<JukeboxQueueModeAttributes, JukeboxQueueModeCreationAttributes> implements JukeboxQueueModeAttributes {
+  id!: number;
+  description!: string;
+
+  // JukeboxQueueMode hasMany JukeboxSession via jukeboxQueueModeId
+  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 JukeboxQueueMode {
+    return JukeboxQueueMode.init({
+    id: {
+      autoIncrement: true,
+      autoIncrementIdentity: true,
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_queue_mode',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_queue_mode_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxSession.ts

@@ -0,0 +1,223 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+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 { JukeboxStatus, JukeboxStatusId } from './JukeboxStatus';
+import type { JukeboxTerminationCondition, JukeboxTerminationConditionId } from './JukeboxTerminationCondition';
+import type { JukeboxType, JukeboxTypeId } from './JukeboxType';
+import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+
+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;
+}
+
+export type JukeboxSessionPk = "id";
+export type JukeboxSessionId = JukeboxSession[JukeboxSessionPk];
+export type JukeboxSessionOptionalAttributes = "id" | "createdAt" | "updatedAt" | "jukeboxStatusId" | "trackQueue" | "description" | "stateMachineArn" | "durationMs";
+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;
+
+  // 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 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 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 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'
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_session',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_session_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" },
+        ]
+      },
+    ]
+  });
+  }
+}