@earbug/db-models 0.0.1

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

package/dist/PlatformGenre.d.ts

@@ -0,0 +1,122 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { CanonToPlatformGenreRelation, CanonToPlatformGenreRelationId } from './CanonToPlatformGenreRelation';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId } from './PlatformAlbumGenreRelation';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformArtistGenreRelation, PlatformArtistGenreRelationId } from './PlatformArtistGenreRelation';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { PlatformTrackGenreRelation, PlatformTrackGenreRelationId } from './PlatformTrackGenreRelation';
+export interface PlatformGenreAttributes {
+    id: string;
+    platformId: number;
+    name: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type PlatformGenrePk = "id";
+export type PlatformGenreId = PlatformGenre[PlatformGenrePk];
+export type PlatformGenreOptionalAttributes = "id" | "createDate" | "updateDate";
+export type PlatformGenreCreationAttributes = Optional<PlatformGenreAttributes, PlatformGenreOptionalAttributes>;
+export declare class PlatformGenre extends Model<PlatformGenreAttributes, PlatformGenreCreationAttributes> implements PlatformGenreAttributes {
+    id: string;
+    platformId: number;
+    name: string;
+    createDate: Date;
+    updateDate: Date;
+    platform: Platform;
+    getPlatform: Sequelize.BelongsToGetAssociationMixin<Platform>;
+    setPlatform: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+    createPlatform: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+    canonGenreIdCanonGenreCanonToPlatformGenreRelations: CanonGenre[];
+    getCanonGenreIdCanonGenreCanonToPlatformGenreRelations: Sequelize.BelongsToManyGetAssociationsMixin<CanonGenre>;
+    setCanonGenreIdCanonGenreCanonToPlatformGenreRelations: Sequelize.BelongsToManySetAssociationsMixin<CanonGenre, CanonGenreId>;
+    addCanonGenreIdCanonGenreCanonToPlatformGenreRelation: Sequelize.BelongsToManyAddAssociationMixin<CanonGenre, CanonGenreId>;
+    addCanonGenreIdCanonGenreCanonToPlatformGenreRelations: Sequelize.BelongsToManyAddAssociationsMixin<CanonGenre, CanonGenreId>;
+    createCanonGenreIdCanonGenreCanonToPlatformGenreRelation: Sequelize.BelongsToManyCreateAssociationMixin<CanonGenre>;
+    removeCanonGenreIdCanonGenreCanonToPlatformGenreRelation: Sequelize.BelongsToManyRemoveAssociationMixin<CanonGenre, CanonGenreId>;
+    removeCanonGenreIdCanonGenreCanonToPlatformGenreRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonGenre, CanonGenreId>;
+    hasCanonGenreIdCanonGenreCanonToPlatformGenreRelation: Sequelize.BelongsToManyHasAssociationMixin<CanonGenre, CanonGenreId>;
+    hasCanonGenreIdCanonGenreCanonToPlatformGenreRelations: Sequelize.BelongsToManyHasAssociationsMixin<CanonGenre, CanonGenreId>;
+    countCanonGenreIdCanonGenreCanonToPlatformGenreRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    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;
+    platformAlbumIdPlatformAlbumPlatformAlbumGenreRelations: PlatformAlbum[];
+    getPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+    setPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    addPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    addPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    createPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+    removePlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    removePlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    hasPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    hasPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    countPlatformAlbumIdPlatformAlbumPlatformAlbumGenreRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformAlbumGenreRelations: PlatformAlbumGenreRelation[];
+    getPlatformAlbumGenreRelations: Sequelize.HasManyGetAssociationsMixin<PlatformAlbumGenreRelation>;
+    setPlatformAlbumGenreRelations: Sequelize.HasManySetAssociationsMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    addPlatformAlbumGenreRelation: Sequelize.HasManyAddAssociationMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    addPlatformAlbumGenreRelations: Sequelize.HasManyAddAssociationsMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    createPlatformAlbumGenreRelation: Sequelize.HasManyCreateAssociationMixin<PlatformAlbumGenreRelation>;
+    removePlatformAlbumGenreRelation: Sequelize.HasManyRemoveAssociationMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    removePlatformAlbumGenreRelations: Sequelize.HasManyRemoveAssociationsMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    hasPlatformAlbumGenreRelation: Sequelize.HasManyHasAssociationMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    hasPlatformAlbumGenreRelations: Sequelize.HasManyHasAssociationsMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    countPlatformAlbumGenreRelations: Sequelize.HasManyCountAssociationsMixin;
+    platformArtistIdPlatformArtistPlatformArtistGenreRelations: PlatformArtist[];
+    getPlatformArtistIdPlatformArtistPlatformArtistGenreRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+    setPlatformArtistIdPlatformArtistPlatformArtistGenreRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    addPlatformArtistIdPlatformArtistPlatformArtistGenreRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+    addPlatformArtistIdPlatformArtistPlatformArtistGenreRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    createPlatformArtistIdPlatformArtistPlatformArtistGenreRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+    removePlatformArtistIdPlatformArtistPlatformArtistGenreRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+    removePlatformArtistIdPlatformArtistPlatformArtistGenreRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    hasPlatformArtistIdPlatformArtistPlatformArtistGenreRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+    hasPlatformArtistIdPlatformArtistPlatformArtistGenreRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    countPlatformArtistIdPlatformArtistPlatformArtistGenreRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformArtistGenreRelations: PlatformArtistGenreRelation[];
+    getPlatformArtistGenreRelations: Sequelize.HasManyGetAssociationsMixin<PlatformArtistGenreRelation>;
+    setPlatformArtistGenreRelations: Sequelize.HasManySetAssociationsMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    addPlatformArtistGenreRelation: Sequelize.HasManyAddAssociationMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    addPlatformArtistGenreRelations: Sequelize.HasManyAddAssociationsMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    createPlatformArtistGenreRelation: Sequelize.HasManyCreateAssociationMixin<PlatformArtistGenreRelation>;
+    removePlatformArtistGenreRelation: Sequelize.HasManyRemoveAssociationMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    removePlatformArtistGenreRelations: Sequelize.HasManyRemoveAssociationsMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    hasPlatformArtistGenreRelation: Sequelize.HasManyHasAssociationMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    hasPlatformArtistGenreRelations: Sequelize.HasManyHasAssociationsMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    countPlatformArtistGenreRelations: Sequelize.HasManyCountAssociationsMixin;
+    platformTrackIdPlatformTrackPlatformTrackGenreRelations: PlatformTrack[];
+    getPlatformTrackIdPlatformTrackPlatformTrackGenreRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformTrack>;
+    setPlatformTrackIdPlatformTrackPlatformTrackGenreRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    addPlatformTrackIdPlatformTrackPlatformTrackGenreRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformTrack, PlatformTrackId>;
+    addPlatformTrackIdPlatformTrackPlatformTrackGenreRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrackIdPlatformTrackPlatformTrackGenreRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformTrack>;
+    removePlatformTrackIdPlatformTrackPlatformTrackGenreRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformTrack, PlatformTrackId>;
+    removePlatformTrackIdPlatformTrackPlatformTrackGenreRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    hasPlatformTrackIdPlatformTrackPlatformTrackGenreRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
+    hasPlatformTrackIdPlatformTrackPlatformTrackGenreRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    countPlatformTrackIdPlatformTrackPlatformTrackGenreRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformTrackGenreRelations: PlatformTrackGenreRelation[];
+    getPlatformTrackGenreRelations: Sequelize.HasManyGetAssociationsMixin<PlatformTrackGenreRelation>;
+    setPlatformTrackGenreRelations: Sequelize.HasManySetAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    addPlatformTrackGenreRelation: Sequelize.HasManyAddAssociationMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    addPlatformTrackGenreRelations: Sequelize.HasManyAddAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    createPlatformTrackGenreRelation: Sequelize.HasManyCreateAssociationMixin<PlatformTrackGenreRelation>;
+    removePlatformTrackGenreRelation: Sequelize.HasManyRemoveAssociationMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    removePlatformTrackGenreRelations: Sequelize.HasManyRemoveAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    hasPlatformTrackGenreRelation: Sequelize.HasManyHasAssociationMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    hasPlatformTrackGenreRelations: Sequelize.HasManyHasAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    countPlatformTrackGenreRelations: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformGenre;
+}

package/dist/PlatformGenre.js

@@ -0,0 +1,90 @@
+"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.PlatformGenre = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class PlatformGenre extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlatformGenre.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            platformId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'platform',
+                    key: 'id'
+                },
+                unique: "platform_genre_name_pkey",
+                field: 'platform_id'
+            },
+            name: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                unique: "platform_genre_name_pkey"
+            },
+            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: 'platform_genre',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "platform_genre_name_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "platform_id" },
+                        { name: "name" },
+                    ]
+                },
+                {
+                    name: "platform_genre_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.PlatformGenre = PlatformGenre;

package/dist/PlatformTrack.d.ts

@@ -0,0 +1,183 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonArtistTrackRelation, CanonArtistTrackRelationId } from './CanonArtistTrackRelation';
+import type { CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId } from './CanonToPlatformTrackRelation';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId } from './PlatformAlbumTrackRelation';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformArtistTrackRelation, PlatformArtistTrackRelationId } from './PlatformArtistTrackRelation';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+import type { PlatformTrackGenreRelation, PlatformTrackGenreRelationId } from './PlatformTrackGenreRelation';
+import type { PlatformUserAlbumTrack, PlatformUserAlbumTrackId } from './PlatformUserAlbumTrack';
+import type { PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId } from './PlatformUserPlaylistTrack';
+export interface PlatformTrackAttributes {
+    id: string;
+    platformId: number;
+    externalTrackId: string;
+    name: string;
+    asciiName: string;
+    durationMs: number;
+    explicit?: boolean;
+    popularity?: number;
+    discNumber?: number;
+    discTrackNumber?: number;
+    createDate: Date;
+    updateDate: Date;
+}
+export type PlatformTrackPk = "id";
+export type PlatformTrackId = PlatformTrack[PlatformTrackPk];
+export type PlatformTrackOptionalAttributes = "id" | "explicit" | "popularity" | "discNumber" | "discTrackNumber" | "createDate" | "updateDate";
+export type PlatformTrackCreationAttributes = Optional<PlatformTrackAttributes, PlatformTrackOptionalAttributes>;
+export declare class PlatformTrack extends Model<PlatformTrackAttributes, PlatformTrackCreationAttributes> implements PlatformTrackAttributes {
+    id: string;
+    platformId: number;
+    externalTrackId: string;
+    name: string;
+    asciiName: string;
+    durationMs: number;
+    explicit?: boolean;
+    popularity?: number;
+    discNumber?: number;
+    discTrackNumber?: number;
+    createDate: Date;
+    updateDate: Date;
+    platform: Platform;
+    getPlatform: Sequelize.BelongsToGetAssociationMixin<Platform>;
+    setPlatform: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+    createPlatform: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+    canonArtistTrackRelations: CanonArtistTrackRelation[];
+    getCanonArtistTrackRelations: Sequelize.HasManyGetAssociationsMixin<CanonArtistTrackRelation>;
+    setCanonArtistTrackRelations: Sequelize.HasManySetAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    addCanonArtistTrackRelation: Sequelize.HasManyAddAssociationMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    addCanonArtistTrackRelations: Sequelize.HasManyAddAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    createCanonArtistTrackRelation: Sequelize.HasManyCreateAssociationMixin<CanonArtistTrackRelation>;
+    removeCanonArtistTrackRelation: Sequelize.HasManyRemoveAssociationMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    removeCanonArtistTrackRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    hasCanonArtistTrackRelation: Sequelize.HasManyHasAssociationMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    hasCanonArtistTrackRelations: Sequelize.HasManyHasAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    countCanonArtistTrackRelations: 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;
+    canonTrackIdCanonTrackCanonToPlatformTrackRelations: CanonTrack[];
+    getCanonTrackIdCanonTrackCanonToPlatformTrackRelations: Sequelize.BelongsToManyGetAssociationsMixin<CanonTrack>;
+    setCanonTrackIdCanonTrackCanonToPlatformTrackRelations: Sequelize.BelongsToManySetAssociationsMixin<CanonTrack, CanonTrackId>;
+    addCanonTrackIdCanonTrackCanonToPlatformTrackRelation: Sequelize.BelongsToManyAddAssociationMixin<CanonTrack, CanonTrackId>;
+    addCanonTrackIdCanonTrackCanonToPlatformTrackRelations: Sequelize.BelongsToManyAddAssociationsMixin<CanonTrack, CanonTrackId>;
+    createCanonTrackIdCanonTrackCanonToPlatformTrackRelation: Sequelize.BelongsToManyCreateAssociationMixin<CanonTrack>;
+    removeCanonTrackIdCanonTrackCanonToPlatformTrackRelation: Sequelize.BelongsToManyRemoveAssociationMixin<CanonTrack, CanonTrackId>;
+    removeCanonTrackIdCanonTrackCanonToPlatformTrackRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonTrack, CanonTrackId>;
+    hasCanonTrackIdCanonTrackCanonToPlatformTrackRelation: Sequelize.BelongsToManyHasAssociationMixin<CanonTrack, CanonTrackId>;
+    hasCanonTrackIdCanonTrackCanonToPlatformTrackRelations: Sequelize.BelongsToManyHasAssociationsMixin<CanonTrack, CanonTrackId>;
+    countCanonTrackIdCanonTrackCanonToPlatformTrackRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformAlbumIdPlatformAlbumPlatformAlbumTrackRelations: PlatformAlbum[];
+    getPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+    setPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    addPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    addPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    createPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+    removePlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    removePlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    hasPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    hasPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    countPlatformAlbumIdPlatformAlbumPlatformAlbumTrackRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformAlbumTrackRelations: PlatformAlbumTrackRelation[];
+    getPlatformAlbumTrackRelations: Sequelize.HasManyGetAssociationsMixin<PlatformAlbumTrackRelation>;
+    setPlatformAlbumTrackRelations: Sequelize.HasManySetAssociationsMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    addPlatformAlbumTrackRelation: Sequelize.HasManyAddAssociationMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    addPlatformAlbumTrackRelations: Sequelize.HasManyAddAssociationsMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    createPlatformAlbumTrackRelation: Sequelize.HasManyCreateAssociationMixin<PlatformAlbumTrackRelation>;
+    removePlatformAlbumTrackRelation: Sequelize.HasManyRemoveAssociationMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    removePlatformAlbumTrackRelations: Sequelize.HasManyRemoveAssociationsMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    hasPlatformAlbumTrackRelation: Sequelize.HasManyHasAssociationMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    hasPlatformAlbumTrackRelations: Sequelize.HasManyHasAssociationsMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    countPlatformAlbumTrackRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonArtistIdPlatformArtistCanonArtistTrackRelations: PlatformArtist[];
+    getCanonArtistIdPlatformArtistCanonArtistTrackRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+    setCanonArtistIdPlatformArtistCanonArtistTrackRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    addCanonArtistIdPlatformArtistCanonArtistTrackRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+    addCanonArtistIdPlatformArtistCanonArtistTrackRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    createCanonArtistIdPlatformArtistCanonArtistTrackRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+    removeCanonArtistIdPlatformArtistCanonArtistTrackRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+    removeCanonArtistIdPlatformArtistCanonArtistTrackRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    hasCanonArtistIdPlatformArtistCanonArtistTrackRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+    hasCanonArtistIdPlatformArtistCanonArtistTrackRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    countCanonArtistIdPlatformArtistCanonArtistTrackRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformArtistIdPlatformArtistPlatformArtistTrackRelations: PlatformArtist[];
+    getPlatformArtistIdPlatformArtistPlatformArtistTrackRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+    setPlatformArtistIdPlatformArtistPlatformArtistTrackRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    addPlatformArtistIdPlatformArtistPlatformArtistTrackRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+    addPlatformArtistIdPlatformArtistPlatformArtistTrackRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    createPlatformArtistIdPlatformArtistPlatformArtistTrackRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+    removePlatformArtistIdPlatformArtistPlatformArtistTrackRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+    removePlatformArtistIdPlatformArtistPlatformArtistTrackRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    hasPlatformArtistIdPlatformArtistPlatformArtistTrackRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+    hasPlatformArtistIdPlatformArtistPlatformArtistTrackRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    countPlatformArtistIdPlatformArtistPlatformArtistTrackRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformArtistTrackRelations: PlatformArtistTrackRelation[];
+    getPlatformArtistTrackRelations: Sequelize.HasManyGetAssociationsMixin<PlatformArtistTrackRelation>;
+    setPlatformArtistTrackRelations: Sequelize.HasManySetAssociationsMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    addPlatformArtistTrackRelation: Sequelize.HasManyAddAssociationMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    addPlatformArtistTrackRelations: Sequelize.HasManyAddAssociationsMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    createPlatformArtistTrackRelation: Sequelize.HasManyCreateAssociationMixin<PlatformArtistTrackRelation>;
+    removePlatformArtistTrackRelation: Sequelize.HasManyRemoveAssociationMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    removePlatformArtistTrackRelations: Sequelize.HasManyRemoveAssociationsMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    hasPlatformArtistTrackRelation: Sequelize.HasManyHasAssociationMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    hasPlatformArtistTrackRelations: Sequelize.HasManyHasAssociationsMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    countPlatformArtistTrackRelations: Sequelize.HasManyCountAssociationsMixin;
+    platformGenreIdPlatformGenrePlatformTrackGenreRelations: PlatformGenre[];
+    getPlatformGenreIdPlatformGenrePlatformTrackGenreRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformGenre>;
+    setPlatformGenreIdPlatformGenrePlatformTrackGenreRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    addPlatformGenreIdPlatformGenrePlatformTrackGenreRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformGenre, PlatformGenreId>;
+    addPlatformGenreIdPlatformGenrePlatformTrackGenreRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    createPlatformGenreIdPlatformGenrePlatformTrackGenreRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformGenre>;
+    removePlatformGenreIdPlatformGenrePlatformTrackGenreRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformGenre, PlatformGenreId>;
+    removePlatformGenreIdPlatformGenrePlatformTrackGenreRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    hasPlatformGenreIdPlatformGenrePlatformTrackGenreRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformGenre, PlatformGenreId>;
+    hasPlatformGenreIdPlatformGenrePlatformTrackGenreRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    countPlatformGenreIdPlatformGenrePlatformTrackGenreRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformTrackGenreRelations: PlatformTrackGenreRelation[];
+    getPlatformTrackGenreRelations: Sequelize.HasManyGetAssociationsMixin<PlatformTrackGenreRelation>;
+    setPlatformTrackGenreRelations: Sequelize.HasManySetAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    addPlatformTrackGenreRelation: Sequelize.HasManyAddAssociationMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    addPlatformTrackGenreRelations: Sequelize.HasManyAddAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    createPlatformTrackGenreRelation: Sequelize.HasManyCreateAssociationMixin<PlatformTrackGenreRelation>;
+    removePlatformTrackGenreRelation: Sequelize.HasManyRemoveAssociationMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    removePlatformTrackGenreRelations: Sequelize.HasManyRemoveAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    hasPlatformTrackGenreRelation: Sequelize.HasManyHasAssociationMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    hasPlatformTrackGenreRelations: Sequelize.HasManyHasAssociationsMixin<PlatformTrackGenreRelation, PlatformTrackGenreRelationId>;
+    countPlatformTrackGenreRelations: Sequelize.HasManyCountAssociationsMixin;
+    platformUserAlbumTracks: PlatformUserAlbumTrack[];
+    getPlatformUserAlbumTracks: Sequelize.HasManyGetAssociationsMixin<PlatformUserAlbumTrack>;
+    setPlatformUserAlbumTracks: Sequelize.HasManySetAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+    addPlatformUserAlbumTrack: Sequelize.HasManyAddAssociationMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+    addPlatformUserAlbumTracks: Sequelize.HasManyAddAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+    createPlatformUserAlbumTrack: Sequelize.HasManyCreateAssociationMixin<PlatformUserAlbumTrack>;
+    removePlatformUserAlbumTrack: Sequelize.HasManyRemoveAssociationMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+    removePlatformUserAlbumTracks: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+    hasPlatformUserAlbumTrack: Sequelize.HasManyHasAssociationMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+    hasPlatformUserAlbumTracks: Sequelize.HasManyHasAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+    countPlatformUserAlbumTracks: Sequelize.HasManyCountAssociationsMixin;
+    platformUserPlaylistTracks: PlatformUserPlaylistTrack[];
+    getPlatformUserPlaylistTracks: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylistTrack>;
+    setPlatformUserPlaylistTracks: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+    addPlatformUserPlaylistTrack: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+    addPlatformUserPlaylistTracks: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+    createPlatformUserPlaylistTrack: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylistTrack>;
+    removePlatformUserPlaylistTrack: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+    removePlatformUserPlaylistTracks: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+    hasPlatformUserPlaylistTrack: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+    hasPlatformUserPlaylistTracks: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+    countPlatformUserPlaylistTracks: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformTrack;
+}

package/dist/PlatformTrack.js

@@ -0,0 +1,129 @@
+"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.PlatformTrack = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class PlatformTrack extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlatformTrack.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            platformId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'platform',
+                    key: 'id'
+                },
+                unique: "uk_platform_id_external_track_id",
+                field: 'platform_id'
+            },
+            externalTrackId: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                unique: "uk_platform_id_external_track_id",
+                field: 'external_track_id'
+            },
+            name: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            asciiName: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'ascii_name'
+            },
+            durationMs: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                field: 'duration_ms'
+            },
+            explicit: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: true
+            },
+            popularity: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: true
+            },
+            discNumber: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: true,
+                field: 'disc_number'
+            },
+            discTrackNumber: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: true,
+                field: 'disc_track_number'
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            }
+        }, {
+            sequelize,
+            tableName: 'platform_track',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "idx_platform_track_external_track_id",
+                    fields: [
+                        { name: "external_track_id" },
+                    ]
+                },
+                {
+                    name: "platform_track_pkey1",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "uk_platform_id_external_track_id",
+                    unique: true,
+                    fields: [
+                        { name: "platform_id" },
+                        { name: "external_track_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.PlatformTrack = PlatformTrack;

package/dist/PlatformTrackGenreRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+export interface PlatformTrackGenreRelationAttributes {
+    platformGenreId: string;
+    platformTrackId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type PlatformTrackGenreRelationPk = "platformGenreId" | "platformTrackId";
+export type PlatformTrackGenreRelationId = PlatformTrackGenreRelation[PlatformTrackGenreRelationPk];
+export type PlatformTrackGenreRelationOptionalAttributes = "createDate" | "updateDate";
+export type PlatformTrackGenreRelationCreationAttributes = Optional<PlatformTrackGenreRelationAttributes, PlatformTrackGenreRelationOptionalAttributes>;
+export declare class PlatformTrackGenreRelation extends Model<PlatformTrackGenreRelationAttributes, PlatformTrackGenreRelationCreationAttributes> implements PlatformTrackGenreRelationAttributes {
+    platformGenreId: string;
+    platformTrackId: string;
+    createDate: Date;
+    updateDate: Date;
+    platformGenre: PlatformGenre;
+    getPlatformGenre: Sequelize.BelongsToGetAssociationMixin<PlatformGenre>;
+    setPlatformGenre: Sequelize.BelongsToSetAssociationMixin<PlatformGenre, PlatformGenreId>;
+    createPlatformGenre: Sequelize.BelongsToCreateAssociationMixin<PlatformGenre>;
+    platformTrack: PlatformTrack;
+    getPlatformTrack: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+    setPlatformTrack: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrack: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformTrackGenreRelation;
+}