@earbug/db-models 0.0.8 → 0.0.10

package/dist/AppUser.d.ts

@@ -6,8 +6,10 @@ import type { AppUserPlatformRelation, AppUserPlatformRelationId } from './AppUs
 import type { JukeboxInvite, JukeboxInviteId } from './JukeboxInvite';
 import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
 import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+import type { Notification, NotificationId } from './Notification';
 import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum';
 import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+import type { RadioShow, RadioShowId } from './RadioShow';
 import type { State, StateId } from './State';
 import type { UserContacts, UserContactsId } from './UserContacts';
 export interface AppUserAttributes {
@@ -120,6 +122,28 @@ export declare class AppUser extends Model<AppUserAttributes, AppUserCreationAtt
     hasJukeboxUser: Sequelize.HasManyHasAssociationMixin<JukeboxUser, JukeboxUserId>;
     hasJukeboxUsers: Sequelize.HasManyHasAssociationsMixin<JukeboxUser, JukeboxUserId>;
     countJukeboxUsers: Sequelize.HasManyCountAssociationsMixin;
+    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;
+    targetUserNotifications: Notification[];
+    getTargetUserNotifications: Sequelize.HasManyGetAssociationsMixin<Notification>;
+    setTargetUserNotifications: Sequelize.HasManySetAssociationsMixin<Notification, NotificationId>;
+    addTargetUserNotification: Sequelize.HasManyAddAssociationMixin<Notification, NotificationId>;
+    addTargetUserNotifications: Sequelize.HasManyAddAssociationsMixin<Notification, NotificationId>;
+    createTargetUserNotification: Sequelize.HasManyCreateAssociationMixin<Notification>;
+    removeTargetUserNotification: Sequelize.HasManyRemoveAssociationMixin<Notification, NotificationId>;
+    removeTargetUserNotifications: Sequelize.HasManyRemoveAssociationsMixin<Notification, NotificationId>;
+    hasTargetUserNotification: Sequelize.HasManyHasAssociationMixin<Notification, NotificationId>;
+    hasTargetUserNotifications: Sequelize.HasManyHasAssociationsMixin<Notification, NotificationId>;
+    countTargetUserNotifications: Sequelize.HasManyCountAssociationsMixin;
     platformUserAlbums: PlatformUserAlbum[];
     getPlatformUserAlbums: Sequelize.HasManyGetAssociationsMixin<PlatformUserAlbum>;
     setPlatformUserAlbums: Sequelize.HasManySetAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
@@ -142,6 +166,17 @@ export declare class AppUser extends Model<AppUserAttributes, AppUserCreationAtt
     hasPlatformUserPlaylist: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
     hasPlatformUserPlaylists: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
     countPlatformUserPlaylists: Sequelize.HasManyCountAssociationsMixin;
+    radioShows: RadioShow[];
+    getRadioShows: Sequelize.HasManyGetAssociationsMixin<RadioShow>;
+    setRadioShows: Sequelize.HasManySetAssociationsMixin<RadioShow, RadioShowId>;
+    addRadioShow: Sequelize.HasManyAddAssociationMixin<RadioShow, RadioShowId>;
+    addRadioShows: Sequelize.HasManyAddAssociationsMixin<RadioShow, RadioShowId>;
+    createRadioShow: Sequelize.HasManyCreateAssociationMixin<RadioShow>;
+    removeRadioShow: Sequelize.HasManyRemoveAssociationMixin<RadioShow, RadioShowId>;
+    removeRadioShows: Sequelize.HasManyRemoveAssociationsMixin<RadioShow, RadioShowId>;
+    hasRadioShow: Sequelize.HasManyHasAssociationMixin<RadioShow, RadioShowId>;
+    hasRadioShows: Sequelize.HasManyHasAssociationsMixin<RadioShow, RadioShowId>;
+    countRadioShows: Sequelize.HasManyCountAssociationsMixin;
     userContacts: UserContacts[];
     getUserContacts: Sequelize.HasManyGetAssociationsMixin<UserContacts>;
     setUserContacts: Sequelize.HasManySetAssociationsMixin<UserContacts, UserContactsId>;

package/dist/CanonGenre.d.ts

@@ -9,6 +9,7 @@ import type { JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId } from './J
 import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
 import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
 import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+import type { RadioShowGenres, RadioShowGenresId } from './RadioShowGenres';
 export interface CanonGenreAttributes {
     name: string;
     asciiName: string;
@@ -129,5 +130,16 @@ export declare class CanonGenre extends Model<CanonGenreAttributes, CanonGenreCr
     hasPlatformGenreIdPlatformGenre: Sequelize.BelongsToManyHasAssociationMixin<PlatformGenre, PlatformGenreId>;
     hasPlatformGenreIdPlatformGenres: Sequelize.BelongsToManyHasAssociationsMixin<PlatformGenre, PlatformGenreId>;
     countPlatformGenreIdPlatformGenres: Sequelize.BelongsToManyCountAssociationsMixin;
+    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;
     static initModel(sequelize: Sequelize.Sequelize): typeof CanonGenre;
 }

package/dist/CanonTrack.d.ts

@@ -7,6 +7,7 @@ import type { CanonArtistTrackRelation, CanonArtistTrackRelationId } from './Can
 import type { CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId } from './CanonToPlatformTrackRelation';
 import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
 import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { RadioShowPlacement, RadioShowPlacementId } from './RadioShowPlacement';
 export interface CanonTrackAttributes {
     name: string;
     asciiName: string;
@@ -109,5 +110,16 @@ export declare class CanonTrack extends Model<CanonTrackAttributes, CanonTrackCr
     hasPlatformTrackIdPlatformTrack: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
     hasPlatformTrackIdPlatformTracks: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
     countPlatformTrackIdPlatformTracks: Sequelize.BelongsToManyCountAssociationsMixin;
+    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;
     static initModel(sequelize: Sequelize.Sequelize): typeof CanonTrack;
 }

package/dist/JukeboxSession.d.ts

@@ -9,6 +9,7 @@ import type { JukeboxStatus, JukeboxStatusId } from './JukeboxStatus';
 import type { JukeboxTerminationCondition, JukeboxTerminationConditionId } from './JukeboxTerminationCondition';
 import type { JukeboxType, JukeboxTypeId } from './JukeboxType';
 import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+import type { Notification, NotificationId } from './Notification';
 export interface JukeboxSessionAttributes {
     typeId: number;
     accessTypeId: number;
@@ -92,6 +93,17 @@ export declare class JukeboxSession extends Model<JukeboxSessionAttributes, Juke
     hasJukeboxUser: Sequelize.HasManyHasAssociationMixin<JukeboxUser, JukeboxUserId>;
     hasJukeboxUsers: Sequelize.HasManyHasAssociationsMixin<JukeboxUser, JukeboxUserId>;
     countJukeboxUsers: Sequelize.HasManyCountAssociationsMixin;
+    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;
     jukeboxStatus: JukeboxStatus;
     getJukeboxStatus: Sequelize.BelongsToGetAssociationMixin<JukeboxStatus>;
     setJukeboxStatus: Sequelize.BelongsToSetAssociationMixin<JukeboxStatus, JukeboxStatusId>;

package/dist/Notification.d.ts

@@ -0,0 +1,62 @@
+import * as Sequelize from 'sequelize';
+import { 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 declare 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;
+    sourceUser: AppUser;
+    getSourceUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setSourceUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createSourceUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    targetUser: AppUser;
+    getTargetUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setTargetUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createTargetUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    jukeboxSession: JukeboxSession;
+    getJukeboxSession: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+    setJukeboxSession: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    createJukeboxSession: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+    notificationType: NotificationType;
+    getNotificationType: Sequelize.BelongsToGetAssociationMixin<NotificationType>;
+    setNotificationType: Sequelize.BelongsToSetAssociationMixin<NotificationType, NotificationTypeId>;
+    createNotificationType: Sequelize.BelongsToCreateAssociationMixin<NotificationType>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof Notification;
+}

package/dist/Notification.js

@@ -0,0 +1,163 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notification = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class Notification extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return Notification.init({
+            targetUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                field: 'target_user_id'
+            },
+            notificationTypeId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'notification_type',
+                    key: 'id'
+                },
+                field: 'notification_type_id'
+            },
+            metadata: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true
+            },
+            readAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                field: 'read_at'
+            },
+            dismissedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                field: 'dismissed_at'
+            },
+            sourceUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                field: 'source_user_id'
+            },
+            jukeboxSessionId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'jukebox_session',
+                    key: 'id'
+                },
+                field: 'jukebox_session_id'
+            },
+            expiresAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                field: 'expires_at'
+            },
+            pushSentAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                field: 'push_sent_at'
+            },
+            pushError: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 'push_error'
+            },
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            isRead: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false,
+                field: 'is_read'
+            },
+            isDismissed: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false,
+                field: 'is_dismissed'
+            },
+            createdAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'created_at'
+            },
+            updatedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'updated_at'
+            },
+            pushSent: {
+                type: sequelize_1.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_target_user_created_at",
+                    fields: [
+                        { name: "target_user_id" },
+                        { name: "created_at", order: "DESC" },
+                    ]
+                },
+                {
+                    name: "notification_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.Notification = Notification;

package/dist/NotificationType.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } 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 declare class NotificationType extends Model<NotificationTypeAttributes, NotificationTypeCreationAttributes> implements NotificationTypeAttributes {
+    id: number;
+    name: string;
+    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;
+}

package/dist/NotificationType.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationType = void 0;
+const sequelize_1 = require("sequelize");
+class NotificationType extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return NotificationType.init({
+            id: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            name: {
+                type: sequelize_1.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" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.NotificationType = NotificationType;

package/dist/RadioShow.d.ts

@@ -0,0 +1,80 @@
+import * as Sequelize from 'sequelize';
+import { 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';
+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 declare class RadioShow extends Model<RadioShowAttributes, RadioShowCreationAttributes> implements RadioShowAttributes {
+    creatorUserId: string;
+    scheduledRelease?: Date;
+    title: string;
+    description?: string;
+    deleted?: boolean;
+    id: string;
+    createDate: Date;
+    updateDate: Date;
+    creatorUser: AppUser;
+    getCreatorUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setCreatorUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createCreatorUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    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;
+    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;
+    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;
+    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;
+    static initModel(sequelize: Sequelize.Sequelize): typeof RadioShow;
+}

package/dist/RadioShow.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RadioShow = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class RadioShow extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return RadioShow.init({
+            creatorUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                field: 'creator_user_id'
+            },
+            scheduledRelease: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                field: 'scheduled_release'
+            },
+            title: {
+                type: sequelize_1.DataTypes.STRING(40),
+                allowNull: false
+            },
+            description: {
+                type: sequelize_1.DataTypes.STRING(512),
+                allowNull: true
+            },
+            deleted: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: true
+            },
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            }
+        }, {
+            sequelize,
+            tableName: 'radio_show',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "radio_show_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.RadioShow = RadioShow;

package/dist/RadioShowGenres.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { RadioShow, RadioShowId } from './RadioShow';
+export interface RadioShowGenresAttributes {
+    canonGenreId: string;
+    radioShowId: string;
+    title: string;
+    id: string;
+}
+export type RadioShowGenresPk = "id";
+export type RadioShowGenresId = RadioShowGenres[RadioShowGenresPk];
+export type RadioShowGenresOptionalAttributes = "id";
+export type RadioShowGenresCreationAttributes = Optional<RadioShowGenresAttributes, RadioShowGenresOptionalAttributes>;
+export declare class RadioShowGenres extends Model<RadioShowGenresAttributes, RadioShowGenresCreationAttributes> implements RadioShowGenresAttributes {
+    canonGenreId: string;
+    radioShowId: string;
+    title: string;
+    id: string;
+    canonGenre: CanonGenre;
+    getCanonGenre: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+    setCanonGenre: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+    createCanonGenre: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+    radioShow: RadioShow;
+    getRadioShow: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
+    setRadioShow: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
+    createRadioShow: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof RadioShowGenres;
+}