@earbug/db-models 0.0.62 → 0.0.63

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/FeedConfig.ts

@@ -0,0 +1,65 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+
+export interface FeedConfigAttributes {
+  id: string;
+  resultsCount: number;
+  createDate?: Date;
+  updateDate?: Date;
+}
+
+export type FeedConfigPk = "id";
+export type FeedConfigId = FeedConfig[FeedConfigPk];
+export type FeedConfigOptionalAttributes = "id" | "resultsCount" | "createDate" | "updateDate";
+export type FeedConfigCreationAttributes = Optional<FeedConfigAttributes, FeedConfigOptionalAttributes>;
+
+export class FeedConfig extends Model<FeedConfigAttributes, FeedConfigCreationAttributes> implements FeedConfigAttributes {
+  id!: string;
+  resultsCount!: number;
+  createDate?: Date;
+  updateDate?: Date;
+
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof FeedConfig {
+    return FeedConfig.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    resultsCount: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      defaultValue: 100,
+      field: 'results_count'
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'feed_config',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "feed_config_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/FeedContentType.ts

@@ -0,0 +1,124 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { UserEngagementFactor, UserEngagementFactorId } from './UserEngagementFactor';
+
+export interface FeedContentTypeAttributes {
+  id: string;
+  name: string;
+  mixPercentage: number;
+  affinityMixHigh: number;
+  affinityMixMedium: number;
+  affinityMixLow: number;
+  apiEndpoint?: string;
+  isActive: boolean;
+  createDate?: Date;
+  updateDate?: Date;
+}
+
+export type FeedContentTypePk = "id";
+export type FeedContentTypeId = FeedContentType[FeedContentTypePk];
+export type FeedContentTypeOptionalAttributes = "id" | "mixPercentage" | "affinityMixHigh" | "affinityMixMedium" | "affinityMixLow" | "apiEndpoint" | "isActive" | "createDate" | "updateDate";
+export type FeedContentTypeCreationAttributes = Optional<FeedContentTypeAttributes, FeedContentTypeOptionalAttributes>;
+
+export class FeedContentType extends Model<FeedContentTypeAttributes, FeedContentTypeCreationAttributes> implements FeedContentTypeAttributes {
+  id!: string;
+  name!: string;
+  mixPercentage!: number;
+  affinityMixHigh!: number;
+  affinityMixMedium!: number;
+  affinityMixLow!: number;
+  apiEndpoint?: string;
+  isActive!: boolean;
+  createDate?: Date;
+  updateDate?: Date;
+
+  // FeedContentType hasMany UserEngagementFactor via contentTypeId
+  userEngagementFactors!: UserEngagementFactor[];
+  getUserEngagementFactors!: Sequelize.HasManyGetAssociationsMixin<UserEngagementFactor>;
+  setUserEngagementFactors!: Sequelize.HasManySetAssociationsMixin<UserEngagementFactor, UserEngagementFactorId>;
+  addUserEngagementFactor!: Sequelize.HasManyAddAssociationMixin<UserEngagementFactor, UserEngagementFactorId>;
+  addUserEngagementFactors!: Sequelize.HasManyAddAssociationsMixin<UserEngagementFactor, UserEngagementFactorId>;
+  createUserEngagementFactor!: Sequelize.HasManyCreateAssociationMixin<UserEngagementFactor>;
+  removeUserEngagementFactor!: Sequelize.HasManyRemoveAssociationMixin<UserEngagementFactor, UserEngagementFactorId>;
+  removeUserEngagementFactors!: Sequelize.HasManyRemoveAssociationsMixin<UserEngagementFactor, UserEngagementFactorId>;
+  hasUserEngagementFactor!: Sequelize.HasManyHasAssociationMixin<UserEngagementFactor, UserEngagementFactorId>;
+  hasUserEngagementFactors!: Sequelize.HasManyHasAssociationsMixin<UserEngagementFactor, UserEngagementFactorId>;
+  countUserEngagementFactors!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof FeedContentType {
+    return FeedContentType.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.STRING(50),
+      allowNull: false
+    },
+    mixPercentage: {
+      type: DataTypes.DECIMAL,
+      allowNull: false,
+      defaultValue: 20,
+      field: 'mix_percentage'
+    },
+    affinityMixHigh: {
+      type: DataTypes.DECIMAL,
+      allowNull: false,
+      defaultValue: 30,
+      field: 'affinity_mix_high'
+    },
+    affinityMixMedium: {
+      type: DataTypes.DECIMAL,
+      allowNull: false,
+      defaultValue: 50,
+      field: 'affinity_mix_medium'
+    },
+    affinityMixLow: {
+      type: DataTypes.DECIMAL,
+      allowNull: false,
+      defaultValue: 20,
+      field: 'affinity_mix_low'
+    },
+    apiEndpoint: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      defaultValue: "",
+      field: 'api_endpoint'
+    },
+    isActive: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: true,
+      field: 'is_active'
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'feed_content_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "feed_content_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/GuestUser.ts

@@ -0,0 +1,137 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+import type { Versus, VersusId } from './Versus';
+
+export interface GuestUserAttributes {
+  id: string;
+  firstName: string;
+  lastName?: string;
+  jukeboxSessionId?: string;
+  ipAddress?: string;
+  createDate: Date;
+  updateDate: Date;
+  versusId?: string;
+}
+
+export type GuestUserPk = "id";
+export type GuestUserId = GuestUser[GuestUserPk];
+export type GuestUserOptionalAttributes = "id" | "lastName" | "jukeboxSessionId" | "ipAddress" | "createDate" | "updateDate" | "versusId";
+export type GuestUserCreationAttributes = Optional<GuestUserAttributes, GuestUserOptionalAttributes>;
+
+export class GuestUser extends Model<GuestUserAttributes, GuestUserCreationAttributes> implements GuestUserAttributes {
+  id!: string;
+  firstName!: string;
+  lastName?: string;
+  jukeboxSessionId?: string;
+  ipAddress?: string;
+  createDate!: Date;
+  updateDate!: Date;
+  versusId?: string;
+
+  // GuestUser hasMany JukeboxQueueEntry via trackAddedGuestUserId
+  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;
+  // GuestUser belongsTo JukeboxSession via jukeboxSessionId
+  jukeboxSession!: JukeboxSession;
+  getJukeboxSession!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+  setJukeboxSession!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+  // GuestUser belongsTo Versus via versusId
+  versu!: Versus;
+  getVersu!: Sequelize.BelongsToGetAssociationMixin<Versus>;
+  setVersu!: Sequelize.BelongsToSetAssociationMixin<Versus, VersusId>;
+  createVersu!: Sequelize.BelongsToCreateAssociationMixin<Versus>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof GuestUser {
+    return GuestUser.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    firstName: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'first_name'
+    },
+    lastName: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'last_name'
+    },
+    jukeboxSessionId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      field: 'jukebox_session_id'
+    },
+    ipAddress: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'ip_address'
+    },
+    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'
+    },
+    versusId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'versus',
+        key: 'id'
+      },
+      field: 'versus_id'
+    }
+  }, {
+    sequelize,
+    tableName: 'guest_user',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "guest_user_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "idx_guest_user_session",
+        fields: [
+          { name: "jukebox_session_id" },
+        ]
+      },
+      {
+        name: "idx_guest_user_versus",
+        fields: [
+          { name: "versus_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" },
+        ]
+      },
+    ]
+  });
+  }
+}