@earbug/db-models 0.0.1

package/dist/JukeboxInvite.js

@@ -0,0 +1,98 @@
+"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.JukeboxInvite = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class JukeboxInvite extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return JukeboxInvite.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            jukeboxSessionId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'jukebox_session',
+                    key: 'id'
+                },
+                field: 'jukebox_session_id'
+            },
+            inviterUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                field: 'inviter_user_id'
+            },
+            invitedUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                field: 'invited_user_id'
+            },
+            email: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true
+            },
+            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'
+            }
+        }, {
+            sequelize,
+            tableName: 'jukebox_invite',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "jukebox_invite_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.JukeboxInvite = JukeboxInvite;

package/dist/JukeboxQueueEntry.d.ts

@@ -0,0 +1,74 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+import type { PlaybackStatus, PlaybackStatusId } from './PlaybackStatus';
+import type { TrackDeletionReason, TrackDeletionReasonId } from './TrackDeletionReason';
+export interface JukeboxQueueEntryAttributes {
+    id: string;
+    jukeboxSessionId: string;
+    trackId: string;
+    playbackPriority?: number;
+    trackAddedUserId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    setOrder: number;
+    trackDeletionReasonId: number;
+    playbackStatusTypeId: number;
+    playbackStarted?: Date;
+    trackThumbsUp?: string[];
+    trackThumbsDown?: string[];
+}
+export type JukeboxQueueEntryPk = "id";
+export type JukeboxQueueEntryId = JukeboxQueueEntry[JukeboxQueueEntryPk];
+export type JukeboxQueueEntryOptionalAttributes = "id" | "playbackPriority" | "createdAt" | "updatedAt" | "setOrder" | "trackDeletionReasonId" | "playbackStatusTypeId" | "playbackStarted" | "trackThumbsUp" | "trackThumbsDown";
+export type JukeboxQueueEntryCreationAttributes = Optional<JukeboxQueueEntryAttributes, JukeboxQueueEntryOptionalAttributes>;
+export declare class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes, JukeboxQueueEntryCreationAttributes> implements JukeboxQueueEntryAttributes {
+    id: string;
+    jukeboxSessionId: string;
+    trackId: string;
+    playbackPriority?: number;
+    trackAddedUserId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    setOrder: number;
+    trackDeletionReasonId: number;
+    playbackStatusTypeId: number;
+    playbackStarted?: Date;
+    trackThumbsUp?: string[];
+    trackThumbsDown?: string[];
+    trackAddedUser: AppUser;
+    getTrackAddedUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setTrackAddedUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createTrackAddedUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    track: CanonTrack;
+    getTrack: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
+    setTrack: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
+    createTrack: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+    jukeboxUsers: JukeboxUser[];
+    getJukeboxUsers: Sequelize.HasManyGetAssociationsMixin<JukeboxUser>;
+    setJukeboxUsers: Sequelize.HasManySetAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    addJukeboxUser: Sequelize.HasManyAddAssociationMixin<JukeboxUser, JukeboxUserId>;
+    addJukeboxUsers: Sequelize.HasManyAddAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    createJukeboxUser: Sequelize.HasManyCreateAssociationMixin<JukeboxUser>;
+    removeJukeboxUser: Sequelize.HasManyRemoveAssociationMixin<JukeboxUser, JukeboxUserId>;
+    removeJukeboxUsers: Sequelize.HasManyRemoveAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    hasJukeboxUser: Sequelize.HasManyHasAssociationMixin<JukeboxUser, JukeboxUserId>;
+    hasJukeboxUsers: Sequelize.HasManyHasAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    countJukeboxUsers: Sequelize.HasManyCountAssociationsMixin;
+    jukeboxSession: JukeboxSession;
+    getJukeboxSession: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+    setJukeboxSession: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    createJukeboxSession: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+    playbackStatusType: PlaybackStatus;
+    getPlaybackStatusType: Sequelize.BelongsToGetAssociationMixin<PlaybackStatus>;
+    setPlaybackStatusType: Sequelize.BelongsToSetAssociationMixin<PlaybackStatus, PlaybackStatusId>;
+    createPlaybackStatusType: Sequelize.BelongsToCreateAssociationMixin<PlaybackStatus>;
+    trackDeletionReason: TrackDeletionReason;
+    getTrackDeletionReason: Sequelize.BelongsToGetAssociationMixin<TrackDeletionReason>;
+    setTrackDeletionReason: Sequelize.BelongsToSetAssociationMixin<TrackDeletionReason, TrackDeletionReasonId>;
+    createTrackDeletionReason: Sequelize.BelongsToCreateAssociationMixin<TrackDeletionReason>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxQueueEntry;
+}

package/dist/JukeboxQueueEntry.js

@@ -0,0 +1,142 @@
+"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.JukeboxQueueEntry = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class JukeboxQueueEntry extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return JukeboxQueueEntry.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            jukeboxSessionId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'jukebox_session',
+                    key: 'id'
+                },
+                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'
+            },
+            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'
+            },
+            setOrder: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 1,
+                field: 'set_order'
+            },
+            trackDeletionReasonId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0,
+                references: {
+                    model: 'track_deletion_reason',
+                    key: 'id'
+                },
+                field: 'track_deletion_reason_id'
+            },
+            playbackStatusTypeId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0,
+                references: {
+                    model: 'playback_status',
+                    key: 'id'
+                },
+                field: 'playback_status_type_id'
+            },
+            playbackStarted: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                field: 'playback_started'
+            },
+            trackThumbsUp: {
+                type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.UUID),
+                allowNull: true,
+                defaultValue: ["ARRAY[]"],
+                field: 'track_thumbs_up'
+            },
+            trackThumbsDown: {
+                type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.UUID),
+                allowNull: true,
+                defaultValue: ["ARRAY[]"],
+                field: 'track_thumbs_down'
+            }
+        }, {
+            sequelize,
+            tableName: 'jukebox_queue_entry',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "jukebox_queue_entry_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.JukeboxQueueEntry = JukeboxQueueEntry;

package/dist/JukeboxQueueMode.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+export interface JukeboxQueueModeAttributes {
+    id: number;
+    description: string;
+}
+export type JukeboxQueueModePk = "id";
+export type JukeboxQueueModeId = JukeboxQueueMode[JukeboxQueueModePk];
+export type JukeboxQueueModeCreationAttributes = JukeboxQueueModeAttributes;
+export declare class JukeboxQueueMode extends Model<JukeboxQueueModeAttributes, JukeboxQueueModeCreationAttributes> implements JukeboxQueueModeAttributes {
+    id: number;
+    description: string;
+    jukeboxSessions: JukeboxSession[];
+    getJukeboxSessions: Sequelize.HasManyGetAssociationsMixin<JukeboxSession>;
+    setJukeboxSessions: Sequelize.HasManySetAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    addJukeboxSession: Sequelize.HasManyAddAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    addJukeboxSessions: Sequelize.HasManyAddAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    createJukeboxSession: Sequelize.HasManyCreateAssociationMixin<JukeboxSession>;
+    removeJukeboxSession: Sequelize.HasManyRemoveAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    removeJukeboxSessions: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    hasJukeboxSession: Sequelize.HasManyHasAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    hasJukeboxSessions: Sequelize.HasManyHasAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    countJukeboxSessions: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxQueueMode;
+}

package/dist/JukeboxQueueMode.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JukeboxQueueMode = void 0;
+const sequelize_1 = require("sequelize");
+class JukeboxQueueMode extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return JukeboxQueueMode.init({
+            id: {
+                autoIncrement: true,
+                autoIncrementIdentity: true,
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            description: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'jukebox_queue_mode',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "jukebox_queue_mode_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.JukeboxQueueMode = JukeboxQueueMode;

package/dist/JukeboxSession.d.ts

@@ -0,0 +1,108 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { JukeboxAccessType, JukeboxAccessTypeId } from './JukeboxAccessType';
+import type { JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId } from './JukeboxCanonGenreRelation';
+import type { JukeboxInvite, JukeboxInviteId } from './JukeboxInvite';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { JukeboxQueueMode, JukeboxQueueModeId } from './JukeboxQueueMode';
+import type { JukeboxStatus, JukeboxStatusId } from './JukeboxStatus';
+import type { JukeboxTerminationCondition, JukeboxTerminationConditionId } from './JukeboxTerminationCondition';
+import type { JukeboxType, JukeboxTypeId } from './JukeboxType';
+import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+export interface JukeboxSessionAttributes {
+    id: string;
+    typeId: number;
+    accessTypeId: number;
+    terminationConditionId: number;
+    jukeboxQueueModeId: number;
+    createdAt: Date;
+    updatedAt: Date;
+    jukeboxStatusId: number;
+    trackQueue?: string[];
+    description?: string;
+    stateMachineArn?: string;
+    durationMs: number;
+}
+export type JukeboxSessionPk = "id";
+export type JukeboxSessionId = JukeboxSession[JukeboxSessionPk];
+export type JukeboxSessionOptionalAttributes = "id" | "createdAt" | "updatedAt" | "jukeboxStatusId" | "trackQueue" | "description" | "stateMachineArn" | "durationMs";
+export type JukeboxSessionCreationAttributes = Optional<JukeboxSessionAttributes, JukeboxSessionOptionalAttributes>;
+export declare class JukeboxSession extends Model<JukeboxSessionAttributes, JukeboxSessionCreationAttributes> implements JukeboxSessionAttributes {
+    id: string;
+    typeId: number;
+    accessTypeId: number;
+    terminationConditionId: number;
+    jukeboxQueueModeId: number;
+    createdAt: Date;
+    updatedAt: Date;
+    jukeboxStatusId: number;
+    trackQueue?: string[];
+    description?: string;
+    stateMachineArn?: string;
+    durationMs: number;
+    accessType: JukeboxAccessType;
+    getAccessType: Sequelize.BelongsToGetAssociationMixin<JukeboxAccessType>;
+    setAccessType: Sequelize.BelongsToSetAssociationMixin<JukeboxAccessType, JukeboxAccessTypeId>;
+    createAccessType: Sequelize.BelongsToCreateAssociationMixin<JukeboxAccessType>;
+    jukeboxQueueMode: JukeboxQueueMode;
+    getJukeboxQueueMode: Sequelize.BelongsToGetAssociationMixin<JukeboxQueueMode>;
+    setJukeboxQueueMode: Sequelize.BelongsToSetAssociationMixin<JukeboxQueueMode, JukeboxQueueModeId>;
+    createJukeboxQueueMode: Sequelize.BelongsToCreateAssociationMixin<JukeboxQueueMode>;
+    jukeboxCanonGenreRelations: JukeboxCanonGenreRelation[];
+    getJukeboxCanonGenreRelations: Sequelize.HasManyGetAssociationsMixin<JukeboxCanonGenreRelation>;
+    setJukeboxCanonGenreRelations: Sequelize.HasManySetAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    addJukeboxCanonGenreRelation: Sequelize.HasManyAddAssociationMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    addJukeboxCanonGenreRelations: Sequelize.HasManyAddAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    createJukeboxCanonGenreRelation: Sequelize.HasManyCreateAssociationMixin<JukeboxCanonGenreRelation>;
+    removeJukeboxCanonGenreRelation: Sequelize.HasManyRemoveAssociationMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    removeJukeboxCanonGenreRelations: Sequelize.HasManyRemoveAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    hasJukeboxCanonGenreRelation: Sequelize.HasManyHasAssociationMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    hasJukeboxCanonGenreRelations: Sequelize.HasManyHasAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    countJukeboxCanonGenreRelations: Sequelize.HasManyCountAssociationsMixin;
+    jukeboxInvites: JukeboxInvite[];
+    getJukeboxInvites: Sequelize.HasManyGetAssociationsMixin<JukeboxInvite>;
+    setJukeboxInvites: Sequelize.HasManySetAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+    addJukeboxInvite: Sequelize.HasManyAddAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+    addJukeboxInvites: Sequelize.HasManyAddAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+    createJukeboxInvite: Sequelize.HasManyCreateAssociationMixin<JukeboxInvite>;
+    removeJukeboxInvite: Sequelize.HasManyRemoveAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+    removeJukeboxInvites: Sequelize.HasManyRemoveAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+    hasJukeboxInvite: Sequelize.HasManyHasAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+    hasJukeboxInvites: Sequelize.HasManyHasAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+    countJukeboxInvites: Sequelize.HasManyCountAssociationsMixin;
+    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;
+    jukeboxUsers: JukeboxUser[];
+    getJukeboxUsers: Sequelize.HasManyGetAssociationsMixin<JukeboxUser>;
+    setJukeboxUsers: Sequelize.HasManySetAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    addJukeboxUser: Sequelize.HasManyAddAssociationMixin<JukeboxUser, JukeboxUserId>;
+    addJukeboxUsers: Sequelize.HasManyAddAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    createJukeboxUser: Sequelize.HasManyCreateAssociationMixin<JukeboxUser>;
+    removeJukeboxUser: Sequelize.HasManyRemoveAssociationMixin<JukeboxUser, JukeboxUserId>;
+    removeJukeboxUsers: Sequelize.HasManyRemoveAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    hasJukeboxUser: Sequelize.HasManyHasAssociationMixin<JukeboxUser, JukeboxUserId>;
+    hasJukeboxUsers: Sequelize.HasManyHasAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    countJukeboxUsers: Sequelize.HasManyCountAssociationsMixin;
+    jukeboxStatus: JukeboxStatus;
+    getJukeboxStatus: Sequelize.BelongsToGetAssociationMixin<JukeboxStatus>;
+    setJukeboxStatus: Sequelize.BelongsToSetAssociationMixin<JukeboxStatus, JukeboxStatusId>;
+    createJukeboxStatus: Sequelize.BelongsToCreateAssociationMixin<JukeboxStatus>;
+    terminationCondition: JukeboxTerminationCondition;
+    getTerminationCondition: Sequelize.BelongsToGetAssociationMixin<JukeboxTerminationCondition>;
+    setTerminationCondition: Sequelize.BelongsToSetAssociationMixin<JukeboxTerminationCondition, JukeboxTerminationConditionId>;
+    createTerminationCondition: Sequelize.BelongsToCreateAssociationMixin<JukeboxTerminationCondition>;
+    type: JukeboxType;
+    getType: Sequelize.BelongsToGetAssociationMixin<JukeboxType>;
+    setType: Sequelize.BelongsToSetAssociationMixin<JukeboxType, JukeboxTypeId>;
+    createType: Sequelize.BelongsToCreateAssociationMixin<JukeboxType>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxSession;
+}

package/dist/JukeboxSession.js

@@ -0,0 +1,133 @@
+"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.JukeboxSession = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class JukeboxSession extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return JukeboxSession.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            typeId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'jukebox_type',
+                    key: 'id'
+                },
+                field: 'type_id'
+            },
+            accessTypeId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'jukebox_access_type',
+                    key: 'id'
+                },
+                field: 'access_type_id'
+            },
+            terminationConditionId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'jukebox_termination_condition',
+                    key: 'id'
+                },
+                field: 'termination_condition_id'
+            },
+            jukeboxQueueModeId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'jukebox_queue_mode',
+                    key: 'id'
+                },
+                field: 'jukebox_queue_mode_id'
+            },
+            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'
+            },
+            jukeboxStatusId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0,
+                references: {
+                    model: 'jukebox_status',
+                    key: 'id'
+                },
+                field: 'jukebox_status_id'
+            },
+            trackQueue: {
+                type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.TEXT),
+                allowNull: true,
+                field: 'track_queue'
+            },
+            description: {
+                type: sequelize_1.DataTypes.STRING(512),
+                allowNull: true
+            },
+            stateMachineArn: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: true,
+                field: 'state_machine_arn'
+            },
+            durationMs: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0,
+                field: 'duration_ms'
+            }
+        }, {
+            sequelize,
+            tableName: 'jukebox_session',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "jukebox_session_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.JukeboxSession = JukeboxSession;

package/dist/JukeboxStatus.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+export interface JukeboxStatusAttributes {
+    id: number;
+    description: string;
+}
+export type JukeboxStatusPk = "id";
+export type JukeboxStatusId = JukeboxStatus[JukeboxStatusPk];
+export type JukeboxStatusCreationAttributes = JukeboxStatusAttributes;
+export declare class JukeboxStatus extends Model<JukeboxStatusAttributes, JukeboxStatusCreationAttributes> implements JukeboxStatusAttributes {
+    id: number;
+    description: string;
+    jukeboxSessions: JukeboxSession[];
+    getJukeboxSessions: Sequelize.HasManyGetAssociationsMixin<JukeboxSession>;
+    setJukeboxSessions: Sequelize.HasManySetAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    addJukeboxSession: Sequelize.HasManyAddAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    addJukeboxSessions: Sequelize.HasManyAddAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    createJukeboxSession: Sequelize.HasManyCreateAssociationMixin<JukeboxSession>;
+    removeJukeboxSession: Sequelize.HasManyRemoveAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    removeJukeboxSessions: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    hasJukeboxSession: Sequelize.HasManyHasAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    hasJukeboxSessions: Sequelize.HasManyHasAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    countJukeboxSessions: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxStatus;
+}