@earbug/db-models 0.0.1

package/dist/CanonAlbumImageHarvested.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanonAlbumImageHarvested = void 0;
+const sequelize_1 = require("sequelize");
+class CanonAlbumImageHarvested extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonAlbumImageHarvested.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            canonAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'canon_album',
+                    key: 'id'
+                },
+                field: 'canon_album_id'
+            },
+            priority: {
+                type: sequelize_1.DataTypes.DECIMAL,
+                allowNull: true,
+                defaultValue: 0
+            },
+            url: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                unique: "canon_album_image_harvested_url_unique"
+            },
+            dateHarvested: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                field: 'date_harvested'
+            },
+            storageKey: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: false,
+                field: 'storage_key'
+            },
+            harvestMethod: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: true,
+                field: 'harvest_method'
+            }
+        }, {
+            sequelize,
+            tableName: 'canon_album_image_harvested',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_album_image_harvested_canon_album_id_index",
+                    fields: [
+                        { name: "canon_album_id" },
+                    ]
+                },
+                {
+                    name: "canon_album_image_harvested_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "canon_album_image_harvested_url_unique",
+                    unique: true,
+                    fields: [
+                        { name: "url" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonAlbumImageHarvested = CanonAlbumImageHarvested;

package/dist/CanonAlbumLabelRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonLabel, CanonLabelId } from './CanonLabel';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+export interface CanonAlbumLabelRelationAttributes {
+    canonAlbumId: string;
+    canonLabelId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonAlbumLabelRelationPk = "canonAlbumId" | "canonLabelId";
+export type CanonAlbumLabelRelationId = CanonAlbumLabelRelation[CanonAlbumLabelRelationPk];
+export type CanonAlbumLabelRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonAlbumLabelRelationCreationAttributes = Optional<CanonAlbumLabelRelationAttributes, CanonAlbumLabelRelationOptionalAttributes>;
+export declare class CanonAlbumLabelRelation extends Model<CanonAlbumLabelRelationAttributes, CanonAlbumLabelRelationCreationAttributes> implements CanonAlbumLabelRelationAttributes {
+    canonAlbumId: string;
+    canonLabelId: string;
+    createDate: Date;
+    updateDate: Date;
+    canonLabel: CanonLabel;
+    getCanonLabel: Sequelize.BelongsToGetAssociationMixin<CanonLabel>;
+    setCanonLabel: Sequelize.BelongsToSetAssociationMixin<CanonLabel, CanonLabelId>;
+    createCanonLabel: Sequelize.BelongsToCreateAssociationMixin<CanonLabel>;
+    canonAlbum: PlatformAlbum;
+    getCanonAlbum: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+    setCanonAlbum: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    createCanonAlbum: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonAlbumLabelRelation;
+}

package/dist/CanonAlbumLabelRelation.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.CanonAlbumLabelRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonAlbumLabelRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonAlbumLabelRelation.init({
+            canonAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'platform_album',
+                    key: 'id'
+                },
+                field: 'canon_album_id'
+            },
+            canonLabelId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'canon_label',
+                    key: 'id'
+                },
+                field: 'canon_label_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_label_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_album_label_relation_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "canon_album_id" },
+                        { name: "canon_label_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonAlbumLabelRelation = CanonAlbumLabelRelation;

package/dist/CanonAlbumTrackRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+export interface CanonAlbumTrackRelationAttributes {
+    canonAlbumId: string;
+    canonTrackId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonAlbumTrackRelationPk = "canonAlbumId" | "canonTrackId";
+export type CanonAlbumTrackRelationId = CanonAlbumTrackRelation[CanonAlbumTrackRelationPk];
+export type CanonAlbumTrackRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonAlbumTrackRelationCreationAttributes = Optional<CanonAlbumTrackRelationAttributes, CanonAlbumTrackRelationOptionalAttributes>;
+export declare class CanonAlbumTrackRelation extends Model<CanonAlbumTrackRelationAttributes, CanonAlbumTrackRelationCreationAttributes> implements CanonAlbumTrackRelationAttributes {
+    canonAlbumId: string;
+    canonTrackId: string;
+    createDate: Date;
+    updateDate: Date;
+    canonAlbum: CanonAlbum;
+    getCanonAlbum: Sequelize.BelongsToGetAssociationMixin<CanonAlbum>;
+    setCanonAlbum: Sequelize.BelongsToSetAssociationMixin<CanonAlbum, CanonAlbumId>;
+    createCanonAlbum: Sequelize.BelongsToCreateAssociationMixin<CanonAlbum>;
+    canonTrack: CanonTrack;
+    getCanonTrack: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
+    setCanonTrack: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
+    createCanonTrack: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonAlbumTrackRelation;
+}

package/dist/CanonAlbumTrackRelation.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.CanonAlbumTrackRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonAlbumTrackRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonAlbumTrackRelation.init({
+            canonAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'canon_album',
+                    key: 'id'
+                },
+                field: 'canon_album_id'
+            },
+            canonTrackId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'canon_track',
+                    key: 'id'
+                },
+                field: 'canon_track_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_track_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_album_track_relation_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "canon_album_id" },
+                        { name: "canon_track_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonAlbumTrackRelation = CanonAlbumTrackRelation;

package/dist/CanonArtist.d.ts

@@ -0,0 +1,91 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonArtistAlbumRelation, CanonArtistAlbumRelationId } from './CanonArtistAlbumRelation';
+import type { CanonArtistImageHarvested, CanonArtistImageHarvestedId } from './CanonArtistImageHarvested';
+import type { CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId } from './CanonToPlatformArtistRelation';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+export interface CanonArtistAttributes {
+    id: string;
+    name: string;
+    asciiName: string;
+    description?: string;
+    hasPhoto: boolean;
+    createDate: Date;
+    updateDate: Date;
+    hasThumbnailPhoto?: boolean;
+    images?: object;
+    lastImageHarvestAttempt?: Date;
+}
+export type CanonArtistPk = "id";
+export type CanonArtistId = CanonArtist[CanonArtistPk];
+export type CanonArtistOptionalAttributes = "id" | "description" | "createDate" | "updateDate" | "hasThumbnailPhoto" | "images" | "lastImageHarvestAttempt";
+export type CanonArtistCreationAttributes = Optional<CanonArtistAttributes, CanonArtistOptionalAttributes>;
+export declare class CanonArtist extends Model<CanonArtistAttributes, CanonArtistCreationAttributes> implements CanonArtistAttributes {
+    id: string;
+    name: string;
+    asciiName: string;
+    description?: string;
+    hasPhoto: boolean;
+    createDate: Date;
+    updateDate: Date;
+    hasThumbnailPhoto?: boolean;
+    images?: object;
+    lastImageHarvestAttempt?: Date;
+    canonArtistAlbumRelations: CanonArtistAlbumRelation[];
+    getCanonArtistAlbumRelations: Sequelize.HasManyGetAssociationsMixin<CanonArtistAlbumRelation>;
+    setCanonArtistAlbumRelations: Sequelize.HasManySetAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    addCanonArtistAlbumRelation: Sequelize.HasManyAddAssociationMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    addCanonArtistAlbumRelations: Sequelize.HasManyAddAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    createCanonArtistAlbumRelation: Sequelize.HasManyCreateAssociationMixin<CanonArtistAlbumRelation>;
+    removeCanonArtistAlbumRelation: Sequelize.HasManyRemoveAssociationMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    removeCanonArtistAlbumRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    hasCanonArtistAlbumRelation: Sequelize.HasManyHasAssociationMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    hasCanonArtistAlbumRelations: Sequelize.HasManyHasAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    countCanonArtistAlbumRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonArtistImageHarvesteds: CanonArtistImageHarvested[];
+    getCanonArtistImageHarvesteds: Sequelize.HasManyGetAssociationsMixin<CanonArtistImageHarvested>;
+    setCanonArtistImageHarvesteds: Sequelize.HasManySetAssociationsMixin<CanonArtistImageHarvested, CanonArtistImageHarvestedId>;
+    addCanonArtistImageHarvested: Sequelize.HasManyAddAssociationMixin<CanonArtistImageHarvested, CanonArtistImageHarvestedId>;
+    addCanonArtistImageHarvesteds: Sequelize.HasManyAddAssociationsMixin<CanonArtistImageHarvested, CanonArtistImageHarvestedId>;
+    createCanonArtistImageHarvested: Sequelize.HasManyCreateAssociationMixin<CanonArtistImageHarvested>;
+    removeCanonArtistImageHarvested: Sequelize.HasManyRemoveAssociationMixin<CanonArtistImageHarvested, CanonArtistImageHarvestedId>;
+    removeCanonArtistImageHarvesteds: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistImageHarvested, CanonArtistImageHarvestedId>;
+    hasCanonArtistImageHarvested: Sequelize.HasManyHasAssociationMixin<CanonArtistImageHarvested, CanonArtistImageHarvestedId>;
+    hasCanonArtistImageHarvesteds: Sequelize.HasManyHasAssociationsMixin<CanonArtistImageHarvested, CanonArtistImageHarvestedId>;
+    countCanonArtistImageHarvesteds: Sequelize.HasManyCountAssociationsMixin;
+    canonToPlatformArtistRelations: CanonToPlatformArtistRelation[];
+    getCanonToPlatformArtistRelations: Sequelize.HasManyGetAssociationsMixin<CanonToPlatformArtistRelation>;
+    setCanonToPlatformArtistRelations: Sequelize.HasManySetAssociationsMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    addCanonToPlatformArtistRelation: Sequelize.HasManyAddAssociationMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    addCanonToPlatformArtistRelations: Sequelize.HasManyAddAssociationsMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    createCanonToPlatformArtistRelation: Sequelize.HasManyCreateAssociationMixin<CanonToPlatformArtistRelation>;
+    removeCanonToPlatformArtistRelation: Sequelize.HasManyRemoveAssociationMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    removeCanonToPlatformArtistRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    hasCanonToPlatformArtistRelation: Sequelize.HasManyHasAssociationMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    hasCanonToPlatformArtistRelations: Sequelize.HasManyHasAssociationsMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    countCanonToPlatformArtistRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonAlbumIdPlatformAlbumCanonArtistAlbumRelations: PlatformAlbum[];
+    getCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+    setCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    addCanonAlbumIdPlatformAlbumCanonArtistAlbumRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    addCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    createCanonAlbumIdPlatformAlbumCanonArtistAlbumRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+    removeCanonAlbumIdPlatformAlbumCanonArtistAlbumRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    removeCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    hasCanonAlbumIdPlatformAlbumCanonArtistAlbumRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    hasCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    countCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformArtistIdPlatformArtists: PlatformArtist[];
+    getPlatformArtistIdPlatformArtists: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+    setPlatformArtistIdPlatformArtists: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    addPlatformArtistIdPlatformArtist: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+    addPlatformArtistIdPlatformArtists: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    createPlatformArtistIdPlatformArtist: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+    removePlatformArtistIdPlatformArtist: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+    removePlatformArtistIdPlatformArtists: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    hasPlatformArtistIdPlatformArtist: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+    hasPlatformArtistIdPlatformArtists: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    countPlatformArtistIdPlatformArtists: Sequelize.BelongsToManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtist;
+}

package/dist/CanonArtist.js

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

package/dist/CanonArtistAlbumRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+export interface CanonArtistAlbumRelationAttributes {
+    canonArtistId: string;
+    canonAlbumId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonArtistAlbumRelationPk = "canonArtistId" | "canonAlbumId";
+export type CanonArtistAlbumRelationId = CanonArtistAlbumRelation[CanonArtistAlbumRelationPk];
+export type CanonArtistAlbumRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonArtistAlbumRelationCreationAttributes = Optional<CanonArtistAlbumRelationAttributes, CanonArtistAlbumRelationOptionalAttributes>;
+export declare class CanonArtistAlbumRelation extends Model<CanonArtistAlbumRelationAttributes, CanonArtistAlbumRelationCreationAttributes> implements CanonArtistAlbumRelationAttributes {
+    canonArtistId: string;
+    canonAlbumId: string;
+    createDate: Date;
+    updateDate: Date;
+    canonArtist: CanonArtist;
+    getCanonArtist: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+    setCanonArtist: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+    createCanonArtist: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+    canonAlbum: PlatformAlbum;
+    getCanonAlbum: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+    setCanonAlbum: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    createCanonAlbum: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtistAlbumRelation;
+}

package/dist/CanonArtistAlbumRelation.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.CanonArtistAlbumRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonArtistAlbumRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonArtistAlbumRelation.init({
+            canonArtistId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'canon_artist',
+                    key: 'id'
+                },
+                field: 'canon_artist_id'
+            },
+            canonAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'platform_album',
+                    key: 'id'
+                },
+                field: 'canon_album_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_artist_album_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_artist_album_relation_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "canon_artist_id" },
+                        { name: "canon_album_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonArtistAlbumRelation = CanonArtistAlbumRelation;

package/dist/CanonArtistExternalReferenceRelation.d.ts

@@ -0,0 +1,31 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+export interface CanonArtistExternalReferenceRelationAttributes {
+    canonArtistId: string;
+    externalReferenceId: string;
+    url: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonArtistExternalReferenceRelationPk = "canonArtistId" | "externalReferenceId";
+export type CanonArtistExternalReferenceRelationId = CanonArtistExternalReferenceRelation[CanonArtistExternalReferenceRelationPk];
+export type CanonArtistExternalReferenceRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonArtistExternalReferenceRelationCreationAttributes = Optional<CanonArtistExternalReferenceRelationAttributes, CanonArtistExternalReferenceRelationOptionalAttributes>;
+export declare class CanonArtistExternalReferenceRelation extends Model<CanonArtistExternalReferenceRelationAttributes, CanonArtistExternalReferenceRelationCreationAttributes> implements CanonArtistExternalReferenceRelationAttributes {
+    canonArtistId: string;
+    externalReferenceId: string;
+    url: string;
+    createDate: Date;
+    updateDate: Date;
+    externalReference: ExternalReference;
+    getExternalReference: Sequelize.BelongsToGetAssociationMixin<ExternalReference>;
+    setExternalReference: Sequelize.BelongsToSetAssociationMixin<ExternalReference, ExternalReferenceId>;
+    createExternalReference: Sequelize.BelongsToCreateAssociationMixin<ExternalReference>;
+    canonArtist: PlatformArtist;
+    getCanonArtist: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+    setCanonArtist: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+    createCanonArtist: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtistExternalReferenceRelation;
+}