@earbug/db-models 0.0.1

package/models/CanonArtistTrackRelation.ts

@@ -0,0 +1,86 @@
+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 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 PlatformArtist via canonArtistId
+  canonArtist!: PlatformArtist;
+  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+  // CanonArtistTrackRelation belongsTo PlatformTrack via canonTrackId
+  canonTrack!: PlatformTrack;
+  getCanonTrack!: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+  setCanonTrack!: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+  createCanonTrack!: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtistTrackRelation {
+    return CanonArtistTrackRelation.init({
+    canonArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_artist',
+        key: 'id'
+      },
+      field: 'canon_artist_id'
+    },
+    canonTrackId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_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" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonGenre.ts

@@ -0,0 +1,208 @@
+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 { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+
+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 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;
+
+  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" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonLabel.ts

@@ -0,0 +1,129 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonAlbumLabelRelation, CanonAlbumLabelRelationId } from './CanonAlbumLabelRelation';
+import type { CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId } from './CanonLabelExternalReferenceRelation';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+
+export interface CanonLabelAttributes {
+  id: string;
+  name: string;
+  asciiName: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonLabelPk = "id";
+export type CanonLabelId = CanonLabel[CanonLabelPk];
+export type CanonLabelOptionalAttributes = "id" | "createDate" | "updateDate";
+export type CanonLabelCreationAttributes = Optional<CanonLabelAttributes, CanonLabelOptionalAttributes>;
+
+export class CanonLabel extends Model<CanonLabelAttributes, CanonLabelCreationAttributes> implements CanonLabelAttributes {
+  id!: string;
+  name!: string;
+  asciiName!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonLabel hasMany CanonAlbumLabelRelation via canonLabelId
+  canonAlbumLabelRelations!: CanonAlbumLabelRelation[];
+  getCanonAlbumLabelRelations!: Sequelize.HasManyGetAssociationsMixin<CanonAlbumLabelRelation>;
+  setCanonAlbumLabelRelations!: Sequelize.HasManySetAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  addCanonAlbumLabelRelation!: Sequelize.HasManyAddAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  addCanonAlbumLabelRelations!: Sequelize.HasManyAddAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  createCanonAlbumLabelRelation!: Sequelize.HasManyCreateAssociationMixin<CanonAlbumLabelRelation>;
+  removeCanonAlbumLabelRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  removeCanonAlbumLabelRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  hasCanonAlbumLabelRelation!: Sequelize.HasManyHasAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  hasCanonAlbumLabelRelations!: Sequelize.HasManyHasAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  countCanonAlbumLabelRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonLabel hasMany CanonLabelExternalReferenceRelation via canonLabelId
+  canonLabelExternalReferenceRelations!: CanonLabelExternalReferenceRelation[];
+  getCanonLabelExternalReferenceRelations!: Sequelize.HasManyGetAssociationsMixin<CanonLabelExternalReferenceRelation>;
+  setCanonLabelExternalReferenceRelations!: Sequelize.HasManySetAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  addCanonLabelExternalReferenceRelation!: Sequelize.HasManyAddAssociationMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  addCanonLabelExternalReferenceRelations!: Sequelize.HasManyAddAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  createCanonLabelExternalReferenceRelation!: Sequelize.HasManyCreateAssociationMixin<CanonLabelExternalReferenceRelation>;
+  removeCanonLabelExternalReferenceRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  removeCanonLabelExternalReferenceRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  hasCanonLabelExternalReferenceRelation!: Sequelize.HasManyHasAssociationMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  hasCanonLabelExternalReferenceRelations!: Sequelize.HasManyHasAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  countCanonLabelExternalReferenceRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonLabel belongsToMany ExternalReference via canonLabelId and externalReferenceId
+  externalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: ExternalReference[];
+  getExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyGetAssociationsMixin<ExternalReference>;
+  setExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManySetAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  addExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelation!: Sequelize.BelongsToManyAddAssociationMixin<ExternalReference, ExternalReferenceId>;
+  addExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyAddAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  createExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelation!: Sequelize.BelongsToManyCreateAssociationMixin<ExternalReference>;
+  removeExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<ExternalReference, ExternalReferenceId>;
+  removeExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  hasExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelation!: Sequelize.BelongsToManyHasAssociationMixin<ExternalReference, ExternalReferenceId>;
+  hasExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyHasAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  countExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonLabel belongsToMany PlatformAlbum via canonLabelId and canonAlbumId
+  canonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: PlatformAlbum[];
+  getCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+  setCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  addCanonAlbumIdPlatformAlbumCanonAlbumLabelRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  addCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  createCanonAlbumIdPlatformAlbumCanonAlbumLabelRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+  removeCanonAlbumIdPlatformAlbumCanonAlbumLabelRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  removeCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  hasCanonAlbumIdPlatformAlbumCanonAlbumLabelRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  hasCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  countCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonLabel {
+    return CanonLabel.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'
+    },
+    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_label',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "label_name_idx",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "label_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonLabelExternalReferenceRelation.ts

@@ -0,0 +1,92 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonLabel, CanonLabelId } from './CanonLabel';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+
+export interface CanonLabelExternalReferenceRelationAttributes {
+  canonLabelId: string;
+  externalReferenceId: string;
+  url: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonLabelExternalReferenceRelationPk = "canonLabelId" | "externalReferenceId";
+export type CanonLabelExternalReferenceRelationId = CanonLabelExternalReferenceRelation[CanonLabelExternalReferenceRelationPk];
+export type CanonLabelExternalReferenceRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonLabelExternalReferenceRelationCreationAttributes = Optional<CanonLabelExternalReferenceRelationAttributes, CanonLabelExternalReferenceRelationOptionalAttributes>;
+
+export class CanonLabelExternalReferenceRelation extends Model<CanonLabelExternalReferenceRelationAttributes, CanonLabelExternalReferenceRelationCreationAttributes> implements CanonLabelExternalReferenceRelationAttributes {
+  canonLabelId!: string;
+  externalReferenceId!: string;
+  url!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonLabelExternalReferenceRelation belongsTo CanonLabel via canonLabelId
+  canonLabel!: CanonLabel;
+  getCanonLabel!: Sequelize.BelongsToGetAssociationMixin<CanonLabel>;
+  setCanonLabel!: Sequelize.BelongsToSetAssociationMixin<CanonLabel, CanonLabelId>;
+  createCanonLabel!: Sequelize.BelongsToCreateAssociationMixin<CanonLabel>;
+  // CanonLabelExternalReferenceRelation 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 CanonLabelExternalReferenceRelation {
+    return CanonLabelExternalReferenceRelation.init({
+    canonLabelId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_label',
+        key: 'id'
+      },
+      field: 'canon_label_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_label_external_reference_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_label_external_reference_relation_pk",
+        unique: true,
+        fields: [
+          { name: "canon_label_id" },
+          { name: "external_reference_id" },
+        ]
+      },
+    ]
+  });
+  }
+}