@earbug/db-models 0.0.60 → 0.0.62

package/models/PlatformUserPlaylistGenreAffinity.ts

@@ -1,136 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { AffinityTier, AffinityTierId } from './AffinityTier';
-import type { CanonGenre, CanonGenreId } from './CanonGenre';
-import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
-
-export interface PlatformUserPlaylistGenreAffinityAttributes {
-  platformUserPlaylistId: string;
-  canonGenreId: string;
-  affinityTierId: number;
-  rank: number;
-  id: string;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-export type PlatformUserPlaylistGenreAffinityPk = "id";
-export type PlatformUserPlaylistGenreAffinityId = PlatformUserPlaylistGenreAffinity[PlatformUserPlaylistGenreAffinityPk];
-export type PlatformUserPlaylistGenreAffinityOptionalAttributes = "id" | "createdAt" | "updatedAt";
-export type PlatformUserPlaylistGenreAffinityCreationAttributes = Optional<PlatformUserPlaylistGenreAffinityAttributes, PlatformUserPlaylistGenreAffinityOptionalAttributes>;
-
-export class PlatformUserPlaylistGenreAffinity extends Model<PlatformUserPlaylistGenreAffinityAttributes, PlatformUserPlaylistGenreAffinityCreationAttributes> implements PlatformUserPlaylistGenreAffinityAttributes {
-  platformUserPlaylistId!: string;
-  canonGenreId!: string;
-  affinityTierId!: number;
-  rank!: number;
-  id!: string;
-  createdAt!: Date;
-  updatedAt!: Date;
-
-  // PlatformUserPlaylistGenreAffinity belongsTo AffinityTier via affinityTierId
-  affinityTier!: AffinityTier;
-  getAffinityTier!: Sequelize.BelongsToGetAssociationMixin<AffinityTier>;
-  setAffinityTier!: Sequelize.BelongsToSetAssociationMixin<AffinityTier, AffinityTierId>;
-  createAffinityTier!: Sequelize.BelongsToCreateAssociationMixin<AffinityTier>;
-  // PlatformUserPlaylistGenreAffinity belongsTo CanonGenre via canonGenreId
-  canonGenre!: CanonGenre;
-  getCanonGenre!: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
-  setCanonGenre!: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
-  createCanonGenre!: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
-  // PlatformUserPlaylistGenreAffinity belongsTo PlatformUserPlaylist via platformUserPlaylistId
-  platformUserPlaylist!: PlatformUserPlaylist;
-  getPlatformUserPlaylist!: Sequelize.BelongsToGetAssociationMixin<PlatformUserPlaylist>;
-  setPlatformUserPlaylist!: Sequelize.BelongsToSetAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
-  createPlatformUserPlaylist!: Sequelize.BelongsToCreateAssociationMixin<PlatformUserPlaylist>;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof PlatformUserPlaylistGenreAffinity {
-    return PlatformUserPlaylistGenreAffinity.init({
-    platformUserPlaylistId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'platform_user_playlist',
-        key: 'id'
-      },
-      unique: "unique_pupga_canon_genre",
-      field: 'platform_user_playlist_id'
-    },
-    canonGenreId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'canon_genre',
-        key: 'id'
-      },
-      unique: "unique_pupga_canon_genre",
-      field: 'canon_genre_id'
-    },
-    affinityTierId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      references: {
-        model: 'affinity_tier',
-        key: 'id'
-      },
-      field: 'affinity_tier_id'
-    },
-    rank: {
-      type: DataTypes.INTEGER,
-      allowNull: false
-    },
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: DataTypes.UUIDV4,
-      primaryKey: true
-    },
-    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: 'platform_user_playlist_genre_affinity',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "idx_platform_user_playlist_genre_affinity",
-        fields: [
-          { name: "platform_user_playlist_id" },
-        ]
-      },
-      {
-        name: "idx_platform_user_playlist_genre_affinity_genre",
-        fields: [
-          { name: "canon_genre_id" },
-        ]
-      },
-      {
-        name: "platform_user_playlist_genre_affinity_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-      {
-        name: "unique_pupga_canon_genre",
-        unique: true,
-        fields: [
-          { name: "platform_user_playlist_id" },
-          { name: "canon_genre_id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/PlatformUserPlaylistTrack.ts

@@ -1,162 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
-import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
-import type { State, StateId } from './State';
-
-export interface PlatformUserPlaylistTrackAttributes {
-  platformTrackId: string;
-  platformUserPlaylistId: string;
-  addedDate?: Date;
-  addedByPlatformUserId?: string;
-  externalPlaylistTrackId: string;
-  id: string;
-  trackPosition: number;
-  isLocal: boolean;
-  createDate: Date;
-  updateDate: Date;
-  stateId: number;
-}
-
-export type PlatformUserPlaylistTrackPk = "id";
-export type PlatformUserPlaylistTrackId = PlatformUserPlaylistTrack[PlatformUserPlaylistTrackPk];
-export type PlatformUserPlaylistTrackOptionalAttributes = "addedDate" | "addedByPlatformUserId" | "id" | "trackPosition" | "createDate" | "updateDate" | "stateId";
-export type PlatformUserPlaylistTrackCreationAttributes = Optional<PlatformUserPlaylistTrackAttributes, PlatformUserPlaylistTrackOptionalAttributes>;
-
-export class PlatformUserPlaylistTrack extends Model<PlatformUserPlaylistTrackAttributes, PlatformUserPlaylistTrackCreationAttributes> implements PlatformUserPlaylistTrackAttributes {
-  platformTrackId!: string;
-  platformUserPlaylistId!: string;
-  addedDate?: Date;
-  addedByPlatformUserId?: string;
-  externalPlaylistTrackId!: string;
-  id!: string;
-  trackPosition!: number;
-  isLocal!: boolean;
-  createDate!: Date;
-  updateDate!: Date;
-  stateId!: number;
-
-  // PlatformUserPlaylistTrack belongsTo PlatformTrack via platformTrackId
-  platformTrack!: PlatformTrack;
-  getPlatformTrack!: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
-  setPlatformTrack!: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
-  createPlatformTrack!: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
-  // PlatformUserPlaylistTrack belongsTo PlatformUserPlaylist via platformUserPlaylistId
-  platformUserPlaylist!: PlatformUserPlaylist;
-  getPlatformUserPlaylist!: Sequelize.BelongsToGetAssociationMixin<PlatformUserPlaylist>;
-  setPlatformUserPlaylist!: Sequelize.BelongsToSetAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
-  createPlatformUserPlaylist!: Sequelize.BelongsToCreateAssociationMixin<PlatformUserPlaylist>;
-  // PlatformUserPlaylistTrack 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 PlatformUserPlaylistTrack {
-    return PlatformUserPlaylistTrack.init({
-    platformTrackId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'platform_track',
-        key: 'id'
-      },
-      unique: "uk_playlist_id_track_id",
-      field: 'platform_track_id'
-    },
-    platformUserPlaylistId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'platform_user_playlist',
-        key: 'id'
-      },
-      unique: "uk_playlist_id_track_id",
-      field: 'platform_user_playlist_id'
-    },
-    addedDate: {
-      type: DataTypes.DATE,
-      allowNull: true,
-      field: 'added_date'
-    },
-    addedByPlatformUserId: {
-      type: DataTypes.TEXT,
-      allowNull: true,
-      field: 'added_by_platform_user_id'
-    },
-    externalPlaylistTrackId: {
-      type: DataTypes.STRING(255),
-      allowNull: false,
-      field: 'external_playlist_track_id'
-    },
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
-      primaryKey: true
-    },
-    trackPosition: {
-      type: DataTypes.INTEGER,
-      allowNull: false,
-      defaultValue: 0,
-      field: 'track_position'
-    },
-    isLocal: {
-      type: DataTypes.BOOLEAN,
-      allowNull: false,
-      defaultValue: false,
-      field: 'is_local'
-    },
-    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'
-    },
-    stateId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      defaultValue: 0,
-      references: {
-        model: 'state',
-        key: 'id'
-      },
-      field: 'state_id'
-    }
-  }, {
-    sequelize,
-    tableName: 'platform_user_playlist_track',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "idx_playlist_track_playlist",
-        fields: [
-          { name: "platform_user_playlist_id" },
-        ]
-      },
-      {
-        name: "playlist_track_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-      {
-        name: "uk_playlist_id_track_id",
-        unique: true,
-        fields: [
-          { name: "platform_track_id" },
-          { name: "platform_user_playlist_id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/PlaybackStatus.ts

@@ -1,47 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-
-export interface PlaybackStatusAttributes {
-  description: string;
-  id: number;
-}
-
-export type PlaybackStatusPk = "id";
-export type PlaybackStatusId = PlaybackStatus[PlaybackStatusPk];
-export type PlaybackStatusCreationAttributes = PlaybackStatusAttributes;
-
-export class PlaybackStatus extends Model<PlaybackStatusAttributes, PlaybackStatusCreationAttributes> implements PlaybackStatusAttributes {
-  description!: string;
-  id!: number;
-
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof PlaybackStatus {
-    return PlaybackStatus.init({
-    description: {
-      type: DataTypes.TEXT,
-      allowNull: false
-    },
-    id: {
-      autoIncrement: true,
-      autoIncrementIdentity: true,
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      primaryKey: true
-    }
-  }, {
-    sequelize,
-    tableName: 'playback_status',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "playback_status_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/PlaybackStatusType.ts

@@ -1,58 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
-
-export interface PlaybackStatusTypeAttributes {
-  id: number;
-  description: string;
-}
-
-export type PlaybackStatusTypePk = "id";
-export type PlaybackStatusTypeId = PlaybackStatusType[PlaybackStatusTypePk];
-export type PlaybackStatusTypeCreationAttributes = PlaybackStatusTypeAttributes;
-
-export class PlaybackStatusType extends Model<PlaybackStatusTypeAttributes, PlaybackStatusTypeCreationAttributes> implements PlaybackStatusTypeAttributes {
-  id!: number;
-  description!: string;
-
-  // PlaybackStatusType hasMany JukeboxQueueEntry via playbackStatusTypeId
-  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 PlaybackStatusType {
-    return PlaybackStatusType.init({
-    id: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      primaryKey: true
-    },
-    description: {
-      type: DataTypes.STRING(255),
-      allowNull: false
-    }
-  }, {
-    sequelize,
-    tableName: 'playback_status_type',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "playback_status_type_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/RadioShow.ts

@@ -1,209 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { AppUser, AppUserId } from './AppUser';
-import type { RadioShowGenres, RadioShowGenresId } from './RadioShowGenres';
-import type { RadioShowMedia, RadioShowMediaId } from './RadioShowMedia';
-import type { RadioShowPlacement, RadioShowPlacementId } from './RadioShowPlacement';
-import type { RadioShowPublishRequests, RadioShowPublishRequestsId } from './RadioShowPublishRequests';
-import type { UserAbuseReports, UserAbuseReportsId } from './UserAbuseReports';
-import type { UserBookmarks, UserBookmarksId } from './UserBookmarks';
-import type { UserComments, UserCommentsId } from './UserComments';
-import type { UserLikes, UserLikesId } from './UserLikes';
-
-export interface RadioShowAttributes {
-  creatorUserId: string;
-  scheduledRelease?: Date;
-  title: string;
-  description?: string;
-  deleted?: boolean;
-  id: string;
-  createDate: Date;
-  updateDate: Date;
-}
-
-export type RadioShowPk = "id";
-export type RadioShowId = RadioShow[RadioShowPk];
-export type RadioShowOptionalAttributes = "scheduledRelease" | "description" | "deleted" | "id" | "createDate" | "updateDate";
-export type RadioShowCreationAttributes = Optional<RadioShowAttributes, RadioShowOptionalAttributes>;
-
-export class RadioShow extends Model<RadioShowAttributes, RadioShowCreationAttributes> implements RadioShowAttributes {
-  creatorUserId!: string;
-  scheduledRelease?: Date;
-  title!: string;
-  description?: string;
-  deleted?: boolean;
-  id!: string;
-  createDate!: Date;
-  updateDate!: Date;
-
-  // RadioShow belongsTo AppUser via creatorUserId
-  creatorUser!: AppUser;
-  getCreatorUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
-  setCreatorUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
-  createCreatorUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
-  // RadioShow hasMany RadioShowGenres via radioShowId
-  radioShowGenres!: RadioShowGenres[];
-  getRadioShowGenres!: Sequelize.HasManyGetAssociationsMixin<RadioShowGenres>;
-  setRadioShowGenres!: Sequelize.HasManySetAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
-  addRadioShowGenre!: Sequelize.HasManyAddAssociationMixin<RadioShowGenres, RadioShowGenresId>;
-  addRadioShowGenres!: Sequelize.HasManyAddAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
-  createRadioShowGenre!: Sequelize.HasManyCreateAssociationMixin<RadioShowGenres>;
-  removeRadioShowGenre!: Sequelize.HasManyRemoveAssociationMixin<RadioShowGenres, RadioShowGenresId>;
-  removeRadioShowGenres!: Sequelize.HasManyRemoveAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
-  hasRadioShowGenre!: Sequelize.HasManyHasAssociationMixin<RadioShowGenres, RadioShowGenresId>;
-  hasRadioShowGenres!: Sequelize.HasManyHasAssociationsMixin<RadioShowGenres, RadioShowGenresId>;
-  countRadioShowGenres!: Sequelize.HasManyCountAssociationsMixin;
-  // RadioShow hasMany RadioShowMedia via radioShowId
-  radioShowMedia!: RadioShowMedia[];
-  getRadioShowMedia!: Sequelize.HasManyGetAssociationsMixin<RadioShowMedia>;
-  setRadioShowMedia!: Sequelize.HasManySetAssociationsMixin<RadioShowMedia, RadioShowMediaId>;
-  addRadioShowMedium!: Sequelize.HasManyAddAssociationMixin<RadioShowMedia, RadioShowMediaId>;
-  addRadioShowMedia!: Sequelize.HasManyAddAssociationsMixin<RadioShowMedia, RadioShowMediaId>;
-  createRadioShowMedium!: Sequelize.HasManyCreateAssociationMixin<RadioShowMedia>;
-  removeRadioShowMedium!: Sequelize.HasManyRemoveAssociationMixin<RadioShowMedia, RadioShowMediaId>;
-  removeRadioShowMedia!: Sequelize.HasManyRemoveAssociationsMixin<RadioShowMedia, RadioShowMediaId>;
-  hasRadioShowMedium!: Sequelize.HasManyHasAssociationMixin<RadioShowMedia, RadioShowMediaId>;
-  hasRadioShowMedia!: Sequelize.HasManyHasAssociationsMixin<RadioShowMedia, RadioShowMediaId>;
-  countRadioShowMedia!: Sequelize.HasManyCountAssociationsMixin;
-  // RadioShow hasMany RadioShowPlacement via radioShowId
-  radioShowPlacements!: RadioShowPlacement[];
-  getRadioShowPlacements!: Sequelize.HasManyGetAssociationsMixin<RadioShowPlacement>;
-  setRadioShowPlacements!: Sequelize.HasManySetAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
-  addRadioShowPlacement!: Sequelize.HasManyAddAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
-  addRadioShowPlacements!: Sequelize.HasManyAddAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
-  createRadioShowPlacement!: Sequelize.HasManyCreateAssociationMixin<RadioShowPlacement>;
-  removeRadioShowPlacement!: Sequelize.HasManyRemoveAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
-  removeRadioShowPlacements!: Sequelize.HasManyRemoveAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
-  hasRadioShowPlacement!: Sequelize.HasManyHasAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
-  hasRadioShowPlacements!: Sequelize.HasManyHasAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
-  countRadioShowPlacements!: Sequelize.HasManyCountAssociationsMixin;
-  // RadioShow hasMany RadioShowPublishRequests via radioShowId
-  radioShowPublishRequests!: RadioShowPublishRequests[];
-  getRadioShowPublishRequests!: Sequelize.HasManyGetAssociationsMixin<RadioShowPublishRequests>;
-  setRadioShowPublishRequests!: Sequelize.HasManySetAssociationsMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
-  addRadioShowPublishRequest!: Sequelize.HasManyAddAssociationMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
-  addRadioShowPublishRequests!: Sequelize.HasManyAddAssociationsMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
-  createRadioShowPublishRequest!: Sequelize.HasManyCreateAssociationMixin<RadioShowPublishRequests>;
-  removeRadioShowPublishRequest!: Sequelize.HasManyRemoveAssociationMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
-  removeRadioShowPublishRequests!: Sequelize.HasManyRemoveAssociationsMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
-  hasRadioShowPublishRequest!: Sequelize.HasManyHasAssociationMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
-  hasRadioShowPublishRequests!: Sequelize.HasManyHasAssociationsMixin<RadioShowPublishRequests, RadioShowPublishRequestsId>;
-  countRadioShowPublishRequests!: Sequelize.HasManyCountAssociationsMixin;
-  // RadioShow hasMany UserAbuseReports via radioShowId
-  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;
-  // RadioShow hasMany UserBookmarks via radioShowId
-  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;
-  // RadioShow hasMany UserComments via radioShowId
-  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;
-  // RadioShow hasMany UserLikes via radioShowId
-  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;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof RadioShow {
-    return RadioShow.init({
-    creatorUserId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'app_user',
-        key: 'id'
-      },
-      field: 'creator_user_id'
-    },
-    scheduledRelease: {
-      type: DataTypes.DATE,
-      allowNull: true,
-      field: 'scheduled_release'
-    },
-    title: {
-      type: DataTypes.STRING(40),
-      allowNull: false
-    },
-    description: {
-      type: DataTypes.STRING(512),
-      allowNull: true
-    },
-    deleted: {
-      type: DataTypes.BOOLEAN,
-      allowNull: true
-    },
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: DataTypes.UUIDV4,
-      primaryKey: true
-    },
-    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: 'radio_show',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "idx_radio_show_creator",
-        fields: [
-          { name: "creator_user_id" },
-        ]
-      },
-      {
-        name: "radio_show_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}