@earbug/db-models 0.0.1

package/dist/CanonTrack.js

@@ -0,0 +1,99 @@
+"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.CanonTrack = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonTrack extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonTrack.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            name: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            asciiName: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'ascii_name'
+            },
+            explicit: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false
+            },
+            discNumber: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: true,
+                field: 'disc_number'
+            },
+            discTrackNumber: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: true,
+                field: 'disc_track_number'
+            },
+            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'
+            },
+            durationMs: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                field: 'duration_ms'
+            }
+        }, {
+            sequelize,
+            tableName: 'canon_track',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_track_lower_name_idx",
+                    fields: []
+                },
+                {
+                    name: "platform_track_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonTrack = CanonTrack;

package/dist/ConfigParam.d.ts

@@ -0,0 +1,19 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+export interface ConfigParamAttributes {
+    name: string;
+    value?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type ConfigParamPk = "name";
+export type ConfigParamId = ConfigParam[ConfigParamPk];
+export type ConfigParamOptionalAttributes = "value" | "createdAt" | "updatedAt";
+export type ConfigParamCreationAttributes = Optional<ConfigParamAttributes, ConfigParamOptionalAttributes>;
+export declare class ConfigParam extends Model<ConfigParamAttributes, ConfigParamCreationAttributes> implements ConfigParamAttributes {
+    name: string;
+    value?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    static initModel(sequelize: Sequelize.Sequelize): typeof ConfigParam;
+}

package/dist/ConfigParam.js

@@ -0,0 +1,70 @@
+"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.ConfigParam = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class ConfigParam extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return ConfigParam.init({
+            name: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                primaryKey: true
+            },
+            value: {
+                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: 'config_param',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "config_param_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "name" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.ConfigParam = ConfigParam;

package/dist/ExternalReference.d.ts

@@ -0,0 +1,139 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId } from './CanonAlbumExternalReferenceRelation';
+import type { CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId } from './CanonArtistExternalReferenceRelation';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId } from './CanonGenreExternalReferenceRelation';
+import type { CanonLabel, CanonLabelId } from './CanonLabel';
+import type { CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId } from './CanonLabelExternalReferenceRelation';
+import type { CanonMember, CanonMemberId } from './CanonMember';
+import type { CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId } from './CanonMemberExternalReferenceRelation';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+export interface ExternalReferenceAttributes {
+    id: string;
+    name: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type ExternalReferencePk = "id";
+export type ExternalReferenceId = ExternalReference[ExternalReferencePk];
+export type ExternalReferenceOptionalAttributes = "id" | "createDate" | "updateDate";
+export type ExternalReferenceCreationAttributes = Optional<ExternalReferenceAttributes, ExternalReferenceOptionalAttributes>;
+export declare class ExternalReference extends Model<ExternalReferenceAttributes, ExternalReferenceCreationAttributes> implements ExternalReferenceAttributes {
+    id: string;
+    name: string;
+    createDate: Date;
+    updateDate: Date;
+    canonAlbumIdCanonAlbums: CanonAlbum[];
+    getCanonAlbumIdCanonAlbums: Sequelize.BelongsToManyGetAssociationsMixin<CanonAlbum>;
+    setCanonAlbumIdCanonAlbums: Sequelize.BelongsToManySetAssociationsMixin<CanonAlbum, CanonAlbumId>;
+    addCanonAlbumIdCanonAlbum: Sequelize.BelongsToManyAddAssociationMixin<CanonAlbum, CanonAlbumId>;
+    addCanonAlbumIdCanonAlbums: Sequelize.BelongsToManyAddAssociationsMixin<CanonAlbum, CanonAlbumId>;
+    createCanonAlbumIdCanonAlbum: Sequelize.BelongsToManyCreateAssociationMixin<CanonAlbum>;
+    removeCanonAlbumIdCanonAlbum: Sequelize.BelongsToManyRemoveAssociationMixin<CanonAlbum, CanonAlbumId>;
+    removeCanonAlbumIdCanonAlbums: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonAlbum, CanonAlbumId>;
+    hasCanonAlbumIdCanonAlbum: Sequelize.BelongsToManyHasAssociationMixin<CanonAlbum, CanonAlbumId>;
+    hasCanonAlbumIdCanonAlbums: Sequelize.BelongsToManyHasAssociationsMixin<CanonAlbum, CanonAlbumId>;
+    countCanonAlbumIdCanonAlbums: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonAlbumExternalReferenceRelations: CanonAlbumExternalReferenceRelation[];
+    getCanonAlbumExternalReferenceRelations: Sequelize.HasManyGetAssociationsMixin<CanonAlbumExternalReferenceRelation>;
+    setCanonAlbumExternalReferenceRelations: Sequelize.HasManySetAssociationsMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+    addCanonAlbumExternalReferenceRelation: Sequelize.HasManyAddAssociationMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+    addCanonAlbumExternalReferenceRelations: Sequelize.HasManyAddAssociationsMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+    createCanonAlbumExternalReferenceRelation: Sequelize.HasManyCreateAssociationMixin<CanonAlbumExternalReferenceRelation>;
+    removeCanonAlbumExternalReferenceRelation: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+    removeCanonAlbumExternalReferenceRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+    hasCanonAlbumExternalReferenceRelation: Sequelize.HasManyHasAssociationMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+    hasCanonAlbumExternalReferenceRelations: Sequelize.HasManyHasAssociationsMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+    countCanonAlbumExternalReferenceRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonArtistExternalReferenceRelations: CanonArtistExternalReferenceRelation[];
+    getCanonArtistExternalReferenceRelations: Sequelize.HasManyGetAssociationsMixin<CanonArtistExternalReferenceRelation>;
+    setCanonArtistExternalReferenceRelations: Sequelize.HasManySetAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    addCanonArtistExternalReferenceRelation: Sequelize.HasManyAddAssociationMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    addCanonArtistExternalReferenceRelations: Sequelize.HasManyAddAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    createCanonArtistExternalReferenceRelation: Sequelize.HasManyCreateAssociationMixin<CanonArtistExternalReferenceRelation>;
+    removeCanonArtistExternalReferenceRelation: Sequelize.HasManyRemoveAssociationMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    removeCanonArtistExternalReferenceRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    hasCanonArtistExternalReferenceRelation: Sequelize.HasManyHasAssociationMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    hasCanonArtistExternalReferenceRelations: Sequelize.HasManyHasAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    countCanonArtistExternalReferenceRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonGenreIdCanonGenreCanonGenreExternalReferenceRelations: CanonGenre[];
+    getCanonGenreIdCanonGenreCanonGenreExternalReferenceRelations: Sequelize.BelongsToManyGetAssociationsMixin<CanonGenre>;
+    setCanonGenreIdCanonGenreCanonGenreExternalReferenceRelations: Sequelize.BelongsToManySetAssociationsMixin<CanonGenre, CanonGenreId>;
+    addCanonGenreIdCanonGenreCanonGenreExternalReferenceRelation: Sequelize.BelongsToManyAddAssociationMixin<CanonGenre, CanonGenreId>;
+    addCanonGenreIdCanonGenreCanonGenreExternalReferenceRelations: Sequelize.BelongsToManyAddAssociationsMixin<CanonGenre, CanonGenreId>;
+    createCanonGenreIdCanonGenreCanonGenreExternalReferenceRelation: Sequelize.BelongsToManyCreateAssociationMixin<CanonGenre>;
+    removeCanonGenreIdCanonGenreCanonGenreExternalReferenceRelation: Sequelize.BelongsToManyRemoveAssociationMixin<CanonGenre, CanonGenreId>;
+    removeCanonGenreIdCanonGenreCanonGenreExternalReferenceRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonGenre, CanonGenreId>;
+    hasCanonGenreIdCanonGenreCanonGenreExternalReferenceRelation: Sequelize.BelongsToManyHasAssociationMixin<CanonGenre, CanonGenreId>;
+    hasCanonGenreIdCanonGenreCanonGenreExternalReferenceRelations: Sequelize.BelongsToManyHasAssociationsMixin<CanonGenre, CanonGenreId>;
+    countCanonGenreIdCanonGenreCanonGenreExternalReferenceRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonGenreExternalReferenceRelations: CanonGenreExternalReferenceRelation[];
+    getCanonGenreExternalReferenceRelations: Sequelize.HasManyGetAssociationsMixin<CanonGenreExternalReferenceRelation>;
+    setCanonGenreExternalReferenceRelations: Sequelize.HasManySetAssociationsMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+    addCanonGenreExternalReferenceRelation: Sequelize.HasManyAddAssociationMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+    addCanonGenreExternalReferenceRelations: Sequelize.HasManyAddAssociationsMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+    createCanonGenreExternalReferenceRelation: Sequelize.HasManyCreateAssociationMixin<CanonGenreExternalReferenceRelation>;
+    removeCanonGenreExternalReferenceRelation: Sequelize.HasManyRemoveAssociationMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+    removeCanonGenreExternalReferenceRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+    hasCanonGenreExternalReferenceRelation: Sequelize.HasManyHasAssociationMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+    hasCanonGenreExternalReferenceRelations: Sequelize.HasManyHasAssociationsMixin<CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId>;
+    countCanonGenreExternalReferenceRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonLabelIdCanonLabelCanonLabelExternalReferenceRelations: CanonLabel[];
+    getCanonLabelIdCanonLabelCanonLabelExternalReferenceRelations: Sequelize.BelongsToManyGetAssociationsMixin<CanonLabel>;
+    setCanonLabelIdCanonLabelCanonLabelExternalReferenceRelations: Sequelize.BelongsToManySetAssociationsMixin<CanonLabel, CanonLabelId>;
+    addCanonLabelIdCanonLabelCanonLabelExternalReferenceRelation: Sequelize.BelongsToManyAddAssociationMixin<CanonLabel, CanonLabelId>;
+    addCanonLabelIdCanonLabelCanonLabelExternalReferenceRelations: Sequelize.BelongsToManyAddAssociationsMixin<CanonLabel, CanonLabelId>;
+    createCanonLabelIdCanonLabelCanonLabelExternalReferenceRelation: Sequelize.BelongsToManyCreateAssociationMixin<CanonLabel>;
+    removeCanonLabelIdCanonLabelCanonLabelExternalReferenceRelation: Sequelize.BelongsToManyRemoveAssociationMixin<CanonLabel, CanonLabelId>;
+    removeCanonLabelIdCanonLabelCanonLabelExternalReferenceRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonLabel, CanonLabelId>;
+    hasCanonLabelIdCanonLabelCanonLabelExternalReferenceRelation: Sequelize.BelongsToManyHasAssociationMixin<CanonLabel, CanonLabelId>;
+    hasCanonLabelIdCanonLabelCanonLabelExternalReferenceRelations: Sequelize.BelongsToManyHasAssociationsMixin<CanonLabel, CanonLabelId>;
+    countCanonLabelIdCanonLabelCanonLabelExternalReferenceRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonLabelExternalReferenceRelations: CanonLabelExternalReferenceRelation[];
+    getCanonLabelExternalReferenceRelations: Sequelize.HasManyGetAssociationsMixin<CanonLabelExternalReferenceRelation>;
+    setCanonLabelExternalReferenceRelations: Sequelize.HasManySetAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    addCanonLabelExternalReferenceRelation: Sequelize.HasManyAddAssociationMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    addCanonLabelExternalReferenceRelations: Sequelize.HasManyAddAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    createCanonLabelExternalReferenceRelation: Sequelize.HasManyCreateAssociationMixin<CanonLabelExternalReferenceRelation>;
+    removeCanonLabelExternalReferenceRelation: Sequelize.HasManyRemoveAssociationMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    removeCanonLabelExternalReferenceRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    hasCanonLabelExternalReferenceRelation: Sequelize.HasManyHasAssociationMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    hasCanonLabelExternalReferenceRelations: Sequelize.HasManyHasAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+    countCanonLabelExternalReferenceRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonMemberIdCanonMemberCanonMemberExternalReferenceRelations: CanonMember[];
+    getCanonMemberIdCanonMemberCanonMemberExternalReferenceRelations: Sequelize.BelongsToManyGetAssociationsMixin<CanonMember>;
+    setCanonMemberIdCanonMemberCanonMemberExternalReferenceRelations: Sequelize.BelongsToManySetAssociationsMixin<CanonMember, CanonMemberId>;
+    addCanonMemberIdCanonMemberCanonMemberExternalReferenceRelation: Sequelize.BelongsToManyAddAssociationMixin<CanonMember, CanonMemberId>;
+    addCanonMemberIdCanonMemberCanonMemberExternalReferenceRelations: Sequelize.BelongsToManyAddAssociationsMixin<CanonMember, CanonMemberId>;
+    createCanonMemberIdCanonMemberCanonMemberExternalReferenceRelation: Sequelize.BelongsToManyCreateAssociationMixin<CanonMember>;
+    removeCanonMemberIdCanonMemberCanonMemberExternalReferenceRelation: Sequelize.BelongsToManyRemoveAssociationMixin<CanonMember, CanonMemberId>;
+    removeCanonMemberIdCanonMemberCanonMemberExternalReferenceRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonMember, CanonMemberId>;
+    hasCanonMemberIdCanonMemberCanonMemberExternalReferenceRelation: Sequelize.BelongsToManyHasAssociationMixin<CanonMember, CanonMemberId>;
+    hasCanonMemberIdCanonMemberCanonMemberExternalReferenceRelations: Sequelize.BelongsToManyHasAssociationsMixin<CanonMember, CanonMemberId>;
+    countCanonMemberIdCanonMemberCanonMemberExternalReferenceRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonMemberExternalReferenceRelations: CanonMemberExternalReferenceRelation[];
+    getCanonMemberExternalReferenceRelations: Sequelize.HasManyGetAssociationsMixin<CanonMemberExternalReferenceRelation>;
+    setCanonMemberExternalReferenceRelations: Sequelize.HasManySetAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    addCanonMemberExternalReferenceRelation: Sequelize.HasManyAddAssociationMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    addCanonMemberExternalReferenceRelations: Sequelize.HasManyAddAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    createCanonMemberExternalReferenceRelation: Sequelize.HasManyCreateAssociationMixin<CanonMemberExternalReferenceRelation>;
+    removeCanonMemberExternalReferenceRelation: Sequelize.HasManyRemoveAssociationMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    removeCanonMemberExternalReferenceRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    hasCanonMemberExternalReferenceRelation: Sequelize.HasManyHasAssociationMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    hasCanonMemberExternalReferenceRelations: Sequelize.HasManyHasAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+    countCanonMemberExternalReferenceRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonArtistIdPlatformArtists: PlatformArtist[];
+    getCanonArtistIdPlatformArtists: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+    setCanonArtistIdPlatformArtists: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    addCanonArtistIdPlatformArtist: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+    addCanonArtistIdPlatformArtists: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    createCanonArtistIdPlatformArtist: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+    removeCanonArtistIdPlatformArtist: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+    removeCanonArtistIdPlatformArtists: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    hasCanonArtistIdPlatformArtist: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+    hasCanonArtistIdPlatformArtists: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    countCanonArtistIdPlatformArtists: Sequelize.BelongsToManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof ExternalReference;
+}

package/dist/ExternalReference.js

@@ -0,0 +1,79 @@
+"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.ExternalReference = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class ExternalReference extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return ExternalReference.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            name: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                unique: "external_reference_un"
+            },
+            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: 'external_reference',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "external_reference_un",
+                    unique: true,
+                    fields: [
+                        { name: "name" },
+                    ]
+                },
+                {
+                    name: "reference_source_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.ExternalReference = ExternalReference;

package/dist/JukeboxAccessType.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+export interface JukeboxAccessTypeAttributes {
+    id: number;
+    description: string;
+}
+export type JukeboxAccessTypePk = "id";
+export type JukeboxAccessTypeId = JukeboxAccessType[JukeboxAccessTypePk];
+export type JukeboxAccessTypeCreationAttributes = JukeboxAccessTypeAttributes;
+export declare class JukeboxAccessType extends Model<JukeboxAccessTypeAttributes, JukeboxAccessTypeCreationAttributes> implements JukeboxAccessTypeAttributes {
+    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 JukeboxAccessType;
+}

package/dist/JukeboxAccessType.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JukeboxAccessType = void 0;
+const sequelize_1 = require("sequelize");
+class JukeboxAccessType extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return JukeboxAccessType.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_access_type',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "jukebox_access_type_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.JukeboxAccessType = JukeboxAccessType;

package/dist/JukeboxCanonGenreRelation.d.ts

@@ -0,0 +1,33 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+export interface JukeboxCanonGenreRelationAttributes {
+    id: string;
+    jukeboxSessionId: string;
+    canonGenreId: string;
+    stateId: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type JukeboxCanonGenreRelationPk = "id";
+export type JukeboxCanonGenreRelationId = JukeboxCanonGenreRelation[JukeboxCanonGenreRelationPk];
+export type JukeboxCanonGenreRelationOptionalAttributes = "id" | "stateId" | "createdAt" | "updatedAt";
+export type JukeboxCanonGenreRelationCreationAttributes = Optional<JukeboxCanonGenreRelationAttributes, JukeboxCanonGenreRelationOptionalAttributes>;
+export declare class JukeboxCanonGenreRelation extends Model<JukeboxCanonGenreRelationAttributes, JukeboxCanonGenreRelationCreationAttributes> implements JukeboxCanonGenreRelationAttributes {
+    id: string;
+    jukeboxSessionId: string;
+    canonGenreId: string;
+    stateId: number;
+    createdAt: Date;
+    updatedAt: Date;
+    canonGenre: CanonGenre;
+    getCanonGenre: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+    setCanonGenre: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+    createCanonGenre: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+    jukeboxSession: JukeboxSession;
+    getJukeboxSession: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+    setJukeboxSession: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    createJukeboxSession: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxCanonGenreRelation;
+}

package/dist/JukeboxCanonGenreRelation.js

@@ -0,0 +1,101 @@
+"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.JukeboxCanonGenreRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class JukeboxCanonGenreRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return JukeboxCanonGenreRelation.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'
+                },
+                unique: "unique_jukebox_canon_genre",
+                field: 'jukebox_session_id'
+            },
+            canonGenreId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'canon_genre',
+                    key: 'id'
+                },
+                unique: "unique_jukebox_canon_genre",
+                field: 'canon_genre_id'
+            },
+            stateId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0,
+                field: 'state_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'
+            }
+        }, {
+            sequelize,
+            tableName: 'jukebox_canon_genre_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "jukebox_canon_genre_relation_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "unique_jukebox_canon_genre",
+                    unique: true,
+                    fields: [
+                        { name: "jukebox_session_id" },
+                        { name: "canon_genre_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.JukeboxCanonGenreRelation = JukeboxCanonGenreRelation;

package/dist/JukeboxInvite.d.ts

@@ -0,0 +1,39 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+export interface JukeboxInviteAttributes {
+    id: string;
+    jukeboxSessionId: string;
+    inviterUserId: string;
+    invitedUserId?: string;
+    email?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type JukeboxInvitePk = "id";
+export type JukeboxInviteId = JukeboxInvite[JukeboxInvitePk];
+export type JukeboxInviteOptionalAttributes = "id" | "invitedUserId" | "email" | "createdAt" | "updatedAt";
+export type JukeboxInviteCreationAttributes = Optional<JukeboxInviteAttributes, JukeboxInviteOptionalAttributes>;
+export declare class JukeboxInvite extends Model<JukeboxInviteAttributes, JukeboxInviteCreationAttributes> implements JukeboxInviteAttributes {
+    id: string;
+    jukeboxSessionId: string;
+    inviterUserId: string;
+    invitedUserId?: string;
+    email?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    invitedUser: AppUser;
+    getInvitedUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setInvitedUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createInvitedUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    inviterUser: AppUser;
+    getInviterUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setInviterUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createInviterUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    jukeboxSession: JukeboxSession;
+    getJukeboxSession: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+    setJukeboxSession: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    createJukeboxSession: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxInvite;
+}