@earbug/db-models 0.0.1

package/dist/AppUserPlatformRelation.js

@@ -0,0 +1,132 @@
+"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.AppUserPlatformRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class AppUserPlatformRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return AppUserPlatformRelation.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            appUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                unique: "uk_platform_relation_app_user_id",
+                field: 'app_user_id'
+            },
+            platformId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'platform',
+                    key: 'id'
+                },
+                field: 'platform_id'
+            },
+            externalUserId: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'external_user_id'
+            },
+            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'
+            },
+            accessToken: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false,
+                field: 'access_token'
+            },
+            refreshToken: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: true,
+                field: 'refresh_token'
+            },
+            expirationDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                field: 'expiration_date'
+            },
+            countryCode: {
+                type: sequelize_1.DataTypes.STRING(2),
+                allowNull: false,
+                field: 'country_code'
+            },
+            stateId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0,
+                field: 'state_id'
+            }
+        }, {
+            sequelize,
+            tableName: 'app_user_platform_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "app_user_platform_relation_app_user_id_platform_id_idx",
+                    unique: true,
+                    fields: [
+                        { name: "app_user_id" },
+                        { name: "platform_id" },
+                    ]
+                },
+                {
+                    name: "app_user_platform_relation_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "uk_platform_relation_app_user_id",
+                    unique: true,
+                    fields: [
+                        { name: "app_user_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.AppUserPlatformRelation = AppUserPlatformRelation;

package/dist/CanonAlbum.d.ts

@@ -0,0 +1,119 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId } from './CanonAlbumExternalReferenceRelation';
+import type { CanonAlbumImageHarvested, CanonAlbumImageHarvestedId } from './CanonAlbumImageHarvested';
+import type { CanonAlbumTrackRelation, CanonAlbumTrackRelationId } from './CanonAlbumTrackRelation';
+import type { CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId } from './CanonToPlatformAlbumRelation';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+export interface CanonAlbumAttributes {
+    id: string;
+    name: string;
+    asciiName: string;
+    releaseDate?: string;
+    noOfDisc?: number;
+    createDate: Date;
+    updateDate: Date;
+    hasPhoto?: boolean;
+    hasThumbnailPhoto?: boolean;
+    description?: string;
+    images?: object;
+    lastImageHarvestAttempt?: Date;
+}
+export type CanonAlbumPk = "id";
+export type CanonAlbumId = CanonAlbum[CanonAlbumPk];
+export type CanonAlbumOptionalAttributes = "id" | "releaseDate" | "noOfDisc" | "createDate" | "updateDate" | "hasPhoto" | "hasThumbnailPhoto" | "description" | "images" | "lastImageHarvestAttempt";
+export type CanonAlbumCreationAttributes = Optional<CanonAlbumAttributes, CanonAlbumOptionalAttributes>;
+export declare class CanonAlbum extends Model<CanonAlbumAttributes, CanonAlbumCreationAttributes> implements CanonAlbumAttributes {
+    id: string;
+    name: string;
+    asciiName: string;
+    releaseDate?: string;
+    noOfDisc?: number;
+    createDate: Date;
+    updateDate: Date;
+    hasPhoto?: boolean;
+    hasThumbnailPhoto?: boolean;
+    description?: string;
+    images?: object;
+    lastImageHarvestAttempt?: Date;
+    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;
+    canonAlbumImageHarvesteds: CanonAlbumImageHarvested[];
+    getCanonAlbumImageHarvesteds: Sequelize.HasManyGetAssociationsMixin<CanonAlbumImageHarvested>;
+    setCanonAlbumImageHarvesteds: Sequelize.HasManySetAssociationsMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+    addCanonAlbumImageHarvested: Sequelize.HasManyAddAssociationMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+    addCanonAlbumImageHarvesteds: Sequelize.HasManyAddAssociationsMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+    createCanonAlbumImageHarvested: Sequelize.HasManyCreateAssociationMixin<CanonAlbumImageHarvested>;
+    removeCanonAlbumImageHarvested: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+    removeCanonAlbumImageHarvesteds: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+    hasCanonAlbumImageHarvested: Sequelize.HasManyHasAssociationMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+    hasCanonAlbumImageHarvesteds: Sequelize.HasManyHasAssociationsMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+    countCanonAlbumImageHarvesteds: Sequelize.HasManyCountAssociationsMixin;
+    canonAlbumTrackRelations: CanonAlbumTrackRelation[];
+    getCanonAlbumTrackRelations: Sequelize.HasManyGetAssociationsMixin<CanonAlbumTrackRelation>;
+    setCanonAlbumTrackRelations: Sequelize.HasManySetAssociationsMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+    addCanonAlbumTrackRelation: Sequelize.HasManyAddAssociationMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+    addCanonAlbumTrackRelations: Sequelize.HasManyAddAssociationsMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+    createCanonAlbumTrackRelation: Sequelize.HasManyCreateAssociationMixin<CanonAlbumTrackRelation>;
+    removeCanonAlbumTrackRelation: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+    removeCanonAlbumTrackRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+    hasCanonAlbumTrackRelation: Sequelize.HasManyHasAssociationMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+    hasCanonAlbumTrackRelations: Sequelize.HasManyHasAssociationsMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+    countCanonAlbumTrackRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonToPlatformAlbumRelations: CanonToPlatformAlbumRelation[];
+    getCanonToPlatformAlbumRelations: Sequelize.HasManyGetAssociationsMixin<CanonToPlatformAlbumRelation>;
+    setCanonToPlatformAlbumRelations: Sequelize.HasManySetAssociationsMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+    addCanonToPlatformAlbumRelation: Sequelize.HasManyAddAssociationMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+    addCanonToPlatformAlbumRelations: Sequelize.HasManyAddAssociationsMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+    createCanonToPlatformAlbumRelation: Sequelize.HasManyCreateAssociationMixin<CanonToPlatformAlbumRelation>;
+    removeCanonToPlatformAlbumRelation: Sequelize.HasManyRemoveAssociationMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+    removeCanonToPlatformAlbumRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+    hasCanonToPlatformAlbumRelation: Sequelize.HasManyHasAssociationMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+    hasCanonToPlatformAlbumRelations: Sequelize.HasManyHasAssociationsMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+    countCanonToPlatformAlbumRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonTrackIdCanonTracks: CanonTrack[];
+    getCanonTrackIdCanonTracks: Sequelize.BelongsToManyGetAssociationsMixin<CanonTrack>;
+    setCanonTrackIdCanonTracks: Sequelize.BelongsToManySetAssociationsMixin<CanonTrack, CanonTrackId>;
+    addCanonTrackIdCanonTrack: Sequelize.BelongsToManyAddAssociationMixin<CanonTrack, CanonTrackId>;
+    addCanonTrackIdCanonTracks: Sequelize.BelongsToManyAddAssociationsMixin<CanonTrack, CanonTrackId>;
+    createCanonTrackIdCanonTrack: Sequelize.BelongsToManyCreateAssociationMixin<CanonTrack>;
+    removeCanonTrackIdCanonTrack: Sequelize.BelongsToManyRemoveAssociationMixin<CanonTrack, CanonTrackId>;
+    removeCanonTrackIdCanonTracks: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonTrack, CanonTrackId>;
+    hasCanonTrackIdCanonTrack: Sequelize.BelongsToManyHasAssociationMixin<CanonTrack, CanonTrackId>;
+    hasCanonTrackIdCanonTracks: Sequelize.BelongsToManyHasAssociationsMixin<CanonTrack, CanonTrackId>;
+    countCanonTrackIdCanonTracks: Sequelize.BelongsToManyCountAssociationsMixin;
+    externalReferenceIdExternalReferences: ExternalReference[];
+    getExternalReferenceIdExternalReferences: Sequelize.BelongsToManyGetAssociationsMixin<ExternalReference>;
+    setExternalReferenceIdExternalReferences: Sequelize.BelongsToManySetAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    addExternalReferenceIdExternalReference: Sequelize.BelongsToManyAddAssociationMixin<ExternalReference, ExternalReferenceId>;
+    addExternalReferenceIdExternalReferences: Sequelize.BelongsToManyAddAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    createExternalReferenceIdExternalReference: Sequelize.BelongsToManyCreateAssociationMixin<ExternalReference>;
+    removeExternalReferenceIdExternalReference: Sequelize.BelongsToManyRemoveAssociationMixin<ExternalReference, ExternalReferenceId>;
+    removeExternalReferenceIdExternalReferences: Sequelize.BelongsToManyRemoveAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    hasExternalReferenceIdExternalReference: Sequelize.BelongsToManyHasAssociationMixin<ExternalReference, ExternalReferenceId>;
+    hasExternalReferenceIdExternalReferences: Sequelize.BelongsToManyHasAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    countExternalReferenceIdExternalReferences: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformAlbumIdPlatformAlbums: PlatformAlbum[];
+    getPlatformAlbumIdPlatformAlbums: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+    setPlatformAlbumIdPlatformAlbums: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    addPlatformAlbumIdPlatformAlbum: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    addPlatformAlbumIdPlatformAlbums: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    createPlatformAlbumIdPlatformAlbum: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+    removePlatformAlbumIdPlatformAlbum: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    removePlatformAlbumIdPlatformAlbums: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    hasPlatformAlbumIdPlatformAlbum: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    hasPlatformAlbumIdPlatformAlbums: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    countPlatformAlbumIdPlatformAlbums: Sequelize.BelongsToManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonAlbum;
+}

package/dist/CanonAlbum.js

@@ -0,0 +1,117 @@
+"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.CanonAlbum = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonAlbum extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonAlbum.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'
+            },
+            releaseDate: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 'release_date'
+            },
+            noOfDisc: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: true,
+                field: 'no_of_disc'
+            },
+            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'
+            },
+            hasPhoto: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: true,
+                defaultValue: false,
+                field: 'has_photo'
+            },
+            hasThumbnailPhoto: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: true,
+                defaultValue: false,
+                field: 'has_thumbnail_photo'
+            },
+            description: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true
+            },
+            images: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true
+            },
+            lastImageHarvestAttempt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                field: 'last_image_harvest_attempt'
+            }
+        }, {
+            sequelize,
+            tableName: 'canon_album',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_album_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "eb_canon_album_last_image_harvest_attempt",
+                    fields: [
+                        { name: "last_image_harvest_attempt" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonAlbum = CanonAlbum;

package/dist/CanonAlbumExternalReferenceRelation.d.ts

@@ -0,0 +1,31 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+export interface CanonAlbumExternalReferenceRelationAttributes {
+    canonAlbumId: string;
+    externalReferenceId: string;
+    url: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonAlbumExternalReferenceRelationPk = "canonAlbumId" | "externalReferenceId";
+export type CanonAlbumExternalReferenceRelationId = CanonAlbumExternalReferenceRelation[CanonAlbumExternalReferenceRelationPk];
+export type CanonAlbumExternalReferenceRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonAlbumExternalReferenceRelationCreationAttributes = Optional<CanonAlbumExternalReferenceRelationAttributes, CanonAlbumExternalReferenceRelationOptionalAttributes>;
+export declare class CanonAlbumExternalReferenceRelation extends Model<CanonAlbumExternalReferenceRelationAttributes, CanonAlbumExternalReferenceRelationCreationAttributes> implements CanonAlbumExternalReferenceRelationAttributes {
+    canonAlbumId: string;
+    externalReferenceId: string;
+    url: string;
+    createDate: Date;
+    updateDate: Date;
+    canonAlbum: CanonAlbum;
+    getCanonAlbum: Sequelize.BelongsToGetAssociationMixin<CanonAlbum>;
+    setCanonAlbum: Sequelize.BelongsToSetAssociationMixin<CanonAlbum, CanonAlbumId>;
+    createCanonAlbum: Sequelize.BelongsToCreateAssociationMixin<CanonAlbum>;
+    externalReference: ExternalReference;
+    getExternalReference: Sequelize.BelongsToGetAssociationMixin<ExternalReference>;
+    setExternalReference: Sequelize.BelongsToSetAssociationMixin<ExternalReference, ExternalReferenceId>;
+    createExternalReference: Sequelize.BelongsToCreateAssociationMixin<ExternalReference>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonAlbumExternalReferenceRelation;
+}

package/dist/CanonAlbumExternalReferenceRelation.js

@@ -0,0 +1,86 @@
+"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.CanonAlbumExternalReferenceRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonAlbumExternalReferenceRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonAlbumExternalReferenceRelation.init({
+            canonAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'canon_album',
+                    key: 'id'
+                },
+                field: 'canon_album_id'
+            },
+            externalReferenceId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'external_reference',
+                    key: 'id'
+                },
+                field: 'external_reference_id'
+            },
+            url: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            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: 'canon_album_external_reference_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_album_external_reference_relation_pk",
+                    unique: true,
+                    fields: [
+                        { name: "canon_album_id" },
+                        { name: "external_reference_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonAlbumExternalReferenceRelation = CanonAlbumExternalReferenceRelation;

package/dist/CanonAlbumGenreRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+export interface CanonAlbumGenreRelationAttributes {
+    canonAlbumId: string;
+    canonGenreId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonAlbumGenreRelationPk = "canonAlbumId" | "canonGenreId";
+export type CanonAlbumGenreRelationId = CanonAlbumGenreRelation[CanonAlbumGenreRelationPk];
+export type CanonAlbumGenreRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonAlbumGenreRelationCreationAttributes = Optional<CanonAlbumGenreRelationAttributes, CanonAlbumGenreRelationOptionalAttributes>;
+export declare class CanonAlbumGenreRelation extends Model<CanonAlbumGenreRelationAttributes, CanonAlbumGenreRelationCreationAttributes> implements CanonAlbumGenreRelationAttributes {
+    canonAlbumId: string;
+    canonGenreId: string;
+    createDate: Date;
+    updateDate: Date;
+    canonGenre: CanonGenre;
+    getCanonGenre: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+    setCanonGenre: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+    createCanonGenre: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+    canonAlbum: PlatformAlbum;
+    getCanonAlbum: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+    setCanonAlbum: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    createCanonAlbum: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonAlbumGenreRelation;
+}

package/dist/CanonAlbumGenreRelation.js

@@ -0,0 +1,82 @@
+"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.CanonAlbumGenreRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonAlbumGenreRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonAlbumGenreRelation.init({
+            canonAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'platform_album',
+                    key: 'id'
+                },
+                field: 'canon_album_id'
+            },
+            canonGenreId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'canon_genre',
+                    key: 'id'
+                },
+                field: 'canon_genre_id'
+            },
+            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: 'canon_album_genre_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_album_genre_relation_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "canon_album_id" },
+                        { name: "canon_genre_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonAlbumGenreRelation = CanonAlbumGenreRelation;

package/dist/CanonAlbumImageHarvested.d.ts

@@ -0,0 +1,30 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+export interface CanonAlbumImageHarvestedAttributes {
+    id: string;
+    canonAlbumId: string;
+    priority?: number;
+    url?: string;
+    dateHarvested: Date;
+    storageKey: string;
+    harvestMethod?: string;
+}
+export type CanonAlbumImageHarvestedPk = "id";
+export type CanonAlbumImageHarvestedId = CanonAlbumImageHarvested[CanonAlbumImageHarvestedPk];
+export type CanonAlbumImageHarvestedOptionalAttributes = "id" | "priority" | "url" | "harvestMethod";
+export type CanonAlbumImageHarvestedCreationAttributes = Optional<CanonAlbumImageHarvestedAttributes, CanonAlbumImageHarvestedOptionalAttributes>;
+export declare class CanonAlbumImageHarvested extends Model<CanonAlbumImageHarvestedAttributes, CanonAlbumImageHarvestedCreationAttributes> implements CanonAlbumImageHarvestedAttributes {
+    id: string;
+    canonAlbumId: string;
+    priority?: number;
+    url?: string;
+    dateHarvested: Date;
+    storageKey: string;
+    harvestMethod?: string;
+    canonAlbum: CanonAlbum;
+    getCanonAlbum: Sequelize.BelongsToGetAssociationMixin<CanonAlbum>;
+    setCanonAlbum: Sequelize.BelongsToSetAssociationMixin<CanonAlbum, CanonAlbumId>;
+    createCanonAlbum: Sequelize.BelongsToCreateAssociationMixin<CanonAlbum>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonAlbumImageHarvested;
+}