@earbug/db-models 0.0.14 → 0.0.16

package/dist/CanonArtist.d.ts

@@ -1,43 +1,52 @@
-import * as Sequelize from 'sequelize';
-import { Model, Optional } from 'sequelize';
-import type { CanonArtistAlbumRelation, CanonArtistAlbumRelationId } from './CanonArtistAlbumRelation';
-import type { CanonArtistImageHarvested, CanonArtistImageHarvestedId } from './CanonArtistImageHarvested';
-import type { CanonArtistTrackRelation, CanonArtistTrackRelationId } from './CanonArtistTrackRelation';
-import type { CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId } from './CanonToPlatformArtistRelation';
-import type { CanonTrack, CanonTrackId } from './CanonTrack';
-import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
-import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import * as Sequelize from "sequelize";
+import { Model, Optional } from "sequelize";
+import type { CanonArtistAlbumRelation, CanonArtistAlbumRelationId } from "./CanonArtistAlbumRelation";
+import type { CanonArtistImageHarvested, CanonArtistImageHarvestedId } from "./CanonArtistImageHarvested";
+import type { CanonArtistTrackRelation, CanonArtistTrackRelationId } from "./CanonArtistTrackRelation";
+import type { CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId } from "./CanonToPlatformArtistRelation";
+import type { CanonTrack, CanonTrackId } from "./CanonTrack";
+import type { MerchItem, MerchItemId } from "./MerchItem";
+import type { MerchOrchestration, MerchOrchestrationId } from "./MerchOrchestration";
+import type { NewsArticle, NewsArticleId } from "./NewsArticle";
+import type { PlatformAlbum, PlatformAlbumId } from "./PlatformAlbum";
+import type { PlatformArtist, PlatformArtistId } from "./PlatformArtist";
 export interface CanonArtistAttributes {
+    id: string;
     name: string;
     asciiName: string;
     description?: string;
-    id: string;
     hasPhoto: boolean;
     createDate: Date;
     updateDate: Date;
     hasThumbnailPhoto?: boolean;
     images?: object;
     lastImageHarvestAttempt?: Date;
+    lastGenreHarvestAttempt?: Date;
+    genreHarvestCount: number;
     merchHarvestDay?: number;
     newsHarvestDay?: number;
+    harvestPopularity?: number;
 }
 export type CanonArtistPk = "id";
 export type CanonArtistId = CanonArtist[CanonArtistPk];
-export type CanonArtistOptionalAttributes = "description" | "id" | "createDate" | "updateDate" | "hasThumbnailPhoto" | "images" | "lastImageHarvestAttempt" | "merchHarvestDay" | "newsHarvestDay";
+export type CanonArtistOptionalAttributes = "id" | "description" | "createDate" | "updateDate" | "hasThumbnailPhoto" | "images" | "lastImageHarvestAttempt" | "lastGenreHarvestAttempt" | "genreHarvestCount" | "merchHarvestDay" | "newsHarvestDay" | "harvestPopularity";
 export type CanonArtistCreationAttributes = Optional<CanonArtistAttributes, CanonArtistOptionalAttributes>;
 export declare class CanonArtist extends Model<CanonArtistAttributes, CanonArtistCreationAttributes> implements CanonArtistAttributes {
-    name: string;
-    asciiName: string;
-    description?: string;
     id: string;
+    name: any;
+    asciiName: any;
+    description?: any;
     hasPhoto: boolean;
     createDate: Date;
     updateDate: Date;
     hasThumbnailPhoto?: boolean;
     images?: object;
     lastImageHarvestAttempt?: Date;
+    lastGenreHarvestAttempt?: Date;
+    genreHarvestCount: number;
     merchHarvestDay?: number;
     newsHarvestDay?: number;
+    harvestPopularity?: number;
     canonArtistAlbumRelations: CanonArtistAlbumRelation[];
     getCanonArtistAlbumRelations: Sequelize.HasManyGetAssociationsMixin<CanonArtistAlbumRelation>;
     setCanonArtistAlbumRelations: Sequelize.HasManySetAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
@@ -93,6 +102,39 @@ export declare class CanonArtist extends Model<CanonArtistAttributes, CanonArtis
     hasCanonTrackIdCanonTrackCanonArtistTrackRelation: Sequelize.BelongsToManyHasAssociationMixin<CanonTrack, CanonTrackId>;
     hasCanonTrackIdCanonTrackCanonArtistTrackRelations: Sequelize.BelongsToManyHasAssociationsMixin<CanonTrack, CanonTrackId>;
     countCanonTrackIdCanonTrackCanonArtistTrackRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    merchItems: MerchItem[];
+    getMerchItems: Sequelize.HasManyGetAssociationsMixin<MerchItem>;
+    setMerchItems: Sequelize.HasManySetAssociationsMixin<MerchItem, MerchItemId>;
+    addMerchItem: Sequelize.HasManyAddAssociationMixin<MerchItem, MerchItemId>;
+    addMerchItems: Sequelize.HasManyAddAssociationsMixin<MerchItem, MerchItemId>;
+    createMerchItem: Sequelize.HasManyCreateAssociationMixin<MerchItem>;
+    removeMerchItem: Sequelize.HasManyRemoveAssociationMixin<MerchItem, MerchItemId>;
+    removeMerchItems: Sequelize.HasManyRemoveAssociationsMixin<MerchItem, MerchItemId>;
+    hasMerchItem: Sequelize.HasManyHasAssociationMixin<MerchItem, MerchItemId>;
+    hasMerchItems: Sequelize.HasManyHasAssociationsMixin<MerchItem, MerchItemId>;
+    countMerchItems: Sequelize.HasManyCountAssociationsMixin;
+    merchOrchestrations: MerchOrchestration[];
+    getMerchOrchestrations: Sequelize.HasManyGetAssociationsMixin<MerchOrchestration>;
+    setMerchOrchestrations: Sequelize.HasManySetAssociationsMixin<MerchOrchestration, MerchOrchestrationId>;
+    addMerchOrchestration: Sequelize.HasManyAddAssociationMixin<MerchOrchestration, MerchOrchestrationId>;
+    addMerchOrchestrations: Sequelize.HasManyAddAssociationsMixin<MerchOrchestration, MerchOrchestrationId>;
+    createMerchOrchestration: Sequelize.HasManyCreateAssociationMixin<MerchOrchestration>;
+    removeMerchOrchestration: Sequelize.HasManyRemoveAssociationMixin<MerchOrchestration, MerchOrchestrationId>;
+    removeMerchOrchestrations: Sequelize.HasManyRemoveAssociationsMixin<MerchOrchestration, MerchOrchestrationId>;
+    hasMerchOrchestration: Sequelize.HasManyHasAssociationMixin<MerchOrchestration, MerchOrchestrationId>;
+    hasMerchOrchestrations: Sequelize.HasManyHasAssociationsMixin<MerchOrchestration, MerchOrchestrationId>;
+    countMerchOrchestrations: Sequelize.HasManyCountAssociationsMixin;
+    newsArticles: NewsArticle[];
+    getNewsArticles: Sequelize.HasManyGetAssociationsMixin<NewsArticle>;
+    setNewsArticles: Sequelize.HasManySetAssociationsMixin<NewsArticle, NewsArticleId>;
+    addNewsArticle: Sequelize.HasManyAddAssociationMixin<NewsArticle, NewsArticleId>;
+    addNewsArticles: Sequelize.HasManyAddAssociationsMixin<NewsArticle, NewsArticleId>;
+    createNewsArticle: Sequelize.HasManyCreateAssociationMixin<NewsArticle>;
+    removeNewsArticle: Sequelize.HasManyRemoveAssociationMixin<NewsArticle, NewsArticleId>;
+    removeNewsArticles: Sequelize.HasManyRemoveAssociationsMixin<NewsArticle, NewsArticleId>;
+    hasNewsArticle: Sequelize.HasManyHasAssociationMixin<NewsArticle, NewsArticleId>;
+    hasNewsArticles: Sequelize.HasManyHasAssociationsMixin<NewsArticle, NewsArticleId>;
+    countNewsArticles: Sequelize.HasManyCountAssociationsMixin;
     canonAlbumIdPlatformAlbumCanonArtistAlbumRelations: PlatformAlbum[];
     getCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
     setCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;

package/dist/CanonArtist.js

@@ -31,93 +31,98 @@ class CanonArtist extends sequelize_1.Model {
         return CanonArtist.init({
             name: {
                 type: sequelize_1.DataTypes.TEXT,
-                allowNull: false
+                allowNull: false,
             },
             asciiName: {
                 type: sequelize_1.DataTypes.TEXT,
                 allowNull: false,
-                field: 'ascii_name'
+                field: "ascii_name",
             },
             description: {
                 type: sequelize_1.DataTypes.TEXT,
-                allowNull: true
+                allowNull: true,
             },
             id: {
                 type: sequelize_1.DataTypes.UUID,
                 allowNull: false,
-                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
-                primaryKey: true
+                defaultValue: Sequelize.Sequelize.fn("uuid_generate_v1"),
+                primaryKey: true,
             },
             hasPhoto: {
                 type: sequelize_1.DataTypes.BOOLEAN,
                 allowNull: false,
                 defaultValue: false,
-                field: 'has_photo'
+                field: "has_photo",
             },
             createDate: {
                 type: sequelize_1.DataTypes.DATE,
                 allowNull: false,
-                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
-                field: 'create_date'
+                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'
+                defaultValue: Sequelize.Sequelize.literal("CURRENT_TIMESTAMP"),
+                field: "update_date",
             },
             hasThumbnailPhoto: {
                 type: sequelize_1.DataTypes.BOOLEAN,
                 allowNull: true,
                 defaultValue: false,
-                field: 'has_thumbnail_photo'
+                field: "has_thumbnail_photo",
             },
             images: {
                 type: sequelize_1.DataTypes.JSONB,
-                allowNull: true
+                allowNull: true,
             },
             lastImageHarvestAttempt: {
                 type: sequelize_1.DataTypes.DATE,
                 allowNull: true,
-                field: 'last_image_harvest_attempt'
+                field: "last_image_harvest_attempt",
+            },
+            lastGenreHarvestAttempt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                field: "last_genre_harvest_attempt",
+            },
+            genreHarvestCount: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0,
+                field: "genre_harvest_count",
             },
             merchHarvestDay: {
-                type: sequelize_1.DataTypes.NUMBER,
+                type: sequelize_1.DataTypes.SMALLINT,
                 allowNull: true,
-                field: 'merch_harvest_day'
+                field: "merch_harvest_day",
             },
             newsHarvestDay: {
-                type: sequelize_1.DataTypes.NUMBER,
+                type: sequelize_1.DataTypes.SMALLINT,
                 allowNull: true,
-                field: 'news_harvest_day'
-            }
+                field: "news_harvest_day",
+            },
         }, {
             sequelize,
-            tableName: 'canon_artist',
-            schema: 'eb',
+            tableName: "canon_artist",
+            schema: "eb",
             timestamps: false,
             indexes: [
                 {
                     name: "artist_name_idx",
                     unique: true,
-                    fields: [
-                        { name: "name" },
-                    ]
+                    fields: [{ name: "name" }],
                 },
                 {
                     name: "artist_pkey",
                     unique: true,
-                    fields: [
-                        { name: "id" },
-                    ]
+                    fields: [{ name: "id" }],
                 },
                 {
                     name: "eb_canon_artist_last_image_harvest_attempt",
-                    fields: [
-                        { name: "last_image_harvest_attempt" },
-                    ]
+                    fields: [{ name: "last_image_harvest_attempt" }],
                 },
-            ]
+            ],
         });
     }
 }

package/dist/GuestUser.d.ts

@@ -0,0 +1,42 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+export interface GuestUserAttributes {
+    firstName: string;
+    lastName?: string;
+    jukeboxSessionId: string;
+    ipAddress?: string;
+    id: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type GuestUserPk = "id";
+export type GuestUserId = GuestUser[GuestUserPk];
+export type GuestUserOptionalAttributes = "lastName" | "ipAddress" | "id" | "createDate" | "updateDate";
+export type GuestUserCreationAttributes = Optional<GuestUserAttributes, GuestUserOptionalAttributes>;
+export declare class GuestUser extends Model<GuestUserAttributes, GuestUserCreationAttributes> implements GuestUserAttributes {
+    firstName: string;
+    lastName?: string;
+    jukeboxSessionId: string;
+    ipAddress?: string;
+    id: string;
+    createDate: Date;
+    updateDate: Date;
+    jukeboxQueueEntries: JukeboxQueueEntry[];
+    getJukeboxQueueEntries: Sequelize.HasManyGetAssociationsMixin<JukeboxQueueEntry>;
+    setJukeboxQueueEntries: Sequelize.HasManySetAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    addJukeboxQueueEntry: Sequelize.HasManyAddAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    addJukeboxQueueEntries: Sequelize.HasManyAddAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    createJukeboxQueueEntry: Sequelize.HasManyCreateAssociationMixin<JukeboxQueueEntry>;
+    removeJukeboxQueueEntry: Sequelize.HasManyRemoveAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    removeJukeboxQueueEntries: Sequelize.HasManyRemoveAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    hasJukeboxQueueEntry: Sequelize.HasManyHasAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    hasJukeboxQueueEntries: Sequelize.HasManyHasAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    countJukeboxQueueEntries: Sequelize.HasManyCountAssociationsMixin;
+    jukeboxSession: JukeboxSession;
+    getJukeboxSession: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+    setJukeboxSession: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    createJukeboxSession: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof GuestUser;
+}

package/dist/GuestUser.js

@@ -0,0 +1,91 @@
+"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.GuestUser = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class GuestUser extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return GuestUser.init({
+            firstName: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'first_name'
+            },
+            lastName: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 'last_name'
+            },
+            jukeboxSessionId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'jukebox_session',
+                    key: 'id'
+                },
+                field: 'jukebox_session_id'
+            },
+            ipAddress: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 'ip_address'
+            },
+            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: 'guest_user',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "guest_user_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.GuestUser = GuestUser;

package/dist/JukeboxQueueEntry.d.ts

@@ -2,15 +2,15 @@ import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
 import type { AppUser, AppUserId } from './AppUser';
 import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { GuestUser, GuestUserId } from './GuestUser';
 import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
 import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
 import type { PlaybackStatusType, PlaybackStatusTypeId } from './PlaybackStatusType';
 import type { TrackDeletionReason, TrackDeletionReasonId } from './TrackDeletionReason';
 export interface JukeboxQueueEntryAttributes {
     jukeboxSessionId: string;
-    trackId: string;
     playbackPriority?: number;
-    trackAddedUserId: string;
     playbackStarted?: Date;
     id: string;
     createdAt: Date;
@@ -18,18 +18,20 @@ export interface JukeboxQueueEntryAttributes {
     setOrder: number;
     trackDeletionReasonId: number;
     playbackStatusTypeId: number;
+    trackId?: string;
+    trackAddedUserId?: string;
     trackThumbsUp?: string[];
     trackThumbsDown?: string[];
+    platformTrackId?: string;
+    trackAddedGuestUserId?: string;
 }
 export type JukeboxQueueEntryPk = "id";
 export type JukeboxQueueEntryId = JukeboxQueueEntry[JukeboxQueueEntryPk];
-export type JukeboxQueueEntryOptionalAttributes = "playbackPriority" | "playbackStarted" | "id" | "createdAt" | "updatedAt" | "setOrder" | "trackDeletionReasonId" | "playbackStatusTypeId" | "trackThumbsUp" | "trackThumbsDown";
+export type JukeboxQueueEntryOptionalAttributes = "playbackPriority" | "playbackStarted" | "id" | "createdAt" | "updatedAt" | "setOrder" | "trackDeletionReasonId" | "playbackStatusTypeId" | "trackId" | "trackAddedUserId" | "trackThumbsUp" | "trackThumbsDown" | "platformTrackId" | "trackAddedGuestUserId";
 export type JukeboxQueueEntryCreationAttributes = Optional<JukeboxQueueEntryAttributes, JukeboxQueueEntryOptionalAttributes>;
 export declare class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes, JukeboxQueueEntryCreationAttributes> implements JukeboxQueueEntryAttributes {
     jukeboxSessionId: string;
-    trackId: string;
     playbackPriority?: number;
-    trackAddedUserId: string;
     playbackStarted?: Date;
     id: string;
     createdAt: Date;
@@ -37,8 +39,12 @@ export declare class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes
     setOrder: number;
     trackDeletionReasonId: number;
     playbackStatusTypeId: number;
+    trackId?: string;
+    trackAddedUserId?: string;
     trackThumbsUp?: string[];
     trackThumbsDown?: string[];
+    platformTrackId?: string;
+    trackAddedGuestUserId?: string;
     trackAddedUser: AppUser;
     getTrackAddedUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
     setTrackAddedUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
@@ -47,6 +53,10 @@ export declare class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes
     getTrack: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
     setTrack: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
     createTrack: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+    trackAddedGuestUser: GuestUser;
+    getTrackAddedGuestUser: Sequelize.BelongsToGetAssociationMixin<GuestUser>;
+    setTrackAddedGuestUser: Sequelize.BelongsToSetAssociationMixin<GuestUser, GuestUserId>;
+    createTrackAddedGuestUser: Sequelize.BelongsToCreateAssociationMixin<GuestUser>;
     jukeboxUsers: JukeboxUser[];
     getJukeboxUsers: Sequelize.HasManyGetAssociationsMixin<JukeboxUser>;
     setJukeboxUsers: Sequelize.HasManySetAssociationsMixin<JukeboxUser, JukeboxUserId>;
@@ -62,6 +72,10 @@ export declare class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes
     getJukeboxSession: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
     setJukeboxSession: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
     createJukeboxSession: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+    platformTrack: PlatformTrack;
+    getPlatformTrack: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+    setPlatformTrack: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrack: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
     playbackStatusType: PlaybackStatusType;
     getPlaybackStatusType: Sequelize.BelongsToGetAssociationMixin<PlaybackStatusType>;
     setPlaybackStatusType: Sequelize.BelongsToSetAssociationMixin<PlaybackStatusType, PlaybackStatusTypeId>;

package/dist/JukeboxQueueEntry.js

@@ -38,29 +38,11 @@ class JukeboxQueueEntry extends sequelize_1.Model {
                 },
                 field: 'jukebox_session_id'
             },
-            trackId: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'canon_track',
-                    key: 'id'
-                },
-                field: 'track_id'
-            },
             playbackPriority: {
                 type: sequelize_1.DataTypes.DECIMAL,
                 allowNull: true,
                 field: 'playback_priority'
             },
-            trackAddedUserId: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'app_user',
-                    key: 'id'
-                },
-                field: 'track_added_user_id'
-            },
             playbackStarted: {
                 type: sequelize_1.DataTypes.DATE,
                 allowNull: true,
@@ -110,6 +92,24 @@ class JukeboxQueueEntry extends sequelize_1.Model {
                 },
                 field: 'playback_status_type_id'
             },
+            trackId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'canon_track',
+                    key: 'id'
+                },
+                field: 'track_id'
+            },
+            trackAddedUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                field: 'track_added_user_id'
+            },
             trackThumbsUp: {
                 type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.UUID),
                 allowNull: true,
@@ -121,6 +121,24 @@ class JukeboxQueueEntry extends sequelize_1.Model {
                 allowNull: true,
                 defaultValue: ["ARRAY[]"],
                 field: 'track_thumbs_down'
+            },
+            platformTrackId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'platform_track',
+                    key: 'id'
+                },
+                field: 'platform_track_id'
+            },
+            trackAddedGuestUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'guest_user',
+                    key: 'id'
+                },
+                field: 'track_added_guest_user_id'
             }
         }, {
             sequelize,

package/dist/JukeboxSession.d.ts

@@ -1,5 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
+import type { GuestUser, GuestUserId } from './GuestUser';
 import type { JukeboxAccessType, JukeboxAccessTypeId } from './JukeboxAccessType';
 import type { JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId } from './JukeboxCanonGenreRelation';
 import type { JukeboxInvite, JukeboxInviteId } from './JukeboxInvite';
@@ -49,6 +50,17 @@ export declare class JukeboxSession extends Model<JukeboxSessionAttributes, Juke
     getJukeboxQueueMode: Sequelize.BelongsToGetAssociationMixin<JukeboxQueueMode>;
     setJukeboxQueueMode: Sequelize.BelongsToSetAssociationMixin<JukeboxQueueMode, JukeboxQueueModeId>;
     createJukeboxQueueMode: Sequelize.BelongsToCreateAssociationMixin<JukeboxQueueMode>;
+    guestUsers: GuestUser[];
+    getGuestUsers: Sequelize.HasManyGetAssociationsMixin<GuestUser>;
+    setGuestUsers: Sequelize.HasManySetAssociationsMixin<GuestUser, GuestUserId>;
+    addGuestUser: Sequelize.HasManyAddAssociationMixin<GuestUser, GuestUserId>;
+    addGuestUsers: Sequelize.HasManyAddAssociationsMixin<GuestUser, GuestUserId>;
+    createGuestUser: Sequelize.HasManyCreateAssociationMixin<GuestUser>;
+    removeGuestUser: Sequelize.HasManyRemoveAssociationMixin<GuestUser, GuestUserId>;
+    removeGuestUsers: Sequelize.HasManyRemoveAssociationsMixin<GuestUser, GuestUserId>;
+    hasGuestUser: Sequelize.HasManyHasAssociationMixin<GuestUser, GuestUserId>;
+    hasGuestUsers: Sequelize.HasManyHasAssociationsMixin<GuestUser, GuestUserId>;
+    countGuestUsers: Sequelize.HasManyCountAssociationsMixin;
     jukeboxCanonGenreRelations: JukeboxCanonGenreRelation[];
     getJukeboxCanonGenreRelations: Sequelize.HasManyGetAssociationsMixin<JukeboxCanonGenreRelation>;
     setJukeboxCanonGenreRelations: Sequelize.HasManySetAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;

package/dist/MerchItem.d.ts

@@ -0,0 +1,50 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { MerchPlatform, MerchPlatformId } from './MerchPlatform';
+import type { MerchType, MerchTypeId } from './MerchType';
+export interface MerchItemAttributes {
+    id: string;
+    canonArtistId: string;
+    merchTypeId: string;
+    merchPlatformId: string;
+    merchItemPlatformId: string;
+    title: string;
+    description: string;
+    photo?: string;
+    popularity?: number;
+    inactive?: boolean;
+    createDate: Date;
+    updateDate: Date;
+}
+export type MerchItemPk = "id";
+export type MerchItemId = MerchItem[MerchItemPk];
+export type MerchItemOptionalAttributes = "id" | "photo" | "popularity" | "inactive" | "createDate" | "updateDate";
+export type MerchItemCreationAttributes = Optional<MerchItemAttributes, MerchItemOptionalAttributes>;
+export declare class MerchItem extends Model<MerchItemAttributes, MerchItemCreationAttributes> implements MerchItemAttributes {
+    id: string;
+    canonArtistId: string;
+    merchTypeId: string;
+    merchPlatformId: string;
+    merchItemPlatformId: string;
+    title: string;
+    description: string;
+    photo?: string;
+    popularity?: number;
+    inactive?: boolean;
+    createDate: Date;
+    updateDate: Date;
+    canonArtist: CanonArtist;
+    getCanonArtist: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+    setCanonArtist: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+    createCanonArtist: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+    merchPlatform: MerchPlatform;
+    getMerchPlatform: Sequelize.BelongsToGetAssociationMixin<MerchPlatform>;
+    setMerchPlatform: Sequelize.BelongsToSetAssociationMixin<MerchPlatform, MerchPlatformId>;
+    createMerchPlatform: Sequelize.BelongsToCreateAssociationMixin<MerchPlatform>;
+    merchType: MerchType;
+    getMerchType: Sequelize.BelongsToGetAssociationMixin<MerchType>;
+    setMerchType: Sequelize.BelongsToSetAssociationMixin<MerchType, MerchTypeId>;
+    createMerchType: Sequelize.BelongsToCreateAssociationMixin<MerchType>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof MerchItem;
+}