@earbug/db-models 0.0.8 → 0.0.10

package/models/AppUser.ts

@@ -6,8 +6,10 @@ import type { AppUserPlatformRelation, AppUserPlatformRelationCreationAttributes
 import type { JukeboxInvite, JukeboxInviteId } from './JukeboxInvite';
 import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
 import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+import type { Notification, NotificationId } from './Notification';
 import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum';
 import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+import type { RadioShow, RadioShowId } from './RadioShow';
 import type { State, StateId } from './State';
 import type { UserContacts, UserContactsId } from './UserContacts';
 
@@ -132,6 +134,30 @@ export class AppUser extends Model<AppUserAttributes, AppUserCreationAttributes>
   hasJukeboxUser!: Sequelize.HasManyHasAssociationMixin<JukeboxUser, JukeboxUserId>;
   hasJukeboxUsers!: Sequelize.HasManyHasAssociationsMixin<JukeboxUser, JukeboxUserId>;
   countJukeboxUsers!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany Notification via sourceUserId
+  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;
+  // AppUser hasMany Notification via targetUserId
+  targetUserNotifications!: Notification[];
+  getTargetUserNotifications!: Sequelize.HasManyGetAssociationsMixin<Notification>;
+  setTargetUserNotifications!: Sequelize.HasManySetAssociationsMixin<Notification, NotificationId>;
+  addTargetUserNotification!: Sequelize.HasManyAddAssociationMixin<Notification, NotificationId>;
+  addTargetUserNotifications!: Sequelize.HasManyAddAssociationsMixin<Notification, NotificationId>;
+  createTargetUserNotification!: Sequelize.HasManyCreateAssociationMixin<Notification>;
+  removeTargetUserNotification!: Sequelize.HasManyRemoveAssociationMixin<Notification, NotificationId>;
+  removeTargetUserNotifications!: Sequelize.HasManyRemoveAssociationsMixin<Notification, NotificationId>;
+  hasTargetUserNotification!: Sequelize.HasManyHasAssociationMixin<Notification, NotificationId>;
+  hasTargetUserNotifications!: Sequelize.HasManyHasAssociationsMixin<Notification, NotificationId>;
+  countTargetUserNotifications!: Sequelize.HasManyCountAssociationsMixin;
   // AppUser hasMany PlatformUserAlbum via appUserId
   platformUserAlbums!: PlatformUserAlbum[];
   getPlatformUserAlbums!: Sequelize.HasManyGetAssociationsMixin<PlatformUserAlbum>;
@@ -156,6 +182,18 @@ export class AppUser extends Model<AppUserAttributes, AppUserCreationAttributes>
   hasPlatformUserPlaylist!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
   hasPlatformUserPlaylists!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
   countPlatformUserPlaylists!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany RadioShow via creatorUserId
+  radioShows!: RadioShow[];
+  getRadioShows!: Sequelize.HasManyGetAssociationsMixin<RadioShow>;
+  setRadioShows!: Sequelize.HasManySetAssociationsMixin<RadioShow, RadioShowId>;
+  addRadioShow!: Sequelize.HasManyAddAssociationMixin<RadioShow, RadioShowId>;
+  addRadioShows!: Sequelize.HasManyAddAssociationsMixin<RadioShow, RadioShowId>;
+  createRadioShow!: Sequelize.HasManyCreateAssociationMixin<RadioShow>;
+  removeRadioShow!: Sequelize.HasManyRemoveAssociationMixin<RadioShow, RadioShowId>;
+  removeRadioShows!: Sequelize.HasManyRemoveAssociationsMixin<RadioShow, RadioShowId>;
+  hasRadioShow!: Sequelize.HasManyHasAssociationMixin<RadioShow, RadioShowId>;
+  hasRadioShows!: Sequelize.HasManyHasAssociationsMixin<RadioShow, RadioShowId>;
+  countRadioShows!: Sequelize.HasManyCountAssociationsMixin;
   // AppUser hasMany UserContacts via appUserId
   userContacts!: UserContacts[];
   getUserContacts!: Sequelize.HasManyGetAssociationsMixin<UserContacts>;

package/models/CanonGenre.ts

@@ -9,6 +9,7 @@ import type { JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId } from './J
 import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
 import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
 import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+import type { RadioShowGenres, RadioShowGenresId } from './RadioShowGenres';
 
 export interface CanonGenreAttributes {
   name: string;
@@ -142,6 +143,18 @@ export class CanonGenre extends Model<CanonGenreAttributes, CanonGenreCreationAt
   hasPlatformGenreIdPlatformGenre!: Sequelize.BelongsToManyHasAssociationMixin<PlatformGenre, PlatformGenreId>;
   hasPlatformGenreIdPlatformGenres!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformGenre, PlatformGenreId>;
   countPlatformGenreIdPlatformGenres!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonGenre hasMany RadioShowGenres via canonGenreId
+  radioShowGenres!: RadioShowGenres[];
+  getRadioShowGenres!: Sequelize.HasManyGetAssociationsMixin<RadioShowGenres>;
+  setRadioShowGenres!: Sequelize.HasManySetAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
+  addRadioShowGenre!: Sequelize.HasManyAddAssociationMixin<RadioShowGenres, RadioShowGenresId>;
+  addRadioShowGenres!: Sequelize.HasManyAddAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
+  createRadioShowGenre!: Sequelize.HasManyCreateAssociationMixin<RadioShowGenres>;
+  removeRadioShowGenre!: Sequelize.HasManyRemoveAssociationMixin<RadioShowGenres, RadioShowGenresId>;
+  removeRadioShowGenres!: Sequelize.HasManyRemoveAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
+  hasRadioShowGenre!: Sequelize.HasManyHasAssociationMixin<RadioShowGenres, RadioShowGenresId>;
+  hasRadioShowGenres!: Sequelize.HasManyHasAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
+  countRadioShowGenres!: Sequelize.HasManyCountAssociationsMixin;
 
   static initModel(sequelize: Sequelize.Sequelize): typeof CanonGenre {
     return CanonGenre.init({

package/models/CanonTrack.ts

@@ -7,6 +7,7 @@ import type { CanonArtistTrackRelation, CanonArtistTrackRelationId } from './Can
 import type { CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId } from './CanonToPlatformTrackRelation';
 import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
 import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { RadioShowPlacement, RadioShowPlacementId } from './RadioShowPlacement';
 
 export interface CanonTrackAttributes {
   name: string;
@@ -120,6 +121,18 @@ export class CanonTrack extends Model<CanonTrackAttributes, CanonTrackCreationAt
   hasPlatformTrackIdPlatformTrack!: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
   hasPlatformTrackIdPlatformTracks!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
   countPlatformTrackIdPlatformTracks!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonTrack hasMany RadioShowPlacement via canonTrackId
+  radioShowPlacements!: RadioShowPlacement[];
+  getRadioShowPlacements!: Sequelize.HasManyGetAssociationsMixin<RadioShowPlacement>;
+  setRadioShowPlacements!: Sequelize.HasManySetAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
+  addRadioShowPlacement!: Sequelize.HasManyAddAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
+  addRadioShowPlacements!: Sequelize.HasManyAddAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
+  createRadioShowPlacement!: Sequelize.HasManyCreateAssociationMixin<RadioShowPlacement>;
+  removeRadioShowPlacement!: Sequelize.HasManyRemoveAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
+  removeRadioShowPlacements!: Sequelize.HasManyRemoveAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
+  hasRadioShowPlacement!: Sequelize.HasManyHasAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
+  hasRadioShowPlacements!: Sequelize.HasManyHasAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
+  countRadioShowPlacements!: Sequelize.HasManyCountAssociationsMixin;
 
   static initModel(sequelize: Sequelize.Sequelize): typeof CanonTrack {
     return CanonTrack.init({

package/models/JukeboxSession.ts

@@ -9,6 +9,7 @@ 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';
 
 export interface JukeboxSessionAttributes {
   typeId: number;
@@ -102,6 +103,18 @@ export class JukeboxSession extends Model<JukeboxSessionAttributes, JukeboxSessi
   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 belongsTo JukeboxStatus via jukeboxStatusId
   jukeboxStatus!: JukeboxStatus;
   getJukeboxStatus!: Sequelize.BelongsToGetAssociationMixin<JukeboxStatus>;

package/models/Notification.ts

@@ -0,0 +1,202 @@
+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 { NotificationType, NotificationTypeId } from './NotificationType';
+
+export interface NotificationAttributes {
+  targetUserId: string;
+  notificationTypeId: number;
+  metadata?: object;
+  readAt?: Date;
+  dismissedAt?: Date;
+  sourceUserId?: string;
+  jukeboxSessionId?: string;
+  expiresAt?: Date;
+  pushSentAt?: Date;
+  pushError?: string;
+  id: string;
+  isRead: boolean;
+  isDismissed: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+  pushSent: boolean;
+}
+
+export type NotificationPk = "id";
+export type NotificationId = Notification[NotificationPk];
+export type NotificationOptionalAttributes = "metadata" | "readAt" | "dismissedAt" | "sourceUserId" | "jukeboxSessionId" | "expiresAt" | "pushSentAt" | "pushError" | "id" | "createdAt" | "updatedAt";
+export type NotificationCreationAttributes = Optional<NotificationAttributes, NotificationOptionalAttributes>;
+
+export class Notification extends Model<NotificationAttributes, NotificationCreationAttributes> implements NotificationAttributes {
+  targetUserId!: string;
+  notificationTypeId!: number;
+  metadata?: object;
+  readAt?: Date;
+  dismissedAt?: Date;
+  sourceUserId?: string;
+  jukeboxSessionId?: string;
+  expiresAt?: Date;
+  pushSentAt?: Date;
+  pushError?: string;
+  id!: string;
+  isRead!: boolean;
+  isDismissed!: boolean;
+  createdAt!: Date;
+  updatedAt!: Date;
+  pushSent!: boolean;
+
+  // Notification belongsTo AppUser via sourceUserId
+  sourceUser!: AppUser;
+  getSourceUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setSourceUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createSourceUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // Notification belongsTo AppUser via targetUserId
+  targetUser!: AppUser;
+  getTargetUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setTargetUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createTargetUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // Notification belongsTo JukeboxSession via jukeboxSessionId
+  jukeboxSession!: JukeboxSession;
+  getJukeboxSession!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+  setJukeboxSession!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+  // Notification belongsTo NotificationType via notificationTypeId
+  notificationType!: NotificationType;
+  getNotificationType!: Sequelize.BelongsToGetAssociationMixin<NotificationType>;
+  setNotificationType!: Sequelize.BelongsToSetAssociationMixin<NotificationType, NotificationTypeId>;
+  createNotificationType!: Sequelize.BelongsToCreateAssociationMixin<NotificationType>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof Notification {
+    return Notification.init({
+    targetUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'target_user_id'
+    },
+    notificationTypeId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'notification_type',
+        key: 'id'
+      },
+      field: 'notification_type_id'
+    },
+    metadata: {
+      type: DataTypes.JSONB,
+      allowNull: true
+    },
+    readAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'read_at'
+    },
+    dismissedAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'dismissed_at'
+    },
+    sourceUserId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'source_user_id'
+    },
+    jukeboxSessionId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      field: 'jukebox_session_id'
+    },
+    expiresAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'expires_at'
+    },
+    pushSentAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'push_sent_at'
+    },
+    pushError: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'push_error'
+    },
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    isRead: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: false,
+      field: 'is_read'
+    },
+    isDismissed: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: false,
+      field: 'is_dismissed'
+    },
+    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'
+    },
+    pushSent: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: false,
+      field: 'push_sent'
+    }
+  }, {
+    sequelize,
+    tableName: 'notification',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_notification_expires_at",
+        fields: [
+          { name: "expires_at" },
+        ]
+      },
+      {
+        name: "idx_notification_target_user_created_at",
+        fields: [
+          { name: "target_user_id" },
+          { name: "created_at", order: "DESC" },
+        ]
+      },
+      {
+        name: "notification_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/NotificationType.ts

@@ -0,0 +1,66 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { Notification, NotificationId } from './Notification';
+
+export interface NotificationTypeAttributes {
+  id: number;
+  name: string;
+}
+
+export type NotificationTypePk = "id";
+export type NotificationTypeId = NotificationType[NotificationTypePk];
+export type NotificationTypeCreationAttributes = NotificationTypeAttributes;
+
+export class NotificationType extends Model<NotificationTypeAttributes, NotificationTypeCreationAttributes> implements NotificationTypeAttributes {
+  id!: number;
+  name!: string;
+
+  // NotificationType hasMany Notification via notificationTypeId
+  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;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof NotificationType {
+    return NotificationType.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "notification_type_name_unique"
+    }
+  }, {
+    sequelize,
+    tableName: 'notification_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "notification_type_name_unique",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "notification_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/RadioShow.ts

@@ -0,0 +1,151 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { RadioShowGenres, RadioShowGenresId } from './RadioShowGenres';
+import type { RadioShowMedia, RadioShowMediaId } from './RadioShowMedia';
+import type { RadioShowPlacement, RadioShowPlacementId } from './RadioShowPlacement';
+import type { RadioShowPublishRequests, RadioShowPublishRequestsId } from './RadioShowPublishRequests';
+
+export interface RadioShowAttributes {
+  creatorUserId: string;
+  scheduledRelease?: Date;
+  title: string;
+  description?: string;
+  deleted?: boolean;
+  id: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type RadioShowPk = "id";
+export type RadioShowId = RadioShow[RadioShowPk];
+export type RadioShowOptionalAttributes = "scheduledRelease" | "description" | "deleted" | "id" | "createDate" | "updateDate";
+export type RadioShowCreationAttributes = Optional<RadioShowAttributes, RadioShowOptionalAttributes>;
+
+export class RadioShow extends Model<RadioShowAttributes, RadioShowCreationAttributes> implements RadioShowAttributes {
+  creatorUserId!: string;
+  scheduledRelease?: Date;
+  title!: string;
+  description?: string;
+  deleted?: boolean;
+  id!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // RadioShow belongsTo AppUser via creatorUserId
+  creatorUser!: AppUser;
+  getCreatorUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setCreatorUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createCreatorUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // RadioShow hasMany RadioShowGenres via radioShowId
+  radioShowGenres!: RadioShowGenres[];
+  getRadioShowGenres!: Sequelize.HasManyGetAssociationsMixin<RadioShowGenres>;
+  setRadioShowGenres!: Sequelize.HasManySetAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
+  addRadioShowGenre!: Sequelize.HasManyAddAssociationMixin<RadioShowGenres, RadioShowGenresId>;
+  addRadioShowGenres!: Sequelize.HasManyAddAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
+  createRadioShowGenre!: Sequelize.HasManyCreateAssociationMixin<RadioShowGenres>;
+  removeRadioShowGenre!: Sequelize.HasManyRemoveAssociationMixin<RadioShowGenres, RadioShowGenresId>;
+  removeRadioShowGenres!: Sequelize.HasManyRemoveAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
+  hasRadioShowGenre!: Sequelize.HasManyHasAssociationMixin<RadioShowGenres, RadioShowGenresId>;
+  hasRadioShowGenres!: Sequelize.HasManyHasAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
+  countRadioShowGenres!: Sequelize.HasManyCountAssociationsMixin;
+  // RadioShow hasMany RadioShowMedia via radioShowId
+  radioShowMedia!: RadioShowMedia[];
+  getRadioShowMedia!: Sequelize.HasManyGetAssociationsMixin<RadioShowMedia>;
+  setRadioShowMedia!: Sequelize.HasManySetAssociationsMixin<RadioShowMedia, RadioShowMediaId>;
+  addRadioShowMedium!: Sequelize.HasManyAddAssociationMixin<RadioShowMedia, RadioShowMediaId>;
+  addRadioShowMedia!: Sequelize.HasManyAddAssociationsMixin<RadioShowMedia, RadioShowMediaId>;
+  createRadioShowMedium!: Sequelize.HasManyCreateAssociationMixin<RadioShowMedia>;
+  removeRadioShowMedium!: Sequelize.HasManyRemoveAssociationMixin<RadioShowMedia, RadioShowMediaId>;
+  removeRadioShowMedia!: Sequelize.HasManyRemoveAssociationsMixin<RadioShowMedia, RadioShowMediaId>;
+  hasRadioShowMedium!: Sequelize.HasManyHasAssociationMixin<RadioShowMedia, RadioShowMediaId>;
+  hasRadioShowMedia!: Sequelize.HasManyHasAssociationsMixin<RadioShowMedia, RadioShowMediaId>;
+  countRadioShowMedia!: Sequelize.HasManyCountAssociationsMixin;
+  // RadioShow hasMany RadioShowPlacement via radioShowId
+  radioShowPlacements!: RadioShowPlacement[];
+  getRadioShowPlacements!: Sequelize.HasManyGetAssociationsMixin<RadioShowPlacement>;
+  setRadioShowPlacements!: Sequelize.HasManySetAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
+  addRadioShowPlacement!: Sequelize.HasManyAddAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
+  addRadioShowPlacements!: Sequelize.HasManyAddAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
+  createRadioShowPlacement!: Sequelize.HasManyCreateAssociationMixin<RadioShowPlacement>;
+  removeRadioShowPlacement!: Sequelize.HasManyRemoveAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
+  removeRadioShowPlacements!: Sequelize.HasManyRemoveAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
+  hasRadioShowPlacement!: Sequelize.HasManyHasAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
+  hasRadioShowPlacements!: Sequelize.HasManyHasAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
+  countRadioShowPlacements!: Sequelize.HasManyCountAssociationsMixin;
+  // RadioShow hasMany RadioShowPublishRequests via radioShowId
+  radioShowPublishRequests!: RadioShowPublishRequests[];
+  getRadioShowPublishRequests!: Sequelize.HasManyGetAssociationsMixin<RadioShowPublishRequests>;
+  setRadioShowPublishRequests!: Sequelize.HasManySetAssociationsMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
+  addRadioShowPublishRequest!: Sequelize.HasManyAddAssociationMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
+  addRadioShowPublishRequests!: Sequelize.HasManyAddAssociationsMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
+  createRadioShowPublishRequest!: Sequelize.HasManyCreateAssociationMixin<RadioShowPublishRequests>;
+  removeRadioShowPublishRequest!: Sequelize.HasManyRemoveAssociationMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
+  removeRadioShowPublishRequests!: Sequelize.HasManyRemoveAssociationsMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
+  hasRadioShowPublishRequest!: Sequelize.HasManyHasAssociationMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
+  hasRadioShowPublishRequests!: Sequelize.HasManyHasAssociationsMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
+  countRadioShowPublishRequests!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof RadioShow {
+    return RadioShow.init({
+    creatorUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'creator_user_id'
+    },
+    scheduledRelease: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'scheduled_release'
+    },
+    title: {
+      type: DataTypes.STRING(40),
+      allowNull: false
+    },
+    description: {
+      type: DataTypes.STRING(512),
+      allowNull: true
+    },
+    deleted: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true
+    },
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'radio_show',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "radio_show_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/RadioShowGenres.ts

@@ -0,0 +1,81 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { RadioShow, RadioShowId } from './RadioShow';
+
+export interface RadioShowGenresAttributes {
+  canonGenreId: string;
+  radioShowId: string;
+  title: string;
+  id: string;
+}
+
+export type RadioShowGenresPk = "id";
+export type RadioShowGenresId = RadioShowGenres[RadioShowGenresPk];
+export type RadioShowGenresOptionalAttributes = "id";
+export type RadioShowGenresCreationAttributes = Optional<RadioShowGenresAttributes, RadioShowGenresOptionalAttributes>;
+
+export class RadioShowGenres extends Model<RadioShowGenresAttributes, RadioShowGenresCreationAttributes> implements RadioShowGenresAttributes {
+  canonGenreId!: string;
+  radioShowId!: string;
+  title!: string;
+  id!: string;
+
+  // RadioShowGenres belongsTo CanonGenre via canonGenreId
+  canonGenre!: CanonGenre;
+  getCanonGenre!: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+  setCanonGenre!: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+  createCanonGenre!: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+  // RadioShowGenres belongsTo RadioShow via radioShowId
+  radioShow!: RadioShow;
+  getRadioShow!: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
+  setRadioShow!: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
+  createRadioShow!: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof RadioShowGenres {
+    return RadioShowGenres.init({
+    canonGenreId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'canon_genre',
+        key: 'id'
+      },
+      field: 'canon_genre_id'
+    },
+    radioShowId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'radio_show',
+        key: 'id'
+      },
+      field: 'radio_show_id'
+    },
+    title: {
+      type: DataTypes.STRING(40),
+      allowNull: false
+    },
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    }
+  }, {
+    sequelize,
+    tableName: 'radio_show_genres',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "radio_show_genres_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}