@earbug/db-models 0.0.62 → 0.0.64

package/models/TrackDeletionReason.ts

@@ -0,0 +1,58 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+
+export interface TrackDeletionReasonAttributes {
+  id: number;
+  description: string;
+}
+
+export type TrackDeletionReasonPk = "id";
+export type TrackDeletionReasonId = TrackDeletionReason[TrackDeletionReasonPk];
+export type TrackDeletionReasonCreationAttributes = TrackDeletionReasonAttributes;
+
+export class TrackDeletionReason extends Model<TrackDeletionReasonAttributes, TrackDeletionReasonCreationAttributes> implements TrackDeletionReasonAttributes {
+  id!: number;
+  description!: string;
+
+  // TrackDeletionReason hasMany JukeboxQueueEntry via trackDeletionReasonId
+  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;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof TrackDeletionReason {
+    return TrackDeletionReason.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.STRING(255),
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'track_deletion_reason',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "track_deletion_reason_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/UnmatchedAlbum.ts

@@ -0,0 +1,66 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+
+export interface UnmatchedAlbumAttributes {
+  id: string;
+  platformAlbumId: string;
+  createDate: Date;
+}
+
+export type UnmatchedAlbumPk = "id";
+export type UnmatchedAlbumId = UnmatchedAlbum[UnmatchedAlbumPk];
+export type UnmatchedAlbumOptionalAttributes = "id" | "createDate";
+export type UnmatchedAlbumCreationAttributes = Optional<UnmatchedAlbumAttributes, UnmatchedAlbumOptionalAttributes>;
+
+export class UnmatchedAlbum extends Model<UnmatchedAlbumAttributes, UnmatchedAlbumCreationAttributes> implements UnmatchedAlbumAttributes {
+  id!: string;
+  platformAlbumId!: string;
+  createDate!: Date;
+
+  // UnmatchedAlbum belongsTo PlatformAlbum via platformAlbumId
+  platformAlbum!: PlatformAlbum;
+  getPlatformAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+  setPlatformAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  createPlatformAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof UnmatchedAlbum {
+    return UnmatchedAlbum.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    platformAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'platform_album',
+        key: 'id'
+      },
+      field: 'platform_album_id'
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'unmatched_album',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "unmatched_album_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/UnmatchedArtist.ts

@@ -0,0 +1,81 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { Platform, PlatformId } from './Platform';
+
+export interface UnmatchedArtistAttributes {
+  id: string;
+  platformId: number;
+  externalArtistId: number;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type UnmatchedArtistPk = "id";
+export type UnmatchedArtistId = UnmatchedArtist[UnmatchedArtistPk];
+export type UnmatchedArtistOptionalAttributes = "id" | "createDate" | "updateDate";
+export type UnmatchedArtistCreationAttributes = Optional<UnmatchedArtistAttributes, UnmatchedArtistOptionalAttributes>;
+
+export class UnmatchedArtist extends Model<UnmatchedArtistAttributes, UnmatchedArtistCreationAttributes> implements UnmatchedArtistAttributes {
+  id!: string;
+  platformId!: number;
+  externalArtistId!: number;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // UnmatchedArtist belongsTo Platform via platformId
+  platform!: Platform;
+  getPlatform!: Sequelize.BelongsToGetAssociationMixin<Platform>;
+  setPlatform!: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+  createPlatform!: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof UnmatchedArtist {
+    return UnmatchedArtist.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    platformId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'platform',
+        key: 'id'
+      },
+      field: 'platform_id'
+    },
+    externalArtistId: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      field: 'external_artist_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: 'unmatched_artist',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "unmatched_artist_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/UserAbuseReports.ts

@@ -0,0 +1,232 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+import type { RadioShow, RadioShowId } from './RadioShow';
+import type { RadioShowMedia, RadioShowMediaId } from './RadioShowMedia';
+import type { UserComments, UserCommentsId } from './UserComments';
+import type { UserMessages, UserMessagesId } from './UserMessages';
+
+export interface UserAbuseReportsAttributes {
+  id: string;
+  reporterUserId: string;
+  reportDate: Date;
+  updateDate: Date;
+  jukeboxId?: string;
+  jukeboxChatMessageId?: string;
+  radioShowId?: string;
+  radioShowMediaId?: string;
+  playlistId?: string;
+  versusThemeTextId?: string;
+  commentId?: string;
+  directMessageId?: string;
+}
+
+export type UserAbuseReportsPk = "id";
+export type UserAbuseReportsId = UserAbuseReports[UserAbuseReportsPk];
+export type UserAbuseReportsOptionalAttributes = "id" | "reportDate" | "updateDate" | "jukeboxId" | "jukeboxChatMessageId" | "radioShowId" | "radioShowMediaId" | "playlistId" | "versusThemeTextId" | "commentId" | "directMessageId";
+export type UserAbuseReportsCreationAttributes = Optional<UserAbuseReportsAttributes, UserAbuseReportsOptionalAttributes>;
+
+export class UserAbuseReports extends Model<UserAbuseReportsAttributes, UserAbuseReportsCreationAttributes> implements UserAbuseReportsAttributes {
+  id!: string;
+  reporterUserId!: string;
+  reportDate!: Date;
+  updateDate!: Date;
+  jukeboxId?: string;
+  jukeboxChatMessageId?: string;
+  radioShowId?: string;
+  radioShowMediaId?: string;
+  playlistId?: string;
+  versusThemeTextId?: string;
+  commentId?: string;
+  directMessageId?: string;
+
+  // UserAbuseReports belongsTo AppUser via reporterUserId
+  reporterUser!: AppUser;
+  getReporterUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setReporterUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createReporterUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // UserAbuseReports belongsTo JukeboxSession via jukeboxId
+  jukebox!: JukeboxSession;
+  getJukebox!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+  setJukebox!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  createJukebox!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+  // UserAbuseReports belongsTo PlatformUserPlaylist via playlistId
+  playlist!: PlatformUserPlaylist;
+  getPlaylist!: Sequelize.BelongsToGetAssociationMixin<PlatformUserPlaylist>;
+  setPlaylist!: Sequelize.BelongsToSetAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  createPlaylist!: Sequelize.BelongsToCreateAssociationMixin<PlatformUserPlaylist>;
+  // UserAbuseReports belongsTo RadioShow via radioShowId
+  radioShow!: RadioShow;
+  getRadioShow!: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
+  setRadioShow!: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
+  createRadioShow!: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+  // UserAbuseReports belongsTo RadioShowMedia via radioShowMediaId
+  radioShowMedium!: RadioShowMedia;
+  getRadioShowMedium!: Sequelize.BelongsToGetAssociationMixin<RadioShowMedia>;
+  setRadioShowMedium!: Sequelize.BelongsToSetAssociationMixin<RadioShowMedia, RadioShowMediaId>;
+  createRadioShowMedium!: Sequelize.BelongsToCreateAssociationMixin<RadioShowMedia>;
+  // UserAbuseReports belongsTo UserComments via commentId
+  comment!: UserComments;
+  getComment!: Sequelize.BelongsToGetAssociationMixin<UserComments>;
+  setComment!: Sequelize.BelongsToSetAssociationMixin<UserComments, UserCommentsId>;
+  createComment!: Sequelize.BelongsToCreateAssociationMixin<UserComments>;
+  // UserAbuseReports belongsTo UserMessages via directMessageId
+  directMessage!: UserMessages;
+  getDirectMessage!: Sequelize.BelongsToGetAssociationMixin<UserMessages>;
+  setDirectMessage!: Sequelize.BelongsToSetAssociationMixin<UserMessages, UserMessagesId>;
+  createDirectMessage!: Sequelize.BelongsToCreateAssociationMixin<UserMessages>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof UserAbuseReports {
+    return UserAbuseReports.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    reporterUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'reporter_user_id'
+    },
+    reportDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'report_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    },
+    jukeboxId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      field: 'jukebox_id'
+    },
+    jukeboxChatMessageId: {
+      type: DataTypes.STRING(50),
+      allowNull: true,
+      field: 'jukebox_chat_message_id'
+    },
+    radioShowId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'radio_show',
+        key: 'id'
+      },
+      field: 'radio_show_id'
+    },
+    radioShowMediaId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'radio_show_media',
+        key: 'id'
+      },
+      field: 'radio_show_media_id'
+    },
+    playlistId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'platform_user_playlist',
+        key: 'id'
+      },
+      field: 'playlist_id'
+    },
+    versusThemeTextId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      field: 'versus_theme_text_id'
+    },
+    commentId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'user_comments',
+        key: 'id'
+      },
+      field: 'comment_id'
+    },
+    directMessageId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'user_messages',
+        key: 'id'
+      },
+      field: 'direct_message_id'
+    }
+  }, {
+    sequelize,
+    tableName: 'user_abuse_reports',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_user_abuse_reports_comment",
+        fields: [
+          { name: "comment_id" },
+        ]
+      },
+      {
+        name: "idx_user_abuse_reports_direct_message",
+        fields: [
+          { name: "direct_message_id" },
+        ]
+      },
+      {
+        name: "idx_user_abuse_reports_jukebox",
+        fields: [
+          { name: "jukebox_id" },
+        ]
+      },
+      {
+        name: "idx_user_abuse_reports_playlist",
+        fields: [
+          { name: "playlist_id" },
+        ]
+      },
+      {
+        name: "idx_user_abuse_reports_radio_show",
+        fields: [
+          { name: "radio_show_id" },
+        ]
+      },
+      {
+        name: "idx_user_abuse_reports_radio_show_media",
+        fields: [
+          { name: "radio_show_media_id" },
+        ]
+      },
+      {
+        name: "idx_user_abuse_reports_reporter",
+        fields: [
+          { name: "reporter_user_id" },
+        ]
+      },
+      {
+        name: "user_abuse_reports_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/UserAffinity.ts

@@ -0,0 +1,117 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AffinityRelationshipType, AffinityRelationshipTypeId } from './AffinityRelationshipType';
+import type { AppUser, AppUserId } from './AppUser';
+
+export interface UserAffinityAttributes {
+  id: string;
+  userId: string;
+  affinityRelationshipTypeId: string;
+  relatedId: string;
+  createDate?: Date;
+  updateDate?: Date;
+}
+
+export type UserAffinityPk = "id";
+export type UserAffinityId = UserAffinity[UserAffinityPk];
+export type UserAffinityOptionalAttributes = "id" | "createDate" | "updateDate";
+export type UserAffinityCreationAttributes = Optional<UserAffinityAttributes, UserAffinityOptionalAttributes>;
+
+export class UserAffinity extends Model<UserAffinityAttributes, UserAffinityCreationAttributes> implements UserAffinityAttributes {
+  id!: string;
+  userId!: string;
+  affinityRelationshipTypeId!: string;
+  relatedId!: string;
+  createDate?: Date;
+  updateDate?: Date;
+
+  // UserAffinity belongsTo AffinityRelationshipType via affinityRelationshipTypeId
+  affinityRelationshipType!: AffinityRelationshipType;
+  getAffinityRelationshipType!: Sequelize.BelongsToGetAssociationMixin<AffinityRelationshipType>;
+  setAffinityRelationshipType!: Sequelize.BelongsToSetAssociationMixin<AffinityRelationshipType, AffinityRelationshipTypeId>;
+  createAffinityRelationshipType!: Sequelize.BelongsToCreateAssociationMixin<AffinityRelationshipType>;
+  // UserAffinity belongsTo AppUser via userId
+  user!: AppUser;
+  getUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof UserAffinity {
+    return UserAffinity.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    userId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      unique: "user_affinity_user_id_affinity_relationship_type_id_related_id_",
+      field: 'user_id'
+    },
+    affinityRelationshipTypeId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'affinity_relationship_type',
+        key: 'id'
+      },
+      unique: "user_affinity_user_id_affinity_relationship_type_id_related_id_",
+      field: 'affinity_relationship_type_id'
+    },
+    relatedId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      unique: "user_affinity_user_id_affinity_relationship_type_id_related_id_",
+      field: 'related_id'
+    },
+    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: 'user_affinity',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "user_affinity_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "user_affinity_user_id_affinity_relationship_type_id_index",
+        fields: [
+          { name: "user_id" },
+          { name: "affinity_relationship_type_id" },
+        ]
+      },
+      {
+        name: "user_affinity_user_id_affinity_relationship_type_id_related_id_",
+        unique: true,
+        fields: [
+          { name: "user_id" },
+          { name: "affinity_relationship_type_id" },
+          { name: "related_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/UserArtistAffinity.ts

@@ -0,0 +1,136 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AffinityTier, AffinityTierId } from './AffinityTier';
+import type { AppUser, AppUserId } from './AppUser';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+
+export interface UserArtistAffinityAttributes {
+  id: string;
+  userId: string;
+  canonArtistId: string;
+  affinityTierId: number;
+  rank: number;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type UserArtistAffinityPk = "id";
+export type UserArtistAffinityId = UserArtistAffinity[UserArtistAffinityPk];
+export type UserArtistAffinityOptionalAttributes = "id" | "createdAt" | "updatedAt";
+export type UserArtistAffinityCreationAttributes = Optional<UserArtistAffinityAttributes, UserArtistAffinityOptionalAttributes>;
+
+export class UserArtistAffinity extends Model<UserArtistAffinityAttributes, UserArtistAffinityCreationAttributes> implements UserArtistAffinityAttributes {
+  id!: string;
+  userId!: string;
+  canonArtistId!: string;
+  affinityTierId!: number;
+  rank!: number;
+  createdAt!: Date;
+  updatedAt!: Date;
+
+  // UserArtistAffinity belongsTo AffinityTier via affinityTierId
+  affinityTier!: AffinityTier;
+  getAffinityTier!: Sequelize.BelongsToGetAssociationMixin<AffinityTier>;
+  setAffinityTier!: Sequelize.BelongsToSetAssociationMixin<AffinityTier, AffinityTierId>;
+  createAffinityTier!: Sequelize.BelongsToCreateAssociationMixin<AffinityTier>;
+  // UserArtistAffinity belongsTo AppUser via userId
+  user!: AppUser;
+  getUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // UserArtistAffinity belongsTo CanonArtist via canonArtistId
+  canonArtist!: CanonArtist;
+  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof UserArtistAffinity {
+    return UserArtistAffinity.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    userId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      unique: "user_artist_affinity_user_id_canon_artist_id_unique",
+      field: 'user_id'
+    },
+    canonArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'canon_artist',
+        key: 'id'
+      },
+      unique: "user_artist_affinity_user_id_canon_artist_id_unique",
+      field: 'canon_artist_id'
+    },
+    affinityTierId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'affinity_tier',
+        key: 'id'
+      },
+      field: 'affinity_tier_id'
+    },
+    rank: {
+      type: DataTypes.INTEGER,
+      allowNull: false
+    },
+    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: 'user_artist_affinity',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_user_artist_affinity_artist",
+        fields: [
+          { name: "canon_artist_id" },
+        ]
+      },
+      {
+        name: "idx_user_artist_affinity_session",
+        fields: [
+          { name: "user_id" },
+        ]
+      },
+      {
+        name: "user_artist_affinity_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "user_artist_affinity_user_id_canon_artist_id_unique",
+        unique: true,
+        fields: [
+          { name: "user_id" },
+          { name: "canon_artist_id" },
+        ]
+      },
+    ]
+  });
+  }
+}