@earbug/db-models 0.0.1

package/models/CanonTrack.ts

@@ -0,0 +1,167 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { CanonAlbumTrackRelation, CanonAlbumTrackRelationId } from './CanonAlbumTrackRelation';
+import type { CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId } from './CanonToPlatformTrackRelation';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+
+export interface CanonTrackAttributes {
+  id: string;
+  name: string;
+  asciiName: string;
+  explicit: boolean;
+  discNumber?: number;
+  discTrackNumber?: number;
+  createDate: Date;
+  updateDate: Date;
+  durationMs: number;
+}
+
+export type CanonTrackPk = "id";
+export type CanonTrackId = CanonTrack[CanonTrackPk];
+export type CanonTrackOptionalAttributes = "id" | "discNumber" | "discTrackNumber" | "createDate" | "updateDate";
+export type CanonTrackCreationAttributes = Optional<CanonTrackAttributes, CanonTrackOptionalAttributes>;
+
+export class CanonTrack extends Model<CanonTrackAttributes, CanonTrackCreationAttributes> implements CanonTrackAttributes {
+  id!: string;
+  name!: string;
+  asciiName!: string;
+  explicit!: boolean;
+  discNumber?: number;
+  discTrackNumber?: number;
+  createDate!: Date;
+  updateDate!: Date;
+  durationMs!: number;
+
+  // CanonTrack belongsToMany CanonAlbum via canonTrackId and canonAlbumId
+  canonAlbumIdCanonAlbumCanonAlbumTrackRelations!: CanonAlbum[];
+  getCanonAlbumIdCanonAlbumCanonAlbumTrackRelations!: Sequelize.BelongsToManyGetAssociationsMixin<CanonAlbum>;
+  setCanonAlbumIdCanonAlbumCanonAlbumTrackRelations!: Sequelize.BelongsToManySetAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  addCanonAlbumIdCanonAlbumCanonAlbumTrackRelation!: Sequelize.BelongsToManyAddAssociationMixin<CanonAlbum, CanonAlbumId>;
+  addCanonAlbumIdCanonAlbumCanonAlbumTrackRelations!: Sequelize.BelongsToManyAddAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  createCanonAlbumIdCanonAlbumCanonAlbumTrackRelation!: Sequelize.BelongsToManyCreateAssociationMixin<CanonAlbum>;
+  removeCanonAlbumIdCanonAlbumCanonAlbumTrackRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonAlbum, CanonAlbumId>;
+  removeCanonAlbumIdCanonAlbumCanonAlbumTrackRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  hasCanonAlbumIdCanonAlbumCanonAlbumTrackRelation!: Sequelize.BelongsToManyHasAssociationMixin<CanonAlbum, CanonAlbumId>;
+  hasCanonAlbumIdCanonAlbumCanonAlbumTrackRelations!: Sequelize.BelongsToManyHasAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  countCanonAlbumIdCanonAlbumCanonAlbumTrackRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonTrack hasMany CanonAlbumTrackRelation via canonTrackId
+  canonAlbumTrackRelations!: CanonAlbumTrackRelation[];
+  getCanonAlbumTrackRelations!: Sequelize.HasManyGetAssociationsMixin<CanonAlbumTrackRelation>;
+  setCanonAlbumTrackRelations!: Sequelize.HasManySetAssociationsMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  addCanonAlbumTrackRelation!: Sequelize.HasManyAddAssociationMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  addCanonAlbumTrackRelations!: Sequelize.HasManyAddAssociationsMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  createCanonAlbumTrackRelation!: Sequelize.HasManyCreateAssociationMixin<CanonAlbumTrackRelation>;
+  removeCanonAlbumTrackRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  removeCanonAlbumTrackRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  hasCanonAlbumTrackRelation!: Sequelize.HasManyHasAssociationMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  hasCanonAlbumTrackRelations!: Sequelize.HasManyHasAssociationsMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  countCanonAlbumTrackRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonTrack hasMany CanonToPlatformTrackRelation via canonTrackId
+  canonToPlatformTrackRelations!: CanonToPlatformTrackRelation[];
+  getCanonToPlatformTrackRelations!: Sequelize.HasManyGetAssociationsMixin<CanonToPlatformTrackRelation>;
+  setCanonToPlatformTrackRelations!: Sequelize.HasManySetAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  addCanonToPlatformTrackRelation!: Sequelize.HasManyAddAssociationMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  addCanonToPlatformTrackRelations!: Sequelize.HasManyAddAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  createCanonToPlatformTrackRelation!: Sequelize.HasManyCreateAssociationMixin<CanonToPlatformTrackRelation>;
+  removeCanonToPlatformTrackRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  removeCanonToPlatformTrackRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  hasCanonToPlatformTrackRelation!: Sequelize.HasManyHasAssociationMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  hasCanonToPlatformTrackRelations!: Sequelize.HasManyHasAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  countCanonToPlatformTrackRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonTrack hasMany JukeboxQueueEntry via trackId
+  jukeboxQueueEntries!: JukeboxQueueEntry[];
+  getJukeboxQueueEntries!: Sequelize.HasManyGetAssociationsMixin<JukeboxQueueEntry>;
+  setJukeboxQueueEntries!: Sequelize.HasManySetAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  addJukeboxQueueEntry!: Sequelize.HasManyAddAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  addJukeboxQueueEntries!: Sequelize.HasManyAddAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  createJukeboxQueueEntry!: Sequelize.HasManyCreateAssociationMixin<JukeboxQueueEntry>;
+  removeJukeboxQueueEntry!: Sequelize.HasManyRemoveAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  removeJukeboxQueueEntries!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  hasJukeboxQueueEntry!: Sequelize.HasManyHasAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  hasJukeboxQueueEntries!: Sequelize.HasManyHasAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  countJukeboxQueueEntries!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonTrack belongsToMany PlatformTrack via canonTrackId and platformTrackId
+  platformTrackIdPlatformTracks!: PlatformTrack[];
+  getPlatformTrackIdPlatformTracks!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformTrack>;
+  setPlatformTrackIdPlatformTracks!: Sequelize.BelongsToManySetAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  addPlatformTrackIdPlatformTrack!: Sequelize.BelongsToManyAddAssociationMixin<PlatformTrack, PlatformTrackId>;
+  addPlatformTrackIdPlatformTracks!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  createPlatformTrackIdPlatformTrack!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformTrack>;
+  removePlatformTrackIdPlatformTrack!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformTrack, PlatformTrackId>;
+  removePlatformTrackIdPlatformTracks!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  hasPlatformTrackIdPlatformTrack!: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
+  hasPlatformTrackIdPlatformTracks!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  countPlatformTrackIdPlatformTracks!: Sequelize.BelongsToManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonTrack {
+    return CanonTrack.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'
+    },
+    explicit: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false
+    },
+    discNumber: {
+      type: DataTypes.SMALLINT,
+      allowNull: true,
+      field: 'disc_number'
+    },
+    discTrackNumber: {
+      type: DataTypes.SMALLINT,
+      allowNull: true,
+      field: 'disc_track_number'
+    },
+    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'
+    },
+    durationMs: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      field: 'duration_ms'
+    }
+  }, {
+    sequelize,
+    tableName: 'canon_track',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_track_lower_name_idx",
+        fields: [
+        ]
+      },
+      {
+        name: "platform_track_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/ConfigParam.ts

@@ -0,0 +1,62 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+
+export interface ConfigParamAttributes {
+  name: string;
+  value?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type ConfigParamPk = "name";
+export type ConfigParamId = ConfigParam[ConfigParamPk];
+export type ConfigParamOptionalAttributes = "value" | "createdAt" | "updatedAt";
+export type ConfigParamCreationAttributes = Optional<ConfigParamAttributes, ConfigParamOptionalAttributes>;
+
+export class ConfigParam extends Model<ConfigParamAttributes, ConfigParamCreationAttributes> implements ConfigParamAttributes {
+  name!: string;
+  value?: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof ConfigParam {
+    return ConfigParam.init({
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      primaryKey: true
+    },
+    value: {
+      type: DataTypes.TEXT,
+      allowNull: true
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    },
+    updatedAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'updated_at'
+    }
+  }, {
+    sequelize,
+    tableName: 'config_param',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "config_param_pkey",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/ExternalReference.ts

@@ -0,0 +1,201 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId } from './CanonAlbumExternalReferenceRelation';
+import type { CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId } from './CanonArtistExternalReferenceRelation';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId } from './CanonGenreExternalReferenceRelation';
+import type { CanonLabel, CanonLabelId } from './CanonLabel';
+import type { CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId } from './CanonLabelExternalReferenceRelation';
+import type { CanonMember, CanonMemberId } from './CanonMember';
+import type { CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId } from './CanonMemberExternalReferenceRelation';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+
+export interface ExternalReferenceAttributes {
+  id: string;
+  name: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type ExternalReferencePk = "id";
+export type ExternalReferenceId = ExternalReference[ExternalReferencePk];
+export type ExternalReferenceOptionalAttributes = "id" | "createDate" | "updateDate";
+export type ExternalReferenceCreationAttributes = Optional<ExternalReferenceAttributes, ExternalReferenceOptionalAttributes>;
+
+export class ExternalReference extends Model<ExternalReferenceAttributes, ExternalReferenceCreationAttributes> implements ExternalReferenceAttributes {
+  id!: string;
+  name!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // ExternalReference belongsToMany CanonAlbum via externalReferenceId and canonAlbumId
+  canonAlbumIdCanonAlbums!: CanonAlbum[];
+  getCanonAlbumIdCanonAlbums!: Sequelize.BelongsToManyGetAssociationsMixin<CanonAlbum>;
+  setCanonAlbumIdCanonAlbums!: Sequelize.BelongsToManySetAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  addCanonAlbumIdCanonAlbum!: Sequelize.BelongsToManyAddAssociationMixin<CanonAlbum, CanonAlbumId>;
+  addCanonAlbumIdCanonAlbums!: Sequelize.BelongsToManyAddAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  createCanonAlbumIdCanonAlbum!: Sequelize.BelongsToManyCreateAssociationMixin<CanonAlbum>;
+  removeCanonAlbumIdCanonAlbum!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonAlbum, CanonAlbumId>;
+  removeCanonAlbumIdCanonAlbums!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  hasCanonAlbumIdCanonAlbum!: Sequelize.BelongsToManyHasAssociationMixin<CanonAlbum, CanonAlbumId>;
+  hasCanonAlbumIdCanonAlbums!: Sequelize.BelongsToManyHasAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  countCanonAlbumIdCanonAlbums!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // ExternalReference hasMany CanonAlbumExternalReferenceRelation via externalReferenceId
+  canonAlbumExternalReferenceRelations!: CanonAlbumExternalReferenceRelation[];
+  getCanonAlbumExternalReferenceRelations!: Sequelize.HasManyGetAssociationsMixin<CanonAlbumExternalReferenceRelation>;
+  setCanonAlbumExternalReferenceRelations!: Sequelize.HasManySetAssociationsMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  addCanonAlbumExternalReferenceRelation!: Sequelize.HasManyAddAssociationMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  addCanonAlbumExternalReferenceRelations!: Sequelize.HasManyAddAssociationsMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  createCanonAlbumExternalReferenceRelation!: Sequelize.HasManyCreateAssociationMixin<CanonAlbumExternalReferenceRelation>;
+  removeCanonAlbumExternalReferenceRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  removeCanonAlbumExternalReferenceRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  hasCanonAlbumExternalReferenceRelation!: Sequelize.HasManyHasAssociationMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  hasCanonAlbumExternalReferenceRelations!: Sequelize.HasManyHasAssociationsMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  countCanonAlbumExternalReferenceRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // ExternalReference hasMany CanonArtistExternalReferenceRelation via externalReferenceId
+  canonArtistExternalReferenceRelations!: CanonArtistExternalReferenceRelation[];
+  getCanonArtistExternalReferenceRelations!: Sequelize.HasManyGetAssociationsMixin<CanonArtistExternalReferenceRelation>;
+  setCanonArtistExternalReferenceRelations!: Sequelize.HasManySetAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  addCanonArtistExternalReferenceRelation!: Sequelize.HasManyAddAssociationMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  addCanonArtistExternalReferenceRelations!: Sequelize.HasManyAddAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  createCanonArtistExternalReferenceRelation!: Sequelize.HasManyCreateAssociationMixin<CanonArtistExternalReferenceRelation>;
+  removeCanonArtistExternalReferenceRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  removeCanonArtistExternalReferenceRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  hasCanonArtistExternalReferenceRelation!: Sequelize.HasManyHasAssociationMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  hasCanonArtistExternalReferenceRelations!: Sequelize.HasManyHasAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+  countCanonArtistExternalReferenceRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // ExternalReference belongsToMany CanonGenre via externalReferenceId and canonGenreId
+  canonGenreIdCanonGenreCanonGenreExternalReferenceRelations!: CanonGenre[];
+  getCanonGenreIdCanonGenreCanonGenreExternalReferenceRelations!: Sequelize.BelongsToManyGetAssociationsMixin<CanonGenre>;
+  setCanonGenreIdCanonGenreCanonGenreExternalReferenceRelations!: Sequelize.BelongsToManySetAssociationsMixin<CanonGenre, CanonGenreId>;
+  addCanonGenreIdCanonGenreCanonGenreExternalReferenceRelation!: Sequelize.BelongsToManyAddAssociationMixin<CanonGenre, CanonGenreId>;
+  addCanonGenreIdCanonGenreCanonGenreExternalReferenceRelations!: Sequelize.BelongsToManyAddAssociationsMixin<CanonGenre, CanonGenreId>;
+  createCanonGenreIdCanonGenreCanonGenreExternalReferenceRelation!: Sequelize.BelongsToManyCreateAssociationMixin<CanonGenre>;
+  removeCanonGenreIdCanonGenreCanonGenreExternalReferenceRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonGenre, CanonGenreId>;
+  removeCanonGenreIdCanonGenreCanonGenreExternalReferenceRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonGenre, CanonGenreId>;
+  hasCanonGenreIdCanonGenreCanonGenreExternalReferenceRelation!: Sequelize.BelongsToManyHasAssociationMixin<CanonGenre, CanonGenreId>;
+  hasCanonGenreIdCanonGenreCanonGenreExternalReferenceRelations!: Sequelize.BelongsToManyHasAssociationsMixin<CanonGenre, CanonGenreId>;
+  countCanonGenreIdCanonGenreCanonGenreExternalReferenceRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // ExternalReference hasMany CanonGenreExternalReferenceRelation via externalReferenceId
+  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;
+  // ExternalReference belongsToMany CanonLabel via externalReferenceId and canonLabelId
+  canonLabelIdCanonLabelCanonLabelExternalReferenceRelations!: CanonLabel[];
+  getCanonLabelIdCanonLabelCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyGetAssociationsMixin<CanonLabel>;
+  setCanonLabelIdCanonLabelCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManySetAssociationsMixin<CanonLabel, CanonLabelId>;
+  addCanonLabelIdCanonLabelCanonLabelExternalReferenceRelation!: Sequelize.BelongsToManyAddAssociationMixin<CanonLabel, CanonLabelId>;
+  addCanonLabelIdCanonLabelCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyAddAssociationsMixin<CanonLabel, CanonLabelId>;
+  createCanonLabelIdCanonLabelCanonLabelExternalReferenceRelation!: Sequelize.BelongsToManyCreateAssociationMixin<CanonLabel>;
+  removeCanonLabelIdCanonLabelCanonLabelExternalReferenceRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonLabel, CanonLabelId>;
+  removeCanonLabelIdCanonLabelCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonLabel, CanonLabelId>;
+  hasCanonLabelIdCanonLabelCanonLabelExternalReferenceRelation!: Sequelize.BelongsToManyHasAssociationMixin<CanonLabel, CanonLabelId>;
+  hasCanonLabelIdCanonLabelCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyHasAssociationsMixin<CanonLabel, CanonLabelId>;
+  countCanonLabelIdCanonLabelCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // ExternalReference hasMany CanonLabelExternalReferenceRelation via externalReferenceId
+  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;
+  // ExternalReference belongsToMany CanonMember via externalReferenceId and canonMemberId
+  canonMemberIdCanonMemberCanonMemberExternalReferenceRelations!: CanonMember[];
+  getCanonMemberIdCanonMemberCanonMemberExternalReferenceRelations!: Sequelize.BelongsToManyGetAssociationsMixin<CanonMember>;
+  setCanonMemberIdCanonMemberCanonMemberExternalReferenceRelations!: Sequelize.BelongsToManySetAssociationsMixin<CanonMember, CanonMemberId>;
+  addCanonMemberIdCanonMemberCanonMemberExternalReferenceRelation!: Sequelize.BelongsToManyAddAssociationMixin<CanonMember, CanonMemberId>;
+  addCanonMemberIdCanonMemberCanonMemberExternalReferenceRelations!: Sequelize.BelongsToManyAddAssociationsMixin<CanonMember, CanonMemberId>;
+  createCanonMemberIdCanonMemberCanonMemberExternalReferenceRelation!: Sequelize.BelongsToManyCreateAssociationMixin<CanonMember>;
+  removeCanonMemberIdCanonMemberCanonMemberExternalReferenceRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonMember, CanonMemberId>;
+  removeCanonMemberIdCanonMemberCanonMemberExternalReferenceRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonMember, CanonMemberId>;
+  hasCanonMemberIdCanonMemberCanonMemberExternalReferenceRelation!: Sequelize.BelongsToManyHasAssociationMixin<CanonMember, CanonMemberId>;
+  hasCanonMemberIdCanonMemberCanonMemberExternalReferenceRelations!: Sequelize.BelongsToManyHasAssociationsMixin<CanonMember, CanonMemberId>;
+  countCanonMemberIdCanonMemberCanonMemberExternalReferenceRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // ExternalReference hasMany CanonMemberExternalReferenceRelation via externalReferenceId
+  canonMemberExternalReferenceRelations!: CanonMemberExternalReferenceRelation[];
+  getCanonMemberExternalReferenceRelations!: Sequelize.HasManyGetAssociationsMixin<CanonMemberExternalReferenceRelation>;
+  setCanonMemberExternalReferenceRelations!: Sequelize.HasManySetAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  addCanonMemberExternalReferenceRelation!: Sequelize.HasManyAddAssociationMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  addCanonMemberExternalReferenceRelations!: Sequelize.HasManyAddAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  createCanonMemberExternalReferenceRelation!: Sequelize.HasManyCreateAssociationMixin<CanonMemberExternalReferenceRelation>;
+  removeCanonMemberExternalReferenceRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  removeCanonMemberExternalReferenceRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  hasCanonMemberExternalReferenceRelation!: Sequelize.HasManyHasAssociationMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  hasCanonMemberExternalReferenceRelations!: Sequelize.HasManyHasAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  countCanonMemberExternalReferenceRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // ExternalReference belongsToMany PlatformArtist via externalReferenceId and canonArtistId
+  canonArtistIdPlatformArtists!: PlatformArtist[];
+  getCanonArtistIdPlatformArtists!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+  setCanonArtistIdPlatformArtists!: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  addCanonArtistIdPlatformArtist!: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+  addCanonArtistIdPlatformArtists!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  createCanonArtistIdPlatformArtist!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+  removeCanonArtistIdPlatformArtist!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+  removeCanonArtistIdPlatformArtists!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  hasCanonArtistIdPlatformArtist!: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+  hasCanonArtistIdPlatformArtists!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  countCanonArtistIdPlatformArtists!: Sequelize.BelongsToManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof ExternalReference {
+    return ExternalReference.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "external_reference_un"
+    },
+    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: 'external_reference',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "external_reference_un",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "reference_source_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxAccessType.ts

@@ -0,0 +1,60 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+
+export interface JukeboxAccessTypeAttributes {
+  id: number;
+  description: string;
+}
+
+export type JukeboxAccessTypePk = "id";
+export type JukeboxAccessTypeId = JukeboxAccessType[JukeboxAccessTypePk];
+export type JukeboxAccessTypeCreationAttributes = JukeboxAccessTypeAttributes;
+
+export class JukeboxAccessType extends Model<JukeboxAccessTypeAttributes, JukeboxAccessTypeCreationAttributes> implements JukeboxAccessTypeAttributes {
+  id!: number;
+  description!: string;
+
+  // JukeboxAccessType hasMany JukeboxSession via accessTypeId
+  jukeboxSessions!: JukeboxSession[];
+  getJukeboxSessions!: Sequelize.HasManyGetAssociationsMixin<JukeboxSession>;
+  setJukeboxSessions!: Sequelize.HasManySetAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  addJukeboxSession!: Sequelize.HasManyAddAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  addJukeboxSessions!: Sequelize.HasManyAddAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.HasManyCreateAssociationMixin<JukeboxSession>;
+  removeJukeboxSession!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  removeJukeboxSessions!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  hasJukeboxSession!: Sequelize.HasManyHasAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  hasJukeboxSessions!: Sequelize.HasManyHasAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  countJukeboxSessions!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxAccessType {
+    return JukeboxAccessType.init({
+    id: {
+      autoIncrement: true,
+      autoIncrementIdentity: true,
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_access_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_access_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxCanonGenreRelation.ts

@@ -0,0 +1,109 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+
+export interface JukeboxCanonGenreRelationAttributes {
+  id: string;
+  jukeboxSessionId: string;
+  canonGenreId: string;
+  stateId: number;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type JukeboxCanonGenreRelationPk = "id";
+export type JukeboxCanonGenreRelationId = JukeboxCanonGenreRelation[JukeboxCanonGenreRelationPk];
+export type JukeboxCanonGenreRelationOptionalAttributes = "id" | "stateId" | "createdAt" | "updatedAt";
+export type JukeboxCanonGenreRelationCreationAttributes = Optional<JukeboxCanonGenreRelationAttributes, JukeboxCanonGenreRelationOptionalAttributes>;
+
+export class JukeboxCanonGenreRelation extends Model<JukeboxCanonGenreRelationAttributes, JukeboxCanonGenreRelationCreationAttributes> implements JukeboxCanonGenreRelationAttributes {
+  id!: string;
+  jukeboxSessionId!: string;
+  canonGenreId!: string;
+  stateId!: number;
+  createdAt!: Date;
+  updatedAt!: Date;
+
+  // JukeboxCanonGenreRelation belongsTo CanonGenre via canonGenreId
+  canonGenre!: CanonGenre;
+  getCanonGenre!: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+  setCanonGenre!: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+  createCanonGenre!: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+  // JukeboxCanonGenreRelation belongsTo JukeboxSession via jukeboxSessionId
+  jukeboxSession!: JukeboxSession;
+  getJukeboxSession!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+  setJukeboxSession!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxCanonGenreRelation {
+    return JukeboxCanonGenreRelation.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    jukeboxSessionId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      unique: "unique_jukebox_canon_genre",
+      field: 'jukebox_session_id'
+    },
+    canonGenreId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'canon_genre',
+        key: 'id'
+      },
+      unique: "unique_jukebox_canon_genre",
+      field: 'canon_genre_id'
+    },
+    stateId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      field: 'state_id'
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    },
+    updatedAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'updated_at'
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_canon_genre_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_canon_genre_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "unique_jukebox_canon_genre",
+        unique: true,
+        fields: [
+          { name: "jukebox_session_id" },
+          { name: "canon_genre_id" },
+        ]
+      },
+    ]
+  });
+  }
+}