@earbug/db-models 0.0.62 → 0.0.63

package/models/AppUser.ts

@@ -0,0 +1,577 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUserDevice, AppUserDeviceId } from './AppUserDevice';
+import type { AppUserFollowRelation, AppUserFollowRelationId } from './AppUserFollowRelation';
+import type { AppUserPlatformRelation, AppUserPlatformRelationCreationAttributes, AppUserPlatformRelationId } from './AppUserPlatformRelation';
+import type { JukeboxInvite, JukeboxInviteId } from './JukeboxInvite';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+import type { Notification, NotificationId } from './Notification';
+import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum';
+import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+import type { RadioShow, RadioShowId } from './RadioShow';
+import type { State, StateId } from './State';
+import type { UserAbuseReports, UserAbuseReportsId } from './UserAbuseReports';
+import type { UserAffinity, UserAffinityId } from './UserAffinity';
+import type { UserArtistAffinity, UserArtistAffinityId } from './UserArtistAffinity';
+import type { UserBookmarks, UserBookmarksId } from './UserBookmarks';
+import type { UserComments, UserCommentsId } from './UserComments';
+import type { UserContacts, UserContactsId } from './UserContacts';
+import type { UserEngagementFactor, UserEngagementFactorId } from './UserEngagementFactor';
+import type { UserGenreAffinity, UserGenreAffinityId } from './UserGenreAffinity';
+import type { UserLikes, UserLikesId } from './UserLikes';
+import type { UserMessages, UserMessagesId } from './UserMessages';
+import type { Versus, VersusId } from './Versus';
+import type { VersusCoCreator, VersusCoCreatorId } from './VersusCoCreator';
+import type { VersusOption, VersusOptionId } from './VersusOption';
+import type { VersusVote, VersusVoteId } from './VersusVote';
+
+export interface AppUserAttributes {
+  id: string;
+  email?: string;
+  firstName: string;
+  createDate: Date;
+  updateDate: Date;
+  syncContacts?: boolean;
+  stateId: number;
+  lastName?: string;
+  autoApproveFollowers: boolean;
+  lastHarvested?: Date;
+  lastHarvestedError?: string;
+  earbugAccessControlPreference: string;
+  unsubscribeAll?: Date;
+  unsubscribeBiweeklyEmail?: Date;
+  unsubscribeFollowingNotifications?: Date;
+  unsubscribeInterestNotifications?: Date;
+  unsubscribeFunNotifications?: Date;
+  hardBounce?: Date;
+  softBounce1?: Date;
+  softBounce2?: Date;
+  softBounce3?: Date;
+  isGuest: boolean;
+  bio?: string;
+}
+
+export type AppUserPk = "id";
+export type AppUserId = AppUser[AppUserPk];
+export type AppUserOptionalAttributes = "id" | "email" | "createDate" | "updateDate" | "syncContacts" | "stateId" | "lastName" | "autoApproveFollowers" | "lastHarvested" | "lastHarvestedError" | "earbugAccessControlPreference" | "unsubscribeAll" | "unsubscribeBiweeklyEmail" | "unsubscribeFollowingNotifications" | "unsubscribeInterestNotifications" | "unsubscribeFunNotifications" | "hardBounce" | "softBounce1" | "softBounce2" | "softBounce3" | "bio";
+export type AppUserCreationAttributes = Optional<AppUserAttributes, AppUserOptionalAttributes>;
+
+export class AppUser extends Model<AppUserAttributes, AppUserCreationAttributes> implements AppUserAttributes {
+  id!: string;
+  email?: string;
+  firstName!: string;
+  createDate!: Date;
+  updateDate!: Date;
+  syncContacts?: boolean;
+  stateId!: number;
+  lastName?: string;
+  autoApproveFollowers!: boolean;
+  lastHarvested?: Date;
+  lastHarvestedError?: string;
+  earbugAccessControlPreference!: string;
+  unsubscribeAll?: Date;
+  unsubscribeBiweeklyEmail?: Date;
+  unsubscribeFollowingNotifications?: Date;
+  unsubscribeInterestNotifications?: Date;
+  unsubscribeFunNotifications?: Date;
+  hardBounce?: Date;
+  softBounce1?: Date;
+  softBounce2?: Date;
+  softBounce3?: Date;
+  isGuest!: boolean;
+  bio?: string;
+
+  // AppUser hasMany AppUserDevice via appUserId
+  appUserDevices!: AppUserDevice[];
+  getAppUserDevices!: Sequelize.HasManyGetAssociationsMixin<AppUserDevice>;
+  setAppUserDevices!: Sequelize.HasManySetAssociationsMixin<AppUserDevice, AppUserDeviceId>;
+  addAppUserDevice!: Sequelize.HasManyAddAssociationMixin<AppUserDevice, AppUserDeviceId>;
+  addAppUserDevices!: Sequelize.HasManyAddAssociationsMixin<AppUserDevice, AppUserDeviceId>;
+  createAppUserDevice!: Sequelize.HasManyCreateAssociationMixin<AppUserDevice>;
+  removeAppUserDevice!: Sequelize.HasManyRemoveAssociationMixin<AppUserDevice, AppUserDeviceId>;
+  removeAppUserDevices!: Sequelize.HasManyRemoveAssociationsMixin<AppUserDevice, AppUserDeviceId>;
+  hasAppUserDevice!: Sequelize.HasManyHasAssociationMixin<AppUserDevice, AppUserDeviceId>;
+  hasAppUserDevices!: Sequelize.HasManyHasAssociationsMixin<AppUserDevice, AppUserDeviceId>;
+  countAppUserDevices!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany AppUserFollowRelation via appUserId
+  appUserFollowRelations!: AppUserFollowRelation[];
+  getAppUserFollowRelations!: Sequelize.HasManyGetAssociationsMixin<AppUserFollowRelation>;
+  setAppUserFollowRelations!: Sequelize.HasManySetAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  addAppUserFollowRelation!: Sequelize.HasManyAddAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  addAppUserFollowRelations!: Sequelize.HasManyAddAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  createAppUserFollowRelation!: Sequelize.HasManyCreateAssociationMixin<AppUserFollowRelation>;
+  removeAppUserFollowRelation!: Sequelize.HasManyRemoveAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  removeAppUserFollowRelations!: Sequelize.HasManyRemoveAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  hasAppUserFollowRelation!: Sequelize.HasManyHasAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  hasAppUserFollowRelations!: Sequelize.HasManyHasAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  countAppUserFollowRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany AppUserFollowRelation via followingAppUserId
+  followingAppUserAppUserFollowRelations!: AppUserFollowRelation[];
+  getFollowingAppUserAppUserFollowRelations!: Sequelize.HasManyGetAssociationsMixin<AppUserFollowRelation>;
+  setFollowingAppUserAppUserFollowRelations!: Sequelize.HasManySetAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  addFollowingAppUserAppUserFollowRelation!: Sequelize.HasManyAddAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  addFollowingAppUserAppUserFollowRelations!: Sequelize.HasManyAddAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  createFollowingAppUserAppUserFollowRelation!: Sequelize.HasManyCreateAssociationMixin<AppUserFollowRelation>;
+  removeFollowingAppUserAppUserFollowRelation!: Sequelize.HasManyRemoveAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  removeFollowingAppUserAppUserFollowRelations!: Sequelize.HasManyRemoveAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  hasFollowingAppUserAppUserFollowRelation!: Sequelize.HasManyHasAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  hasFollowingAppUserAppUserFollowRelations!: Sequelize.HasManyHasAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  countFollowingAppUserAppUserFollowRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasOne AppUserPlatformRelation via appUserId
+  appUserPlatformRelation!: AppUserPlatformRelation;
+  getAppUserPlatformRelation!: Sequelize.HasOneGetAssociationMixin<AppUserPlatformRelation>;
+  setAppUserPlatformRelation!: Sequelize.HasOneSetAssociationMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+  createAppUserPlatformRelation!: Sequelize.HasOneCreateAssociationMixin<AppUserPlatformRelation>;
+  // AppUser hasMany JukeboxInvite via invitedUserId
+  jukeboxInvites!: JukeboxInvite[];
+  getJukeboxInvites!: Sequelize.HasManyGetAssociationsMixin<JukeboxInvite>;
+  setJukeboxInvites!: Sequelize.HasManySetAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  addJukeboxInvite!: Sequelize.HasManyAddAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+  addJukeboxInvites!: Sequelize.HasManyAddAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  createJukeboxInvite!: Sequelize.HasManyCreateAssociationMixin<JukeboxInvite>;
+  removeJukeboxInvite!: Sequelize.HasManyRemoveAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+  removeJukeboxInvites!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  hasJukeboxInvite!: Sequelize.HasManyHasAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+  hasJukeboxInvites!: Sequelize.HasManyHasAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  countJukeboxInvites!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany JukeboxInvite via inviterUserId
+  inviterUserJukeboxInvites!: JukeboxInvite[];
+  getInviterUserJukeboxInvites!: Sequelize.HasManyGetAssociationsMixin<JukeboxInvite>;
+  setInviterUserJukeboxInvites!: Sequelize.HasManySetAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  addInviterUserJukeboxInvite!: Sequelize.HasManyAddAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+  addInviterUserJukeboxInvites!: Sequelize.HasManyAddAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  createInviterUserJukeboxInvite!: Sequelize.HasManyCreateAssociationMixin<JukeboxInvite>;
+  removeInviterUserJukeboxInvite!: Sequelize.HasManyRemoveAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+  removeInviterUserJukeboxInvites!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  hasInviterUserJukeboxInvite!: Sequelize.HasManyHasAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+  hasInviterUserJukeboxInvites!: Sequelize.HasManyHasAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  countInviterUserJukeboxInvites!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany JukeboxQueueEntry via trackAddedUserId
+  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;
+  // AppUser hasMany JukeboxUser via appUserId
+  jukeboxUsers!: JukeboxUser[];
+  getJukeboxUsers!: Sequelize.HasManyGetAssociationsMixin<JukeboxUser>;
+  setJukeboxUsers!: Sequelize.HasManySetAssociationsMixin<JukeboxUser, JukeboxUserId>;
+  addJukeboxUser!: Sequelize.HasManyAddAssociationMixin<JukeboxUser, JukeboxUserId>;
+  addJukeboxUsers!: Sequelize.HasManyAddAssociationsMixin<JukeboxUser, JukeboxUserId>;
+  createJukeboxUser!: Sequelize.HasManyCreateAssociationMixin<JukeboxUser>;
+  removeJukeboxUser!: Sequelize.HasManyRemoveAssociationMixin<JukeboxUser, JukeboxUserId>;
+  removeJukeboxUsers!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxUser, JukeboxUserId>;
+  hasJukeboxUser!: Sequelize.HasManyHasAssociationMixin<JukeboxUser, JukeboxUserId>;
+  hasJukeboxUsers!: Sequelize.HasManyHasAssociationsMixin<JukeboxUser, JukeboxUserId>;
+  countJukeboxUsers!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany Notification via sourceUserId
+  notifications!: Notification[];
+  getNotifications!: Sequelize.HasManyGetAssociationsMixin<Notification>;
+  setNotifications!: Sequelize.HasManySetAssociationsMixin<Notification, NotificationId>;
+  addNotification!: Sequelize.HasManyAddAssociationMixin<Notification, NotificationId>;
+  addNotifications!: Sequelize.HasManyAddAssociationsMixin<Notification, NotificationId>;
+  createNotification!: Sequelize.HasManyCreateAssociationMixin<Notification>;
+  removeNotification!: Sequelize.HasManyRemoveAssociationMixin<Notification, NotificationId>;
+  removeNotifications!: Sequelize.HasManyRemoveAssociationsMixin<Notification, NotificationId>;
+  hasNotification!: Sequelize.HasManyHasAssociationMixin<Notification, NotificationId>;
+  hasNotifications!: Sequelize.HasManyHasAssociationsMixin<Notification, NotificationId>;
+  countNotifications!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany Notification via targetUserId
+  targetUserNotifications!: Notification[];
+  getTargetUserNotifications!: Sequelize.HasManyGetAssociationsMixin<Notification>;
+  setTargetUserNotifications!: Sequelize.HasManySetAssociationsMixin<Notification, NotificationId>;
+  addTargetUserNotification!: Sequelize.HasManyAddAssociationMixin<Notification, NotificationId>;
+  addTargetUserNotifications!: Sequelize.HasManyAddAssociationsMixin<Notification, NotificationId>;
+  createTargetUserNotification!: Sequelize.HasManyCreateAssociationMixin<Notification>;
+  removeTargetUserNotification!: Sequelize.HasManyRemoveAssociationMixin<Notification, NotificationId>;
+  removeTargetUserNotifications!: Sequelize.HasManyRemoveAssociationsMixin<Notification, NotificationId>;
+  hasTargetUserNotification!: Sequelize.HasManyHasAssociationMixin<Notification, NotificationId>;
+  hasTargetUserNotifications!: Sequelize.HasManyHasAssociationsMixin<Notification, NotificationId>;
+  countTargetUserNotifications!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany PlatformUserAlbum via appUserId
+  platformUserAlbums!: PlatformUserAlbum[];
+  getPlatformUserAlbums!: Sequelize.HasManyGetAssociationsMixin<PlatformUserAlbum>;
+  setPlatformUserAlbums!: Sequelize.HasManySetAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  addPlatformUserAlbum!: Sequelize.HasManyAddAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  addPlatformUserAlbums!: Sequelize.HasManyAddAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  createPlatformUserAlbum!: Sequelize.HasManyCreateAssociationMixin<PlatformUserAlbum>;
+  removePlatformUserAlbum!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  removePlatformUserAlbums!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  hasPlatformUserAlbum!: Sequelize.HasManyHasAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  hasPlatformUserAlbums!: Sequelize.HasManyHasAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  countPlatformUserAlbums!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany PlatformUserPlaylist via appUserId
+  platformUserPlaylists!: PlatformUserPlaylist[];
+  getPlatformUserPlaylists!: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylist>;
+  setPlatformUserPlaylists!: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  addPlatformUserPlaylist!: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  addPlatformUserPlaylists!: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  createPlatformUserPlaylist!: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylist>;
+  removePlatformUserPlaylist!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  removePlatformUserPlaylists!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  hasPlatformUserPlaylist!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  hasPlatformUserPlaylists!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  countPlatformUserPlaylists!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany RadioShow via creatorUserId
+  radioShows!: RadioShow[];
+  getRadioShows!: Sequelize.HasManyGetAssociationsMixin<RadioShow>;
+  setRadioShows!: Sequelize.HasManySetAssociationsMixin<RadioShow, RadioShowId>;
+  addRadioShow!: Sequelize.HasManyAddAssociationMixin<RadioShow, RadioShowId>;
+  addRadioShows!: Sequelize.HasManyAddAssociationsMixin<RadioShow, RadioShowId>;
+  createRadioShow!: Sequelize.HasManyCreateAssociationMixin<RadioShow>;
+  removeRadioShow!: Sequelize.HasManyRemoveAssociationMixin<RadioShow, RadioShowId>;
+  removeRadioShows!: Sequelize.HasManyRemoveAssociationsMixin<RadioShow, RadioShowId>;
+  hasRadioShow!: Sequelize.HasManyHasAssociationMixin<RadioShow, RadioShowId>;
+  hasRadioShows!: Sequelize.HasManyHasAssociationsMixin<RadioShow, RadioShowId>;
+  countRadioShows!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany UserAbuseReports via reporterUserId
+  userAbuseReports!: UserAbuseReports[];
+  getUserAbuseReports!: Sequelize.HasManyGetAssociationsMixin<UserAbuseReports>;
+  setUserAbuseReports!: Sequelize.HasManySetAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  addUserAbuseReport!: Sequelize.HasManyAddAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  addUserAbuseReports!: Sequelize.HasManyAddAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  createUserAbuseReport!: Sequelize.HasManyCreateAssociationMixin<UserAbuseReports>;
+  removeUserAbuseReport!: Sequelize.HasManyRemoveAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  removeUserAbuseReports!: Sequelize.HasManyRemoveAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  hasUserAbuseReport!: Sequelize.HasManyHasAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  hasUserAbuseReports!: Sequelize.HasManyHasAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  countUserAbuseReports!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany UserAffinity via userId
+  userAffinities!: UserAffinity[];
+  getUserAffinities!: Sequelize.HasManyGetAssociationsMixin<UserAffinity>;
+  setUserAffinities!: Sequelize.HasManySetAssociationsMixin<UserAffinity, UserAffinityId>;
+  addUserAffinity!: Sequelize.HasManyAddAssociationMixin<UserAffinity, UserAffinityId>;
+  addUserAffinities!: Sequelize.HasManyAddAssociationsMixin<UserAffinity, UserAffinityId>;
+  createUserAffinity!: Sequelize.HasManyCreateAssociationMixin<UserAffinity>;
+  removeUserAffinity!: Sequelize.HasManyRemoveAssociationMixin<UserAffinity, UserAffinityId>;
+  removeUserAffinities!: Sequelize.HasManyRemoveAssociationsMixin<UserAffinity, UserAffinityId>;
+  hasUserAffinity!: Sequelize.HasManyHasAssociationMixin<UserAffinity, UserAffinityId>;
+  hasUserAffinities!: Sequelize.HasManyHasAssociationsMixin<UserAffinity, UserAffinityId>;
+  countUserAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany UserArtistAffinity via userId
+  userArtistAffinities!: UserArtistAffinity[];
+  getUserArtistAffinities!: Sequelize.HasManyGetAssociationsMixin<UserArtistAffinity>;
+  setUserArtistAffinities!: Sequelize.HasManySetAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  addUserArtistAffinity!: Sequelize.HasManyAddAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
+  addUserArtistAffinities!: Sequelize.HasManyAddAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  createUserArtistAffinity!: Sequelize.HasManyCreateAssociationMixin<UserArtistAffinity>;
+  removeUserArtistAffinity!: Sequelize.HasManyRemoveAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
+  removeUserArtistAffinities!: Sequelize.HasManyRemoveAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  hasUserArtistAffinity!: Sequelize.HasManyHasAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
+  hasUserArtistAffinities!: Sequelize.HasManyHasAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  countUserArtistAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany UserBookmarks via appUserId
+  userBookmarks!: UserBookmarks[];
+  getUserBookmarks!: Sequelize.HasManyGetAssociationsMixin<UserBookmarks>;
+  setUserBookmarks!: Sequelize.HasManySetAssociationsMixin<UserBookmarks, UserBookmarksId>;
+  addUserBookmark!: Sequelize.HasManyAddAssociationMixin<UserBookmarks, UserBookmarksId>;
+  addUserBookmarks!: Sequelize.HasManyAddAssociationsMixin<UserBookmarks, UserBookmarksId>;
+  createUserBookmark!: Sequelize.HasManyCreateAssociationMixin<UserBookmarks>;
+  removeUserBookmark!: Sequelize.HasManyRemoveAssociationMixin<UserBookmarks, UserBookmarksId>;
+  removeUserBookmarks!: Sequelize.HasManyRemoveAssociationsMixin<UserBookmarks, UserBookmarksId>;
+  hasUserBookmark!: Sequelize.HasManyHasAssociationMixin<UserBookmarks, UserBookmarksId>;
+  hasUserBookmarks!: Sequelize.HasManyHasAssociationsMixin<UserBookmarks, UserBookmarksId>;
+  countUserBookmarks!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany UserComments via appUserId
+  userComments!: UserComments[];
+  getUserComments!: Sequelize.HasManyGetAssociationsMixin<UserComments>;
+  setUserComments!: Sequelize.HasManySetAssociationsMixin<UserComments, UserCommentsId>;
+  addUserComment!: Sequelize.HasManyAddAssociationMixin<UserComments, UserCommentsId>;
+  addUserComments!: Sequelize.HasManyAddAssociationsMixin<UserComments, UserCommentsId>;
+  createUserComment!: Sequelize.HasManyCreateAssociationMixin<UserComments>;
+  removeUserComment!: Sequelize.HasManyRemoveAssociationMixin<UserComments, UserCommentsId>;
+  removeUserComments!: Sequelize.HasManyRemoveAssociationsMixin<UserComments, UserCommentsId>;
+  hasUserComment!: Sequelize.HasManyHasAssociationMixin<UserComments, UserCommentsId>;
+  hasUserComments!: Sequelize.HasManyHasAssociationsMixin<UserComments, UserCommentsId>;
+  countUserComments!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany UserContacts via appUserId
+  userContacts!: UserContacts[];
+  getUserContacts!: Sequelize.HasManyGetAssociationsMixin<UserContacts>;
+  setUserContacts!: Sequelize.HasManySetAssociationsMixin<UserContacts, UserContactsId>;
+  addUserContact!: Sequelize.HasManyAddAssociationMixin<UserContacts, UserContactsId>;
+  addUserContacts!: Sequelize.HasManyAddAssociationsMixin<UserContacts, UserContactsId>;
+  createUserContact!: Sequelize.HasManyCreateAssociationMixin<UserContacts>;
+  removeUserContact!: Sequelize.HasManyRemoveAssociationMixin<UserContacts, UserContactsId>;
+  removeUserContacts!: Sequelize.HasManyRemoveAssociationsMixin<UserContacts, UserContactsId>;
+  hasUserContact!: Sequelize.HasManyHasAssociationMixin<UserContacts, UserContactsId>;
+  hasUserContacts!: Sequelize.HasManyHasAssociationsMixin<UserContacts, UserContactsId>;
+  countUserContacts!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany UserEngagementFactor via userId
+  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;
+  // AppUser hasMany UserGenreAffinity via userId
+  userGenreAffinities!: UserGenreAffinity[];
+  getUserGenreAffinities!: Sequelize.HasManyGetAssociationsMixin<UserGenreAffinity>;
+  setUserGenreAffinities!: Sequelize.HasManySetAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  addUserGenreAffinity!: Sequelize.HasManyAddAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
+  addUserGenreAffinities!: Sequelize.HasManyAddAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  createUserGenreAffinity!: Sequelize.HasManyCreateAssociationMixin<UserGenreAffinity>;
+  removeUserGenreAffinity!: Sequelize.HasManyRemoveAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
+  removeUserGenreAffinities!: Sequelize.HasManyRemoveAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  hasUserGenreAffinity!: Sequelize.HasManyHasAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
+  hasUserGenreAffinities!: Sequelize.HasManyHasAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  countUserGenreAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany UserLikes via appUserId
+  userLikes!: UserLikes[];
+  getUserLikes!: Sequelize.HasManyGetAssociationsMixin<UserLikes>;
+  setUserLikes!: Sequelize.HasManySetAssociationsMixin<UserLikes, UserLikesId>;
+  addUserLike!: Sequelize.HasManyAddAssociationMixin<UserLikes, UserLikesId>;
+  addUserLikes!: Sequelize.HasManyAddAssociationsMixin<UserLikes, UserLikesId>;
+  createUserLike!: Sequelize.HasManyCreateAssociationMixin<UserLikes>;
+  removeUserLike!: Sequelize.HasManyRemoveAssociationMixin<UserLikes, UserLikesId>;
+  removeUserLikes!: Sequelize.HasManyRemoveAssociationsMixin<UserLikes, UserLikesId>;
+  hasUserLike!: Sequelize.HasManyHasAssociationMixin<UserLikes, UserLikesId>;
+  hasUserLikes!: Sequelize.HasManyHasAssociationsMixin<UserLikes, UserLikesId>;
+  countUserLikes!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany UserMessages via recipientId
+  userMessages!: UserMessages[];
+  getUserMessages!: Sequelize.HasManyGetAssociationsMixin<UserMessages>;
+  setUserMessages!: Sequelize.HasManySetAssociationsMixin<UserMessages, UserMessagesId>;
+  addUserMessage!: Sequelize.HasManyAddAssociationMixin<UserMessages, UserMessagesId>;
+  addUserMessages!: Sequelize.HasManyAddAssociationsMixin<UserMessages, UserMessagesId>;
+  createUserMessage!: Sequelize.HasManyCreateAssociationMixin<UserMessages>;
+  removeUserMessage!: Sequelize.HasManyRemoveAssociationMixin<UserMessages, UserMessagesId>;
+  removeUserMessages!: Sequelize.HasManyRemoveAssociationsMixin<UserMessages, UserMessagesId>;
+  hasUserMessage!: Sequelize.HasManyHasAssociationMixin<UserMessages, UserMessagesId>;
+  hasUserMessages!: Sequelize.HasManyHasAssociationsMixin<UserMessages, UserMessagesId>;
+  countUserMessages!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany UserMessages via senderId
+  senderUserMessages!: UserMessages[];
+  getSenderUserMessages!: Sequelize.HasManyGetAssociationsMixin<UserMessages>;
+  setSenderUserMessages!: Sequelize.HasManySetAssociationsMixin<UserMessages, UserMessagesId>;
+  addSenderUserMessage!: Sequelize.HasManyAddAssociationMixin<UserMessages, UserMessagesId>;
+  addSenderUserMessages!: Sequelize.HasManyAddAssociationsMixin<UserMessages, UserMessagesId>;
+  createSenderUserMessage!: Sequelize.HasManyCreateAssociationMixin<UserMessages>;
+  removeSenderUserMessage!: Sequelize.HasManyRemoveAssociationMixin<UserMessages, UserMessagesId>;
+  removeSenderUserMessages!: Sequelize.HasManyRemoveAssociationsMixin<UserMessages, UserMessagesId>;
+  hasSenderUserMessage!: Sequelize.HasManyHasAssociationMixin<UserMessages, UserMessagesId>;
+  hasSenderUserMessages!: Sequelize.HasManyHasAssociationsMixin<UserMessages, UserMessagesId>;
+  countSenderUserMessages!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany Versus via creatorUserId
+  versus!: Versus[];
+  getVersus!: Sequelize.HasManyGetAssociationsMixin<Versus>;
+  setVersus!: Sequelize.HasManySetAssociationsMixin<Versus, VersusId>;
+  addVersu!: Sequelize.HasManyAddAssociationMixin<Versus, VersusId>;
+  addVersus!: Sequelize.HasManyAddAssociationsMixin<Versus, VersusId>;
+  createVersu!: Sequelize.HasManyCreateAssociationMixin<Versus>;
+  removeVersu!: Sequelize.HasManyRemoveAssociationMixin<Versus, VersusId>;
+  removeVersus!: Sequelize.HasManyRemoveAssociationsMixin<Versus, VersusId>;
+  hasVersu!: Sequelize.HasManyHasAssociationMixin<Versus, VersusId>;
+  hasVersus!: Sequelize.HasManyHasAssociationsMixin<Versus, VersusId>;
+  countVersus!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany VersusCoCreator via appUserId
+  versusCoCreators!: VersusCoCreator[];
+  getVersusCoCreators!: Sequelize.HasManyGetAssociationsMixin<VersusCoCreator>;
+  setVersusCoCreators!: Sequelize.HasManySetAssociationsMixin<VersusCoCreator, VersusCoCreatorId>;
+  addVersusCoCreator!: Sequelize.HasManyAddAssociationMixin<VersusCoCreator, VersusCoCreatorId>;
+  addVersusCoCreators!: Sequelize.HasManyAddAssociationsMixin<VersusCoCreator, VersusCoCreatorId>;
+  createVersusCoCreator!: Sequelize.HasManyCreateAssociationMixin<VersusCoCreator>;
+  removeVersusCoCreator!: Sequelize.HasManyRemoveAssociationMixin<VersusCoCreator, VersusCoCreatorId>;
+  removeVersusCoCreators!: Sequelize.HasManyRemoveAssociationsMixin<VersusCoCreator, VersusCoCreatorId>;
+  hasVersusCoCreator!: Sequelize.HasManyHasAssociationMixin<VersusCoCreator, VersusCoCreatorId>;
+  hasVersusCoCreators!: Sequelize.HasManyHasAssociationsMixin<VersusCoCreator, VersusCoCreatorId>;
+  countVersusCoCreators!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany VersusOption via appUserId
+  versusOptions!: VersusOption[];
+  getVersusOptions!: Sequelize.HasManyGetAssociationsMixin<VersusOption>;
+  setVersusOptions!: Sequelize.HasManySetAssociationsMixin<VersusOption, VersusOptionId>;
+  addVersusOption!: Sequelize.HasManyAddAssociationMixin<VersusOption, VersusOptionId>;
+  addVersusOptions!: Sequelize.HasManyAddAssociationsMixin<VersusOption, VersusOptionId>;
+  createVersusOption!: Sequelize.HasManyCreateAssociationMixin<VersusOption>;
+  removeVersusOption!: Sequelize.HasManyRemoveAssociationMixin<VersusOption, VersusOptionId>;
+  removeVersusOptions!: Sequelize.HasManyRemoveAssociationsMixin<VersusOption, VersusOptionId>;
+  hasVersusOption!: Sequelize.HasManyHasAssociationMixin<VersusOption, VersusOptionId>;
+  hasVersusOptions!: Sequelize.HasManyHasAssociationsMixin<VersusOption, VersusOptionId>;
+  countVersusOptions!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany VersusVote via appUserId
+  versusVotes!: VersusVote[];
+  getVersusVotes!: Sequelize.HasManyGetAssociationsMixin<VersusVote>;
+  setVersusVotes!: Sequelize.HasManySetAssociationsMixin<VersusVote, VersusVoteId>;
+  addVersusVote!: Sequelize.HasManyAddAssociationMixin<VersusVote, VersusVoteId>;
+  addVersusVotes!: Sequelize.HasManyAddAssociationsMixin<VersusVote, VersusVoteId>;
+  createVersusVote!: Sequelize.HasManyCreateAssociationMixin<VersusVote>;
+  removeVersusVote!: Sequelize.HasManyRemoveAssociationMixin<VersusVote, VersusVoteId>;
+  removeVersusVotes!: Sequelize.HasManyRemoveAssociationsMixin<VersusVote, VersusVoteId>;
+  hasVersusVote!: Sequelize.HasManyHasAssociationMixin<VersusVote, VersusVoteId>;
+  hasVersusVotes!: Sequelize.HasManyHasAssociationsMixin<VersusVote, VersusVoteId>;
+  countVersusVotes!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser belongsTo State via stateId
+  state!: State;
+  getState!: Sequelize.BelongsToGetAssociationMixin<State>;
+  setState!: Sequelize.BelongsToSetAssociationMixin<State, StateId>;
+  createState!: Sequelize.BelongsToCreateAssociationMixin<State>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof AppUser {
+    return AppUser.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    email: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      unique: "uk_app_user_email"
+    },
+    firstName: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'first_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'
+    },
+    syncContacts: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      defaultValue: false,
+      field: 'sync_contacts'
+    },
+    stateId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      references: {
+        model: 'state',
+        key: 'id'
+      },
+      field: 'state_id'
+    },
+    lastName: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'last_name'
+    },
+    autoApproveFollowers: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: true,
+      field: 'auto_approve_followers'
+    },
+    lastHarvested: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'last_harvested'
+    },
+    lastHarvestedError: {
+      type: DataTypes.STRING(512),
+      allowNull: true,
+      field: 'last_harvested_error'
+    },
+    earbugAccessControlPreference: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      defaultValue: "PUBLIC",
+      field: 'earbug_access_control_preference'
+    },
+    unsubscribeAll: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'unsubscribe_all'
+    },
+    unsubscribeBiweeklyEmail: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'unsubscribe_biweekly_email'
+    },
+    unsubscribeFollowingNotifications: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'unsubscribe_following_notifications'
+    },
+    unsubscribeInterestNotifications: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'unsubscribe_interest_notifications'
+    },
+    unsubscribeFunNotifications: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'unsubscribe_fun_notifications'
+    },
+    hardBounce: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'hard_bounce'
+    },
+    softBounce1: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'soft_bounce_1'
+    },
+    softBounce2: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'soft_bounce_2'
+    },
+    softBounce3: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'soft_bounce_3'
+    },
+    isGuest: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: false,
+      field: 'is_guest'
+    },
+    bio: {
+      type: DataTypes.TEXT,
+      allowNull: true
+    }
+  }, {
+    sequelize,
+    tableName: 'app_user',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "app_user_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "idx_app_user_hard_bounce",
+        fields: [
+          { name: "hard_bounce" },
+        ]
+      },
+      {
+        name: "uk_app_user_email",
+        unique: true,
+        fields: [
+          { name: "email" },
+        ]
+      },
+    ]
+  });
+  }
+}