@earbug/db-models 0.0.59 → 0.0.62

package/models/NewsPlatform.ts

@@ -1,76 +0,0 @@
-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

@@ -1,75 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-
-export interface NewsSiteAttributes {
-  name: string;
-  domain?: string;
-  scrapingBaseUrl: string;
-  id: number;
-  active?: boolean;
-}
-
-export type NewsSitePk = "id";
-export type NewsSiteId = NewsSite[NewsSitePk];
-export type NewsSiteOptionalAttributes = "domain" | "id" | "active";
-export type NewsSiteCreationAttributes = Optional<NewsSiteAttributes, NewsSiteOptionalAttributes>;
-
-export class NewsSite extends Model<NewsSiteAttributes, NewsSiteCreationAttributes> implements NewsSiteAttributes {
-  name!: string;
-  domain?: string;
-  scrapingBaseUrl!: string;
-  id!: number;
-  active?: boolean;
-
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof NewsSite {
-    return NewsSite.init({
-    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'
-    },
-    id: {
-      autoIncrement: true,
-      type: DataTypes.INTEGER,
-      allowNull: false,
-      primaryKey: true
-    },
-    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

@@ -1,214 +0,0 @@
-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 {
-  targetUserId: string;
-  notificationTypeId: number;
-  metadata?: object;
-  readAt?: Date;
-  dismissedAt?: Date;
-  sourceUserId?: string;
-  jukeboxSessionId?: string;
-  expiresAt?: Date;
-  pushSentAt?: Date;
-  pushError?: string;
-  id: string;
-  isRead: boolean;
-  isDismissed: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-  pushSent: boolean;
-}
-
-export type NotificationPk = "id";
-export type NotificationId = Notification[NotificationPk];
-export type NotificationOptionalAttributes = "metadata" | "readAt" | "dismissedAt" | "sourceUserId" | "jukeboxSessionId" | "expiresAt" | "pushSentAt" | "pushError" | "id" | "createdAt" | "updatedAt";
-export type NotificationCreationAttributes = Optional<NotificationAttributes, NotificationOptionalAttributes>;
-
-export class Notification extends Model<NotificationAttributes, NotificationCreationAttributes> implements NotificationAttributes {
-  targetUserId!: string;
-  notificationTypeId!: number;
-  metadata?: object;
-  readAt?: Date;
-  dismissedAt?: Date;
-  sourceUserId?: string;
-  jukeboxSessionId?: string;
-  expiresAt?: Date;
-  pushSentAt?: Date;
-  pushError?: string;
-  id!: string;
-  isRead!: boolean;
-  isDismissed!: boolean;
-  createdAt!: Date;
-  updatedAt!: Date;
-  pushSent!: boolean;
-
-  // 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({
-    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
-    },
-    readAt: {
-      type: DataTypes.DATE,
-      allowNull: true,
-      field: 'read_at'
-    },
-    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'
-    },
-    expiresAt: {
-      type: DataTypes.DATE,
-      allowNull: true,
-      field: 'expires_at'
-    },
-    pushSentAt: {
-      type: DataTypes.DATE,
-      allowNull: true,
-      field: 'push_sent_at'
-    },
-    pushError: {
-      type: DataTypes.TEXT,
-      allowNull: true,
-      field: 'push_error'
-    },
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: DataTypes.UUIDV4,
-      primaryKey: true
-    },
-    isRead: {
-      type: DataTypes.BOOLEAN,
-      allowNull: false,
-      defaultValue: false,
-      field: 'is_read'
-    },
-    isDismissed: {
-      type: DataTypes.BOOLEAN,
-      allowNull: false,
-      defaultValue: false,
-      field: 'is_dismissed'
-    },
-    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'
-    },
-    pushSent: {
-      type: DataTypes.BOOLEAN,
-      allowNull: false,
-      defaultValue: false,
-      field: 'push_sent'
-    }
-  }, {
-    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

@@ -1,66 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,189 +0,0 @@
-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 {
-  name: string;
-  createDate: Date;
-  updateDate: Date;
-  id: number;
-}
-
-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 {
-  name!: string;
-  createDate!: Date;
-  updateDate!: Date;
-  id!: number;
-
-  // 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({
-    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'
-    },
-    id: {
-      autoIncrement: true,
-      autoIncrementIdentity: true,
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      primaryKey: true
-    }
-  }, {
-    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" },
-        ]
-      },
-    ]
-  });
-  }
-}