@earbug/db-models 0.0.62 → 0.0.63

package/models/PlatformAlbum.ts

@@ -0,0 +1,398 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { CanonAlbumGenreRelation, CanonAlbumGenreRelationId } from './CanonAlbumGenreRelation';
+import type { CanonAlbumLabelRelation, CanonAlbumLabelRelationId } from './CanonAlbumLabelRelation';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { CanonArtistAlbumRelation, CanonArtistAlbumRelationId } from './CanonArtistAlbumRelation';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { CanonLabel, CanonLabelId } from './CanonLabel';
+import type { CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId } from './CanonToPlatformAlbumRelation';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId } from './PlatformAlbumGenreRelation';
+import type { PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId } from './PlatformAlbumTrackRelation';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId } from './PlatformArtistAlbumRelation';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum';
+import type { UnmatchedAlbum, UnmatchedAlbumId } from './UnmatchedAlbum';
+import type { Versus, VersusId } from './Versus';
+import type { VersusOption, VersusOptionId } from './VersusOption';
+import type { VersusPublishIssue, VersusPublishIssueId } from './VersusPublishIssue';
+
+export interface PlatformAlbumAttributes {
+  id: string;
+  platformId: number;
+  externalAlbumId: string;
+  name: string;
+  asciiName: string;
+  albumType?: string;
+  releaseDate?: string;
+  popularity?: number;
+  recordLabel?: string;
+  createDate: Date;
+  updateDate: Date;
+  images?: object;
+  lastHarvestDate?: Date;
+  lastHarvestLog?: string;
+}
+
+export type PlatformAlbumPk = "id";
+export type PlatformAlbumId = PlatformAlbum[PlatformAlbumPk];
+export type PlatformAlbumOptionalAttributes = "id" | "albumType" | "releaseDate" | "popularity" | "recordLabel" | "createDate" | "updateDate" | "images" | "lastHarvestDate" | "lastHarvestLog";
+export type PlatformAlbumCreationAttributes = Optional<PlatformAlbumAttributes, PlatformAlbumOptionalAttributes>;
+
+export class PlatformAlbum extends Model<PlatformAlbumAttributes, PlatformAlbumCreationAttributes> implements PlatformAlbumAttributes {
+  id!: string;
+  platformId!: number;
+  externalAlbumId!: string;
+  name!: string;
+  asciiName!: string;
+  albumType?: string;
+  releaseDate?: string;
+  popularity?: number;
+  recordLabel?: string;
+  createDate!: Date;
+  updateDate!: Date;
+  images?: object;
+  lastHarvestDate?: Date;
+  lastHarvestLog?: string;
+
+  // PlatformAlbum belongsTo Platform via platformId
+  platform!: Platform;
+  getPlatform!: Sequelize.BelongsToGetAssociationMixin<Platform>;
+  setPlatform!: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+  createPlatform!: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+  // PlatformAlbum belongsToMany CanonAlbum via platformAlbumId and canonAlbumId
+  canonAlbumIdCanonAlbumCanonToPlatformAlbumRelations!: CanonAlbum[];
+  getCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelations!: Sequelize.BelongsToManyGetAssociationsMixin<CanonAlbum>;
+  setCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelations!: Sequelize.BelongsToManySetAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  addCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelation!: Sequelize.BelongsToManyAddAssociationMixin<CanonAlbum, CanonAlbumId>;
+  addCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelations!: Sequelize.BelongsToManyAddAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  createCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelation!: Sequelize.BelongsToManyCreateAssociationMixin<CanonAlbum>;
+  removeCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonAlbum, CanonAlbumId>;
+  removeCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  hasCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelation!: Sequelize.BelongsToManyHasAssociationMixin<CanonAlbum, CanonAlbumId>;
+  hasCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelations!: Sequelize.BelongsToManyHasAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  countCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformAlbum hasMany CanonAlbumGenreRelation via canonAlbumId
+  canonAlbumGenreRelations!: CanonAlbumGenreRelation[];
+  getCanonAlbumGenreRelations!: Sequelize.HasManyGetAssociationsMixin<CanonAlbumGenreRelation>;
+  setCanonAlbumGenreRelations!: Sequelize.HasManySetAssociationsMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+  addCanonAlbumGenreRelation!: Sequelize.HasManyAddAssociationMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+  addCanonAlbumGenreRelations!: Sequelize.HasManyAddAssociationsMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+  createCanonAlbumGenreRelation!: Sequelize.HasManyCreateAssociationMixin<CanonAlbumGenreRelation>;
+  removeCanonAlbumGenreRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+  removeCanonAlbumGenreRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+  hasCanonAlbumGenreRelation!: Sequelize.HasManyHasAssociationMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+  hasCanonAlbumGenreRelations!: Sequelize.HasManyHasAssociationsMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+  countCanonAlbumGenreRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformAlbum hasMany CanonAlbumLabelRelation via canonAlbumId
+  canonAlbumLabelRelations!: CanonAlbumLabelRelation[];
+  getCanonAlbumLabelRelations!: Sequelize.HasManyGetAssociationsMixin<CanonAlbumLabelRelation>;
+  setCanonAlbumLabelRelations!: Sequelize.HasManySetAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  addCanonAlbumLabelRelation!: Sequelize.HasManyAddAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  addCanonAlbumLabelRelations!: Sequelize.HasManyAddAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  createCanonAlbumLabelRelation!: Sequelize.HasManyCreateAssociationMixin<CanonAlbumLabelRelation>;
+  removeCanonAlbumLabelRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  removeCanonAlbumLabelRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  hasCanonAlbumLabelRelation!: Sequelize.HasManyHasAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  hasCanonAlbumLabelRelations!: Sequelize.HasManyHasAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  countCanonAlbumLabelRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformAlbum belongsToMany CanonArtist via canonAlbumId and canonArtistId
+  canonArtistIdCanonArtists!: CanonArtist[];
+  getCanonArtistIdCanonArtists!: Sequelize.BelongsToManyGetAssociationsMixin<CanonArtist>;
+  setCanonArtistIdCanonArtists!: Sequelize.BelongsToManySetAssociationsMixin<CanonArtist, CanonArtistId>;
+  addCanonArtistIdCanonArtist!: Sequelize.BelongsToManyAddAssociationMixin<CanonArtist, CanonArtistId>;
+  addCanonArtistIdCanonArtists!: Sequelize.BelongsToManyAddAssociationsMixin<CanonArtist, CanonArtistId>;
+  createCanonArtistIdCanonArtist!: Sequelize.BelongsToManyCreateAssociationMixin<CanonArtist>;
+  removeCanonArtistIdCanonArtist!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonArtist, CanonArtistId>;
+  removeCanonArtistIdCanonArtists!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonArtist, CanonArtistId>;
+  hasCanonArtistIdCanonArtist!: Sequelize.BelongsToManyHasAssociationMixin<CanonArtist, CanonArtistId>;
+  hasCanonArtistIdCanonArtists!: Sequelize.BelongsToManyHasAssociationsMixin<CanonArtist, CanonArtistId>;
+  countCanonArtistIdCanonArtists!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformAlbum hasMany CanonArtistAlbumRelation via canonAlbumId
+  canonArtistAlbumRelations!: CanonArtistAlbumRelation[];
+  getCanonArtistAlbumRelations!: Sequelize.HasManyGetAssociationsMixin<CanonArtistAlbumRelation>;
+  setCanonArtistAlbumRelations!: Sequelize.HasManySetAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+  addCanonArtistAlbumRelation!: Sequelize.HasManyAddAssociationMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+  addCanonArtistAlbumRelations!: Sequelize.HasManyAddAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+  createCanonArtistAlbumRelation!: Sequelize.HasManyCreateAssociationMixin<CanonArtistAlbumRelation>;
+  removeCanonArtistAlbumRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+  removeCanonArtistAlbumRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+  hasCanonArtistAlbumRelation!: Sequelize.HasManyHasAssociationMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+  hasCanonArtistAlbumRelations!: Sequelize.HasManyHasAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+  countCanonArtistAlbumRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformAlbum belongsToMany CanonGenre via canonAlbumId and canonGenreId
+  canonGenreIdCanonGenres!: CanonGenre[];
+  getCanonGenreIdCanonGenres!: Sequelize.BelongsToManyGetAssociationsMixin<CanonGenre>;
+  setCanonGenreIdCanonGenres!: Sequelize.BelongsToManySetAssociationsMixin<CanonGenre, CanonGenreId>;
+  addCanonGenreIdCanonGenre!: Sequelize.BelongsToManyAddAssociationMixin<CanonGenre, CanonGenreId>;
+  addCanonGenreIdCanonGenres!: Sequelize.BelongsToManyAddAssociationsMixin<CanonGenre, CanonGenreId>;
+  createCanonGenreIdCanonGenre!: Sequelize.BelongsToManyCreateAssociationMixin<CanonGenre>;
+  removeCanonGenreIdCanonGenre!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonGenre, CanonGenreId>;
+  removeCanonGenreIdCanonGenres!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonGenre, CanonGenreId>;
+  hasCanonGenreIdCanonGenre!: Sequelize.BelongsToManyHasAssociationMixin<CanonGenre, CanonGenreId>;
+  hasCanonGenreIdCanonGenres!: Sequelize.BelongsToManyHasAssociationsMixin<CanonGenre, CanonGenreId>;
+  countCanonGenreIdCanonGenres!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformAlbum belongsToMany CanonLabel via canonAlbumId and canonLabelId
+  canonLabelIdCanonLabels!: CanonLabel[];
+  getCanonLabelIdCanonLabels!: Sequelize.BelongsToManyGetAssociationsMixin<CanonLabel>;
+  setCanonLabelIdCanonLabels!: Sequelize.BelongsToManySetAssociationsMixin<CanonLabel, CanonLabelId>;
+  addCanonLabelIdCanonLabel!: Sequelize.BelongsToManyAddAssociationMixin<CanonLabel, CanonLabelId>;
+  addCanonLabelIdCanonLabels!: Sequelize.BelongsToManyAddAssociationsMixin<CanonLabel, CanonLabelId>;
+  createCanonLabelIdCanonLabel!: Sequelize.BelongsToManyCreateAssociationMixin<CanonLabel>;
+  removeCanonLabelIdCanonLabel!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonLabel, CanonLabelId>;
+  removeCanonLabelIdCanonLabels!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonLabel, CanonLabelId>;
+  hasCanonLabelIdCanonLabel!: Sequelize.BelongsToManyHasAssociationMixin<CanonLabel, CanonLabelId>;
+  hasCanonLabelIdCanonLabels!: Sequelize.BelongsToManyHasAssociationsMixin<CanonLabel, CanonLabelId>;
+  countCanonLabelIdCanonLabels!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformAlbum hasMany CanonToPlatformAlbumRelation via platformAlbumId
+  canonToPlatformAlbumRelations!: CanonToPlatformAlbumRelation[];
+  getCanonToPlatformAlbumRelations!: Sequelize.HasManyGetAssociationsMixin<CanonToPlatformAlbumRelation>;
+  setCanonToPlatformAlbumRelations!: Sequelize.HasManySetAssociationsMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  addCanonToPlatformAlbumRelation!: Sequelize.HasManyAddAssociationMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  addCanonToPlatformAlbumRelations!: Sequelize.HasManyAddAssociationsMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  createCanonToPlatformAlbumRelation!: Sequelize.HasManyCreateAssociationMixin<CanonToPlatformAlbumRelation>;
+  removeCanonToPlatformAlbumRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  removeCanonToPlatformAlbumRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  hasCanonToPlatformAlbumRelation!: Sequelize.HasManyHasAssociationMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  hasCanonToPlatformAlbumRelations!: Sequelize.HasManyHasAssociationsMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  countCanonToPlatformAlbumRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformAlbum hasMany PlatformAlbumGenreRelation via platformAlbumId
+  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;
+  // PlatformAlbum hasMany PlatformAlbumTrackRelation via platformAlbumId
+  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;
+  // PlatformAlbum belongsToMany PlatformArtist via platformAlbumId and platformArtistId
+  platformArtistIdPlatformArtistPlatformArtistAlbumRelations!: PlatformArtist[];
+  getPlatformArtistIdPlatformArtistPlatformArtistAlbumRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+  setPlatformArtistIdPlatformArtistPlatformArtistAlbumRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  addPlatformArtistIdPlatformArtistPlatformArtistAlbumRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+  addPlatformArtistIdPlatformArtistPlatformArtistAlbumRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  createPlatformArtistIdPlatformArtistPlatformArtistAlbumRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+  removePlatformArtistIdPlatformArtistPlatformArtistAlbumRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+  removePlatformArtistIdPlatformArtistPlatformArtistAlbumRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  hasPlatformArtistIdPlatformArtistPlatformArtistAlbumRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+  hasPlatformArtistIdPlatformArtistPlatformArtistAlbumRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  countPlatformArtistIdPlatformArtistPlatformArtistAlbumRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformAlbum hasMany PlatformArtistAlbumRelation via platformAlbumId
+  platformArtistAlbumRelations!: PlatformArtistAlbumRelation[];
+  getPlatformArtistAlbumRelations!: Sequelize.HasManyGetAssociationsMixin<PlatformArtistAlbumRelation>;
+  setPlatformArtistAlbumRelations!: Sequelize.HasManySetAssociationsMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+  addPlatformArtistAlbumRelation!: Sequelize.HasManyAddAssociationMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+  addPlatformArtistAlbumRelations!: Sequelize.HasManyAddAssociationsMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+  createPlatformArtistAlbumRelation!: Sequelize.HasManyCreateAssociationMixin<PlatformArtistAlbumRelation>;
+  removePlatformArtistAlbumRelation!: Sequelize.HasManyRemoveAssociationMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+  removePlatformArtistAlbumRelations!: Sequelize.HasManyRemoveAssociationsMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+  hasPlatformArtistAlbumRelation!: Sequelize.HasManyHasAssociationMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+  hasPlatformArtistAlbumRelations!: Sequelize.HasManyHasAssociationsMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+  countPlatformArtistAlbumRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformAlbum belongsToMany PlatformGenre via platformAlbumId and platformGenreId
+  platformGenreIdPlatformGenrePlatformAlbumGenreRelations!: PlatformGenre[];
+  getPlatformGenreIdPlatformGenrePlatformAlbumGenreRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformGenre>;
+  setPlatformGenreIdPlatformGenrePlatformAlbumGenreRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  addPlatformGenreIdPlatformGenrePlatformAlbumGenreRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformGenre, PlatformGenreId>;
+  addPlatformGenreIdPlatformGenrePlatformAlbumGenreRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  createPlatformGenreIdPlatformGenrePlatformAlbumGenreRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformGenre>;
+  removePlatformGenreIdPlatformGenrePlatformAlbumGenreRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformGenre, PlatformGenreId>;
+  removePlatformGenreIdPlatformGenrePlatformAlbumGenreRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  hasPlatformGenreIdPlatformGenrePlatformAlbumGenreRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformGenre, PlatformGenreId>;
+  hasPlatformGenreIdPlatformGenrePlatformAlbumGenreRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  countPlatformGenreIdPlatformGenrePlatformAlbumGenreRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformAlbum belongsToMany PlatformTrack via platformAlbumId and platformTrackId
+  platformTrackIdPlatformTrackPlatformAlbumTrackRelations!: PlatformTrack[];
+  getPlatformTrackIdPlatformTrackPlatformAlbumTrackRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformTrack>;
+  setPlatformTrackIdPlatformTrackPlatformAlbumTrackRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  addPlatformTrackIdPlatformTrackPlatformAlbumTrackRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformTrack, PlatformTrackId>;
+  addPlatformTrackIdPlatformTrackPlatformAlbumTrackRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  createPlatformTrackIdPlatformTrackPlatformAlbumTrackRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformTrack>;
+  removePlatformTrackIdPlatformTrackPlatformAlbumTrackRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformTrack, PlatformTrackId>;
+  removePlatformTrackIdPlatformTrackPlatformAlbumTrackRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  hasPlatformTrackIdPlatformTrackPlatformAlbumTrackRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
+  hasPlatformTrackIdPlatformTrackPlatformAlbumTrackRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  countPlatformTrackIdPlatformTrackPlatformAlbumTrackRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformAlbum hasMany PlatformUserAlbum via platformAlbumId
+  platformUserAlbums!: PlatformUserAlbum[];
+  getPlatformUserAlbums!: Sequelize.HasManyGetAssociationsMixin<PlatformUserAlbum>;
+  setPlatformUserAlbums!: Sequelize.HasManySetAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  addPlatformUserAlbum!: Sequelize.HasManyAddAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  addPlatformUserAlbums!: Sequelize.HasManyAddAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  createPlatformUserAlbum!: Sequelize.HasManyCreateAssociationMixin<PlatformUserAlbum>;
+  removePlatformUserAlbum!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  removePlatformUserAlbums!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  hasPlatformUserAlbum!: Sequelize.HasManyHasAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  hasPlatformUserAlbums!: Sequelize.HasManyHasAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  countPlatformUserAlbums!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformAlbum hasMany UnmatchedAlbum via platformAlbumId
+  unmatchedAlbums!: UnmatchedAlbum[];
+  getUnmatchedAlbums!: Sequelize.HasManyGetAssociationsMixin<UnmatchedAlbum>;
+  setUnmatchedAlbums!: Sequelize.HasManySetAssociationsMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+  addUnmatchedAlbum!: Sequelize.HasManyAddAssociationMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+  addUnmatchedAlbums!: Sequelize.HasManyAddAssociationsMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+  createUnmatchedAlbum!: Sequelize.HasManyCreateAssociationMixin<UnmatchedAlbum>;
+  removeUnmatchedAlbum!: Sequelize.HasManyRemoveAssociationMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+  removeUnmatchedAlbums!: Sequelize.HasManyRemoveAssociationsMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+  hasUnmatchedAlbum!: Sequelize.HasManyHasAssociationMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+  hasUnmatchedAlbums!: Sequelize.HasManyHasAssociationsMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+  countUnmatchedAlbums!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformAlbum hasMany Versus via platformAlbumId
+  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;
+  // PlatformAlbum hasMany VersusOption via platformAlbumId
+  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;
+  // PlatformAlbum hasMany VersusPublishIssue via platformAlbumId
+  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 PlatformAlbum {
+    return PlatformAlbum.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_album_id",
+      field: 'platform_id'
+    },
+    externalAlbumId: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "uk_platform_id_external_album_id",
+      field: 'external_album_id'
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    asciiName: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'ascii_name'
+    },
+    albumType: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'album_type'
+    },
+    releaseDate: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'release_date'
+    },
+    popularity: {
+      type: DataTypes.SMALLINT,
+      allowNull: true
+    },
+    recordLabel: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'record_label'
+    },
+    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'
+    },
+    images: {
+      type: DataTypes.JSONB,
+      allowNull: true
+    },
+    lastHarvestDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'last_harvest_date'
+    },
+    lastHarvestLog: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'last_harvest_log'
+    }
+  }, {
+    sequelize,
+    tableName: 'platform_album',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "platform_album_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "uk_platform_id_external_album_id",
+        unique: true,
+        fields: [
+          { name: "platform_id" },
+          { name: "external_album_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/PlatformAlbumGenreRelation.ts

@@ -0,0 +1,86 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+
+export interface PlatformAlbumGenreRelationAttributes {
+  platformAlbumId: string;
+  platformGenreId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type PlatformAlbumGenreRelationPk = "platformAlbumId" | "platformGenreId";
+export type PlatformAlbumGenreRelationId = PlatformAlbumGenreRelation[PlatformAlbumGenreRelationPk];
+export type PlatformAlbumGenreRelationOptionalAttributes = "createDate" | "updateDate";
+export type PlatformAlbumGenreRelationCreationAttributes = Optional<PlatformAlbumGenreRelationAttributes, PlatformAlbumGenreRelationOptionalAttributes>;
+
+export class PlatformAlbumGenreRelation extends Model<PlatformAlbumGenreRelationAttributes, PlatformAlbumGenreRelationCreationAttributes> implements PlatformAlbumGenreRelationAttributes {
+  platformAlbumId!: string;
+  platformGenreId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // PlatformAlbumGenreRelation belongsTo PlatformAlbum via platformAlbumId
+  platformAlbum!: PlatformAlbum;
+  getPlatformAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+  setPlatformAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  createPlatformAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+  // PlatformAlbumGenreRelation belongsTo PlatformGenre via platformGenreId
+  platformGenre!: PlatformGenre;
+  getPlatformGenre!: Sequelize.BelongsToGetAssociationMixin<PlatformGenre>;
+  setPlatformGenre!: Sequelize.BelongsToSetAssociationMixin<PlatformGenre, PlatformGenreId>;
+  createPlatformGenre!: Sequelize.BelongsToCreateAssociationMixin<PlatformGenre>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof PlatformAlbumGenreRelation {
+    return PlatformAlbumGenreRelation.init({
+    platformAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_album',
+        key: 'id'
+      },
+      field: 'platform_album_id'
+    },
+    platformGenreId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_genre',
+        key: 'id'
+      },
+      field: 'platform_genre_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_album_genre_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "platform_album_genre_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "platform_album_id" },
+          { name: "platform_genre_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/PlatformAlbumTrackRelation.ts

@@ -0,0 +1,92 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+
+export interface PlatformAlbumTrackRelationAttributes {
+  platformAlbumId: string;
+  platformTrackId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type PlatformAlbumTrackRelationPk = "platformAlbumId" | "platformTrackId";
+export type PlatformAlbumTrackRelationId = PlatformAlbumTrackRelation[PlatformAlbumTrackRelationPk];
+export type PlatformAlbumTrackRelationOptionalAttributes = "createDate" | "updateDate";
+export type PlatformAlbumTrackRelationCreationAttributes = Optional<PlatformAlbumTrackRelationAttributes, PlatformAlbumTrackRelationOptionalAttributes>;
+
+export class PlatformAlbumTrackRelation extends Model<PlatformAlbumTrackRelationAttributes, PlatformAlbumTrackRelationCreationAttributes> implements PlatformAlbumTrackRelationAttributes {
+  platformAlbumId!: string;
+  platformTrackId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // PlatformAlbumTrackRelation belongsTo PlatformAlbum via platformAlbumId
+  platformAlbum!: PlatformAlbum;
+  getPlatformAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+  setPlatformAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  createPlatformAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+  // PlatformAlbumTrackRelation 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 PlatformAlbumTrackRelation {
+    return PlatformAlbumTrackRelation.init({
+    platformAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_album',
+        key: 'id'
+      },
+      field: 'platform_album_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_album_track_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_platform_album_track_track",
+        fields: [
+          { name: "platform_track_id" },
+        ]
+      },
+      {
+        name: "platform_album_track_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "platform_album_id" },
+          { name: "platform_track_id" },
+        ]
+      },
+    ]
+  });
+  }
+}