@earbug/db-models 0.0.9 → 0.0.10

package/dist/AppUser.d.ts

@@ -9,6 +9,7 @@ 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 {
@@ -165,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/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;
+}

package/dist/RadioShowGenres.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RadioShowGenres = void 0;
+const sequelize_1 = require("sequelize");
+class RadioShowGenres extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return RadioShowGenres.init({
+            canonGenreId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'canon_genre',
+                    key: 'id'
+                },
+                field: 'canon_genre_id'
+            },
+            radioShowId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'radio_show',
+                    key: 'id'
+                },
+                field: 'radio_show_id'
+            },
+            title: {
+                type: sequelize_1.DataTypes.STRING(40),
+                allowNull: false
+            },
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            }
+        }, {
+            sequelize,
+            tableName: 'radio_show_genres',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "radio_show_genres_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.RadioShowGenres = RadioShowGenres;

package/dist/RadioShowMedia.d.ts

@@ -0,0 +1,30 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { RadioShow, RadioShowId } from './RadioShow';
+export interface RadioShowMediaAttributes {
+    radioShowId: string;
+    originalMediaType?: number;
+    s3VideoUrl?: string;
+    s3AudioUrl: string;
+    approved?: boolean;
+    id: string;
+    createDate: Date;
+}
+export type RadioShowMediaPk = "id";
+export type RadioShowMediaId = RadioShowMedia[RadioShowMediaPk];
+export type RadioShowMediaOptionalAttributes = "originalMediaType" | "s3VideoUrl" | "approved" | "id" | "createDate";
+export type RadioShowMediaCreationAttributes = Optional<RadioShowMediaAttributes, RadioShowMediaOptionalAttributes>;
+export declare class RadioShowMedia extends Model<RadioShowMediaAttributes, RadioShowMediaCreationAttributes> implements RadioShowMediaAttributes {
+    radioShowId: string;
+    originalMediaType?: number;
+    s3VideoUrl?: string;
+    s3AudioUrl: string;
+    approved?: boolean;
+    id: string;
+    createDate: Date;
+    radioShow: RadioShow;
+    getRadioShow: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
+    setRadioShow: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
+    createRadioShow: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof RadioShowMedia;
+}

package/dist/RadioShowMedia.js

@@ -0,0 +1,89 @@
+"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.RadioShowMedia = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class RadioShowMedia extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return RadioShowMedia.init({
+            radioShowId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'radio_show',
+                    key: 'id'
+                },
+                field: 'radio_show_id'
+            },
+            originalMediaType: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: true,
+                field: 'original_media_type'
+            },
+            s3VideoUrl: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 's3_video_url'
+            },
+            s3AudioUrl: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 's3_audio_url'
+            },
+            approved: {
+                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'
+            }
+        }, {
+            sequelize,
+            tableName: 'radio_show_media',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "radio_show_media_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.RadioShowMedia = RadioShowMedia;

package/dist/RadioShowPlacement.d.ts

@@ -0,0 +1,35 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { RadioShow, RadioShowId } from './RadioShow';
+export interface RadioShowPlacementAttributes {
+    radioShowId: string;
+    canonTrackId?: string;
+    radioShowMediaId?: string;
+    seqNum: number;
+    startTime?: string;
+    endTime?: string;
+    id: string;
+}
+export type RadioShowPlacementPk = "id";
+export type RadioShowPlacementId = RadioShowPlacement[RadioShowPlacementPk];
+export type RadioShowPlacementOptionalAttributes = "canonTrackId" | "radioShowMediaId" | "startTime" | "endTime" | "id";
+export type RadioShowPlacementCreationAttributes = Optional<RadioShowPlacementAttributes, RadioShowPlacementOptionalAttributes>;
+export declare class RadioShowPlacement extends Model<RadioShowPlacementAttributes, RadioShowPlacementCreationAttributes> implements RadioShowPlacementAttributes {
+    radioShowId: string;
+    canonTrackId?: string;
+    radioShowMediaId?: string;
+    seqNum: number;
+    startTime?: string;
+    endTime?: string;
+    id: string;
+    canonTrack: CanonTrack;
+    getCanonTrack: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
+    setCanonTrack: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
+    createCanonTrack: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+    radioShow: RadioShow;
+    getRadioShow: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
+    setRadioShow: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
+    createRadioShow: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof RadioShowPlacement;
+}

package/dist/RadioShowPlacement.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RadioShowPlacement = void 0;
+const sequelize_1 = require("sequelize");
+class RadioShowPlacement extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return RadioShowPlacement.init({
+            radioShowId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'radio_show',
+                    key: 'id'
+                },
+                field: 'radio_show_id'
+            },
+            canonTrackId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'canon_track',
+                    key: 'id'
+                },
+                field: 'canon_track_id'
+            },
+            radioShowMediaId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                field: 'radio_show_media_id'
+            },
+            seqNum: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                field: 'seq_num'
+            },
+            startTime: {
+                type: sequelize_1.DataTypes.TIME,
+                allowNull: true,
+                field: 'start_time'
+            },
+            endTime: {
+                type: sequelize_1.DataTypes.TIME,
+                allowNull: true,
+                field: 'end_time'
+            },
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            }
+        }, {
+            sequelize,
+            tableName: 'radio_show_placement',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "radio_show_placement_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.RadioShowPlacement = RadioShowPlacement;

package/dist/RadioShowPublishRequests.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { RadioShow, RadioShowId } from './RadioShow';
+export interface RadioShowPublishRequestsAttributes {
+    radioShowId: string;
+    approved?: boolean;
+    id: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type RadioShowPublishRequestsPk = "id";
+export type RadioShowPublishRequestsId = RadioShowPublishRequests[RadioShowPublishRequestsPk];
+export type RadioShowPublishRequestsOptionalAttributes = "approved" | "id" | "createDate" | "updateDate";
+export type RadioShowPublishRequestsCreationAttributes = Optional<RadioShowPublishRequestsAttributes, RadioShowPublishRequestsOptionalAttributes>;
+export declare class RadioShowPublishRequests extends Model<RadioShowPublishRequestsAttributes, RadioShowPublishRequestsCreationAttributes> implements RadioShowPublishRequestsAttributes {
+    radioShowId: string;
+    approved?: boolean;
+    id: string;
+    createDate: Date;
+    updateDate: Date;
+    radioShow: RadioShow;
+    getRadioShow: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
+    setRadioShow: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
+    createRadioShow: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof RadioShowPublishRequests;
+}

package/dist/RadioShowPublishRequests.js

@@ -0,0 +1,80 @@
+"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.RadioShowPublishRequests = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class RadioShowPublishRequests extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return RadioShowPublishRequests.init({
+            radioShowId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'radio_show',
+                    key: 'id'
+                },
+                field: 'radio_show_id'
+            },
+            approved: {
+                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_publish_requests',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "radio_show_publish_requests_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.RadioShowPublishRequests = RadioShowPublishRequests;