@earbug/db-models 0.0.1

package/dist/CanonMemberExternalReferenceRelation.d.ts

@@ -0,0 +1,33 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonMember, CanonMemberId } from './CanonMember';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+export interface CanonMemberExternalReferenceRelationAttributes {
+    id: string;
+    canonMemberId: string;
+    externalReferenceId: string;
+    url: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonMemberExternalReferenceRelationPk = "canonMemberId" | "externalReferenceId";
+export type CanonMemberExternalReferenceRelationId = CanonMemberExternalReferenceRelation[CanonMemberExternalReferenceRelationPk];
+export type CanonMemberExternalReferenceRelationOptionalAttributes = "id" | "createDate" | "updateDate";
+export type CanonMemberExternalReferenceRelationCreationAttributes = Optional<CanonMemberExternalReferenceRelationAttributes, CanonMemberExternalReferenceRelationOptionalAttributes>;
+export declare class CanonMemberExternalReferenceRelation extends Model<CanonMemberExternalReferenceRelationAttributes, CanonMemberExternalReferenceRelationCreationAttributes> implements CanonMemberExternalReferenceRelationAttributes {
+    id: string;
+    canonMemberId: string;
+    externalReferenceId: string;
+    url: string;
+    createDate: Date;
+    updateDate: Date;
+    canonMember: CanonMember;
+    getCanonMember: Sequelize.BelongsToGetAssociationMixin<CanonMember>;
+    setCanonMember: Sequelize.BelongsToSetAssociationMixin<CanonMember, CanonMemberId>;
+    createCanonMember: Sequelize.BelongsToCreateAssociationMixin<CanonMember>;
+    externalReference: ExternalReference;
+    getExternalReference: Sequelize.BelongsToGetAssociationMixin<ExternalReference>;
+    setExternalReference: Sequelize.BelongsToSetAssociationMixin<ExternalReference, ExternalReferenceId>;
+    createExternalReference: Sequelize.BelongsToCreateAssociationMixin<ExternalReference>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonMemberExternalReferenceRelation;
+}

package/dist/CanonMemberExternalReferenceRelation.js

@@ -0,0 +1,91 @@
+"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.CanonMemberExternalReferenceRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonMemberExternalReferenceRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonMemberExternalReferenceRelation.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1')
+            },
+            canonMemberId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'canon_member',
+                    key: 'id'
+                },
+                field: 'canon_member_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_member_external_reference_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_member_external_reference_relation_pk",
+                    unique: true,
+                    fields: [
+                        { name: "canon_member_id" },
+                        { name: "external_reference_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonMemberExternalReferenceRelation = CanonMemberExternalReferenceRelation;

package/dist/CanonToPlatformAlbumRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+export interface CanonToPlatformAlbumRelationAttributes {
+    canonAlbumId: string;
+    platformAlbumId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonToPlatformAlbumRelationPk = "canonAlbumId" | "platformAlbumId";
+export type CanonToPlatformAlbumRelationId = CanonToPlatformAlbumRelation[CanonToPlatformAlbumRelationPk];
+export type CanonToPlatformAlbumRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonToPlatformAlbumRelationCreationAttributes = Optional<CanonToPlatformAlbumRelationAttributes, CanonToPlatformAlbumRelationOptionalAttributes>;
+export declare class CanonToPlatformAlbumRelation extends Model<CanonToPlatformAlbumRelationAttributes, CanonToPlatformAlbumRelationCreationAttributes> implements CanonToPlatformAlbumRelationAttributes {
+    canonAlbumId: string;
+    platformAlbumId: string;
+    createDate: Date;
+    updateDate: Date;
+    canonAlbum: CanonAlbum;
+    getCanonAlbum: Sequelize.BelongsToGetAssociationMixin<CanonAlbum>;
+    setCanonAlbum: Sequelize.BelongsToSetAssociationMixin<CanonAlbum, CanonAlbumId>;
+    createCanonAlbum: Sequelize.BelongsToCreateAssociationMixin<CanonAlbum>;
+    platformAlbum: PlatformAlbum;
+    getPlatformAlbum: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+    setPlatformAlbum: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    createPlatformAlbum: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonToPlatformAlbumRelation;
+}

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

package/dist/CanonToPlatformArtistRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+export interface CanonToPlatformArtistRelationAttributes {
+    canonArtistId: string;
+    platformArtistId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonToPlatformArtistRelationPk = "canonArtistId" | "platformArtistId";
+export type CanonToPlatformArtistRelationId = CanonToPlatformArtistRelation[CanonToPlatformArtistRelationPk];
+export type CanonToPlatformArtistRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonToPlatformArtistRelationCreationAttributes = Optional<CanonToPlatformArtistRelationAttributes, CanonToPlatformArtistRelationOptionalAttributes>;
+export declare class CanonToPlatformArtistRelation extends Model<CanonToPlatformArtistRelationAttributes, CanonToPlatformArtistRelationCreationAttributes> implements CanonToPlatformArtistRelationAttributes {
+    canonArtistId: string;
+    platformArtistId: string;
+    createDate: Date;
+    updateDate: Date;
+    canonArtist: CanonArtist;
+    getCanonArtist: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+    setCanonArtist: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+    createCanonArtist: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+    platformArtist: PlatformArtist;
+    getPlatformArtist: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+    setPlatformArtist: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+    createPlatformArtist: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonToPlatformArtistRelation;
+}

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

package/dist/CanonToPlatformGenreRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+export interface CanonToPlatformGenreRelationAttributes {
+    canonGenreId: string;
+    platformGenreId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonToPlatformGenreRelationPk = "canonGenreId" | "platformGenreId";
+export type CanonToPlatformGenreRelationId = CanonToPlatformGenreRelation[CanonToPlatformGenreRelationPk];
+export type CanonToPlatformGenreRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonToPlatformGenreRelationCreationAttributes = Optional<CanonToPlatformGenreRelationAttributes, CanonToPlatformGenreRelationOptionalAttributes>;
+export declare class CanonToPlatformGenreRelation extends Model<CanonToPlatformGenreRelationAttributes, CanonToPlatformGenreRelationCreationAttributes> implements CanonToPlatformGenreRelationAttributes {
+    canonGenreId: string;
+    platformGenreId: string;
+    createDate: Date;
+    updateDate: Date;
+    canonGenre: CanonGenre;
+    getCanonGenre: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+    setCanonGenre: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+    createCanonGenre: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+    platformGenre: PlatformGenre;
+    getPlatformGenre: Sequelize.BelongsToGetAssociationMixin<PlatformGenre>;
+    setPlatformGenre: Sequelize.BelongsToSetAssociationMixin<PlatformGenre, PlatformGenreId>;
+    createPlatformGenre: Sequelize.BelongsToCreateAssociationMixin<PlatformGenre>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonToPlatformGenreRelation;
+}

package/dist/CanonToPlatformGenreRelation.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.CanonToPlatformGenreRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class CanonToPlatformGenreRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return CanonToPlatformGenreRelation.init({
+            canonGenreId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'canon_genre',
+                    key: 'id'
+                },
+                field: 'canon_genre_id'
+            },
+            platformGenreId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'platform_genre',
+                    key: 'id'
+                },
+                field: 'platform_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_to_platform_genre_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "canon_to_platform_genre_relation_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "canon_genre_id" },
+                        { name: "platform_genre_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.CanonToPlatformGenreRelation = CanonToPlatformGenreRelation;

package/dist/CanonToPlatformTrackRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+export interface CanonToPlatformTrackRelationAttributes {
+    canonTrackId: string;
+    platformTrackId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type CanonToPlatformTrackRelationPk = "canonTrackId" | "platformTrackId";
+export type CanonToPlatformTrackRelationId = CanonToPlatformTrackRelation[CanonToPlatformTrackRelationPk];
+export type CanonToPlatformTrackRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonToPlatformTrackRelationCreationAttributes = Optional<CanonToPlatformTrackRelationAttributes, CanonToPlatformTrackRelationOptionalAttributes>;
+export declare class CanonToPlatformTrackRelation extends Model<CanonToPlatformTrackRelationAttributes, CanonToPlatformTrackRelationCreationAttributes> implements CanonToPlatformTrackRelationAttributes {
+    canonTrackId: string;
+    platformTrackId: string;
+    createDate: Date;
+    updateDate: Date;
+    canonTrack: CanonTrack;
+    getCanonTrack: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
+    setCanonTrack: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
+    createCanonTrack: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+    platformTrack: PlatformTrack;
+    getPlatformTrack: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+    setPlatformTrack: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrack: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonToPlatformTrackRelation;
+}

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

package/dist/CanonTrack.d.ts

@@ -0,0 +1,89 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { CanonAlbumTrackRelation, CanonAlbumTrackRelationId } from './CanonAlbumTrackRelation';
+import type { CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId } from './CanonToPlatformTrackRelation';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+export interface CanonTrackAttributes {
+    id: string;
+    name: string;
+    asciiName: string;
+    explicit: boolean;
+    discNumber?: number;
+    discTrackNumber?: number;
+    createDate: Date;
+    updateDate: Date;
+    durationMs: number;
+}
+export type CanonTrackPk = "id";
+export type CanonTrackId = CanonTrack[CanonTrackPk];
+export type CanonTrackOptionalAttributes = "id" | "discNumber" | "discTrackNumber" | "createDate" | "updateDate";
+export type CanonTrackCreationAttributes = Optional<CanonTrackAttributes, CanonTrackOptionalAttributes>;
+export declare class CanonTrack extends Model<CanonTrackAttributes, CanonTrackCreationAttributes> implements CanonTrackAttributes {
+    id: string;
+    name: string;
+    asciiName: string;
+    explicit: boolean;
+    discNumber?: number;
+    discTrackNumber?: number;
+    createDate: Date;
+    updateDate: Date;
+    durationMs: number;
+    canonAlbumIdCanonAlbumCanonAlbumTrackRelations: CanonAlbum[];
+    getCanonAlbumIdCanonAlbumCanonAlbumTrackRelations: Sequelize.BelongsToManyGetAssociationsMixin<CanonAlbum>;
+    setCanonAlbumIdCanonAlbumCanonAlbumTrackRelations: Sequelize.BelongsToManySetAssociationsMixin<CanonAlbum, CanonAlbumId>;
+    addCanonAlbumIdCanonAlbumCanonAlbumTrackRelation: Sequelize.BelongsToManyAddAssociationMixin<CanonAlbum, CanonAlbumId>;
+    addCanonAlbumIdCanonAlbumCanonAlbumTrackRelations: Sequelize.BelongsToManyAddAssociationsMixin<CanonAlbum, CanonAlbumId>;
+    createCanonAlbumIdCanonAlbumCanonAlbumTrackRelation: Sequelize.BelongsToManyCreateAssociationMixin<CanonAlbum>;
+    removeCanonAlbumIdCanonAlbumCanonAlbumTrackRelation: Sequelize.BelongsToManyRemoveAssociationMixin<CanonAlbum, CanonAlbumId>;
+    removeCanonAlbumIdCanonAlbumCanonAlbumTrackRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonAlbum, CanonAlbumId>;
+    hasCanonAlbumIdCanonAlbumCanonAlbumTrackRelation: Sequelize.BelongsToManyHasAssociationMixin<CanonAlbum, CanonAlbumId>;
+    hasCanonAlbumIdCanonAlbumCanonAlbumTrackRelations: Sequelize.BelongsToManyHasAssociationsMixin<CanonAlbum, CanonAlbumId>;
+    countCanonAlbumIdCanonAlbumCanonAlbumTrackRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    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;
+    canonToPlatformTrackRelations: CanonToPlatformTrackRelation[];
+    getCanonToPlatformTrackRelations: Sequelize.HasManyGetAssociationsMixin<CanonToPlatformTrackRelation>;
+    setCanonToPlatformTrackRelations: Sequelize.HasManySetAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+    addCanonToPlatformTrackRelation: Sequelize.HasManyAddAssociationMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+    addCanonToPlatformTrackRelations: Sequelize.HasManyAddAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+    createCanonToPlatformTrackRelation: Sequelize.HasManyCreateAssociationMixin<CanonToPlatformTrackRelation>;
+    removeCanonToPlatformTrackRelation: Sequelize.HasManyRemoveAssociationMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+    removeCanonToPlatformTrackRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+    hasCanonToPlatformTrackRelation: Sequelize.HasManyHasAssociationMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+    hasCanonToPlatformTrackRelations: Sequelize.HasManyHasAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+    countCanonToPlatformTrackRelations: Sequelize.HasManyCountAssociationsMixin;
+    jukeboxQueueEntries: JukeboxQueueEntry[];
+    getJukeboxQueueEntries: Sequelize.HasManyGetAssociationsMixin<JukeboxQueueEntry>;
+    setJukeboxQueueEntries: Sequelize.HasManySetAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    addJukeboxQueueEntry: Sequelize.HasManyAddAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    addJukeboxQueueEntries: Sequelize.HasManyAddAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    createJukeboxQueueEntry: Sequelize.HasManyCreateAssociationMixin<JukeboxQueueEntry>;
+    removeJukeboxQueueEntry: Sequelize.HasManyRemoveAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    removeJukeboxQueueEntries: Sequelize.HasManyRemoveAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    hasJukeboxQueueEntry: Sequelize.HasManyHasAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    hasJukeboxQueueEntries: Sequelize.HasManyHasAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    countJukeboxQueueEntries: Sequelize.HasManyCountAssociationsMixin;
+    platformTrackIdPlatformTracks: PlatformTrack[];
+    getPlatformTrackIdPlatformTracks: Sequelize.BelongsToManyGetAssociationsMixin<PlatformTrack>;
+    setPlatformTrackIdPlatformTracks: Sequelize.BelongsToManySetAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    addPlatformTrackIdPlatformTrack: Sequelize.BelongsToManyAddAssociationMixin<PlatformTrack, PlatformTrackId>;
+    addPlatformTrackIdPlatformTracks: Sequelize.BelongsToManyAddAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrackIdPlatformTrack: Sequelize.BelongsToManyCreateAssociationMixin<PlatformTrack>;
+    removePlatformTrackIdPlatformTrack: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformTrack, PlatformTrackId>;
+    removePlatformTrackIdPlatformTracks: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    hasPlatformTrackIdPlatformTrack: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
+    hasPlatformTrackIdPlatformTracks: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    countPlatformTrackIdPlatformTracks: Sequelize.BelongsToManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof CanonTrack;
+}