@earbug/db-models 0.0.1

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

package/dist/CanonArtistGenreRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+export interface CanonArtistGenreRelationAttributes {
+    canonArtistId: string;
+    canonGenreId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonArtistGenreRelationPk = "canonArtistId" | "canonGenreId";
+export type CanonArtistGenreRelationId = CanonArtistGenreRelation[CanonArtistGenreRelationPk];
+export type CanonArtistGenreRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonArtistGenreRelationCreationAttributes = Optional<CanonArtistGenreRelationAttributes, CanonArtistGenreRelationOptionalAttributes>;
+export declare class CanonArtistGenreRelation extends Model<CanonArtistGenreRelationAttributes, CanonArtistGenreRelationCreationAttributes> implements CanonArtistGenreRelationAttributes {
+    canonArtistId: string;
+    canonGenreId: string;
+    createDate: Date;
+    updateDate: Date;
+    canonGenre: CanonGenre;
+    getCanonGenre: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+    setCanonGenre: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+    createCanonGenre: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+    canonArtist: PlatformArtist;
+    getCanonArtist: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+    setCanonArtist: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+    createCanonArtist: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtistGenreRelation;
+}

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

package/dist/CanonArtistImageHarvested.d.ts

@@ -0,0 +1,30 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+export interface CanonArtistImageHarvestedAttributes {
+    id: string;
+    canonArtistId: string;
+    priority?: number;
+    url?: string;
+    dateHarvested: Date;
+    storageKey: string;
+    harvestMethod?: string;
+}
+export type CanonArtistImageHarvestedPk = "id";
+export type CanonArtistImageHarvestedId = CanonArtistImageHarvested[CanonArtistImageHarvestedPk];
+export type CanonArtistImageHarvestedOptionalAttributes = "id" | "priority" | "url" | "harvestMethod";
+export type CanonArtistImageHarvestedCreationAttributes = Optional<CanonArtistImageHarvestedAttributes, CanonArtistImageHarvestedOptionalAttributes>;
+export declare class CanonArtistImageHarvested extends Model<CanonArtistImageHarvestedAttributes, CanonArtistImageHarvestedCreationAttributes> implements CanonArtistImageHarvestedAttributes {
+    id: string;
+    canonArtistId: string;
+    priority?: number;
+    url?: string;
+    dateHarvested: Date;
+    storageKey: string;
+    harvestMethod?: string;
+    canonArtist: CanonArtist;
+    getCanonArtist: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+    setCanonArtist: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+    createCanonArtist: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtistImageHarvested;
+}

package/dist/CanonArtistImageHarvested.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanonArtistImageHarvested = void 0;
+const sequelize_1 = require("sequelize");
+class CanonArtistImageHarvested extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonArtistImageHarvested.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            canonArtistId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'canon_artist',
+                    key: 'id'
+                },
+                field: 'canon_artist_id'
+            },
+            priority: {
+                type: sequelize_1.DataTypes.DECIMAL,
+                allowNull: true,
+                defaultValue: 0
+            },
+            url: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true
+            },
+            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_artist_image_harvested',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_artist_image_harvested_canon_artist_id_index",
+                    fields: [
+                        { name: "canon_artist_id" },
+                    ]
+                },
+                {
+                    name: "canon_artist_image_harvested_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonArtistImageHarvested = CanonArtistImageHarvested;

package/dist/CanonArtistMemberRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonMember, CanonMemberId } from './CanonMember';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+export interface CanonArtistMemberRelationAttributes {
+    canonArtistId: string;
+    canonMemberId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonArtistMemberRelationPk = "canonArtistId" | "canonMemberId";
+export type CanonArtistMemberRelationId = CanonArtistMemberRelation[CanonArtistMemberRelationPk];
+export type CanonArtistMemberRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonArtistMemberRelationCreationAttributes = Optional<CanonArtistMemberRelationAttributes, CanonArtistMemberRelationOptionalAttributes>;
+export declare class CanonArtistMemberRelation extends Model<CanonArtistMemberRelationAttributes, CanonArtistMemberRelationCreationAttributes> implements CanonArtistMemberRelationAttributes {
+    canonArtistId: string;
+    canonMemberId: string;
+    createDate: Date;
+    updateDate: Date;
+    canonMember: CanonMember;
+    getCanonMember: Sequelize.BelongsToGetAssociationMixin<CanonMember>;
+    setCanonMember: Sequelize.BelongsToSetAssociationMixin<CanonMember, CanonMemberId>;
+    createCanonMember: Sequelize.BelongsToCreateAssociationMixin<CanonMember>;
+    canonArtist: PlatformArtist;
+    getCanonArtist: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+    setCanonArtist: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+    createCanonArtist: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtistMemberRelation;
+}

package/dist/CanonArtistMemberRelation.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.CanonArtistMemberRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonArtistMemberRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonArtistMemberRelation.init({
+            canonArtistId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'platform_artist',
+                    key: 'id'
+                },
+                field: 'canon_artist_id'
+            },
+            canonMemberId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'canon_member',
+                    key: 'id'
+                },
+                field: 'canon_member_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_member_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_artist_member_relation_pk",
+                    unique: true,
+                    fields: [
+                        { name: "canon_artist_id" },
+                        { name: "canon_member_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonArtistMemberRelation = CanonArtistMemberRelation;

package/dist/CanonArtistTrackRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+export interface CanonArtistTrackRelationAttributes {
+    canonArtistId: string;
+    canonTrackId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonArtistTrackRelationPk = "canonArtistId" | "canonTrackId";
+export type CanonArtistTrackRelationId = CanonArtistTrackRelation[CanonArtistTrackRelationPk];
+export type CanonArtistTrackRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonArtistTrackRelationCreationAttributes = Optional<CanonArtistTrackRelationAttributes, CanonArtistTrackRelationOptionalAttributes>;
+export declare class CanonArtistTrackRelation extends Model<CanonArtistTrackRelationAttributes, CanonArtistTrackRelationCreationAttributes> implements CanonArtistTrackRelationAttributes {
+    canonArtistId: string;
+    canonTrackId: string;
+    createDate: Date;
+    updateDate: Date;
+    canonArtist: PlatformArtist;
+    getCanonArtist: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+    setCanonArtist: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+    createCanonArtist: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+    canonTrack: PlatformTrack;
+    getCanonTrack: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+    setCanonTrack: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+    createCanonTrack: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonArtistTrackRelation;
+}

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

package/dist/CanonGenre.d.ts

@@ -0,0 +1,133 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonAlbumGenreRelation, CanonAlbumGenreRelationId } from './CanonAlbumGenreRelation';
+import type { CanonArtistGenreRelation, CanonArtistGenreRelationId } from './CanonArtistGenreRelation';
+import type { CanonGenreExternalReferenceRelation, CanonGenreExternalReferenceRelationId } from './CanonGenreExternalReferenceRelation';
+import type { CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId } from './CanonToPlatformGenreRelation';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+import type { JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId } from './JukeboxCanonGenreRelation';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+export interface CanonGenreAttributes {
+    id: string;
+    name: string;
+    asciiName: string;
+    description: string;
+    parentGenreId?: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonGenrePk = "id";
+export type CanonGenreId = CanonGenre[CanonGenrePk];
+export type CanonGenreOptionalAttributes = "id" | "parentGenreId" | "createDate" | "updateDate";
+export type CanonGenreCreationAttributes = Optional<CanonGenreAttributes, CanonGenreOptionalAttributes>;
+export declare class CanonGenre extends Model<CanonGenreAttributes, CanonGenreCreationAttributes> implements CanonGenreAttributes {
+    id: string;
+    name: string;
+    asciiName: string;
+    description: string;
+    parentGenreId?: string;
+    createDate: Date;
+    updateDate: Date;
+    canonAlbumGenreRelations: CanonAlbumGenreRelation[];
+    getCanonAlbumGenreRelations: Sequelize.HasManyGetAssociationsMixin<CanonAlbumGenreRelation>;
+    setCanonAlbumGenreRelations: Sequelize.HasManySetAssociationsMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    addCanonAlbumGenreRelation: Sequelize.HasManyAddAssociationMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    addCanonAlbumGenreRelations: Sequelize.HasManyAddAssociationsMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    createCanonAlbumGenreRelation: Sequelize.HasManyCreateAssociationMixin<CanonAlbumGenreRelation>;
+    removeCanonAlbumGenreRelation: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    removeCanonAlbumGenreRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    hasCanonAlbumGenreRelation: Sequelize.HasManyHasAssociationMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    hasCanonAlbumGenreRelations: Sequelize.HasManyHasAssociationsMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    countCanonAlbumGenreRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonArtistGenreRelations: CanonArtistGenreRelation[];
+    getCanonArtistGenreRelations: Sequelize.HasManyGetAssociationsMixin<CanonArtistGenreRelation>;
+    setCanonArtistGenreRelations: Sequelize.HasManySetAssociationsMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    addCanonArtistGenreRelation: Sequelize.HasManyAddAssociationMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    addCanonArtistGenreRelations: Sequelize.HasManyAddAssociationsMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    createCanonArtistGenreRelation: Sequelize.HasManyCreateAssociationMixin<CanonArtistGenreRelation>;
+    removeCanonArtistGenreRelation: Sequelize.HasManyRemoveAssociationMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    removeCanonArtistGenreRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    hasCanonArtistGenreRelation: Sequelize.HasManyHasAssociationMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    hasCanonArtistGenreRelations: Sequelize.HasManyHasAssociationsMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    countCanonArtistGenreRelations: Sequelize.HasManyCountAssociationsMixin;
+    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;
+    canonToPlatformGenreRelations: CanonToPlatformGenreRelation[];
+    getCanonToPlatformGenreRelations: Sequelize.HasManyGetAssociationsMixin<CanonToPlatformGenreRelation>;
+    setCanonToPlatformGenreRelations: Sequelize.HasManySetAssociationsMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+    addCanonToPlatformGenreRelation: Sequelize.HasManyAddAssociationMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+    addCanonToPlatformGenreRelations: Sequelize.HasManyAddAssociationsMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+    createCanonToPlatformGenreRelation: Sequelize.HasManyCreateAssociationMixin<CanonToPlatformGenreRelation>;
+    removeCanonToPlatformGenreRelation: Sequelize.HasManyRemoveAssociationMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+    removeCanonToPlatformGenreRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+    hasCanonToPlatformGenreRelation: Sequelize.HasManyHasAssociationMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+    hasCanonToPlatformGenreRelations: Sequelize.HasManyHasAssociationsMixin<CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId>;
+    countCanonToPlatformGenreRelations: Sequelize.HasManyCountAssociationsMixin;
+    externalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations: ExternalReference[];
+    getExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations: Sequelize.BelongsToManyGetAssociationsMixin<ExternalReference>;
+    setExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations: Sequelize.BelongsToManySetAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    addExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelation: Sequelize.BelongsToManyAddAssociationMixin<ExternalReference, ExternalReferenceId>;
+    addExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations: Sequelize.BelongsToManyAddAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    createExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelation: Sequelize.BelongsToManyCreateAssociationMixin<ExternalReference>;
+    removeExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelation: Sequelize.BelongsToManyRemoveAssociationMixin<ExternalReference, ExternalReferenceId>;
+    removeExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    hasExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelation: Sequelize.BelongsToManyHasAssociationMixin<ExternalReference, ExternalReferenceId>;
+    hasExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations: Sequelize.BelongsToManyHasAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    countExternalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    jukeboxCanonGenreRelations: JukeboxCanonGenreRelation[];
+    getJukeboxCanonGenreRelations: Sequelize.HasManyGetAssociationsMixin<JukeboxCanonGenreRelation>;
+    setJukeboxCanonGenreRelations: Sequelize.HasManySetAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    addJukeboxCanonGenreRelation: Sequelize.HasManyAddAssociationMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    addJukeboxCanonGenreRelations: Sequelize.HasManyAddAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    createJukeboxCanonGenreRelation: Sequelize.HasManyCreateAssociationMixin<JukeboxCanonGenreRelation>;
+    removeJukeboxCanonGenreRelation: Sequelize.HasManyRemoveAssociationMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    removeJukeboxCanonGenreRelations: Sequelize.HasManyRemoveAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    hasJukeboxCanonGenreRelation: Sequelize.HasManyHasAssociationMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    hasJukeboxCanonGenreRelations: Sequelize.HasManyHasAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
+    countJukeboxCanonGenreRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonAlbumIdPlatformAlbums: PlatformAlbum[];
+    getCanonAlbumIdPlatformAlbums: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+    setCanonAlbumIdPlatformAlbums: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    addCanonAlbumIdPlatformAlbum: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    addCanonAlbumIdPlatformAlbums: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    createCanonAlbumIdPlatformAlbum: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+    removeCanonAlbumIdPlatformAlbum: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    removeCanonAlbumIdPlatformAlbums: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    hasCanonAlbumIdPlatformAlbum: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    hasCanonAlbumIdPlatformAlbums: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    countCanonAlbumIdPlatformAlbums: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonArtistIdPlatformArtistCanonArtistGenreRelations: PlatformArtist[];
+    getCanonArtistIdPlatformArtistCanonArtistGenreRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+    setCanonArtistIdPlatformArtistCanonArtistGenreRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    addCanonArtistIdPlatformArtistCanonArtistGenreRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+    addCanonArtistIdPlatformArtistCanonArtistGenreRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    createCanonArtistIdPlatformArtistCanonArtistGenreRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+    removeCanonArtistIdPlatformArtistCanonArtistGenreRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+    removeCanonArtistIdPlatformArtistCanonArtistGenreRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    hasCanonArtistIdPlatformArtistCanonArtistGenreRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+    hasCanonArtistIdPlatformArtistCanonArtistGenreRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    countCanonArtistIdPlatformArtistCanonArtistGenreRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformGenreIdPlatformGenres: PlatformGenre[];
+    getPlatformGenreIdPlatformGenres: Sequelize.BelongsToManyGetAssociationsMixin<PlatformGenre>;
+    setPlatformGenreIdPlatformGenres: Sequelize.BelongsToManySetAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    addPlatformGenreIdPlatformGenre: Sequelize.BelongsToManyAddAssociationMixin<PlatformGenre, PlatformGenreId>;
+    addPlatformGenreIdPlatformGenres: Sequelize.BelongsToManyAddAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    createPlatformGenreIdPlatformGenre: Sequelize.BelongsToManyCreateAssociationMixin<PlatformGenre>;
+    removePlatformGenreIdPlatformGenre: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformGenre, PlatformGenreId>;
+    removePlatformGenreIdPlatformGenres: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    hasPlatformGenreIdPlatformGenre: Sequelize.BelongsToManyHasAssociationMixin<PlatformGenre, PlatformGenreId>;
+    hasPlatformGenreIdPlatformGenres: Sequelize.BelongsToManyHasAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    countPlatformGenreIdPlatformGenres: Sequelize.BelongsToManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonGenre;
+}