@earbug/db-models 0.0.62 → 0.0.63

package/models/PlatformGenre.ts

@@ -0,0 +1,194 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId } from './CanonToPlatformGenreRelation';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId } from './PlatformAlbumGenreRelation';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformArtistGenreRelation, PlatformArtistGenreRelationId } from './PlatformArtistGenreRelation';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { PlatformTrackGenreRelation, PlatformTrackGenreRelationId } from './PlatformTrackGenreRelation';
+
+export interface PlatformGenreAttributes {
+  id: string;
+  platformId: number;
+  name: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type PlatformGenrePk = "id";
+export type PlatformGenreId = PlatformGenre[PlatformGenrePk];
+export type PlatformGenreOptionalAttributes = "id" | "createDate" | "updateDate";
+export type PlatformGenreCreationAttributes = Optional<PlatformGenreAttributes, PlatformGenreOptionalAttributes>;
+
+export class PlatformGenre extends Model<PlatformGenreAttributes, PlatformGenreCreationAttributes> implements PlatformGenreAttributes {
+  id!: string;
+  platformId!: number;
+  name!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // PlatformGenre belongsTo Platform via platformId
+  platform!: Platform;
+  getPlatform!: Sequelize.BelongsToGetAssociationMixin<Platform>;
+  setPlatform!: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+  createPlatform!: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+  // PlatformGenre belongsToMany CanonGenre via platformGenreId and canonGenreId
+  canonGenreIdCanonGenreCanonToPlatformGenreRelations!: CanonGenre[];
+  getCanonGenreIdCanonGenreCanonToPlatformGenreRelations!: Sequelize.BelongsToManyGetAssociationsMixin<CanonGenre>;
+  setCanonGenreIdCanonGenreCanonToPlatformGenreRelations!: Sequelize.BelongsToManySetAssociationsMixin<CanonGenre, CanonGenreId>;
+  addCanonGenreIdCanonGenreCanonToPlatformGenreRelation!: Sequelize.BelongsToManyAddAssociationMixin<CanonGenre, CanonGenreId>;
+  addCanonGenreIdCanonGenreCanonToPlatformGenreRelations!: Sequelize.BelongsToManyAddAssociationsMixin<CanonGenre, CanonGenreId>;
+  createCanonGenreIdCanonGenreCanonToPlatformGenreRelation!: Sequelize.BelongsToManyCreateAssociationMixin<CanonGenre>;
+  removeCanonGenreIdCanonGenreCanonToPlatformGenreRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonGenre, CanonGenreId>;
+  removeCanonGenreIdCanonGenreCanonToPlatformGenreRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonGenre, CanonGenreId>;
+  hasCanonGenreIdCanonGenreCanonToPlatformGenreRelation!: Sequelize.BelongsToManyHasAssociationMixin<CanonGenre, CanonGenreId>;
+  hasCanonGenreIdCanonGenreCanonToPlatformGenreRelations!: Sequelize.BelongsToManyHasAssociationsMixin<CanonGenre, CanonGenreId>;
+  countCanonGenreIdCanonGenreCanonToPlatformGenreRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformGenre hasMany CanonToPlatformGenreRelation via platformGenreId
+  canonToPlatformGenreRelations!: CanonToPlatformGenreRelation[];
+  getCanonToPlatformGenreRelations!: Sequelize.HasManyGetAssociationsMixin<CanonToPlatformGenreRelation>;
+  setCanonToPlatformGenreRelations!: Sequelize.HasManySetAssociationsMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  addCanonToPlatformGenreRelation!: Sequelize.HasManyAddAssociationMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  addCanonToPlatformGenreRelations!: Sequelize.HasManyAddAssociationsMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  createCanonToPlatformGenreRelation!: Sequelize.HasManyCreateAssociationMixin<CanonToPlatformGenreRelation>;
+  removeCanonToPlatformGenreRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  removeCanonToPlatformGenreRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  hasCanonToPlatformGenreRelation!: Sequelize.HasManyHasAssociationMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  hasCanonToPlatformGenreRelations!: Sequelize.HasManyHasAssociationsMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  countCanonToPlatformGenreRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformGenre belongsToMany PlatformAlbum via platformGenreId and platformAlbumId
+  platformAlbumIdPlatformAlbumPlatformAlbumGenreRelations!: PlatformAlbum[];
+  getPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+  setPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  addPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  addPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  createPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+  removePlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  removePlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  hasPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  hasPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  countPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformGenre hasMany PlatformAlbumGenreRelation via platformGenreId
+  platformAlbumGenreRelations!: PlatformAlbumGenreRelation[];
+  getPlatformAlbumGenreRelations!: Sequelize.HasManyGetAssociationsMixin<PlatformAlbumGenreRelation>;
+  setPlatformAlbumGenreRelations!: Sequelize.HasManySetAssociationsMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+  addPlatformAlbumGenreRelation!: Sequelize.HasManyAddAssociationMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+  addPlatformAlbumGenreRelations!: Sequelize.HasManyAddAssociationsMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+  createPlatformAlbumGenreRelation!: Sequelize.HasManyCreateAssociationMixin<PlatformAlbumGenreRelation>;
+  removePlatformAlbumGenreRelation!: Sequelize.HasManyRemoveAssociationMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+  removePlatformAlbumGenreRelations!: Sequelize.HasManyRemoveAssociationsMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+  hasPlatformAlbumGenreRelation!: Sequelize.HasManyHasAssociationMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+  hasPlatformAlbumGenreRelations!: Sequelize.HasManyHasAssociationsMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+  countPlatformAlbumGenreRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformGenre belongsToMany PlatformArtist via platformGenreId and platformArtistId
+  platformArtistIdPlatformArtistPlatformArtistGenreRelations!: PlatformArtist[];
+  getPlatformArtistIdPlatformArtistPlatformArtistGenreRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+  setPlatformArtistIdPlatformArtistPlatformArtistGenreRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  addPlatformArtistIdPlatformArtistPlatformArtistGenreRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+  addPlatformArtistIdPlatformArtistPlatformArtistGenreRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  createPlatformArtistIdPlatformArtistPlatformArtistGenreRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+  removePlatformArtistIdPlatformArtistPlatformArtistGenreRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+  removePlatformArtistIdPlatformArtistPlatformArtistGenreRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  hasPlatformArtistIdPlatformArtistPlatformArtistGenreRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+  hasPlatformArtistIdPlatformArtistPlatformArtistGenreRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  countPlatformArtistIdPlatformArtistPlatformArtistGenreRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformGenre hasMany PlatformArtistGenreRelation via platformGenreId
+  platformArtistGenreRelations!: PlatformArtistGenreRelation[];
+  getPlatformArtistGenreRelations!: Sequelize.HasManyGetAssociationsMixin<PlatformArtistGenreRelation>;
+  setPlatformArtistGenreRelations!: Sequelize.HasManySetAssociationsMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+  addPlatformArtistGenreRelation!: Sequelize.HasManyAddAssociationMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+  addPlatformArtistGenreRelations!: Sequelize.HasManyAddAssociationsMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+  createPlatformArtistGenreRelation!: Sequelize.HasManyCreateAssociationMixin<PlatformArtistGenreRelation>;
+  removePlatformArtistGenreRelation!: Sequelize.HasManyRemoveAssociationMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+  removePlatformArtistGenreRelations!: Sequelize.HasManyRemoveAssociationsMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+  hasPlatformArtistGenreRelation!: Sequelize.HasManyHasAssociationMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+  hasPlatformArtistGenreRelations!: Sequelize.HasManyHasAssociationsMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+  countPlatformArtistGenreRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformGenre belongsToMany PlatformTrack via platformGenreId and platformTrackId
+  platformTrackIdPlatformTrackPlatformTrackGenreRelations!: PlatformTrack[];
+  getPlatformTrackIdPlatformTrackPlatformTrackGenreRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformTrack>;
+  setPlatformTrackIdPlatformTrackPlatformTrackGenreRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  addPlatformTrackIdPlatformTrackPlatformTrackGenreRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformTrack, PlatformTrackId>;
+  addPlatformTrackIdPlatformTrackPlatformTrackGenreRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  createPlatformTrackIdPlatformTrackPlatformTrackGenreRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformTrack>;
+  removePlatformTrackIdPlatformTrackPlatformTrackGenreRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformTrack, PlatformTrackId>;
+  removePlatformTrackIdPlatformTrackPlatformTrackGenreRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  hasPlatformTrackIdPlatformTrackPlatformTrackGenreRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
+  hasPlatformTrackIdPlatformTrackPlatformTrackGenreRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  countPlatformTrackIdPlatformTrackPlatformTrackGenreRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformGenre hasMany PlatformTrackGenreRelation via platformGenreId
+  platformTrackGenreRelations!: PlatformTrackGenreRelation[];
+  getPlatformTrackGenreRelations!: Sequelize.HasManyGetAssociationsMixin<PlatformTrackGenreRelation>;
+  setPlatformTrackGenreRelations!: Sequelize.HasManySetAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  addPlatformTrackGenreRelation!: Sequelize.HasManyAddAssociationMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  addPlatformTrackGenreRelations!: Sequelize.HasManyAddAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  createPlatformTrackGenreRelation!: Sequelize.HasManyCreateAssociationMixin<PlatformTrackGenreRelation>;
+  removePlatformTrackGenreRelation!: Sequelize.HasManyRemoveAssociationMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  removePlatformTrackGenreRelations!: Sequelize.HasManyRemoveAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  hasPlatformTrackGenreRelation!: Sequelize.HasManyHasAssociationMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  hasPlatformTrackGenreRelations!: Sequelize.HasManyHasAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  countPlatformTrackGenreRelations!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof PlatformGenre {
+    return PlatformGenre.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    platformId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'platform',
+        key: 'id'
+      },
+      unique: "platform_genre_name_pkey",
+      field: 'platform_id'
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "platform_genre_name_pkey"
+    },
+    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: 'platform_genre',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "platform_genre_name_pkey",
+        unique: true,
+        fields: [
+          { name: "platform_id" },
+          { name: "name" },
+        ]
+      },
+      {
+        name: "platform_genre_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/PlatformTrack.ts

@@ -0,0 +1,339 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId } from './CanonToPlatformTrackRelation';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId } from './PlatformAlbumTrackRelation';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformArtistTrackRelation, PlatformArtistTrackRelationId } from './PlatformArtistTrackRelation';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+import type { PlatformTrackGenreRelation, PlatformTrackGenreRelationId } from './PlatformTrackGenreRelation';
+import type { PlatformUserAlbumTrack, PlatformUserAlbumTrackId } from './PlatformUserAlbumTrack';
+import type { PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId } from './PlatformUserPlaylistTrack';
+import type { Versus, VersusId } from './Versus';
+import type { VersusOption, VersusOptionId } from './VersusOption';
+import type { VersusPublishIssue, VersusPublishIssueId } from './VersusPublishIssue';
+
+export interface PlatformTrackAttributes {
+  id: string;
+  platformId: number;
+  externalTrackId: string;
+  name: string;
+  asciiName: string;
+  durationMs: number;
+  explicit?: boolean;
+  popularity?: number;
+  discNumber?: number;
+  discTrackNumber?: number;
+  createDate: Date;
+  updateDate: Date;
+  lastHarvestDate?: Date;
+  lastHarvestLog?: string;
+}
+
+export type PlatformTrackPk = "id";
+export type PlatformTrackId = PlatformTrack[PlatformTrackPk];
+export type PlatformTrackOptionalAttributes = "id" | "explicit" | "popularity" | "discNumber" | "discTrackNumber" | "createDate" | "updateDate" | "lastHarvestDate" | "lastHarvestLog";
+export type PlatformTrackCreationAttributes = Optional<PlatformTrackAttributes, PlatformTrackOptionalAttributes>;
+
+export class PlatformTrack extends Model<PlatformTrackAttributes, PlatformTrackCreationAttributes> implements PlatformTrackAttributes {
+  id!: string;
+  platformId!: number;
+  externalTrackId!: string;
+  name!: string;
+  asciiName!: string;
+  durationMs!: number;
+  explicit?: boolean;
+  popularity?: number;
+  discNumber?: number;
+  discTrackNumber?: number;
+  createDate!: Date;
+  updateDate!: Date;
+  lastHarvestDate?: Date;
+  lastHarvestLog?: string;
+
+  // PlatformTrack belongsTo Platform via platformId
+  platform!: Platform;
+  getPlatform!: Sequelize.BelongsToGetAssociationMixin<Platform>;
+  setPlatform!: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+  createPlatform!: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+  // PlatformTrack hasMany CanonToPlatformTrackRelation via platformTrackId
+  canonToPlatformTrackRelations!: CanonToPlatformTrackRelation[];
+  getCanonToPlatformTrackRelations!: Sequelize.HasManyGetAssociationsMixin<CanonToPlatformTrackRelation>;
+  setCanonToPlatformTrackRelations!: Sequelize.HasManySetAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  addCanonToPlatformTrackRelation!: Sequelize.HasManyAddAssociationMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  addCanonToPlatformTrackRelations!: Sequelize.HasManyAddAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  createCanonToPlatformTrackRelation!: Sequelize.HasManyCreateAssociationMixin<CanonToPlatformTrackRelation>;
+  removeCanonToPlatformTrackRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  removeCanonToPlatformTrackRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  hasCanonToPlatformTrackRelation!: Sequelize.HasManyHasAssociationMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  hasCanonToPlatformTrackRelations!: Sequelize.HasManyHasAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  countCanonToPlatformTrackRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformTrack belongsToMany CanonTrack via platformTrackId and canonTrackId
+  canonTrackIdCanonTrackCanonToPlatformTrackRelations!: CanonTrack[];
+  getCanonTrackIdCanonTrackCanonToPlatformTrackRelations!: Sequelize.BelongsToManyGetAssociationsMixin<CanonTrack>;
+  setCanonTrackIdCanonTrackCanonToPlatformTrackRelations!: Sequelize.BelongsToManySetAssociationsMixin<CanonTrack, CanonTrackId>;
+  addCanonTrackIdCanonTrackCanonToPlatformTrackRelation!: Sequelize.BelongsToManyAddAssociationMixin<CanonTrack, CanonTrackId>;
+  addCanonTrackIdCanonTrackCanonToPlatformTrackRelations!: Sequelize.BelongsToManyAddAssociationsMixin<CanonTrack, CanonTrackId>;
+  createCanonTrackIdCanonTrackCanonToPlatformTrackRelation!: Sequelize.BelongsToManyCreateAssociationMixin<CanonTrack>;
+  removeCanonTrackIdCanonTrackCanonToPlatformTrackRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonTrack, CanonTrackId>;
+  removeCanonTrackIdCanonTrackCanonToPlatformTrackRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonTrack, CanonTrackId>;
+  hasCanonTrackIdCanonTrackCanonToPlatformTrackRelation!: Sequelize.BelongsToManyHasAssociationMixin<CanonTrack, CanonTrackId>;
+  hasCanonTrackIdCanonTrackCanonToPlatformTrackRelations!: Sequelize.BelongsToManyHasAssociationsMixin<CanonTrack, CanonTrackId>;
+  countCanonTrackIdCanonTrackCanonToPlatformTrackRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformTrack hasMany JukeboxQueueEntry via platformTrackId
+  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;
+  // PlatformTrack belongsToMany PlatformAlbum via platformTrackId and platformAlbumId
+  platformAlbumIdPlatformAlbumPlatformAlbumTrackRelations!: PlatformAlbum[];
+  getPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+  setPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  addPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  addPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  createPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+  removePlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  removePlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  hasPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  hasPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  countPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformTrack hasMany PlatformAlbumTrackRelation via platformTrackId
+  platformAlbumTrackRelations!: PlatformAlbumTrackRelation[];
+  getPlatformAlbumTrackRelations!: Sequelize.HasManyGetAssociationsMixin<PlatformAlbumTrackRelation>;
+  setPlatformAlbumTrackRelations!: Sequelize.HasManySetAssociationsMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+  addPlatformAlbumTrackRelation!: Sequelize.HasManyAddAssociationMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+  addPlatformAlbumTrackRelations!: Sequelize.HasManyAddAssociationsMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+  createPlatformAlbumTrackRelation!: Sequelize.HasManyCreateAssociationMixin<PlatformAlbumTrackRelation>;
+  removePlatformAlbumTrackRelation!: Sequelize.HasManyRemoveAssociationMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+  removePlatformAlbumTrackRelations!: Sequelize.HasManyRemoveAssociationsMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+  hasPlatformAlbumTrackRelation!: Sequelize.HasManyHasAssociationMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+  hasPlatformAlbumTrackRelations!: Sequelize.HasManyHasAssociationsMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+  countPlatformAlbumTrackRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformTrack belongsToMany PlatformArtist via platformTrackId and platformArtistId
+  platformArtistIdPlatformArtistPlatformArtistTrackRelations!: PlatformArtist[];
+  getPlatformArtistIdPlatformArtistPlatformArtistTrackRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+  setPlatformArtistIdPlatformArtistPlatformArtistTrackRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  addPlatformArtistIdPlatformArtistPlatformArtistTrackRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+  addPlatformArtistIdPlatformArtistPlatformArtistTrackRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  createPlatformArtistIdPlatformArtistPlatformArtistTrackRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+  removePlatformArtistIdPlatformArtistPlatformArtistTrackRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+  removePlatformArtistIdPlatformArtistPlatformArtistTrackRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  hasPlatformArtistIdPlatformArtistPlatformArtistTrackRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+  hasPlatformArtistIdPlatformArtistPlatformArtistTrackRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  countPlatformArtistIdPlatformArtistPlatformArtistTrackRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformTrack hasMany PlatformArtistTrackRelation via platformTrackId
+  platformArtistTrackRelations!: PlatformArtistTrackRelation[];
+  getPlatformArtistTrackRelations!: Sequelize.HasManyGetAssociationsMixin<PlatformArtistTrackRelation>;
+  setPlatformArtistTrackRelations!: Sequelize.HasManySetAssociationsMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+  addPlatformArtistTrackRelation!: Sequelize.HasManyAddAssociationMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+  addPlatformArtistTrackRelations!: Sequelize.HasManyAddAssociationsMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+  createPlatformArtistTrackRelation!: Sequelize.HasManyCreateAssociationMixin<PlatformArtistTrackRelation>;
+  removePlatformArtistTrackRelation!: Sequelize.HasManyRemoveAssociationMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+  removePlatformArtistTrackRelations!: Sequelize.HasManyRemoveAssociationsMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+  hasPlatformArtistTrackRelation!: Sequelize.HasManyHasAssociationMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+  hasPlatformArtistTrackRelations!: Sequelize.HasManyHasAssociationsMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+  countPlatformArtistTrackRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformTrack belongsToMany PlatformGenre via platformTrackId and platformGenreId
+  platformGenreIdPlatformGenrePlatformTrackGenreRelations!: PlatformGenre[];
+  getPlatformGenreIdPlatformGenrePlatformTrackGenreRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformGenre>;
+  setPlatformGenreIdPlatformGenrePlatformTrackGenreRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  addPlatformGenreIdPlatformGenrePlatformTrackGenreRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformGenre, PlatformGenreId>;
+  addPlatformGenreIdPlatformGenrePlatformTrackGenreRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  createPlatformGenreIdPlatformGenrePlatformTrackGenreRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformGenre>;
+  removePlatformGenreIdPlatformGenrePlatformTrackGenreRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformGenre, PlatformGenreId>;
+  removePlatformGenreIdPlatformGenrePlatformTrackGenreRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  hasPlatformGenreIdPlatformGenrePlatformTrackGenreRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformGenre, PlatformGenreId>;
+  hasPlatformGenreIdPlatformGenrePlatformTrackGenreRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  countPlatformGenreIdPlatformGenrePlatformTrackGenreRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformTrack hasMany PlatformTrackGenreRelation via platformTrackId
+  platformTrackGenreRelations!: PlatformTrackGenreRelation[];
+  getPlatformTrackGenreRelations!: Sequelize.HasManyGetAssociationsMixin<PlatformTrackGenreRelation>;
+  setPlatformTrackGenreRelations!: Sequelize.HasManySetAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  addPlatformTrackGenreRelation!: Sequelize.HasManyAddAssociationMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  addPlatformTrackGenreRelations!: Sequelize.HasManyAddAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  createPlatformTrackGenreRelation!: Sequelize.HasManyCreateAssociationMixin<PlatformTrackGenreRelation>;
+  removePlatformTrackGenreRelation!: Sequelize.HasManyRemoveAssociationMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  removePlatformTrackGenreRelations!: Sequelize.HasManyRemoveAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  hasPlatformTrackGenreRelation!: Sequelize.HasManyHasAssociationMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  hasPlatformTrackGenreRelations!: Sequelize.HasManyHasAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+  countPlatformTrackGenreRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformTrack hasMany PlatformUserAlbumTrack via platformTrackId
+  platformUserAlbumTracks!: PlatformUserAlbumTrack[];
+  getPlatformUserAlbumTracks!: Sequelize.HasManyGetAssociationsMixin<PlatformUserAlbumTrack>;
+  setPlatformUserAlbumTracks!: Sequelize.HasManySetAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  addPlatformUserAlbumTrack!: Sequelize.HasManyAddAssociationMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  addPlatformUserAlbumTracks!: Sequelize.HasManyAddAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  createPlatformUserAlbumTrack!: Sequelize.HasManyCreateAssociationMixin<PlatformUserAlbumTrack>;
+  removePlatformUserAlbumTrack!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  removePlatformUserAlbumTracks!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  hasPlatformUserAlbumTrack!: Sequelize.HasManyHasAssociationMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  hasPlatformUserAlbumTracks!: Sequelize.HasManyHasAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  countPlatformUserAlbumTracks!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformTrack hasMany PlatformUserPlaylistTrack via platformTrackId
+  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;
+  // PlatformTrack hasMany Versus via platformTrackId
+  versus!: Versus[];
+  getVersus!: Sequelize.HasManyGetAssociationsMixin<Versus>;
+  setVersus!: Sequelize.HasManySetAssociationsMixin<Versus, VersusId>;
+  addVersu!: Sequelize.HasManyAddAssociationMixin<Versus, VersusId>;
+  addVersus!: Sequelize.HasManyAddAssociationsMixin<Versus, VersusId>;
+  createVersu!: Sequelize.HasManyCreateAssociationMixin<Versus>;
+  removeVersu!: Sequelize.HasManyRemoveAssociationMixin<Versus, VersusId>;
+  removeVersus!: Sequelize.HasManyRemoveAssociationsMixin<Versus, VersusId>;
+  hasVersu!: Sequelize.HasManyHasAssociationMixin<Versus, VersusId>;
+  hasVersus!: Sequelize.HasManyHasAssociationsMixin<Versus, VersusId>;
+  countVersus!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformTrack hasMany VersusOption via platformTrackId
+  versusOptions!: VersusOption[];
+  getVersusOptions!: Sequelize.HasManyGetAssociationsMixin<VersusOption>;
+  setVersusOptions!: Sequelize.HasManySetAssociationsMixin<VersusOption, VersusOptionId>;
+  addVersusOption!: Sequelize.HasManyAddAssociationMixin<VersusOption, VersusOptionId>;
+  addVersusOptions!: Sequelize.HasManyAddAssociationsMixin<VersusOption, VersusOptionId>;
+  createVersusOption!: Sequelize.HasManyCreateAssociationMixin<VersusOption>;
+  removeVersusOption!: Sequelize.HasManyRemoveAssociationMixin<VersusOption, VersusOptionId>;
+  removeVersusOptions!: Sequelize.HasManyRemoveAssociationsMixin<VersusOption, VersusOptionId>;
+  hasVersusOption!: Sequelize.HasManyHasAssociationMixin<VersusOption, VersusOptionId>;
+  hasVersusOptions!: Sequelize.HasManyHasAssociationsMixin<VersusOption, VersusOptionId>;
+  countVersusOptions!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformTrack hasMany VersusPublishIssue via platformTrackId
+  versusPublishIssues!: VersusPublishIssue[];
+  getVersusPublishIssues!: Sequelize.HasManyGetAssociationsMixin<VersusPublishIssue>;
+  setVersusPublishIssues!: Sequelize.HasManySetAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
+  addVersusPublishIssue!: Sequelize.HasManyAddAssociationMixin<VersusPublishIssue, VersusPublishIssueId>;
+  addVersusPublishIssues!: Sequelize.HasManyAddAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
+  createVersusPublishIssue!: Sequelize.HasManyCreateAssociationMixin<VersusPublishIssue>;
+  removeVersusPublishIssue!: Sequelize.HasManyRemoveAssociationMixin<VersusPublishIssue, VersusPublishIssueId>;
+  removeVersusPublishIssues!: Sequelize.HasManyRemoveAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
+  hasVersusPublishIssue!: Sequelize.HasManyHasAssociationMixin<VersusPublishIssue, VersusPublishIssueId>;
+  hasVersusPublishIssues!: Sequelize.HasManyHasAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
+  countVersusPublishIssues!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof PlatformTrack {
+    return PlatformTrack.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    platformId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'platform',
+        key: 'id'
+      },
+      unique: "uk_platform_id_external_track_id",
+      field: 'platform_id'
+    },
+    externalTrackId: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "uk_platform_id_external_track_id",
+      field: 'external_track_id'
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    asciiName: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'ascii_name'
+    },
+    durationMs: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      field: 'duration_ms'
+    },
+    explicit: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true
+    },
+    popularity: {
+      type: DataTypes.SMALLINT,
+      allowNull: true
+    },
+    discNumber: {
+      type: DataTypes.SMALLINT,
+      allowNull: true,
+      field: 'disc_number'
+    },
+    discTrackNumber: {
+      type: DataTypes.SMALLINT,
+      allowNull: true,
+      field: 'disc_track_number'
+    },
+    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'
+    },
+    lastHarvestDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'last_harvest_date'
+    },
+    lastHarvestLog: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'last_harvest_log'
+    }
+  }, {
+    sequelize,
+    tableName: 'platform_track',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_platform_track_external_track_id",
+        fields: [
+          { name: "external_track_id" },
+        ]
+      },
+      {
+        name: "platform_track_pkey1",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "uk_platform_id_external_track_id",
+        unique: true,
+        fields: [
+          { name: "platform_id" },
+          { name: "external_track_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/PlatformTrackGenreRelation.ts

@@ -0,0 +1,86 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+
+export interface PlatformTrackGenreRelationAttributes {
+  platformGenreId: string;
+  platformTrackId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type PlatformTrackGenreRelationPk = "platformGenreId" | "platformTrackId";
+export type PlatformTrackGenreRelationId = PlatformTrackGenreRelation[PlatformTrackGenreRelationPk];
+export type PlatformTrackGenreRelationOptionalAttributes = "createDate" | "updateDate";
+export type PlatformTrackGenreRelationCreationAttributes = Optional<PlatformTrackGenreRelationAttributes, PlatformTrackGenreRelationOptionalAttributes>;
+
+export class PlatformTrackGenreRelation extends Model<PlatformTrackGenreRelationAttributes, PlatformTrackGenreRelationCreationAttributes> implements PlatformTrackGenreRelationAttributes {
+  platformGenreId!: string;
+  platformTrackId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // PlatformTrackGenreRelation belongsTo PlatformGenre via platformGenreId
+  platformGenre!: PlatformGenre;
+  getPlatformGenre!: Sequelize.BelongsToGetAssociationMixin<PlatformGenre>;
+  setPlatformGenre!: Sequelize.BelongsToSetAssociationMixin<PlatformGenre, PlatformGenreId>;
+  createPlatformGenre!: Sequelize.BelongsToCreateAssociationMixin<PlatformGenre>;
+  // PlatformTrackGenreRelation belongsTo PlatformTrack via platformTrackId
+  platformTrack!: PlatformTrack;
+  getPlatformTrack!: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+  setPlatformTrack!: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+  createPlatformTrack!: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof PlatformTrackGenreRelation {
+    return PlatformTrackGenreRelation.init({
+    platformGenreId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_genre',
+        key: 'id'
+      },
+      field: 'platform_genre_id'
+    },
+    platformTrackId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_track',
+        key: 'id'
+      },
+      field: 'platform_track_id'
+    },
+    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: 'platform_track_genre_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "platform_track_genre_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "platform_track_id" },
+          { name: "platform_genre_id" },
+        ]
+      },
+    ]
+  });
+  }
+}