@earbug/db-models 0.0.62 → 0.0.63

package/models/NewsPlatform.ts

@@ -0,0 +1,76 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { NewsArticle, NewsArticleId } from './NewsArticle';
+
+export interface NewsPlatformAttributes {
+  id: string;
+  name: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type NewsPlatformPk = "id";
+export type NewsPlatformId = NewsPlatform[NewsPlatformPk];
+export type NewsPlatformOptionalAttributes = "id" | "createDate" | "updateDate";
+export type NewsPlatformCreationAttributes = Optional<NewsPlatformAttributes, NewsPlatformOptionalAttributes>;
+
+export class NewsPlatform extends Model<NewsPlatformAttributes, NewsPlatformCreationAttributes> implements NewsPlatformAttributes {
+  id!: string;
+  name!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // NewsPlatform hasMany NewsArticle via newsPlatformId
+  newsArticles!: NewsArticle[];
+  getNewsArticles!: Sequelize.HasManyGetAssociationsMixin<NewsArticle>;
+  setNewsArticles!: Sequelize.HasManySetAssociationsMixin<NewsArticle, NewsArticleId>;
+  addNewsArticle!: Sequelize.HasManyAddAssociationMixin<NewsArticle, NewsArticleId>;
+  addNewsArticles!: Sequelize.HasManyAddAssociationsMixin<NewsArticle, NewsArticleId>;
+  createNewsArticle!: Sequelize.HasManyCreateAssociationMixin<NewsArticle>;
+  removeNewsArticle!: Sequelize.HasManyRemoveAssociationMixin<NewsArticle, NewsArticleId>;
+  removeNewsArticles!: Sequelize.HasManyRemoveAssociationsMixin<NewsArticle, NewsArticleId>;
+  hasNewsArticle!: Sequelize.HasManyHasAssociationMixin<NewsArticle, NewsArticleId>;
+  hasNewsArticles!: Sequelize.HasManyHasAssociationsMixin<NewsArticle, NewsArticleId>;
+  countNewsArticles!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof NewsPlatform {
+    return NewsPlatform.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'news_platform',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "news_platform_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/NewsSite.ts

@@ -0,0 +1,75 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+
+export interface NewsSiteAttributes {
+  id: number;
+  name: string;
+  domain?: string;
+  scrapingBaseUrl: string;
+  active?: boolean;
+}
+
+export type NewsSitePk = "id";
+export type NewsSiteId = NewsSite[NewsSitePk];
+export type NewsSiteOptionalAttributes = "id" | "domain" | "active";
+export type NewsSiteCreationAttributes = Optional<NewsSiteAttributes, NewsSiteOptionalAttributes>;
+
+export class NewsSite extends Model<NewsSiteAttributes, NewsSiteCreationAttributes> implements NewsSiteAttributes {
+  id!: number;
+  name!: string;
+  domain?: string;
+  scrapingBaseUrl!: string;
+  active?: boolean;
+
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof NewsSite {
+    return NewsSite.init({
+    id: {
+      autoIncrement: true,
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.STRING(255),
+      allowNull: false,
+      unique: "news_site_name_unique"
+    },
+    domain: {
+      type: DataTypes.STRING(255),
+      allowNull: true
+    },
+    scrapingBaseUrl: {
+      type: DataTypes.STRING(255),
+      allowNull: false,
+      field: 'scraping_base_url'
+    },
+    active: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      defaultValue: false
+    }
+  }, {
+    sequelize,
+    tableName: 'news_site',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "news_site_name_unique",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "news_site_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/Notification.ts

@@ -0,0 +1,214 @@
+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 { NotificationType, NotificationTypeId } from './NotificationType';
+
+export interface NotificationAttributes {
+  id: string;
+  targetUserId: string;
+  notificationTypeId: number;
+  metadata?: object;
+  isRead: boolean;
+  readAt?: Date;
+  isDismissed: boolean;
+  dismissedAt?: Date;
+  sourceUserId?: string;
+  jukeboxSessionId?: string;
+  createdAt: Date;
+  updatedAt: Date;
+  expiresAt?: Date;
+  pushSent: boolean;
+  pushSentAt?: Date;
+  pushError?: string;
+}
+
+export type NotificationPk = "id";
+export type NotificationId = Notification[NotificationPk];
+export type NotificationOptionalAttributes = "id" | "metadata" | "readAt" | "dismissedAt" | "sourceUserId" | "jukeboxSessionId" | "createdAt" | "updatedAt" | "expiresAt" | "pushSentAt" | "pushError";
+export type NotificationCreationAttributes = Optional<NotificationAttributes, NotificationOptionalAttributes>;
+
+export class Notification extends Model<NotificationAttributes, NotificationCreationAttributes> implements NotificationAttributes {
+  id!: string;
+  targetUserId!: string;
+  notificationTypeId!: number;
+  metadata?: object;
+  isRead!: boolean;
+  readAt?: Date;
+  isDismissed!: boolean;
+  dismissedAt?: Date;
+  sourceUserId?: string;
+  jukeboxSessionId?: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+  expiresAt?: Date;
+  pushSent!: boolean;
+  pushSentAt?: Date;
+  pushError?: string;
+
+  // Notification belongsTo AppUser via sourceUserId
+  sourceUser!: AppUser;
+  getSourceUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setSourceUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createSourceUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // Notification belongsTo AppUser via targetUserId
+  targetUser!: AppUser;
+  getTargetUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setTargetUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createTargetUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // Notification belongsTo JukeboxSession via jukeboxSessionId
+  jukeboxSession!: JukeboxSession;
+  getJukeboxSession!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+  setJukeboxSession!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+  // Notification belongsTo NotificationType via notificationTypeId
+  notificationType!: NotificationType;
+  getNotificationType!: Sequelize.BelongsToGetAssociationMixin<NotificationType>;
+  setNotificationType!: Sequelize.BelongsToSetAssociationMixin<NotificationType, NotificationTypeId>;
+  createNotificationType!: Sequelize.BelongsToCreateAssociationMixin<NotificationType>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof Notification {
+    return Notification.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    targetUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'target_user_id'
+    },
+    notificationTypeId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'notification_type',
+        key: 'id'
+      },
+      field: 'notification_type_id'
+    },
+    metadata: {
+      type: DataTypes.JSONB,
+      allowNull: true
+    },
+    isRead: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: false,
+      field: 'is_read'
+    },
+    readAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'read_at'
+    },
+    isDismissed: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: false,
+      field: 'is_dismissed'
+    },
+    dismissedAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'dismissed_at'
+    },
+    sourceUserId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'source_user_id'
+    },
+    jukeboxSessionId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      field: 'jukebox_session_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'
+    },
+    expiresAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'expires_at'
+    },
+    pushSent: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: false,
+      field: 'push_sent'
+    },
+    pushSentAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'push_sent_at'
+    },
+    pushError: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'push_error'
+    }
+  }, {
+    sequelize,
+    tableName: 'notification',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_notification_expires_at",
+        fields: [
+          { name: "expires_at" },
+        ]
+      },
+      {
+        name: "idx_notification_session",
+        fields: [
+          { name: "jukebox_session_id" },
+        ]
+      },
+      {
+        name: "idx_notification_source_user",
+        fields: [
+          { name: "source_user_id" },
+        ]
+      },
+      {
+        name: "idx_notification_target_user_created_at",
+        fields: [
+          { name: "target_user_id" },
+          { name: "created_at", order: "DESC" },
+        ]
+      },
+      {
+        name: "notification_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/NotificationType.ts

@@ -0,0 +1,66 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { Notification, NotificationId } from './Notification';
+
+export interface NotificationTypeAttributes {
+  id: number;
+  name: string;
+}
+
+export type NotificationTypePk = "id";
+export type NotificationTypeId = NotificationType[NotificationTypePk];
+export type NotificationTypeCreationAttributes = NotificationTypeAttributes;
+
+export class NotificationType extends Model<NotificationTypeAttributes, NotificationTypeCreationAttributes> implements NotificationTypeAttributes {
+  id!: number;
+  name!: string;
+
+  // NotificationType hasMany Notification via notificationTypeId
+  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;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof NotificationType {
+    return NotificationType.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "notification_type_name_unique"
+    }
+  }, {
+    sequelize,
+    tableName: 'notification_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "notification_type_name_unique",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "notification_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/PauseStatusType.ts

@@ -0,0 +1,58 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+
+export interface PauseStatusTypeAttributes {
+  id: number;
+  description: string;
+}
+
+export type PauseStatusTypePk = "id";
+export type PauseStatusTypeId = PauseStatusType[PauseStatusTypePk];
+export type PauseStatusTypeCreationAttributes = PauseStatusTypeAttributes;
+
+export class PauseStatusType extends Model<PauseStatusTypeAttributes, PauseStatusTypeCreationAttributes> implements PauseStatusTypeAttributes {
+  id!: number;
+  description!: string;
+
+  // PauseStatusType hasMany JukeboxUser via pauseStatusTypeId
+  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;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof PauseStatusType {
+    return PauseStatusType.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.STRING(255),
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'pause_status_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "pause_status_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/Platform.ts

@@ -0,0 +1,189 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUserPlatformRelation, AppUserPlatformRelationId } from './AppUserPlatformRelation';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum';
+import type { PlatformUserAlbumTrack, PlatformUserAlbumTrackId } from './PlatformUserAlbumTrack';
+import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+import type { UnmatchedArtist, UnmatchedArtistId } from './UnmatchedArtist';
+
+export interface PlatformAttributes {
+  id: number;
+  name: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type PlatformPk = "id";
+export type PlatformId = Platform[PlatformPk];
+export type PlatformOptionalAttributes = "createDate" | "updateDate";
+export type PlatformCreationAttributes = Optional<PlatformAttributes, PlatformOptionalAttributes>;
+
+export class Platform extends Model<PlatformAttributes, PlatformCreationAttributes> implements PlatformAttributes {
+  id!: number;
+  name!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // Platform hasMany AppUserPlatformRelation via platformId
+  appUserPlatformRelations!: AppUserPlatformRelation[];
+  getAppUserPlatformRelations!: Sequelize.HasManyGetAssociationsMixin<AppUserPlatformRelation>;
+  setAppUserPlatformRelations!: Sequelize.HasManySetAssociationsMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+  addAppUserPlatformRelation!: Sequelize.HasManyAddAssociationMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+  addAppUserPlatformRelations!: Sequelize.HasManyAddAssociationsMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+  createAppUserPlatformRelation!: Sequelize.HasManyCreateAssociationMixin<AppUserPlatformRelation>;
+  removeAppUserPlatformRelation!: Sequelize.HasManyRemoveAssociationMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+  removeAppUserPlatformRelations!: Sequelize.HasManyRemoveAssociationsMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+  hasAppUserPlatformRelation!: Sequelize.HasManyHasAssociationMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+  hasAppUserPlatformRelations!: Sequelize.HasManyHasAssociationsMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+  countAppUserPlatformRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // Platform hasMany PlatformAlbum via platformId
+  platformAlbums!: PlatformAlbum[];
+  getPlatformAlbums!: Sequelize.HasManyGetAssociationsMixin<PlatformAlbum>;
+  setPlatformAlbums!: Sequelize.HasManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  addPlatformAlbum!: Sequelize.HasManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  addPlatformAlbums!: Sequelize.HasManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  createPlatformAlbum!: Sequelize.HasManyCreateAssociationMixin<PlatformAlbum>;
+  removePlatformAlbum!: Sequelize.HasManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  removePlatformAlbums!: Sequelize.HasManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  hasPlatformAlbum!: Sequelize.HasManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  hasPlatformAlbums!: Sequelize.HasManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  countPlatformAlbums!: Sequelize.HasManyCountAssociationsMixin;
+  // Platform hasMany PlatformArtist via platformId
+  platformArtists!: PlatformArtist[];
+  getPlatformArtists!: Sequelize.HasManyGetAssociationsMixin<PlatformArtist>;
+  setPlatformArtists!: Sequelize.HasManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  addPlatformArtist!: Sequelize.HasManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+  addPlatformArtists!: Sequelize.HasManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  createPlatformArtist!: Sequelize.HasManyCreateAssociationMixin<PlatformArtist>;
+  removePlatformArtist!: Sequelize.HasManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+  removePlatformArtists!: Sequelize.HasManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  hasPlatformArtist!: Sequelize.HasManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+  hasPlatformArtists!: Sequelize.HasManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  countPlatformArtists!: Sequelize.HasManyCountAssociationsMixin;
+  // Platform hasMany PlatformGenre via platformId
+  platformGenres!: PlatformGenre[];
+  getPlatformGenres!: Sequelize.HasManyGetAssociationsMixin<PlatformGenre>;
+  setPlatformGenres!: Sequelize.HasManySetAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  addPlatformGenre!: Sequelize.HasManyAddAssociationMixin<PlatformGenre, PlatformGenreId>;
+  addPlatformGenres!: Sequelize.HasManyAddAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  createPlatformGenre!: Sequelize.HasManyCreateAssociationMixin<PlatformGenre>;
+  removePlatformGenre!: Sequelize.HasManyRemoveAssociationMixin<PlatformGenre, PlatformGenreId>;
+  removePlatformGenres!: Sequelize.HasManyRemoveAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  hasPlatformGenre!: Sequelize.HasManyHasAssociationMixin<PlatformGenre, PlatformGenreId>;
+  hasPlatformGenres!: Sequelize.HasManyHasAssociationsMixin<PlatformGenre, PlatformGenreId>;
+  countPlatformGenres!: Sequelize.HasManyCountAssociationsMixin;
+  // Platform hasMany PlatformTrack via platformId
+  platformTracks!: PlatformTrack[];
+  getPlatformTracks!: Sequelize.HasManyGetAssociationsMixin<PlatformTrack>;
+  setPlatformTracks!: Sequelize.HasManySetAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  addPlatformTrack!: Sequelize.HasManyAddAssociationMixin<PlatformTrack, PlatformTrackId>;
+  addPlatformTracks!: Sequelize.HasManyAddAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  createPlatformTrack!: Sequelize.HasManyCreateAssociationMixin<PlatformTrack>;
+  removePlatformTrack!: Sequelize.HasManyRemoveAssociationMixin<PlatformTrack, PlatformTrackId>;
+  removePlatformTracks!: Sequelize.HasManyRemoveAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  hasPlatformTrack!: Sequelize.HasManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
+  hasPlatformTracks!: Sequelize.HasManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  countPlatformTracks!: Sequelize.HasManyCountAssociationsMixin;
+  // Platform hasMany PlatformUserAlbum via platformId
+  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;
+  // Platform hasMany PlatformUserAlbumTrack via platformId
+  platformUserAlbumTracks!: PlatformUserAlbumTrack[];
+  getPlatformUserAlbumTracks!: Sequelize.HasManyGetAssociationsMixin<PlatformUserAlbumTrack>;
+  setPlatformUserAlbumTracks!: Sequelize.HasManySetAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  addPlatformUserAlbumTrack!: Sequelize.HasManyAddAssociationMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  addPlatformUserAlbumTracks!: Sequelize.HasManyAddAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  createPlatformUserAlbumTrack!: Sequelize.HasManyCreateAssociationMixin<PlatformUserAlbumTrack>;
+  removePlatformUserAlbumTrack!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  removePlatformUserAlbumTracks!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  hasPlatformUserAlbumTrack!: Sequelize.HasManyHasAssociationMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  hasPlatformUserAlbumTracks!: Sequelize.HasManyHasAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  countPlatformUserAlbumTracks!: Sequelize.HasManyCountAssociationsMixin;
+  // Platform hasMany PlatformUserPlaylist via platformId
+  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;
+  // Platform hasMany UnmatchedArtist via platformId
+  unmatchedArtists!: UnmatchedArtist[];
+  getUnmatchedArtists!: Sequelize.HasManyGetAssociationsMixin<UnmatchedArtist>;
+  setUnmatchedArtists!: Sequelize.HasManySetAssociationsMixin<UnmatchedArtist, UnmatchedArtistId>;
+  addUnmatchedArtist!: Sequelize.HasManyAddAssociationMixin<UnmatchedArtist, UnmatchedArtistId>;
+  addUnmatchedArtists!: Sequelize.HasManyAddAssociationsMixin<UnmatchedArtist, UnmatchedArtistId>;
+  createUnmatchedArtist!: Sequelize.HasManyCreateAssociationMixin<UnmatchedArtist>;
+  removeUnmatchedArtist!: Sequelize.HasManyRemoveAssociationMixin<UnmatchedArtist, UnmatchedArtistId>;
+  removeUnmatchedArtists!: Sequelize.HasManyRemoveAssociationsMixin<UnmatchedArtist, UnmatchedArtistId>;
+  hasUnmatchedArtist!: Sequelize.HasManyHasAssociationMixin<UnmatchedArtist, UnmatchedArtistId>;
+  hasUnmatchedArtists!: Sequelize.HasManyHasAssociationsMixin<UnmatchedArtist, UnmatchedArtistId>;
+  countUnmatchedArtists!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof Platform {
+    return Platform.init({
+    id: {
+      autoIncrement: true,
+      autoIncrementIdentity: true,
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "uk_name"
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'platform',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "external_source_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "uk_name",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+    ]
+  });
+  }
+}