@earbug/db-models 0.0.62 → 0.0.63

package/models/CanonArtist.ts

@@ -0,0 +1,356 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonArtistAlbumRelation, CanonArtistAlbumRelationId } from './CanonArtistAlbumRelation';
+import type { CanonArtistTrackRelation, CanonArtistTrackRelationId } from './CanonArtistTrackRelation';
+import type { CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId } from './CanonToPlatformArtistRelation';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId } from './JukeboxSessionArtistAffinity';
+import type { MerchItem, MerchItemId } from './MerchItem';
+import type { MerchOrchestration, MerchOrchestrationId } from './MerchOrchestration';
+import type { NewsArticle, NewsArticleId } from './NewsArticle';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId } from './PlatformUserPlaylistArtistAffinity';
+import type { UserArtistAffinity, UserArtistAffinityId } from './UserArtistAffinity';
+import type { Versus, VersusId } from './Versus';
+import type { VersusOption, VersusOptionId } from './VersusOption';
+
+export interface CanonArtistAttributes {
+  id: string;
+  name: string;
+  asciiName: string;
+  description?: string;
+  hasPhoto: boolean;
+  createDate: Date;
+  updateDate: Date;
+  hasThumbnailPhoto?: boolean;
+  images?: object;
+  lastImageHarvestAttempt?: Date;
+  merchHarvestDay?: number;
+  newsHarvestDay?: number;
+  popularityRank?: number;
+  lastGenreHarvestAttempt?: Date;
+  genreHarvestCount: number;
+  popularityScore: number;
+}
+
+export type CanonArtistPk = "id";
+export type CanonArtistId = CanonArtist[CanonArtistPk];
+export type CanonArtistOptionalAttributes = "id" | "description" | "createDate" | "updateDate" | "hasThumbnailPhoto" | "images" | "lastImageHarvestAttempt" | "merchHarvestDay" | "newsHarvestDay" | "popularityRank" | "lastGenreHarvestAttempt" | "genreHarvestCount" | "popularityScore";
+export type CanonArtistCreationAttributes = Optional<CanonArtistAttributes, CanonArtistOptionalAttributes>;
+
+export class CanonArtist extends Model<CanonArtistAttributes, CanonArtistCreationAttributes> implements CanonArtistAttributes {
+  id!: string;
+  name!: string;
+  asciiName!: string;
+  description?: string;
+  hasPhoto!: boolean;
+  createDate!: Date;
+  updateDate!: Date;
+  hasThumbnailPhoto?: boolean;
+  images?: object;
+  lastImageHarvestAttempt?: Date;
+  merchHarvestDay?: number;
+  newsHarvestDay?: number;
+  popularityRank?: number;
+  lastGenreHarvestAttempt?: Date;
+  genreHarvestCount!: number;
+  popularityScore!: number;
+
+  // CanonArtist hasMany CanonArtistAlbumRelation via canonArtistId
+  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;
+  // CanonArtist hasMany CanonArtistTrackRelation via canonArtistId
+  canonArtistTrackRelations!: CanonArtistTrackRelation[];
+  getCanonArtistTrackRelations!: Sequelize.HasManyGetAssociationsMixin<CanonArtistTrackRelation>;
+  setCanonArtistTrackRelations!: Sequelize.HasManySetAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  addCanonArtistTrackRelation!: Sequelize.HasManyAddAssociationMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  addCanonArtistTrackRelations!: Sequelize.HasManyAddAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  createCanonArtistTrackRelation!: Sequelize.HasManyCreateAssociationMixin<CanonArtistTrackRelation>;
+  removeCanonArtistTrackRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  removeCanonArtistTrackRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  hasCanonArtistTrackRelation!: Sequelize.HasManyHasAssociationMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  hasCanonArtistTrackRelations!: Sequelize.HasManyHasAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  countCanonArtistTrackRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonArtist hasMany CanonToPlatformArtistRelation via canonArtistId
+  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;
+  // CanonArtist belongsToMany CanonTrack via canonArtistId and canonTrackId
+  canonTrackIdCanonTrackCanonArtistTrackRelations!: CanonTrack[];
+  getCanonTrackIdCanonTrackCanonArtistTrackRelations!: Sequelize.BelongsToManyGetAssociationsMixin<CanonTrack>;
+  setCanonTrackIdCanonTrackCanonArtistTrackRelations!: Sequelize.BelongsToManySetAssociationsMixin<CanonTrack, CanonTrackId>;
+  addCanonTrackIdCanonTrackCanonArtistTrackRelation!: Sequelize.BelongsToManyAddAssociationMixin<CanonTrack, CanonTrackId>;
+  addCanonTrackIdCanonTrackCanonArtistTrackRelations!: Sequelize.BelongsToManyAddAssociationsMixin<CanonTrack, CanonTrackId>;
+  createCanonTrackIdCanonTrackCanonArtistTrackRelation!: Sequelize.BelongsToManyCreateAssociationMixin<CanonTrack>;
+  removeCanonTrackIdCanonTrackCanonArtistTrackRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonTrack, CanonTrackId>;
+  removeCanonTrackIdCanonTrackCanonArtistTrackRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonTrack, CanonTrackId>;
+  hasCanonTrackIdCanonTrackCanonArtistTrackRelation!: Sequelize.BelongsToManyHasAssociationMixin<CanonTrack, CanonTrackId>;
+  hasCanonTrackIdCanonTrackCanonArtistTrackRelations!: Sequelize.BelongsToManyHasAssociationsMixin<CanonTrack, CanonTrackId>;
+  countCanonTrackIdCanonTrackCanonArtistTrackRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonArtist hasMany JukeboxSessionArtistAffinity via canonArtistId
+  jukeboxSessionArtistAffinities!: JukeboxSessionArtistAffinity[];
+  getJukeboxSessionArtistAffinities!: Sequelize.HasManyGetAssociationsMixin<JukeboxSessionArtistAffinity>;
+  setJukeboxSessionArtistAffinities!: Sequelize.HasManySetAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  addJukeboxSessionArtistAffinity!: Sequelize.HasManyAddAssociationMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  addJukeboxSessionArtistAffinities!: Sequelize.HasManyAddAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  createJukeboxSessionArtistAffinity!: Sequelize.HasManyCreateAssociationMixin<JukeboxSessionArtistAffinity>;
+  removeJukeboxSessionArtistAffinity!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  removeJukeboxSessionArtistAffinities!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  hasJukeboxSessionArtistAffinity!: Sequelize.HasManyHasAssociationMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  hasJukeboxSessionArtistAffinities!: Sequelize.HasManyHasAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  countJukeboxSessionArtistAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonArtist hasMany MerchItem via canonArtistId
+  merchItems!: MerchItem[];
+  getMerchItems!: Sequelize.HasManyGetAssociationsMixin<MerchItem>;
+  setMerchItems!: Sequelize.HasManySetAssociationsMixin<MerchItem, MerchItemId>;
+  addMerchItem!: Sequelize.HasManyAddAssociationMixin<MerchItem, MerchItemId>;
+  addMerchItems!: Sequelize.HasManyAddAssociationsMixin<MerchItem, MerchItemId>;
+  createMerchItem!: Sequelize.HasManyCreateAssociationMixin<MerchItem>;
+  removeMerchItem!: Sequelize.HasManyRemoveAssociationMixin<MerchItem, MerchItemId>;
+  removeMerchItems!: Sequelize.HasManyRemoveAssociationsMixin<MerchItem, MerchItemId>;
+  hasMerchItem!: Sequelize.HasManyHasAssociationMixin<MerchItem, MerchItemId>;
+  hasMerchItems!: Sequelize.HasManyHasAssociationsMixin<MerchItem, MerchItemId>;
+  countMerchItems!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonArtist hasMany MerchOrchestration via canonArtistId
+  merchOrchestrations!: MerchOrchestration[];
+  getMerchOrchestrations!: Sequelize.HasManyGetAssociationsMixin<MerchOrchestration>;
+  setMerchOrchestrations!: Sequelize.HasManySetAssociationsMixin<MerchOrchestration, MerchOrchestrationId>;
+  addMerchOrchestration!: Sequelize.HasManyAddAssociationMixin<MerchOrchestration, MerchOrchestrationId>;
+  addMerchOrchestrations!: Sequelize.HasManyAddAssociationsMixin<MerchOrchestration, MerchOrchestrationId>;
+  createMerchOrchestration!: Sequelize.HasManyCreateAssociationMixin<MerchOrchestration>;
+  removeMerchOrchestration!: Sequelize.HasManyRemoveAssociationMixin<MerchOrchestration, MerchOrchestrationId>;
+  removeMerchOrchestrations!: Sequelize.HasManyRemoveAssociationsMixin<MerchOrchestration, MerchOrchestrationId>;
+  hasMerchOrchestration!: Sequelize.HasManyHasAssociationMixin<MerchOrchestration, MerchOrchestrationId>;
+  hasMerchOrchestrations!: Sequelize.HasManyHasAssociationsMixin<MerchOrchestration, MerchOrchestrationId>;
+  countMerchOrchestrations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonArtist hasMany NewsArticle via canonArtistId
+  newsArticles!: NewsArticle[];
+  getNewsArticles!: Sequelize.HasManyGetAssociationsMixin<NewsArticle>;
+  setNewsArticles!: Sequelize.HasManySetAssociationsMixin<NewsArticle, NewsArticleId>;
+  addNewsArticle!: Sequelize.HasManyAddAssociationMixin<NewsArticle, NewsArticleId>;
+  addNewsArticles!: Sequelize.HasManyAddAssociationsMixin<NewsArticle, NewsArticleId>;
+  createNewsArticle!: Sequelize.HasManyCreateAssociationMixin<NewsArticle>;
+  removeNewsArticle!: Sequelize.HasManyRemoveAssociationMixin<NewsArticle, NewsArticleId>;
+  removeNewsArticles!: Sequelize.HasManyRemoveAssociationsMixin<NewsArticle, NewsArticleId>;
+  hasNewsArticle!: Sequelize.HasManyHasAssociationMixin<NewsArticle, NewsArticleId>;
+  hasNewsArticles!: Sequelize.HasManyHasAssociationsMixin<NewsArticle, NewsArticleId>;
+  countNewsArticles!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonArtist belongsToMany PlatformAlbum via canonArtistId and canonAlbumId
+  canonAlbumIdPlatformAlbumCanonArtistAlbumRelations!: PlatformAlbum[];
+  getCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+  setCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  addCanonAlbumIdPlatformAlbumCanonArtistAlbumRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  addCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  createCanonAlbumIdPlatformAlbumCanonArtistAlbumRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+  removeCanonAlbumIdPlatformAlbumCanonArtistAlbumRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  removeCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  hasCanonAlbumIdPlatformAlbumCanonArtistAlbumRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  hasCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  countCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonArtist belongsToMany PlatformArtist via canonArtistId and platformArtistId
+  platformArtistIdPlatformArtists!: PlatformArtist[];
+  getPlatformArtistIdPlatformArtists!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+  setPlatformArtistIdPlatformArtists!: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  addPlatformArtistIdPlatformArtist!: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+  addPlatformArtistIdPlatformArtists!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  createPlatformArtistIdPlatformArtist!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+  removePlatformArtistIdPlatformArtist!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+  removePlatformArtistIdPlatformArtists!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  hasPlatformArtistIdPlatformArtist!: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+  hasPlatformArtistIdPlatformArtists!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  countPlatformArtistIdPlatformArtists!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonArtist hasMany PlatformUserPlaylistArtistAffinity via canonArtistId
+  platformUserPlaylistArtistAffinities!: PlatformUserPlaylistArtistAffinity[];
+  getPlatformUserPlaylistArtistAffinities!: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylistArtistAffinity>;
+  setPlatformUserPlaylistArtistAffinities!: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  addPlatformUserPlaylistArtistAffinity!: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  addPlatformUserPlaylistArtistAffinities!: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  createPlatformUserPlaylistArtistAffinity!: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylistArtistAffinity>;
+  removePlatformUserPlaylistArtistAffinity!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  removePlatformUserPlaylistArtistAffinities!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  hasPlatformUserPlaylistArtistAffinity!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  hasPlatformUserPlaylistArtistAffinities!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  countPlatformUserPlaylistArtistAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonArtist hasMany UserArtistAffinity via canonArtistId
+  userArtistAffinities!: UserArtistAffinity[];
+  getUserArtistAffinities!: Sequelize.HasManyGetAssociationsMixin<UserArtistAffinity>;
+  setUserArtistAffinities!: Sequelize.HasManySetAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  addUserArtistAffinity!: Sequelize.HasManyAddAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
+  addUserArtistAffinities!: Sequelize.HasManyAddAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  createUserArtistAffinity!: Sequelize.HasManyCreateAssociationMixin<UserArtistAffinity>;
+  removeUserArtistAffinity!: Sequelize.HasManyRemoveAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
+  removeUserArtistAffinities!: Sequelize.HasManyRemoveAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  hasUserArtistAffinity!: Sequelize.HasManyHasAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
+  hasUserArtistAffinities!: Sequelize.HasManyHasAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  countUserArtistAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonArtist hasMany Versus via canonArtistId
+  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;
+  // CanonArtist hasMany VersusOption via canonArtistId
+  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;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtist {
+    return CanonArtist.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    asciiName: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'ascii_name'
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: true
+    },
+    hasPhoto: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: false,
+      field: 'has_photo'
+    },
+    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'
+    },
+    hasThumbnailPhoto: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      defaultValue: false,
+      field: 'has_thumbnail_photo'
+    },
+    images: {
+      type: DataTypes.JSONB,
+      allowNull: true
+    },
+    lastImageHarvestAttempt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'last_image_harvest_attempt'
+    },
+    merchHarvestDay: {
+      type: DataTypes.SMALLINT,
+      allowNull: true,
+      field: 'merch_harvest_day'
+    },
+    newsHarvestDay: {
+      type: DataTypes.SMALLINT,
+      allowNull: true,
+      field: 'news_harvest_day'
+    },
+    popularityRank: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+      field: 'popularity_rank'
+    },
+    lastGenreHarvestAttempt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'last_genre_harvest_attempt'
+    },
+    genreHarvestCount: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      defaultValue: 0,
+      field: 'genre_harvest_count'
+    },
+    popularityScore: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      defaultValue: 0,
+      field: 'popularity_score'
+    }
+  }, {
+    sequelize,
+    tableName: 'canon_artist',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "artist_name_idx",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "artist_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "eb_canon_artist_last_image_harvest_attempt",
+        fields: [
+          { name: "last_image_harvest_attempt" },
+        ]
+      },
+      {
+        name: "idx_canon_artist_merch_day",
+        fields: [
+          { name: "merch_harvest_day" },
+        ]
+      },
+      {
+        name: "idx_canon_artist_news_day",
+        fields: [
+          { name: "news_harvest_day" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonArtistAlbumRelation.ts

@@ -0,0 +1,92 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+
+export interface CanonArtistAlbumRelationAttributes {
+  canonArtistId: string;
+  canonAlbumId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonArtistAlbumRelationPk = "canonArtistId" | "canonAlbumId";
+export type CanonArtistAlbumRelationId = CanonArtistAlbumRelation[CanonArtistAlbumRelationPk];
+export type CanonArtistAlbumRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonArtistAlbumRelationCreationAttributes = Optional<CanonArtistAlbumRelationAttributes, CanonArtistAlbumRelationOptionalAttributes>;
+
+export class CanonArtistAlbumRelation extends Model<CanonArtistAlbumRelationAttributes, CanonArtistAlbumRelationCreationAttributes> implements CanonArtistAlbumRelationAttributes {
+  canonArtistId!: string;
+  canonAlbumId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonArtistAlbumRelation belongsTo CanonArtist via canonArtistId
+  canonArtist!: CanonArtist;
+  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+  // CanonArtistAlbumRelation belongsTo PlatformAlbum via canonAlbumId
+  canonAlbum!: PlatformAlbum;
+  getCanonAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+  setCanonAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  createCanonAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtistAlbumRelation {
+    return CanonArtistAlbumRelation.init({
+    canonArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_artist',
+        key: 'id'
+      },
+      field: 'canon_artist_id'
+    },
+    canonAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_album',
+        key: 'id'
+      },
+      field: 'canon_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: 'canon_artist_album_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_artist_album_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "canon_artist_id" },
+          { name: "canon_album_id" },
+        ]
+      },
+      {
+        name: "idx_canon_artist_album_album",
+        fields: [
+          { name: "canon_album_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonArtistExternalReferenceRelation.ts

@@ -0,0 +1,92 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+
+export interface CanonArtistExternalReferenceRelationAttributes {
+  canonArtistId: string;
+  externalReferenceId: string;
+  url: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonArtistExternalReferenceRelationPk = "canonArtistId" | "externalReferenceId";
+export type CanonArtistExternalReferenceRelationId = CanonArtistExternalReferenceRelation[CanonArtistExternalReferenceRelationPk];
+export type CanonArtistExternalReferenceRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonArtistExternalReferenceRelationCreationAttributes = Optional<CanonArtistExternalReferenceRelationAttributes, CanonArtistExternalReferenceRelationOptionalAttributes>;
+
+export class CanonArtistExternalReferenceRelation extends Model<CanonArtistExternalReferenceRelationAttributes, CanonArtistExternalReferenceRelationCreationAttributes> implements CanonArtistExternalReferenceRelationAttributes {
+  canonArtistId!: string;
+  externalReferenceId!: string;
+  url!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonArtistExternalReferenceRelation belongsTo ExternalReference via externalReferenceId
+  externalReference!: ExternalReference;
+  getExternalReference!: Sequelize.BelongsToGetAssociationMixin<ExternalReference>;
+  setExternalReference!: Sequelize.BelongsToSetAssociationMixin<ExternalReference, ExternalReferenceId>;
+  createExternalReference!: Sequelize.BelongsToCreateAssociationMixin<ExternalReference>;
+  // CanonArtistExternalReferenceRelation belongsTo PlatformArtist via canonArtistId
+  canonArtist!: PlatformArtist;
+  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtistExternalReferenceRelation {
+    return CanonArtistExternalReferenceRelation.init({
+    canonArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_artist',
+        key: 'id'
+      },
+      field: 'canon_artist_id'
+    },
+    externalReferenceId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'external_reference',
+        key: 'id'
+      },
+      field: 'external_reference_id'
+    },
+    url: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    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: 'canon_artist_external_reference_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_artist_external_reference_relation_pk",
+        unique: true,
+        fields: [
+          { name: "canon_artist_id" },
+          { name: "external_reference_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonArtistGenreRelation.ts

@@ -0,0 +1,86 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+
+export interface CanonArtistGenreRelationAttributes {
+  canonArtistId: string;
+  canonGenreId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonArtistGenreRelationPk = "canonArtistId" | "canonGenreId";
+export type CanonArtistGenreRelationId = CanonArtistGenreRelation[CanonArtistGenreRelationPk];
+export type CanonArtistGenreRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonArtistGenreRelationCreationAttributes = Optional<CanonArtistGenreRelationAttributes, CanonArtistGenreRelationOptionalAttributes>;
+
+export class CanonArtistGenreRelation extends Model<CanonArtistGenreRelationAttributes, CanonArtistGenreRelationCreationAttributes> implements CanonArtistGenreRelationAttributes {
+  canonArtistId!: string;
+  canonGenreId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonArtistGenreRelation belongsTo CanonGenre via canonGenreId
+  canonGenre!: CanonGenre;
+  getCanonGenre!: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+  setCanonGenre!: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+  createCanonGenre!: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+  // CanonArtistGenreRelation belongsTo PlatformArtist via canonArtistId
+  canonArtist!: PlatformArtist;
+  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtistGenreRelation {
+    return CanonArtistGenreRelation.init({
+    canonArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_artist',
+        key: 'id'
+      },
+      field: 'canon_artist_id'
+    },
+    canonGenreId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_genre',
+        key: 'id'
+      },
+      field: 'canon_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: 'canon_artist_genre_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_artist_genre_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "canon_artist_id" },
+          { name: "canon_genre_id" },
+        ]
+      },
+    ]
+  });
+  }
+}