@earbug/db-models 0.0.62 → 0.0.63

package/models/PlatformUserPlaylistGenreAffinity.ts

@@ -0,0 +1,136 @@
+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 {
+  id: string;
+  platformUserPlaylistId: string;
+  canonGenreId: string;
+  affinityTierId: number;
+  rank: number;
+  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 {
+  id!: string;
+  platformUserPlaylistId!: string;
+  canonGenreId!: string;
+  affinityTierId!: number;
+  rank!: number;
+  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({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    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
+    },
+    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

@@ -0,0 +1,162 @@
+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 {
+  id: string;
+  platformTrackId: string;
+  platformUserPlaylistId: string;
+  trackPosition: number;
+  addedDate?: Date;
+  addedByPlatformUserId?: string;
+  isLocal: boolean;
+  createDate: Date;
+  updateDate: Date;
+  stateId: number;
+  externalPlaylistTrackId: string;
+}
+
+export type PlatformUserPlaylistTrackPk = "id";
+export type PlatformUserPlaylistTrackId = PlatformUserPlaylistTrack[PlatformUserPlaylistTrackPk];
+export type PlatformUserPlaylistTrackOptionalAttributes = "id" | "trackPosition" | "addedDate" | "addedByPlatformUserId" | "createDate" | "updateDate" | "stateId";
+export type PlatformUserPlaylistTrackCreationAttributes = Optional<PlatformUserPlaylistTrackAttributes, PlatformUserPlaylistTrackOptionalAttributes>;
+
+export class PlatformUserPlaylistTrack extends Model<PlatformUserPlaylistTrackAttributes, PlatformUserPlaylistTrackCreationAttributes> implements PlatformUserPlaylistTrackAttributes {
+  id!: string;
+  platformTrackId!: string;
+  platformUserPlaylistId!: string;
+  trackPosition!: number;
+  addedDate?: Date;
+  addedByPlatformUserId?: string;
+  isLocal!: boolean;
+  createDate!: Date;
+  updateDate!: Date;
+  stateId!: number;
+  externalPlaylistTrackId!: string;
+
+  // 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({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    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'
+    },
+    trackPosition: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      defaultValue: 0,
+      field: 'track_position'
+    },
+    addedDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'added_date'
+    },
+    addedByPlatformUserId: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'added_by_platform_user_id'
+    },
+    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'
+    },
+    externalPlaylistTrackId: {
+      type: DataTypes.STRING(255),
+      allowNull: false,
+      field: 'external_playlist_track_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

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

package/models/PlaybackStatusType.ts

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

@@ -0,0 +1,209 @@
+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 {
+  id: string;
+  creatorUserId: string;
+  scheduledRelease?: Date;
+  title: string;
+  description?: string;
+  deleted?: boolean;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type RadioShowPk = "id";
+export type RadioShowId = RadioShow[RadioShowPk];
+export type RadioShowOptionalAttributes = "id" | "scheduledRelease" | "description" | "deleted" | "createDate" | "updateDate";
+export type RadioShowCreationAttributes = Optional<RadioShowAttributes, RadioShowOptionalAttributes>;
+
+export class RadioShow extends Model<RadioShowAttributes, RadioShowCreationAttributes> implements RadioShowAttributes {
+  id!: string;
+  creatorUserId!: string;
+  scheduledRelease?: Date;
+  title!: string;
+  description?: string;
+  deleted?: boolean;
+  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({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    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
+    },
+    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" },
+        ]
+      },
+    ]
+  });
+  }
+}