@earbug/db-models 0.0.62 → 0.0.63

package/models/CanonArtistMemberRelation.ts

@@ -0,0 +1,86 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonMember, CanonMemberId } from './CanonMember';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+
+export interface CanonArtistMemberRelationAttributes {
+  canonArtistId: string;
+  canonMemberId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonArtistMemberRelationPk = "canonArtistId" | "canonMemberId";
+export type CanonArtistMemberRelationId = CanonArtistMemberRelation[CanonArtistMemberRelationPk];
+export type CanonArtistMemberRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonArtistMemberRelationCreationAttributes = Optional<CanonArtistMemberRelationAttributes, CanonArtistMemberRelationOptionalAttributes>;
+
+export class CanonArtistMemberRelation extends Model<CanonArtistMemberRelationAttributes, CanonArtistMemberRelationCreationAttributes> implements CanonArtistMemberRelationAttributes {
+  canonArtistId!: string;
+  canonMemberId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonArtistMemberRelation belongsTo CanonMember via canonMemberId
+  canonMember!: CanonMember;
+  getCanonMember!: Sequelize.BelongsToGetAssociationMixin<CanonMember>;
+  setCanonMember!: Sequelize.BelongsToSetAssociationMixin<CanonMember, CanonMemberId>;
+  createCanonMember!: Sequelize.BelongsToCreateAssociationMixin<CanonMember>;
+  // CanonArtistMemberRelation 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 CanonArtistMemberRelation {
+    return CanonArtistMemberRelation.init({
+    canonArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_artist',
+        key: 'id'
+      },
+      field: 'canon_artist_id'
+    },
+    canonMemberId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_member',
+        key: 'id'
+      },
+      field: 'canon_member_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_member_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_artist_member_relation_pk",
+        unique: true,
+        fields: [
+          { name: "canon_artist_id" },
+          { name: "canon_member_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonArtistTrackRelation.ts

@@ -0,0 +1,92 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+
+export interface CanonArtistTrackRelationAttributes {
+  canonArtistId: string;
+  canonTrackId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonArtistTrackRelationPk = "canonArtistId" | "canonTrackId";
+export type CanonArtistTrackRelationId = CanonArtistTrackRelation[CanonArtistTrackRelationPk];
+export type CanonArtistTrackRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonArtistTrackRelationCreationAttributes = Optional<CanonArtistTrackRelationAttributes, CanonArtistTrackRelationOptionalAttributes>;
+
+export class CanonArtistTrackRelation extends Model<CanonArtistTrackRelationAttributes, CanonArtistTrackRelationCreationAttributes> implements CanonArtistTrackRelationAttributes {
+  canonArtistId!: string;
+  canonTrackId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonArtistTrackRelation belongsTo CanonArtist via canonArtistId
+  canonArtist!: CanonArtist;
+  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+  // CanonArtistTrackRelation belongsTo CanonTrack via canonTrackId
+  canonTrack!: CanonTrack;
+  getCanonTrack!: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
+  setCanonTrack!: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
+  createCanonTrack!: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtistTrackRelation {
+    return CanonArtistTrackRelation.init({
+    canonArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_artist',
+        key: 'id'
+      },
+      field: 'canon_artist_id'
+    },
+    canonTrackId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_track',
+        key: 'id'
+      },
+      field: 'canon_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: 'canon_artist_track_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_artist_track_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "canon_artist_id" },
+          { name: "canon_track_id" },
+        ]
+      },
+      {
+        name: "idx_canon_artist_track_track",
+        fields: [
+          { name: "canon_track_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonGenre.ts

@@ -0,0 +1,273 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonAlbumGenreRelation, CanonAlbumGenreRelationId } from './CanonAlbumGenreRelation';
+import type { CanonArtistGenreRelation, CanonArtistGenreRelationId } from './CanonArtistGenreRelation';
+import type { CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId } from './CanonGenreExternalReferenceRelation';
+import type { CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId } from './CanonToPlatformGenreRelation';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+import type { JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId } from './JukeboxCanonGenreRelation';
+import type { JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId } from './JukeboxSessionGenreAffinity';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+import type { PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId } from './PlatformUserPlaylistGenreAffinity';
+import type { RadioShowGenres, RadioShowGenresId } from './RadioShowGenres';
+import type { UserGenreAffinity, UserGenreAffinityId } from './UserGenreAffinity';
+import type { Versus, VersusId } from './Versus';
+
+export interface CanonGenreAttributes {
+  id: string;
+  name: string;
+  asciiName: string;
+  description: string;
+  parentGenreId?: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonGenrePk = "id";
+export type CanonGenreId = CanonGenre[CanonGenrePk];
+export type CanonGenreOptionalAttributes = "id" | "parentGenreId" | "createDate" | "updateDate";
+export type CanonGenreCreationAttributes = Optional<CanonGenreAttributes, CanonGenreOptionalAttributes>;
+
+export class CanonGenre extends Model<CanonGenreAttributes, CanonGenreCreationAttributes> implements CanonGenreAttributes {
+  id!: string;
+  name!: string;
+  asciiName!: string;
+  description!: string;
+  parentGenreId?: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonGenre hasMany CanonAlbumGenreRelation via canonGenreId
+  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;
+  // CanonGenre hasMany CanonArtistGenreRelation via canonGenreId
+  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;
+  // CanonGenre hasMany CanonGenreExternalReferenceRelation via canonGenreId
+  canonGenreExternalReferenceRelations!: CanonGenreExternalReferenceRelation[];
+  getCanonGenreExternalReferenceRelations!: Sequelize.HasManyGetAssociationsMixin<CanonGenreExternalReferenceRelation>;
+  setCanonGenreExternalReferenceRelations!: Sequelize.HasManySetAssociationsMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+  addCanonGenreExternalReferenceRelation!: Sequelize.HasManyAddAssociationMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+  addCanonGenreExternalReferenceRelations!: Sequelize.HasManyAddAssociationsMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+  createCanonGenreExternalReferenceRelation!: Sequelize.HasManyCreateAssociationMixin<CanonGenreExternalReferenceRelation>;
+  removeCanonGenreExternalReferenceRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+  removeCanonGenreExternalReferenceRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+  hasCanonGenreExternalReferenceRelation!: Sequelize.HasManyHasAssociationMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+  hasCanonGenreExternalReferenceRelations!: Sequelize.HasManyHasAssociationsMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+  countCanonGenreExternalReferenceRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonGenre hasMany CanonToPlatformGenreRelation via canonGenreId
+  canonToPlatformGenreRelations!: CanonToPlatformGenreRelation[];
+  getCanonToPlatformGenreRelations!: Sequelize.HasManyGetAssociationsMixin<CanonToPlatformGenreRelation>;
+  setCanonToPlatformGenreRelations!: Sequelize.HasManySetAssociationsMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  addCanonToPlatformGenreRelation!: Sequelize.HasManyAddAssociationMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  addCanonToPlatformGenreRelations!: Sequelize.HasManyAddAssociationsMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  createCanonToPlatformGenreRelation!: Sequelize.HasManyCreateAssociationMixin<CanonToPlatformGenreRelation>;
+  removeCanonToPlatformGenreRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  removeCanonToPlatformGenreRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  hasCanonToPlatformGenreRelation!: Sequelize.HasManyHasAssociationMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  hasCanonToPlatformGenreRelations!: Sequelize.HasManyHasAssociationsMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+  countCanonToPlatformGenreRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonGenre belongsToMany ExternalReference via canonGenreId and externalReferenceId
+  externalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations!: ExternalReference[];
+  getExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations!: Sequelize.BelongsToManyGetAssociationsMixin<ExternalReference>;
+  setExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations!: Sequelize.BelongsToManySetAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  addExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelation!: Sequelize.BelongsToManyAddAssociationMixin<ExternalReference, ExternalReferenceId>;
+  addExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations!: Sequelize.BelongsToManyAddAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  createExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelation!: Sequelize.BelongsToManyCreateAssociationMixin<ExternalReference>;
+  removeExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<ExternalReference, ExternalReferenceId>;
+  removeExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  hasExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelation!: Sequelize.BelongsToManyHasAssociationMixin<ExternalReference, ExternalReferenceId>;
+  hasExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations!: Sequelize.BelongsToManyHasAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  countExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonGenre hasMany JukeboxCanonGenreRelation via canonGenreId
+  jukeboxCanonGenreRelations!: JukeboxCanonGenreRelation[];
+  getJukeboxCanonGenreRelations!: Sequelize.HasManyGetAssociationsMixin<JukeboxCanonGenreRelation>;
+  setJukeboxCanonGenreRelations!: Sequelize.HasManySetAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+  addJukeboxCanonGenreRelation!: Sequelize.HasManyAddAssociationMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+  addJukeboxCanonGenreRelations!: Sequelize.HasManyAddAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+  createJukeboxCanonGenreRelation!: Sequelize.HasManyCreateAssociationMixin<JukeboxCanonGenreRelation>;
+  removeJukeboxCanonGenreRelation!: Sequelize.HasManyRemoveAssociationMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+  removeJukeboxCanonGenreRelations!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+  hasJukeboxCanonGenreRelation!: Sequelize.HasManyHasAssociationMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+  hasJukeboxCanonGenreRelations!: Sequelize.HasManyHasAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+  countJukeboxCanonGenreRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonGenre hasMany JukeboxSessionGenreAffinity via canonGenreId
+  jukeboxSessionGenreAffinities!: JukeboxSessionGenreAffinity[];
+  getJukeboxSessionGenreAffinities!: Sequelize.HasManyGetAssociationsMixin<JukeboxSessionGenreAffinity>;
+  setJukeboxSessionGenreAffinities!: Sequelize.HasManySetAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  addJukeboxSessionGenreAffinity!: Sequelize.HasManyAddAssociationMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  addJukeboxSessionGenreAffinities!: Sequelize.HasManyAddAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  createJukeboxSessionGenreAffinity!: Sequelize.HasManyCreateAssociationMixin<JukeboxSessionGenreAffinity>;
+  removeJukeboxSessionGenreAffinity!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  removeJukeboxSessionGenreAffinities!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  hasJukeboxSessionGenreAffinity!: Sequelize.HasManyHasAssociationMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  hasJukeboxSessionGenreAffinities!: Sequelize.HasManyHasAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  countJukeboxSessionGenreAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonGenre belongsToMany PlatformAlbum via canonGenreId and canonAlbumId
+  canonAlbumIdPlatformAlbums!: PlatformAlbum[];
+  getCanonAlbumIdPlatformAlbums!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+  setCanonAlbumIdPlatformAlbums!: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  addCanonAlbumIdPlatformAlbum!: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  addCanonAlbumIdPlatformAlbums!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  createCanonAlbumIdPlatformAlbum!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+  removeCanonAlbumIdPlatformAlbum!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  removeCanonAlbumIdPlatformAlbums!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  hasCanonAlbumIdPlatformAlbum!: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  hasCanonAlbumIdPlatformAlbums!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  countCanonAlbumIdPlatformAlbums!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonGenre belongsToMany PlatformArtist via canonGenreId and canonArtistId
+  canonArtistIdPlatformArtistCanonArtistGenreRelations!: PlatformArtist[];
+  getCanonArtistIdPlatformArtistCanonArtistGenreRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+  setCanonArtistIdPlatformArtistCanonArtistGenreRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  addCanonArtistIdPlatformArtistCanonArtistGenreRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+  addCanonArtistIdPlatformArtistCanonArtistGenreRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  createCanonArtistIdPlatformArtistCanonArtistGenreRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+  removeCanonArtistIdPlatformArtistCanonArtistGenreRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+  removeCanonArtistIdPlatformArtistCanonArtistGenreRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  hasCanonArtistIdPlatformArtistCanonArtistGenreRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+  hasCanonArtistIdPlatformArtistCanonArtistGenreRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  countCanonArtistIdPlatformArtistCanonArtistGenreRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonGenre belongsToMany PlatformGenre via canonGenreId and platformGenreId
+  platformGenreIdPlatformGenres!: PlatformGenre[];
+  getPlatformGenreIdPlatformGenres!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformGenre>;
+  setPlatformGenreIdPlatformGenres!: Sequelize.BelongsToManySetAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  addPlatformGenreIdPlatformGenre!: Sequelize.BelongsToManyAddAssociationMixin<PlatformGenre, PlatformGenreId>;
+  addPlatformGenreIdPlatformGenres!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  createPlatformGenreIdPlatformGenre!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformGenre>;
+  removePlatformGenreIdPlatformGenre!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformGenre, PlatformGenreId>;
+  removePlatformGenreIdPlatformGenres!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  hasPlatformGenreIdPlatformGenre!: Sequelize.BelongsToManyHasAssociationMixin<PlatformGenre, PlatformGenreId>;
+  hasPlatformGenreIdPlatformGenres!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  countPlatformGenreIdPlatformGenres!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonGenre hasMany PlatformUserPlaylistGenreAffinity via canonGenreId
+  platformUserPlaylistGenreAffinities!: PlatformUserPlaylistGenreAffinity[];
+  getPlatformUserPlaylistGenreAffinities!: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylistGenreAffinity>;
+  setPlatformUserPlaylistGenreAffinities!: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  addPlatformUserPlaylistGenreAffinity!: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  addPlatformUserPlaylistGenreAffinities!: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  createPlatformUserPlaylistGenreAffinity!: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylistGenreAffinity>;
+  removePlatformUserPlaylistGenreAffinity!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  removePlatformUserPlaylistGenreAffinities!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  hasPlatformUserPlaylistGenreAffinity!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  hasPlatformUserPlaylistGenreAffinities!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  countPlatformUserPlaylistGenreAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonGenre hasMany RadioShowGenres via canonGenreId
+  radioShowGenres!: RadioShowGenres[];
+  getRadioShowGenres!: Sequelize.HasManyGetAssociationsMixin<RadioShowGenres>;
+  setRadioShowGenres!: Sequelize.HasManySetAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
+  addRadioShowGenre!: Sequelize.HasManyAddAssociationMixin<RadioShowGenres, RadioShowGenresId>;
+  addRadioShowGenres!: Sequelize.HasManyAddAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
+  createRadioShowGenre!: Sequelize.HasManyCreateAssociationMixin<RadioShowGenres>;
+  removeRadioShowGenre!: Sequelize.HasManyRemoveAssociationMixin<RadioShowGenres, RadioShowGenresId>;
+  removeRadioShowGenres!: Sequelize.HasManyRemoveAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
+  hasRadioShowGenre!: Sequelize.HasManyHasAssociationMixin<RadioShowGenres, RadioShowGenresId>;
+  hasRadioShowGenres!: Sequelize.HasManyHasAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
+  countRadioShowGenres!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonGenre hasMany UserGenreAffinity via canonGenreId
+  userGenreAffinities!: UserGenreAffinity[];
+  getUserGenreAffinities!: Sequelize.HasManyGetAssociationsMixin<UserGenreAffinity>;
+  setUserGenreAffinities!: Sequelize.HasManySetAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  addUserGenreAffinity!: Sequelize.HasManyAddAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
+  addUserGenreAffinities!: Sequelize.HasManyAddAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  createUserGenreAffinity!: Sequelize.HasManyCreateAssociationMixin<UserGenreAffinity>;
+  removeUserGenreAffinity!: Sequelize.HasManyRemoveAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
+  removeUserGenreAffinities!: Sequelize.HasManyRemoveAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  hasUserGenreAffinity!: Sequelize.HasManyHasAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
+  hasUserGenreAffinities!: Sequelize.HasManyHasAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  countUserGenreAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonGenre hasMany Versus via canonGenreId
+  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;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonGenre {
+    return CanonGenre.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "genre_name_pkey"
+    },
+    asciiName: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'ascii_name'
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    parentGenreId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      field: 'parent_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_genre',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "genre_name_pkey",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "genre_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonGenreExternalReferenceRelation.ts

@@ -0,0 +1,92 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+
+export interface CanonGenreExternalReferenceRelationAttributes {
+  canonGenreId: string;
+  externalReferenceId: string;
+  url: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonGenreExternalReferenceRelationPk = "canonGenreId" | "externalReferenceId";
+export type CanonGenreExternalReferenceRelationId = CanonGenreExternalReferenceRelation[CanonGenreExternalReferenceRelationPk];
+export type CanonGenreExternalReferenceRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonGenreExternalReferenceRelationCreationAttributes = Optional<CanonGenreExternalReferenceRelationAttributes, CanonGenreExternalReferenceRelationOptionalAttributes>;
+
+export class CanonGenreExternalReferenceRelation extends Model<CanonGenreExternalReferenceRelationAttributes, CanonGenreExternalReferenceRelationCreationAttributes> implements CanonGenreExternalReferenceRelationAttributes {
+  canonGenreId!: string;
+  externalReferenceId!: string;
+  url!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonGenreExternalReferenceRelation belongsTo CanonGenre via canonGenreId
+  canonGenre!: CanonGenre;
+  getCanonGenre!: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+  setCanonGenre!: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+  createCanonGenre!: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+  // CanonGenreExternalReferenceRelation belongsTo ExternalReference via externalReferenceId
+  externalReference!: ExternalReference;
+  getExternalReference!: Sequelize.BelongsToGetAssociationMixin<ExternalReference>;
+  setExternalReference!: Sequelize.BelongsToSetAssociationMixin<ExternalReference, ExternalReferenceId>;
+  createExternalReference!: Sequelize.BelongsToCreateAssociationMixin<ExternalReference>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonGenreExternalReferenceRelation {
+    return CanonGenreExternalReferenceRelation.init({
+    canonGenreId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_genre',
+        key: 'id'
+      },
+      field: 'canon_genre_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_genre_external_reference_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_genre_external_reference_relation_pk",
+        unique: true,
+        fields: [
+          { name: "external_reference_id" },
+          { name: "canon_genre_id" },
+        ]
+      },
+    ]
+  });
+  }
+}