@earbug/db-models 0.0.1

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

package/dist/PlatformUserAlbum.d.ts

@@ -0,0 +1,54 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformUserAlbumTrack, PlatformUserAlbumTrackId } from './PlatformUserAlbumTrack';
+export interface PlatformUserAlbumAttributes {
+    id: string;
+    appUserId: string;
+    platformId: number;
+    externalUserAlbumId: string;
+    platformAlbumId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    stateId: number;
+}
+export type PlatformUserAlbumPk = "id";
+export type PlatformUserAlbumId = PlatformUserAlbum[PlatformUserAlbumPk];
+export type PlatformUserAlbumOptionalAttributes = "id" | "createdAt" | "updatedAt" | "stateId";
+export type PlatformUserAlbumCreationAttributes = Optional<PlatformUserAlbumAttributes, PlatformUserAlbumOptionalAttributes>;
+export declare class PlatformUserAlbum extends Model<PlatformUserAlbumAttributes, PlatformUserAlbumCreationAttributes> implements PlatformUserAlbumAttributes {
+    id: string;
+    appUserId: string;
+    platformId: number;
+    externalUserAlbumId: string;
+    platformAlbumId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    stateId: number;
+    appUser: AppUser;
+    getAppUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setAppUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createAppUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    platform: Platform;
+    getPlatform: Sequelize.BelongsToGetAssociationMixin<Platform>;
+    setPlatform: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+    createPlatform: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+    platformAlbum: PlatformAlbum;
+    getPlatformAlbum: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+    setPlatformAlbum: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    createPlatformAlbum: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+    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;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformUserAlbum;
+}

package/dist/PlatformUserAlbum.js

@@ -0,0 +1,121 @@
+"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.PlatformUserAlbum = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class PlatformUserAlbum extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlatformUserAlbum.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            appUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                unique: "platform_user_album_app_user_id_platform_album_id_unique",
+                field: 'app_user_id'
+            },
+            platformId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'platform',
+                    key: 'id'
+                },
+                field: 'platform_id'
+            },
+            externalUserAlbumId: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: false,
+                field: 'external_user_album_id'
+            },
+            platformAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'platform_album',
+                    key: 'id'
+                },
+                unique: "platform_user_album_app_user_id_platform_album_id_unique",
+                field: 'platform_album_id'
+            },
+            createdAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'created_at'
+            },
+            updatedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'updated_at'
+            },
+            stateId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0,
+                field: 'state_id'
+            }
+        }, {
+            sequelize,
+            tableName: 'platform_user_album',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "platform_user_album_app_user_id_index",
+                    fields: [
+                        { name: "app_user_id" },
+                    ]
+                },
+                {
+                    name: "platform_user_album_app_user_id_platform_album_id_unique",
+                    unique: true,
+                    fields: [
+                        { name: "app_user_id" },
+                        { name: "platform_album_id" },
+                    ]
+                },
+                {
+                    name: "platform_user_album_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.PlatformUserAlbum = PlatformUserAlbum;

package/dist/PlatformUserAlbumTrack.d.ts

@@ -0,0 +1,42 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum';
+export interface PlatformUserAlbumTrackAttributes {
+    id: string;
+    platformUserAlbumId: string;
+    platformId: number;
+    externalUserAlbumTrackId: string;
+    platformTrackId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    stateId: number;
+}
+export type PlatformUserAlbumTrackPk = "id";
+export type PlatformUserAlbumTrackId = PlatformUserAlbumTrack[PlatformUserAlbumTrackPk];
+export type PlatformUserAlbumTrackOptionalAttributes = "id" | "createdAt" | "updatedAt" | "stateId";
+export type PlatformUserAlbumTrackCreationAttributes = Optional<PlatformUserAlbumTrackAttributes, PlatformUserAlbumTrackOptionalAttributes>;
+export declare class PlatformUserAlbumTrack extends Model<PlatformUserAlbumTrackAttributes, PlatformUserAlbumTrackCreationAttributes> implements PlatformUserAlbumTrackAttributes {
+    id: string;
+    platformUserAlbumId: string;
+    platformId: number;
+    externalUserAlbumTrackId: string;
+    platformTrackId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    stateId: number;
+    platform: Platform;
+    getPlatform: Sequelize.BelongsToGetAssociationMixin<Platform>;
+    setPlatform: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+    createPlatform: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+    platformTrack: PlatformTrack;
+    getPlatformTrack: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+    setPlatformTrack: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrack: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+    platformUserAlbum: PlatformUserAlbum;
+    getPlatformUserAlbum: Sequelize.BelongsToGetAssociationMixin<PlatformUserAlbum>;
+    setPlatformUserAlbum: Sequelize.BelongsToSetAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    createPlatformUserAlbum: Sequelize.BelongsToCreateAssociationMixin<PlatformUserAlbum>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformUserAlbumTrack;
+}

package/dist/PlatformUserAlbumTrack.js

@@ -0,0 +1,121 @@
+"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.PlatformUserAlbumTrack = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class PlatformUserAlbumTrack extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlatformUserAlbumTrack.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            platformUserAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'platform_user_album',
+                    key: 'id'
+                },
+                unique: "platform_user_album_track_platform_user_album_id_platform_track",
+                field: 'platform_user_album_id'
+            },
+            platformId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'platform',
+                    key: 'id'
+                },
+                field: 'platform_id'
+            },
+            externalUserAlbumTrackId: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: false,
+                field: 'external_user_album_track_id'
+            },
+            platformTrackId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'platform_track',
+                    key: 'id'
+                },
+                unique: "platform_user_album_track_platform_user_album_id_platform_track",
+                field: 'platform_track_id'
+            },
+            createdAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'created_at'
+            },
+            updatedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'updated_at'
+            },
+            stateId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0,
+                field: 'state_id'
+            }
+        }, {
+            sequelize,
+            tableName: 'platform_user_album_track',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "platform_user_album_track_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "platform_user_album_track_platform_user_album_id_index",
+                    fields: [
+                        { name: "platform_user_album_id" },
+                    ]
+                },
+                {
+                    name: "platform_user_album_track_platform_user_album_id_platform_track",
+                    unique: true,
+                    fields: [
+                        { name: "platform_user_album_id" },
+                        { name: "platform_track_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.PlatformUserAlbumTrack = PlatformUserAlbumTrack;

package/dist/PlatformUserPlaylist.d.ts

@@ -0,0 +1,62 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId } from './PlatformUserPlaylistTrack';
+import type { State, StateId } from './State';
+export interface PlatformUserPlaylistAttributes {
+    id: string;
+    appUserId: string;
+    platformId: number;
+    externalPlaylistId: string;
+    name: string;
+    description?: string;
+    public?: boolean;
+    snapshotId: string;
+    collaborative: boolean;
+    createDate: Date;
+    updateDate: Date;
+    stateId: number;
+}
+export type PlatformUserPlaylistPk = "id";
+export type PlatformUserPlaylistId = PlatformUserPlaylist[PlatformUserPlaylistPk];
+export type PlatformUserPlaylistOptionalAttributes = "id" | "description" | "public" | "createDate" | "updateDate" | "stateId";
+export type PlatformUserPlaylistCreationAttributes = Optional<PlatformUserPlaylistAttributes, PlatformUserPlaylistOptionalAttributes>;
+export declare class PlatformUserPlaylist extends Model<PlatformUserPlaylistAttributes, PlatformUserPlaylistCreationAttributes> implements PlatformUserPlaylistAttributes {
+    id: string;
+    appUserId: string;
+    platformId: number;
+    externalPlaylistId: string;
+    name: string;
+    description?: string;
+    public?: boolean;
+    snapshotId: string;
+    collaborative: boolean;
+    createDate: Date;
+    updateDate: Date;
+    stateId: number;
+    appUser: AppUser;
+    getAppUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setAppUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createAppUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    platform: Platform;
+    getPlatform: Sequelize.BelongsToGetAssociationMixin<Platform>;
+    setPlatform: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+    createPlatform: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+    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;
+    state: State;
+    getState: Sequelize.BelongsToGetAssociationMixin<State>;
+    setState: Sequelize.BelongsToSetAssociationMixin<State, StateId>;
+    createState: Sequelize.BelongsToCreateAssociationMixin<State>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformUserPlaylist;
+}

package/dist/PlatformUserPlaylist.js

@@ -0,0 +1,135 @@
+"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.PlatformUserPlaylist = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class PlatformUserPlaylist extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlatformUserPlaylist.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            appUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                unique: "uk_app_user_platform_playlist",
+                field: 'app_user_id'
+            },
+            platformId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'platform',
+                    key: 'id'
+                },
+                unique: "uk_app_user_platform_playlist",
+                field: 'platform_id'
+            },
+            externalPlaylistId: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                unique: "uk_app_user_platform_playlist",
+                field: 'external_playlist_id'
+            },
+            name: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            description: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true
+            },
+            public: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: true,
+                defaultValue: false
+            },
+            snapshotId: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'snapshot_id'
+            },
+            collaborative: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: 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'
+            },
+            stateId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0,
+                references: {
+                    model: 'state',
+                    key: 'id'
+                },
+                field: 'state_id'
+            }
+        }, {
+            sequelize,
+            tableName: 'platform_user_playlist',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "playlist_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "uk_app_user_platform_playlist",
+                    unique: true,
+                    fields: [
+                        { name: "app_user_id" },
+                        { name: "platform_id" },
+                        { name: "external_playlist_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.PlatformUserPlaylist = PlatformUserPlaylist;

package/dist/PlatformUserPlaylistTrack.d.ts

@@ -0,0 +1,48 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+import type { State, StateId } from './State';
+export interface PlatformUserPlaylistTrackAttributes {
+    id: string;
+    platformTrackId: string;
+    platformUserPlaylistId: string;
+    trackPosition: number;
+    addedDate?: Date;
+    addedByPlatformUserId?: string;
+    isLocal: boolean;
+    createDate: Date;
+    updateDate: Date;
+    stateId: number;
+    externalPlaylistTrackId: string;
+}
+export type PlatformUserPlaylistTrackPk = "id";
+export type PlatformUserPlaylistTrackId = PlatformUserPlaylistTrack[PlatformUserPlaylistTrackPk];
+export type PlatformUserPlaylistTrackOptionalAttributes = "id" | "trackPosition" | "addedDate" | "addedByPlatformUserId" | "createDate" | "updateDate" | "stateId";
+export type PlatformUserPlaylistTrackCreationAttributes = Optional<PlatformUserPlaylistTrackAttributes, PlatformUserPlaylistTrackOptionalAttributes>;
+export declare class PlatformUserPlaylistTrack extends Model<PlatformUserPlaylistTrackAttributes, PlatformUserPlaylistTrackCreationAttributes> implements PlatformUserPlaylistTrackAttributes {
+    id: string;
+    platformTrackId: string;
+    platformUserPlaylistId: string;
+    trackPosition: number;
+    addedDate?: Date;
+    addedByPlatformUserId?: string;
+    isLocal: boolean;
+    createDate: Date;
+    updateDate: Date;
+    stateId: number;
+    externalPlaylistTrackId: string;
+    platformTrack: PlatformTrack;
+    getPlatformTrack: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+    setPlatformTrack: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrack: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+    platformUserPlaylist: PlatformUserPlaylist;
+    getPlatformUserPlaylist: Sequelize.BelongsToGetAssociationMixin<PlatformUserPlaylist>;
+    setPlatformUserPlaylist: Sequelize.BelongsToSetAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    createPlatformUserPlaylist: Sequelize.BelongsToCreateAssociationMixin<PlatformUserPlaylist>;
+    state: State;
+    getState: Sequelize.BelongsToGetAssociationMixin<State>;
+    setState: Sequelize.BelongsToSetAssociationMixin<State, StateId>;
+    createState: Sequelize.BelongsToCreateAssociationMixin<State>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformUserPlaylistTrack;
+}