@earbug/db-models 0.0.62 → 0.0.63

package/models/PlatformArtist.ts

@@ -0,0 +1,358 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId } from './CanonArtistExternalReferenceRelation';
+import type { CanonArtistGenreRelation, CanonArtistGenreRelationId } from './CanonArtistGenreRelation';
+import type { CanonArtistMemberRelation, CanonArtistMemberRelationId } from './CanonArtistMemberRelation';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { CanonMember, CanonMemberId } from './CanonMember';
+import type { CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId } from './CanonToPlatformArtistRelation';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId } from './PlatformArtistAlbumRelation';
+import type { PlatformArtistGenreRelation, PlatformArtistGenreRelationId } from './PlatformArtistGenreRelation';
+import type { PlatformArtistTrackRelation, PlatformArtistTrackRelationId } from './PlatformArtistTrackRelation';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { Versus, VersusId } from './Versus';
+import type { VersusOption, VersusOptionId } from './VersusOption';
+import type { VersusPublishIssue, VersusPublishIssueId } from './VersusPublishIssue';
+
+export interface PlatformArtistAttributes {
+  id: string;
+  externalArtistId: string;
+  platformId: number;
+  name: string;
+  asciiName: string;
+  externalUri?: string;
+  createDate: Date;
+  updateDate: Date;
+  genres?: string[];
+  lastHarvestDate?: Date;
+  lastHarvestLog?: string;
+  images?: object;
+}
+
+export type PlatformArtistPk = "id";
+export type PlatformArtistId = PlatformArtist[PlatformArtistPk];
+export type PlatformArtistOptionalAttributes = "id" | "externalUri" | "createDate" | "updateDate" | "genres" | "lastHarvestDate" | "lastHarvestLog" | "images";
+export type PlatformArtistCreationAttributes = Optional<PlatformArtistAttributes, PlatformArtistOptionalAttributes>;
+
+export class PlatformArtist extends Model<PlatformArtistAttributes, PlatformArtistCreationAttributes> implements PlatformArtistAttributes {
+  id!: string;
+  externalArtistId!: string;
+  platformId!: number;
+  name!: string;
+  asciiName!: string;
+  externalUri?: string;
+  createDate!: Date;
+  updateDate!: Date;
+  genres?: string[];
+  lastHarvestDate?: Date;
+  lastHarvestLog?: string;
+  images?: object;
+
+  // PlatformArtist belongsTo Platform via platformId
+  platform!: Platform;
+  getPlatform!: Sequelize.BelongsToGetAssociationMixin<Platform>;
+  setPlatform!: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+  createPlatform!: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+  // PlatformArtist belongsToMany CanonArtist via platformArtistId and canonArtistId
+  canonArtistIdCanonArtistCanonToPlatformArtistRelations!: CanonArtist[];
+  getCanonArtistIdCanonArtistCanonToPlatformArtistRelations!: Sequelize.BelongsToManyGetAssociationsMixin<CanonArtist>;
+  setCanonArtistIdCanonArtistCanonToPlatformArtistRelations!: Sequelize.BelongsToManySetAssociationsMixin<CanonArtist, CanonArtistId>;
+  addCanonArtistIdCanonArtistCanonToPlatformArtistRelation!: Sequelize.BelongsToManyAddAssociationMixin<CanonArtist, CanonArtistId>;
+  addCanonArtistIdCanonArtistCanonToPlatformArtistRelations!: Sequelize.BelongsToManyAddAssociationsMixin<CanonArtist, CanonArtistId>;
+  createCanonArtistIdCanonArtistCanonToPlatformArtistRelation!: Sequelize.BelongsToManyCreateAssociationMixin<CanonArtist>;
+  removeCanonArtistIdCanonArtistCanonToPlatformArtistRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonArtist, CanonArtistId>;
+  removeCanonArtistIdCanonArtistCanonToPlatformArtistRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonArtist, CanonArtistId>;
+  hasCanonArtistIdCanonArtistCanonToPlatformArtistRelation!: Sequelize.BelongsToManyHasAssociationMixin<CanonArtist, CanonArtistId>;
+  hasCanonArtistIdCanonArtistCanonToPlatformArtistRelations!: Sequelize.BelongsToManyHasAssociationsMixin<CanonArtist, CanonArtistId>;
+  countCanonArtistIdCanonArtistCanonToPlatformArtistRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformArtist hasMany CanonArtistExternalReferenceRelation via canonArtistId
+  canonArtistExternalReferenceRelations!: CanonArtistExternalReferenceRelation[];
+  getCanonArtistExternalReferenceRelations!: Sequelize.HasManyGetAssociationsMixin<CanonArtistExternalReferenceRelation>;
+  setCanonArtistExternalReferenceRelations!: Sequelize.HasManySetAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  addCanonArtistExternalReferenceRelation!: Sequelize.HasManyAddAssociationMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  addCanonArtistExternalReferenceRelations!: Sequelize.HasManyAddAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  createCanonArtistExternalReferenceRelation!: Sequelize.HasManyCreateAssociationMixin<CanonArtistExternalReferenceRelation>;
+  removeCanonArtistExternalReferenceRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  removeCanonArtistExternalReferenceRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  hasCanonArtistExternalReferenceRelation!: Sequelize.HasManyHasAssociationMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  hasCanonArtistExternalReferenceRelations!: Sequelize.HasManyHasAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  countCanonArtistExternalReferenceRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformArtist hasMany CanonArtistGenreRelation via canonArtistId
+  canonArtistGenreRelations!: CanonArtistGenreRelation[];
+  getCanonArtistGenreRelations!: Sequelize.HasManyGetAssociationsMixin<CanonArtistGenreRelation>;
+  setCanonArtistGenreRelations!: Sequelize.HasManySetAssociationsMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+  addCanonArtistGenreRelation!: Sequelize.HasManyAddAssociationMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+  addCanonArtistGenreRelations!: Sequelize.HasManyAddAssociationsMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+  createCanonArtistGenreRelation!: Sequelize.HasManyCreateAssociationMixin<CanonArtistGenreRelation>;
+  removeCanonArtistGenreRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+  removeCanonArtistGenreRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+  hasCanonArtistGenreRelation!: Sequelize.HasManyHasAssociationMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+  hasCanonArtistGenreRelations!: Sequelize.HasManyHasAssociationsMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+  countCanonArtistGenreRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformArtist hasMany CanonArtistMemberRelation via canonArtistId
+  canonArtistMemberRelations!: CanonArtistMemberRelation[];
+  getCanonArtistMemberRelations!: Sequelize.HasManyGetAssociationsMixin<CanonArtistMemberRelation>;
+  setCanonArtistMemberRelations!: Sequelize.HasManySetAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  addCanonArtistMemberRelation!: Sequelize.HasManyAddAssociationMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  addCanonArtistMemberRelations!: Sequelize.HasManyAddAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  createCanonArtistMemberRelation!: Sequelize.HasManyCreateAssociationMixin<CanonArtistMemberRelation>;
+  removeCanonArtistMemberRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  removeCanonArtistMemberRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  hasCanonArtistMemberRelation!: Sequelize.HasManyHasAssociationMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  hasCanonArtistMemberRelations!: Sequelize.HasManyHasAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  countCanonArtistMemberRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformArtist belongsToMany CanonGenre via canonArtistId and canonGenreId
+  canonGenreIdCanonGenreCanonArtistGenreRelations!: CanonGenre[];
+  getCanonGenreIdCanonGenreCanonArtistGenreRelations!: Sequelize.BelongsToManyGetAssociationsMixin<CanonGenre>;
+  setCanonGenreIdCanonGenreCanonArtistGenreRelations!: Sequelize.BelongsToManySetAssociationsMixin<CanonGenre, CanonGenreId>;
+  addCanonGenreIdCanonGenreCanonArtistGenreRelation!: Sequelize.BelongsToManyAddAssociationMixin<CanonGenre, CanonGenreId>;
+  addCanonGenreIdCanonGenreCanonArtistGenreRelations!: Sequelize.BelongsToManyAddAssociationsMixin<CanonGenre, CanonGenreId>;
+  createCanonGenreIdCanonGenreCanonArtistGenreRelation!: Sequelize.BelongsToManyCreateAssociationMixin<CanonGenre>;
+  removeCanonGenreIdCanonGenreCanonArtistGenreRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonGenre, CanonGenreId>;
+  removeCanonGenreIdCanonGenreCanonArtistGenreRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonGenre, CanonGenreId>;
+  hasCanonGenreIdCanonGenreCanonArtistGenreRelation!: Sequelize.BelongsToManyHasAssociationMixin<CanonGenre, CanonGenreId>;
+  hasCanonGenreIdCanonGenreCanonArtistGenreRelations!: Sequelize.BelongsToManyHasAssociationsMixin<CanonGenre, CanonGenreId>;
+  countCanonGenreIdCanonGenreCanonArtistGenreRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformArtist belongsToMany CanonMember via canonArtistId and canonMemberId
+  canonMemberIdCanonMembers!: CanonMember[];
+  getCanonMemberIdCanonMembers!: Sequelize.BelongsToManyGetAssociationsMixin<CanonMember>;
+  setCanonMemberIdCanonMembers!: Sequelize.BelongsToManySetAssociationsMixin<CanonMember, CanonMemberId>;
+  addCanonMemberIdCanonMember!: Sequelize.BelongsToManyAddAssociationMixin<CanonMember, CanonMemberId>;
+  addCanonMemberIdCanonMembers!: Sequelize.BelongsToManyAddAssociationsMixin<CanonMember, CanonMemberId>;
+  createCanonMemberIdCanonMember!: Sequelize.BelongsToManyCreateAssociationMixin<CanonMember>;
+  removeCanonMemberIdCanonMember!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonMember, CanonMemberId>;
+  removeCanonMemberIdCanonMembers!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonMember, CanonMemberId>;
+  hasCanonMemberIdCanonMember!: Sequelize.BelongsToManyHasAssociationMixin<CanonMember, CanonMemberId>;
+  hasCanonMemberIdCanonMembers!: Sequelize.BelongsToManyHasAssociationsMixin<CanonMember, CanonMemberId>;
+  countCanonMemberIdCanonMembers!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformArtist hasMany CanonToPlatformArtistRelation via platformArtistId
+  canonToPlatformArtistRelations!: CanonToPlatformArtistRelation[];
+  getCanonToPlatformArtistRelations!: Sequelize.HasManyGetAssociationsMixin<CanonToPlatformArtistRelation>;
+  setCanonToPlatformArtistRelations!: Sequelize.HasManySetAssociationsMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+  addCanonToPlatformArtistRelation!: Sequelize.HasManyAddAssociationMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+  addCanonToPlatformArtistRelations!: Sequelize.HasManyAddAssociationsMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+  createCanonToPlatformArtistRelation!: Sequelize.HasManyCreateAssociationMixin<CanonToPlatformArtistRelation>;
+  removeCanonToPlatformArtistRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+  removeCanonToPlatformArtistRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+  hasCanonToPlatformArtistRelation!: Sequelize.HasManyHasAssociationMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+  hasCanonToPlatformArtistRelations!: Sequelize.HasManyHasAssociationsMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+  countCanonToPlatformArtistRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformArtist belongsToMany ExternalReference via canonArtistId and externalReferenceId
+  externalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations!: ExternalReference[];
+  getExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations!: Sequelize.BelongsToManyGetAssociationsMixin<ExternalReference>;
+  setExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations!: Sequelize.BelongsToManySetAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  addExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelation!: Sequelize.BelongsToManyAddAssociationMixin<ExternalReference, ExternalReferenceId>;
+  addExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations!: Sequelize.BelongsToManyAddAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  createExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelation!: Sequelize.BelongsToManyCreateAssociationMixin<ExternalReference>;
+  removeExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<ExternalReference, ExternalReferenceId>;
+  removeExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  hasExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelation!: Sequelize.BelongsToManyHasAssociationMixin<ExternalReference, ExternalReferenceId>;
+  hasExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations!: Sequelize.BelongsToManyHasAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  countExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformArtist belongsToMany PlatformAlbum via platformArtistId and platformAlbumId
+  platformAlbumIdPlatformAlbumPlatformArtistAlbumRelations!: PlatformAlbum[];
+  getPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+  setPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  addPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  addPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  createPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+  removePlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  removePlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  hasPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  hasPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  countPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformArtist hasMany PlatformArtistAlbumRelation via platformArtistId
+  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;
+  // PlatformArtist hasMany PlatformArtistGenreRelation via platformArtistId
+  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;
+  // PlatformArtist hasMany PlatformArtistTrackRelation via platformArtistId
+  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;
+  // PlatformArtist belongsToMany PlatformGenre via platformArtistId and platformGenreId
+  platformGenreIdPlatformGenrePlatformArtistGenreRelations!: PlatformGenre[];
+  getPlatformGenreIdPlatformGenrePlatformArtistGenreRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformGenre>;
+  setPlatformGenreIdPlatformGenrePlatformArtistGenreRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  addPlatformGenreIdPlatformGenrePlatformArtistGenreRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformGenre, PlatformGenreId>;
+  addPlatformGenreIdPlatformGenrePlatformArtistGenreRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  createPlatformGenreIdPlatformGenrePlatformArtistGenreRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformGenre>;
+  removePlatformGenreIdPlatformGenrePlatformArtistGenreRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformGenre, PlatformGenreId>;
+  removePlatformGenreIdPlatformGenrePlatformArtistGenreRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  hasPlatformGenreIdPlatformGenrePlatformArtistGenreRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformGenre, PlatformGenreId>;
+  hasPlatformGenreIdPlatformGenrePlatformArtistGenreRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  countPlatformGenreIdPlatformGenrePlatformArtistGenreRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformArtist belongsToMany PlatformTrack via platformArtistId and platformTrackId
+  platformTrackIdPlatformTrackPlatformArtistTrackRelations!: PlatformTrack[];
+  getPlatformTrackIdPlatformTrackPlatformArtistTrackRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformTrack>;
+  setPlatformTrackIdPlatformTrackPlatformArtistTrackRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  addPlatformTrackIdPlatformTrackPlatformArtistTrackRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformTrack, PlatformTrackId>;
+  addPlatformTrackIdPlatformTrackPlatformArtistTrackRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  createPlatformTrackIdPlatformTrackPlatformArtistTrackRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformTrack>;
+  removePlatformTrackIdPlatformTrackPlatformArtistTrackRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformTrack, PlatformTrackId>;
+  removePlatformTrackIdPlatformTrackPlatformArtistTrackRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  hasPlatformTrackIdPlatformTrackPlatformArtistTrackRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
+  hasPlatformTrackIdPlatformTrackPlatformArtistTrackRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  countPlatformTrackIdPlatformTrackPlatformArtistTrackRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // PlatformArtist hasMany Versus via platformArtistId
+  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;
+  // PlatformArtist hasMany VersusOption via platformArtistId
+  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;
+  // PlatformArtist hasMany VersusPublishIssue via platformArtistId
+  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 PlatformArtist {
+    return PlatformArtist.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    externalArtistId: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "uk_platform_id_external_artist_id",
+      field: 'external_artist_id'
+    },
+    platformId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'platform',
+        key: 'id'
+      },
+      unique: "uk_platform_id_external_artist_id",
+      field: 'platform_id'
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    asciiName: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'ascii_name'
+    },
+    externalUri: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'external_uri'
+    },
+    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'
+    },
+    genres: {
+      type: DataTypes.ARRAY(DataTypes.TEXT),
+      allowNull: true
+    },
+    lastHarvestDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'last_harvest_date'
+    },
+    lastHarvestLog: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'last_harvest_log'
+    },
+    images: {
+      type: DataTypes.JSONB,
+      allowNull: true
+    }
+  }, {
+    sequelize,
+    tableName: 'platform_artist',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "platform_artist_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "uk_platform_id_external_artist_id",
+        unique: true,
+        fields: [
+          { name: "platform_id" },
+          { name: "external_artist_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/PlatformArtistAlbumRelation.ts

@@ -0,0 +1,92 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+
+export interface PlatformArtistAlbumRelationAttributes {
+  platformArtistId: string;
+  platformAlbumId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type PlatformArtistAlbumRelationPk = "platformArtistId" | "platformAlbumId";
+export type PlatformArtistAlbumRelationId = PlatformArtistAlbumRelation[PlatformArtistAlbumRelationPk];
+export type PlatformArtistAlbumRelationOptionalAttributes = "createDate" | "updateDate";
+export type PlatformArtistAlbumRelationCreationAttributes = Optional<PlatformArtistAlbumRelationAttributes, PlatformArtistAlbumRelationOptionalAttributes>;
+
+export class PlatformArtistAlbumRelation extends Model<PlatformArtistAlbumRelationAttributes, PlatformArtistAlbumRelationCreationAttributes> implements PlatformArtistAlbumRelationAttributes {
+  platformArtistId!: string;
+  platformAlbumId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // PlatformArtistAlbumRelation belongsTo PlatformAlbum via platformAlbumId
+  platformAlbum!: PlatformAlbum;
+  getPlatformAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+  setPlatformAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  createPlatformAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+  // PlatformArtistAlbumRelation belongsTo PlatformArtist via platformArtistId
+  platformArtist!: PlatformArtist;
+  getPlatformArtist!: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+  setPlatformArtist!: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+  createPlatformArtist!: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof PlatformArtistAlbumRelation {
+    return PlatformArtistAlbumRelation.init({
+    platformArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_artist',
+        key: 'id'
+      },
+      field: 'platform_artist_id'
+    },
+    platformAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_album',
+        key: 'id'
+      },
+      field: 'platform_album_id'
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'platform_artist_album_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_platform_artist_album_album",
+        fields: [
+          { name: "platform_album_id" },
+        ]
+      },
+      {
+        name: "platform_artist_album_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "platform_artist_id" },
+          { name: "platform_album_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/PlatformArtistGenreRelation.ts

@@ -0,0 +1,86 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+
+export interface PlatformArtistGenreRelationAttributes {
+  platformArtistId: string;
+  platformGenreId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type PlatformArtistGenreRelationPk = "platformArtistId" | "platformGenreId";
+export type PlatformArtistGenreRelationId = PlatformArtistGenreRelation[PlatformArtistGenreRelationPk];
+export type PlatformArtistGenreRelationOptionalAttributes = "createDate" | "updateDate";
+export type PlatformArtistGenreRelationCreationAttributes = Optional<PlatformArtistGenreRelationAttributes, PlatformArtistGenreRelationOptionalAttributes>;
+
+export class PlatformArtistGenreRelation extends Model<PlatformArtistGenreRelationAttributes, PlatformArtistGenreRelationCreationAttributes> implements PlatformArtistGenreRelationAttributes {
+  platformArtistId!: string;
+  platformGenreId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // PlatformArtistGenreRelation belongsTo PlatformArtist via platformArtistId
+  platformArtist!: PlatformArtist;
+  getPlatformArtist!: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+  setPlatformArtist!: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+  createPlatformArtist!: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+  // PlatformArtistGenreRelation 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 PlatformArtistGenreRelation {
+    return PlatformArtistGenreRelation.init({
+    platformArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_artist',
+        key: 'id'
+      },
+      field: 'platform_artist_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_artist_genre_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "platform_artist_genre_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "platform_artist_id" },
+          { name: "platform_genre_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/PlatformArtistTrackRelation.ts

@@ -0,0 +1,92 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+
+export interface PlatformArtistTrackRelationAttributes {
+  platformArtistId: string;
+  platformTrackId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type PlatformArtistTrackRelationPk = "platformArtistId" | "platformTrackId";
+export type PlatformArtistTrackRelationId = PlatformArtistTrackRelation[PlatformArtistTrackRelationPk];
+export type PlatformArtistTrackRelationOptionalAttributes = "createDate" | "updateDate";
+export type PlatformArtistTrackRelationCreationAttributes = Optional<PlatformArtistTrackRelationAttributes, PlatformArtistTrackRelationOptionalAttributes>;
+
+export class PlatformArtistTrackRelation extends Model<PlatformArtistTrackRelationAttributes, PlatformArtistTrackRelationCreationAttributes> implements PlatformArtistTrackRelationAttributes {
+  platformArtistId!: string;
+  platformTrackId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // PlatformArtistTrackRelation belongsTo PlatformArtist via platformArtistId
+  platformArtist!: PlatformArtist;
+  getPlatformArtist!: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+  setPlatformArtist!: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+  createPlatformArtist!: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+  // PlatformArtistTrackRelation 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 PlatformArtistTrackRelation {
+    return PlatformArtistTrackRelation.init({
+    platformArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_artist',
+        key: 'id'
+      },
+      field: 'platform_artist_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_artist_track_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_platform_artist_track_track",
+        fields: [
+          { name: "platform_track_id" },
+        ]
+      },
+      {
+        name: "platform_artist_track_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "platform_artist_id" },
+          { name: "platform_track_id" },
+        ]
+      },
+    ]
+  });
+  }
+}