@earbug/db-models 0.0.62 → 0.0.63

package/models/RadioShowGenres.ts

@@ -0,0 +1,107 @@
+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;
+  seqNum?: number;
+}
+
+export type RadioShowGenresPk = "id";
+export type RadioShowGenresId = RadioShowGenres[RadioShowGenresPk];
+export type RadioShowGenresOptionalAttributes = "id" | "seqNum";
+export type RadioShowGenresCreationAttributes = Optional<RadioShowGenresAttributes, RadioShowGenresOptionalAttributes>;
+
+export class RadioShowGenres extends Model<RadioShowGenresAttributes, RadioShowGenresCreationAttributes> implements RadioShowGenresAttributes {
+  canonGenreId!: string;
+  radioShowId!: string;
+  title!: string;
+  id!: string;
+  seqNum?: number;
+
+  // 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'
+      },
+      unique: "uq_radio_show_genre_unique",
+      field: 'canon_genre_id'
+    },
+    radioShowId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'radio_show',
+        key: 'id'
+      },
+      unique: "uq_radio_show_genre_unique",
+      field: 'radio_show_id'
+    },
+    title: {
+      type: DataTypes.STRING(40),
+      allowNull: false
+    },
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    seqNum: {
+      type: DataTypes.SMALLINT,
+      allowNull: true,
+      unique: "uq_radio_show_genre_seq_unique",
+      field: 'seq_num'
+    }
+  }, {
+    sequelize,
+    tableName: 'radio_show_genres',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "radio_show_genres_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "uq_radio_show_genre_seq_unique",
+        unique: true,
+        fields: [
+          { name: "radio_show_id" },
+          { name: "seq_num" },
+        ]
+      },
+      {
+        name: "uq_radio_show_genre_unique",
+        unique: true,
+        fields: [
+          { name: "radio_show_id" },
+          { name: "canon_genre_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/RadioShowMedia.ts

@@ -0,0 +1,181 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { RadioShow, RadioShowId } from './RadioShow';
+import type { UserAbuseReports, UserAbuseReportsId } from './UserAbuseReports';
+
+export interface RadioShowMediaAttributes {
+  id: string;
+  radioShowId: string;
+  originalMediaType?: number;
+  s3VideoUrl?: string;
+  s3AudioUrl: string;
+  createDate: Date;
+  description?: string;
+  cropInstructions?: string;
+  deleted?: boolean;
+  sourceS3Key?: string;
+  isAppRecorded?: boolean;
+  automatedModerationApproved?: boolean;
+  automatedModerationRejectionMetadata?: object;
+  automatedModerationDecidedAt?: Date;
+  manualModerationApproved?: boolean;
+  manualModerationDecidedAt?: Date;
+  manualModerationBy?: string;
+}
+
+export type RadioShowMediaPk = "id";
+export type RadioShowMediaId = RadioShowMedia[RadioShowMediaPk];
+export type RadioShowMediaOptionalAttributes = "id" | "originalMediaType" | "s3VideoUrl" | "createDate" | "description" | "cropInstructions" | "deleted" | "sourceS3Key" | "isAppRecorded" | "automatedModerationApproved" | "automatedModerationRejectionMetadata" | "automatedModerationDecidedAt" | "manualModerationApproved" | "manualModerationDecidedAt" | "manualModerationBy";
+export type RadioShowMediaCreationAttributes = Optional<RadioShowMediaAttributes, RadioShowMediaOptionalAttributes>;
+
+export class RadioShowMedia extends Model<RadioShowMediaAttributes, RadioShowMediaCreationAttributes> implements RadioShowMediaAttributes {
+  id!: string;
+  radioShowId!: string;
+  originalMediaType?: number;
+  s3VideoUrl?: string;
+  s3AudioUrl!: string;
+  createDate!: Date;
+  description?: string;
+  cropInstructions?: string;
+  deleted?: boolean;
+  sourceS3Key?: string;
+  isAppRecorded?: boolean;
+  automatedModerationApproved?: boolean;
+  automatedModerationRejectionMetadata?: object;
+  automatedModerationDecidedAt?: Date;
+  manualModerationApproved?: boolean;
+  manualModerationDecidedAt?: Date;
+  manualModerationBy?: string;
+
+  // RadioShowMedia belongsTo RadioShow via radioShowId
+  radioShow!: RadioShow;
+  getRadioShow!: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
+  setRadioShow!: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
+  createRadioShow!: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+  // RadioShowMedia hasMany UserAbuseReports via radioShowMediaId
+  userAbuseReports!: UserAbuseReports[];
+  getUserAbuseReports!: Sequelize.HasManyGetAssociationsMixin<UserAbuseReports>;
+  setUserAbuseReports!: Sequelize.HasManySetAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  addUserAbuseReport!: Sequelize.HasManyAddAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  addUserAbuseReports!: Sequelize.HasManyAddAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  createUserAbuseReport!: Sequelize.HasManyCreateAssociationMixin<UserAbuseReports>;
+  removeUserAbuseReport!: Sequelize.HasManyRemoveAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  removeUserAbuseReports!: Sequelize.HasManyRemoveAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  hasUserAbuseReport!: Sequelize.HasManyHasAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  hasUserAbuseReports!: Sequelize.HasManyHasAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  countUserAbuseReports!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof RadioShowMedia {
+    return RadioShowMedia.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    radioShowId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'radio_show',
+        key: 'id'
+      },
+      field: 'radio_show_id'
+    },
+    originalMediaType: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+      field: 'original_media_type'
+    },
+    s3VideoUrl: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 's3_video_url'
+    },
+    s3AudioUrl: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 's3_audio_url'
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: true
+    },
+    cropInstructions: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'crop_instructions'
+    },
+    deleted: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true
+    },
+    sourceS3Key: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'source_s3_key'
+    },
+    isAppRecorded: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      field: 'is_app_recorded'
+    },
+    automatedModerationApproved: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      field: 'automated_moderation_approved'
+    },
+    automatedModerationRejectionMetadata: {
+      type: DataTypes.JSONB,
+      allowNull: true,
+      field: 'automated_moderation_rejection_metadata'
+    },
+    automatedModerationDecidedAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'automated_moderation_decided_at'
+    },
+    manualModerationApproved: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      field: 'manual_moderation_approved'
+    },
+    manualModerationDecidedAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'manual_moderation_decided_at'
+    },
+    manualModerationBy: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'manual_moderation_by'
+    }
+  }, {
+    sequelize,
+    tableName: 'radio_show_media',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_radio_show_media_show",
+        fields: [
+          { name: "radio_show_id" },
+        ]
+      },
+      {
+        name: "radio_show_media_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/RadioShowPlacement.ts

@@ -0,0 +1,115 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { RadioShow, RadioShowId } from './RadioShow';
+
+export interface RadioShowPlacementAttributes {
+  id: string;
+  radioShowId: string;
+  canonTrackId?: string;
+  radioShowMediaId?: string;
+  seqNum: number;
+  startTime?: string;
+  endTime?: string;
+  deleted?: boolean;
+}
+
+export type RadioShowPlacementPk = "id";
+export type RadioShowPlacementId = RadioShowPlacement[RadioShowPlacementPk];
+export type RadioShowPlacementOptionalAttributes = "id" | "canonTrackId" | "radioShowMediaId" | "startTime" | "endTime" | "deleted";
+export type RadioShowPlacementCreationAttributes = Optional<RadioShowPlacementAttributes, RadioShowPlacementOptionalAttributes>;
+
+export class RadioShowPlacement extends Model<RadioShowPlacementAttributes, RadioShowPlacementCreationAttributes> implements RadioShowPlacementAttributes {
+  id!: string;
+  radioShowId!: string;
+  canonTrackId?: string;
+  radioShowMediaId?: string;
+  seqNum!: number;
+  startTime?: string;
+  endTime?: string;
+  deleted?: boolean;
+
+  // RadioShowPlacement belongsTo CanonTrack via canonTrackId
+  canonTrack!: CanonTrack;
+  getCanonTrack!: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
+  setCanonTrack!: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
+  createCanonTrack!: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+  // RadioShowPlacement 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 RadioShowPlacement {
+    return RadioShowPlacement.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    radioShowId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'radio_show',
+        key: 'id'
+      },
+      field: 'radio_show_id'
+    },
+    canonTrackId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'canon_track',
+        key: 'id'
+      },
+      field: 'canon_track_id'
+    },
+    radioShowMediaId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      field: 'radio_show_media_id'
+    },
+    seqNum: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      field: 'seq_num'
+    },
+    startTime: {
+      type: DataTypes.TIME,
+      allowNull: true,
+      field: 'start_time'
+    },
+    endTime: {
+      type: DataTypes.TIME,
+      allowNull: true,
+      field: 'end_time'
+    },
+    deleted: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true
+    }
+  }, {
+    sequelize,
+    tableName: 'radio_show_placement',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_radio_show_placement_show",
+        fields: [
+          { name: "radio_show_id" },
+        ]
+      },
+      {
+        name: "radio_show_placement_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/RadioShowPublishRequests.ts

@@ -0,0 +1,86 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { RadioShow, RadioShowId } from './RadioShow';
+
+export interface RadioShowPublishRequestsAttributes {
+  id: string;
+  radioShowId: string;
+  approved?: boolean;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type RadioShowPublishRequestsPk = "id";
+export type RadioShowPublishRequestsId = RadioShowPublishRequests[RadioShowPublishRequestsPk];
+export type RadioShowPublishRequestsOptionalAttributes = "id" | "approved" | "createDate" | "updateDate";
+export type RadioShowPublishRequestsCreationAttributes = Optional<RadioShowPublishRequestsAttributes, RadioShowPublishRequestsOptionalAttributes>;
+
+export class RadioShowPublishRequests extends Model<RadioShowPublishRequestsAttributes, RadioShowPublishRequestsCreationAttributes> implements RadioShowPublishRequestsAttributes {
+  id!: string;
+  radioShowId!: string;
+  approved?: boolean;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // RadioShowPublishRequests 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 RadioShowPublishRequests {
+    return RadioShowPublishRequests.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    radioShowId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'radio_show',
+        key: 'id'
+      },
+      field: 'radio_show_id'
+    },
+    approved: {
+      type: DataTypes.BOOLEAN,
+      allowNull: 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_publish_requests',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_radio_show_publish_show",
+        fields: [
+          { name: "radio_show_id" },
+        ]
+      },
+      {
+        name: "radio_show_publish_requests_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/State.ts

@@ -0,0 +1,86 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+import type { PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId } from './PlatformUserPlaylistTrack';
+
+export interface StateAttributes {
+  id: number;
+  description: string;
+}
+
+export type StatePk = "id";
+export type StateId = State[StatePk];
+export type StateCreationAttributes = StateAttributes;
+
+export class State extends Model<StateAttributes, StateCreationAttributes> implements StateAttributes {
+  id!: number;
+  description!: string;
+
+  // State hasMany AppUser via stateId
+  appUsers!: AppUser[];
+  getAppUsers!: Sequelize.HasManyGetAssociationsMixin<AppUser>;
+  setAppUsers!: Sequelize.HasManySetAssociationsMixin<AppUser, AppUserId>;
+  addAppUser!: Sequelize.HasManyAddAssociationMixin<AppUser, AppUserId>;
+  addAppUsers!: Sequelize.HasManyAddAssociationsMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.HasManyCreateAssociationMixin<AppUser>;
+  removeAppUser!: Sequelize.HasManyRemoveAssociationMixin<AppUser, AppUserId>;
+  removeAppUsers!: Sequelize.HasManyRemoveAssociationsMixin<AppUser, AppUserId>;
+  hasAppUser!: Sequelize.HasManyHasAssociationMixin<AppUser, AppUserId>;
+  hasAppUsers!: Sequelize.HasManyHasAssociationsMixin<AppUser, AppUserId>;
+  countAppUsers!: Sequelize.HasManyCountAssociationsMixin;
+  // State hasMany PlatformUserPlaylist via stateId
+  platformUserPlaylists!: PlatformUserPlaylist[];
+  getPlatformUserPlaylists!: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylist>;
+  setPlatformUserPlaylists!: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  addPlatformUserPlaylist!: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  addPlatformUserPlaylists!: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  createPlatformUserPlaylist!: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylist>;
+  removePlatformUserPlaylist!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  removePlatformUserPlaylists!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  hasPlatformUserPlaylist!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  hasPlatformUserPlaylists!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  countPlatformUserPlaylists!: Sequelize.HasManyCountAssociationsMixin;
+  // State hasMany PlatformUserPlaylistTrack via stateId
+  platformUserPlaylistTracks!: PlatformUserPlaylistTrack[];
+  getPlatformUserPlaylistTracks!: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylistTrack>;
+  setPlatformUserPlaylistTracks!: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  addPlatformUserPlaylistTrack!: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  addPlatformUserPlaylistTracks!: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  createPlatformUserPlaylistTrack!: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylistTrack>;
+  removePlatformUserPlaylistTrack!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  removePlatformUserPlaylistTracks!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  hasPlatformUserPlaylistTrack!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  hasPlatformUserPlaylistTracks!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  countPlatformUserPlaylistTracks!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof State {
+    return State.init({
+    id: {
+      autoIncrement: true,
+      autoIncrementIdentity: true,
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'state',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "state_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/TrackDeletionReason.ts

@@ -0,0 +1,58 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+
+export interface TrackDeletionReasonAttributes {
+  id: number;
+  description: string;
+}
+
+export type TrackDeletionReasonPk = "id";
+export type TrackDeletionReasonId = TrackDeletionReason[TrackDeletionReasonPk];
+export type TrackDeletionReasonCreationAttributes = TrackDeletionReasonAttributes;
+
+export class TrackDeletionReason extends Model<TrackDeletionReasonAttributes, TrackDeletionReasonCreationAttributes> implements TrackDeletionReasonAttributes {
+  id!: number;
+  description!: string;
+
+  // TrackDeletionReason hasMany JukeboxQueueEntry via trackDeletionReasonId
+  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;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof TrackDeletionReason {
+    return TrackDeletionReason.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.STRING(255),
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'track_deletion_reason',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "track_deletion_reason_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/UnmatchedAlbum.ts

@@ -0,0 +1,66 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+
+export interface UnmatchedAlbumAttributes {
+  id: string;
+  platformAlbumId: string;
+  createDate: Date;
+}
+
+export type UnmatchedAlbumPk = "id";
+export type UnmatchedAlbumId = UnmatchedAlbum[UnmatchedAlbumPk];
+export type UnmatchedAlbumOptionalAttributes = "id" | "createDate";
+export type UnmatchedAlbumCreationAttributes = Optional<UnmatchedAlbumAttributes, UnmatchedAlbumOptionalAttributes>;
+
+export class UnmatchedAlbum extends Model<UnmatchedAlbumAttributes, UnmatchedAlbumCreationAttributes> implements UnmatchedAlbumAttributes {
+  id!: string;
+  platformAlbumId!: string;
+  createDate!: Date;
+
+  // UnmatchedAlbum belongsTo PlatformAlbum via platformAlbumId
+  platformAlbum!: PlatformAlbum;
+  getPlatformAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+  setPlatformAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  createPlatformAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof UnmatchedAlbum {
+    return UnmatchedAlbum.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    platformAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'platform_album',
+        key: 'id'
+      },
+      field: 'platform_album_id'
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'unmatched_album',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "unmatched_album_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}