@earbug/db-models 0.0.9 → 0.0.11

package/models/RadioShow.ts

@@ -0,0 +1,151 @@
+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';
+
+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;
+
+  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: "radio_show_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/RadioShowGenres.ts

@@ -0,0 +1,81 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, 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 class RadioShowGenres extends Model<RadioShowGenresAttributes, RadioShowGenresCreationAttributes> implements RadioShowGenresAttributes {
+  canonGenreId!: string;
+  radioShowId!: string;
+  title!: string;
+  id!: string;
+
+  // RadioShowGenres belongsTo CanonGenre via canonGenreId
+  canonGenre!: CanonGenre;
+  getCanonGenre!: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+  setCanonGenre!: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+  createCanonGenre!: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+  // RadioShowGenres belongsTo RadioShow via radioShowId
+  radioShow!: RadioShow;
+  getRadioShow!: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
+  setRadioShow!: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
+  createRadioShow!: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof RadioShowGenres {
+    return RadioShowGenres.init({
+    canonGenreId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'canon_genre',
+        key: 'id'
+      },
+      field: 'canon_genre_id'
+    },
+    radioShowId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'radio_show',
+        key: 'id'
+      },
+      field: 'radio_show_id'
+    },
+    title: {
+      type: DataTypes.STRING(40),
+      allowNull: false
+    },
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    }
+  }, {
+    sequelize,
+    tableName: 'radio_show_genres',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "radio_show_genres_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/RadioShowMedia.ts

@@ -0,0 +1,93 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, 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 class RadioShowMedia extends Model<RadioShowMediaAttributes, RadioShowMediaCreationAttributes> implements RadioShowMediaAttributes {
+  radioShowId!: string;
+  originalMediaType?: number;
+  s3VideoUrl?: string;
+  s3AudioUrl!: string;
+  approved?: boolean;
+  id!: string;
+  createDate!: Date;
+
+  // RadioShowMedia belongsTo RadioShow via radioShowId
+  radioShow!: RadioShow;
+  getRadioShow!: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
+  setRadioShow!: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
+  createRadioShow!: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof RadioShowMedia {
+    return RadioShowMedia.init({
+    radioShowId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'radio_show',
+        key: 'id'
+      },
+      field: 'radio_show_id'
+    },
+    originalMediaType: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+      field: 'original_media_type'
+    },
+    s3VideoUrl: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 's3_video_url'
+    },
+    s3AudioUrl: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 's3_audio_url'
+    },
+    approved: {
+      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'
+    }
+  }, {
+    sequelize,
+    tableName: 'radio_show_media',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "radio_show_media_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/RadioShowPlacement.ts

@@ -0,0 +1,103 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, 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 class RadioShowPlacement extends Model<RadioShowPlacementAttributes, RadioShowPlacementCreationAttributes> implements RadioShowPlacementAttributes {
+  radioShowId!: string;
+  canonTrackId?: string;
+  radioShowMediaId?: string;
+  seqNum!: number;
+  startTime?: string;
+  endTime?: string;
+  id!: string;
+
+  // RadioShowPlacement belongsTo CanonTrack via canonTrackId
+  canonTrack!: CanonTrack;
+  getCanonTrack!: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
+  setCanonTrack!: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
+  createCanonTrack!: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+  // RadioShowPlacement belongsTo RadioShow via radioShowId
+  radioShow!: RadioShow;
+  getRadioShow!: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
+  setRadioShow!: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
+  createRadioShow!: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof RadioShowPlacement {
+    return RadioShowPlacement.init({
+    radioShowId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'radio_show',
+        key: 'id'
+      },
+      field: 'radio_show_id'
+    },
+    canonTrackId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'canon_track',
+        key: 'id'
+      },
+      field: 'canon_track_id'
+    },
+    radioShowMediaId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      field: 'radio_show_media_id'
+    },
+    seqNum: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      field: 'seq_num'
+    },
+    startTime: {
+      type: DataTypes.TIME,
+      allowNull: true,
+      field: 'start_time'
+    },
+    endTime: {
+      type: DataTypes.TIME,
+      allowNull: true,
+      field: 'end_time'
+    },
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    }
+  }, {
+    sequelize,
+    tableName: 'radio_show_placement',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "radio_show_placement_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/RadioShowPublishRequests.ts

@@ -0,0 +1,80 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, 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 class RadioShowPublishRequests extends Model<RadioShowPublishRequestsAttributes, RadioShowPublishRequestsCreationAttributes> implements RadioShowPublishRequestsAttributes {
+  radioShowId!: string;
+  approved?: boolean;
+  id!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // RadioShowPublishRequests belongsTo RadioShow via radioShowId
+  radioShow!: RadioShow;
+  getRadioShow!: Sequelize.BelongsToGetAssociationMixin<RadioShow>;
+  setRadioShow!: Sequelize.BelongsToSetAssociationMixin<RadioShow, RadioShowId>;
+  createRadioShow!: Sequelize.BelongsToCreateAssociationMixin<RadioShow>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof RadioShowPublishRequests {
+    return RadioShowPublishRequests.init({
+    radioShowId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'radio_show',
+        key: 'id'
+      },
+      field: 'radio_show_id'
+    },
+    approved: {
+      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_publish_requests',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "radio_show_publish_requests_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/init-models.ts

@@ -1,4 +1,6 @@
 import type { Sequelize } from "sequelize";
+import { AccessControlPreference as _AccessControlPreference } from "./AccessControlPreference";
+import type { AccessControlPreferenceAttributes, AccessControlPreferenceCreationAttributes } from "./AccessControlPreference";
 import { AppUser as _AppUser } from "./AppUser";
 import type { AppUserAttributes, AppUserCreationAttributes } from "./AppUser";
 import { AppUserDevice as _AppUserDevice } from "./AppUserDevice";
@@ -131,6 +133,16 @@ import { PlaybackStatus as _PlaybackStatus } from "./PlaybackStatus";
 import type { PlaybackStatusAttributes, PlaybackStatusCreationAttributes } from "./PlaybackStatus";
 import { PlaybackStatusType as _PlaybackStatusType } from "./PlaybackStatusType";
 import type { PlaybackStatusTypeAttributes, PlaybackStatusTypeCreationAttributes } from "./PlaybackStatusType";
+import { RadioShow as _RadioShow } from "./RadioShow";
+import type { RadioShowAttributes, RadioShowCreationAttributes } from "./RadioShow";
+import { RadioShowGenres as _RadioShowGenres } from "./RadioShowGenres";
+import type { RadioShowGenresAttributes, RadioShowGenresCreationAttributes } from "./RadioShowGenres";
+import { RadioShowMedia as _RadioShowMedia } from "./RadioShowMedia";
+import type { RadioShowMediaAttributes, RadioShowMediaCreationAttributes } from "./RadioShowMedia";
+import { RadioShowPlacement as _RadioShowPlacement } from "./RadioShowPlacement";
+import type { RadioShowPlacementAttributes, RadioShowPlacementCreationAttributes } from "./RadioShowPlacement";
+import { RadioShowPublishRequests as _RadioShowPublishRequests } from "./RadioShowPublishRequests";
+import type { RadioShowPublishRequestsAttributes, RadioShowPublishRequestsCreationAttributes } from "./RadioShowPublishRequests";
 import { State as _State } from "./State";
 import type { StateAttributes, StateCreationAttributes } from "./State";
 import { TrackDeletionReason as _TrackDeletionReason } from "./TrackDeletionReason";
@@ -143,6 +155,7 @@ import { UserContacts as _UserContacts } from "./UserContacts";
 import type { UserContactsAttributes, UserContactsCreationAttributes } from "./UserContacts";
 
 export {
+  _AccessControlPreference as AccessControlPreference,
   _AppUser as AppUser,
   _AppUserDevice as AppUserDevice,
   _AppUserFollowRelation as AppUserFollowRelation,
@@ -209,6 +222,11 @@ export {
   _PlatformUserPlaylistTrack as PlatformUserPlaylistTrack,
   _PlaybackStatus as PlaybackStatus,
   _PlaybackStatusType as PlaybackStatusType,
+  _RadioShow as RadioShow,
+  _RadioShowGenres as RadioShowGenres,
+  _RadioShowMedia as RadioShowMedia,
+  _RadioShowPlacement as RadioShowPlacement,
+  _RadioShowPublishRequests as RadioShowPublishRequests,
   _State as State,
   _TrackDeletionReason as TrackDeletionReason,
   _UnmatchedAlbum as UnmatchedAlbum,
@@ -217,6 +235,8 @@ export {
 };
 
 export type {
+  AccessControlPreferenceAttributes,
+  AccessControlPreferenceCreationAttributes,
   AppUserAttributes,
   AppUserCreationAttributes,
   AppUserDeviceAttributes,
@@ -349,6 +369,16 @@ export type {
   PlaybackStatusCreationAttributes,
   PlaybackStatusTypeAttributes,
   PlaybackStatusTypeCreationAttributes,
+  RadioShowAttributes,
+  RadioShowCreationAttributes,
+  RadioShowGenresAttributes,
+  RadioShowGenresCreationAttributes,
+  RadioShowMediaAttributes,
+  RadioShowMediaCreationAttributes,
+  RadioShowPlacementAttributes,
+  RadioShowPlacementCreationAttributes,
+  RadioShowPublishRequestsAttributes,
+  RadioShowPublishRequestsCreationAttributes,
   StateAttributes,
   StateCreationAttributes,
   TrackDeletionReasonAttributes,
@@ -362,6 +392,7 @@ export type {
 };
 
 export function initModels(sequelize: Sequelize) {
+  const AccessControlPreference = _AccessControlPreference.initModel(sequelize);
   const AppUser = _AppUser.initModel(sequelize);
   const AppUserDevice = _AppUserDevice.initModel(sequelize);
   const AppUserFollowRelation = _AppUserFollowRelation.initModel(sequelize);
@@ -428,6 +459,11 @@ export function initModels(sequelize: Sequelize) {
   const PlatformUserPlaylistTrack = _PlatformUserPlaylistTrack.initModel(sequelize);
   const PlaybackStatus = _PlaybackStatus.initModel(sequelize);
   const PlaybackStatusType = _PlaybackStatusType.initModel(sequelize);
+  const RadioShow = _RadioShow.initModel(sequelize);
+  const RadioShowGenres = _RadioShowGenres.initModel(sequelize);
+  const RadioShowMedia = _RadioShowMedia.initModel(sequelize);
+  const RadioShowPlacement = _RadioShowPlacement.initModel(sequelize);
+  const RadioShowPublishRequests = _RadioShowPublishRequests.initModel(sequelize);
   const State = _State.initModel(sequelize);
   const TrackDeletionReason = _TrackDeletionReason.initModel(sequelize);
   const UnmatchedAlbum = _UnmatchedAlbum.initModel(sequelize);
@@ -502,6 +538,8 @@ export function initModels(sequelize: Sequelize) {
   AppUser.hasMany(PlatformUserAlbum, { as: "platformUserAlbums", foreignKey: "appUserId"});
   PlatformUserPlaylist.belongsTo(AppUser, { as: "appUser", foreignKey: "appUserId"});
   AppUser.hasMany(PlatformUserPlaylist, { as: "platformUserPlaylists", foreignKey: "appUserId"});
+  RadioShow.belongsTo(AppUser, { as: "creatorUser", foreignKey: "creatorUserId"});
+  AppUser.hasMany(RadioShow, { as: "radioShows", foreignKey: "creatorUserId"});
   UserContacts.belongsTo(AppUser, { as: "appUser", foreignKey: "appUserId"});
   AppUser.hasMany(UserContacts, { as: "userContacts", foreignKey: "appUserId"});
   CanonAlbumExternalReferenceRelation.belongsTo(CanonAlbum, { as: "canonAlbum", foreignKey: "canonAlbumId"});
@@ -530,6 +568,8 @@ export function initModels(sequelize: Sequelize) {
   CanonGenre.hasMany(CanonToPlatformGenreRelation, { as: "canonToPlatformGenreRelations", foreignKey: "canonGenreId"});
   JukeboxCanonGenreRelation.belongsTo(CanonGenre, { as: "canonGenre", foreignKey: "canonGenreId"});
   CanonGenre.hasMany(JukeboxCanonGenreRelation, { as: "jukeboxCanonGenreRelations", foreignKey: "canonGenreId"});
+  RadioShowGenres.belongsTo(CanonGenre, { as: "canonGenre", foreignKey: "canonGenreId"});
+  CanonGenre.hasMany(RadioShowGenres, { as: "radioShowGenres", foreignKey: "canonGenreId"});
   CanonAlbumLabelRelation.belongsTo(CanonLabel, { as: "canonLabel", foreignKey: "canonLabelId"});
   CanonLabel.hasMany(CanonAlbumLabelRelation, { as: "canonAlbumLabelRelations", foreignKey: "canonLabelId"});
   CanonLabelExternalReferenceRelation.belongsTo(CanonLabel, { as: "canonLabel", foreignKey: "canonLabelId"});
@@ -546,6 +586,8 @@ export function initModels(sequelize: Sequelize) {
   CanonTrack.hasMany(CanonToPlatformTrackRelation, { as: "canonToPlatformTrackRelations", foreignKey: "canonTrackId"});
   JukeboxQueueEntry.belongsTo(CanonTrack, { as: "track", foreignKey: "trackId"});
   CanonTrack.hasMany(JukeboxQueueEntry, { as: "jukeboxQueueEntries", foreignKey: "trackId"});
+  RadioShowPlacement.belongsTo(CanonTrack, { as: "canonTrack", foreignKey: "canonTrackId"});
+  CanonTrack.hasMany(RadioShowPlacement, { as: "radioShowPlacements", foreignKey: "canonTrackId"});
   CanonAlbumExternalReferenceRelation.belongsTo(ExternalReference, { as: "externalReference", foreignKey: "externalReferenceId"});
   ExternalReference.hasMany(CanonAlbumExternalReferenceRelation, { as: "canonAlbumExternalReferenceRelations", foreignKey: "externalReferenceId"});
   CanonArtistExternalReferenceRelation.belongsTo(ExternalReference, { as: "externalReference", foreignKey: "externalReferenceId"});
@@ -660,6 +702,14 @@ export function initModels(sequelize: Sequelize) {
   PlatformUserPlaylist.hasMany(PlatformUserPlaylistTrack, { as: "platformUserPlaylistTracks", foreignKey: "platformUserPlaylistId"});
   JukeboxQueueEntry.belongsTo(PlaybackStatusType, { as: "playbackStatusType", foreignKey: "playbackStatusTypeId"});
   PlaybackStatusType.hasMany(JukeboxQueueEntry, { as: "jukeboxQueueEntries", foreignKey: "playbackStatusTypeId"});
+  RadioShowGenres.belongsTo(RadioShow, { as: "radioShow", foreignKey: "radioShowId"});
+  RadioShow.hasMany(RadioShowGenres, { as: "radioShowGenres", foreignKey: "radioShowId"});
+  RadioShowMedia.belongsTo(RadioShow, { as: "radioShow", foreignKey: "radioShowId"});
+  RadioShow.hasMany(RadioShowMedia, { as: "radioShowMedia", foreignKey: "radioShowId"});
+  RadioShowPlacement.belongsTo(RadioShow, { as: "radioShow", foreignKey: "radioShowId"});
+  RadioShow.hasMany(RadioShowPlacement, { as: "radioShowPlacements", foreignKey: "radioShowId"});
+  RadioShowPublishRequests.belongsTo(RadioShow, { as: "radioShow", foreignKey: "radioShowId"});
+  RadioShow.hasMany(RadioShowPublishRequests, { as: "radioShowPublishRequests", foreignKey: "radioShowId"});
   AppUser.belongsTo(State, { as: "state", foreignKey: "stateId"});
   State.hasMany(AppUser, { as: "appUsers", foreignKey: "stateId"});
   PlatformUserPlaylist.belongsTo(State, { as: "state", foreignKey: "stateId"});
@@ -670,6 +720,7 @@ export function initModels(sequelize: Sequelize) {
   TrackDeletionReason.hasMany(JukeboxQueueEntry, { as: "jukeboxQueueEntries", foreignKey: "trackDeletionReasonId"});
 
   return {
+    AccessControlPreference: AccessControlPreference,
     AppUser: AppUser,
     AppUserDevice: AppUserDevice,
     AppUserFollowRelation: AppUserFollowRelation,
@@ -736,6 +787,11 @@ export function initModels(sequelize: Sequelize) {
     PlatformUserPlaylistTrack: PlatformUserPlaylistTrack,
     PlaybackStatus: PlaybackStatus,
     PlaybackStatusType: PlaybackStatusType,
+    RadioShow: RadioShow,
+    RadioShowGenres: RadioShowGenres,
+    RadioShowMedia: RadioShowMedia,
+    RadioShowPlacement: RadioShowPlacement,
+    RadioShowPublishRequests: RadioShowPublishRequests,
     State: State,
     TrackDeletionReason: TrackDeletionReason,
     UnmatchedAlbum: UnmatchedAlbum,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@earbug/db-models",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "main": "dist/init-models.js",
   "types": "dist/init-models.d.ts",
   "scripts": {