@earbug/db-models 0.0.59 → 0.0.62

package/models/PlatformAlbum.ts

@@ -1,398 +0,0 @@
-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 {
-  platformId: number;
-  externalAlbumId: string;
-  name: string;
-  asciiName: string;
-  albumType?: string;
-  releaseDate?: string;
-  popularity?: number;
-  recordLabel?: string;
-  images?: object;
-  id: string;
-  createDate: Date;
-  updateDate: Date;
-  lastHarvestDate?: Date;
-  lastHarvestLog?: string;
-}
-
-export type PlatformAlbumPk = "id";
-export type PlatformAlbumId = PlatformAlbum[PlatformAlbumPk];
-export type PlatformAlbumOptionalAttributes = "albumType" | "releaseDate" | "popularity" | "recordLabel" | "images" | "id" | "createDate" | "updateDate" | "lastHarvestDate" | "lastHarvestLog";
-export type PlatformAlbumCreationAttributes = Optional<PlatformAlbumAttributes, PlatformAlbumOptionalAttributes>;
-
-export class PlatformAlbum extends Model<PlatformAlbumAttributes, PlatformAlbumCreationAttributes> implements PlatformAlbumAttributes {
-  platformId!: number;
-  externalAlbumId!: string;
-  name!: string;
-  asciiName!: string;
-  albumType?: string;
-  releaseDate?: string;
-  popularity?: number;
-  recordLabel?: string;
-  images?: object;
-  id!: string;
-  createDate!: Date;
-  updateDate!: Date;
-  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({
-    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'
-    },
-    images: {
-      type: DataTypes.JSONB,
-      allowNull: true
-    },
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
-      primaryKey: true
-    },
-    createDate: {
-      type: DataTypes.DATE,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
-      field: 'create_date'
-    },
-    updateDate: {
-      type: DataTypes.DATE,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
-      field: 'update_date'
-    },
-    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

@@ -1,86 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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" },
-        ]
-      },
-    ]
-  });
-  }
-}