@earbug/db-models 0.0.1

package/dist/PlatformUserPlaylistTrack.js

@@ -0,0 +1,132 @@
+"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.PlatformUserPlaylistTrack = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class PlatformUserPlaylistTrack extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlatformUserPlaylistTrack.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            platformTrackId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'platform_track',
+                    key: 'id'
+                },
+                unique: "uk_playlist_id_track_id",
+                field: 'platform_track_id'
+            },
+            platformUserPlaylistId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'platform_user_playlist',
+                    key: 'id'
+                },
+                unique: "uk_playlist_id_track_id",
+                field: 'platform_user_playlist_id'
+            },
+            trackPosition: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0,
+                field: 'track_position'
+            },
+            addedDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                field: 'added_date'
+            },
+            addedByPlatformUserId: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 'added_by_platform_user_id'
+            },
+            isLocal: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false,
+                field: 'is_local'
+            },
+            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'
+            },
+            externalPlaylistTrackId: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: false,
+                field: 'external_playlist_track_id'
+            }
+        }, {
+            sequelize,
+            tableName: 'platform_user_playlist_track',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "playlist_track_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "uk_playlist_id_track_id",
+                    unique: true,
+                    fields: [
+                        { name: "platform_track_id" },
+                        { name: "platform_user_playlist_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.PlatformUserPlaylistTrack = PlatformUserPlaylistTrack;

package/dist/PlaybackStatus.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+export interface PlaybackStatusAttributes {
+    id: number;
+    description: string;
+}
+export type PlaybackStatusPk = "id";
+export type PlaybackStatusId = PlaybackStatus[PlaybackStatusPk];
+export type PlaybackStatusCreationAttributes = PlaybackStatusAttributes;
+export declare class PlaybackStatus extends Model<PlaybackStatusAttributes, PlaybackStatusCreationAttributes> implements PlaybackStatusAttributes {
+    id: number;
+    description: string;
+    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;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlaybackStatus;
+}

package/dist/PlaybackStatus.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaybackStatus = void 0;
+const sequelize_1 = require("sequelize");
+class PlaybackStatus extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlaybackStatus.init({
+            id: {
+                autoIncrement: true,
+                autoIncrementIdentity: true,
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            description: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'playback_status',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "playback_status_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.PlaybackStatus = PlaybackStatus;

package/dist/State.d.ts

@@ -0,0 +1,50 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+import type { PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId } from './PlatformUserPlaylistTrack';
+export interface StateAttributes {
+    id: number;
+    description: string;
+}
+export type StatePk = "id";
+export type StateId = State[StatePk];
+export type StateCreationAttributes = StateAttributes;
+export declare class State extends Model<StateAttributes, StateCreationAttributes> implements StateAttributes {
+    id: number;
+    description: string;
+    appUsers: AppUser[];
+    getAppUsers: Sequelize.HasManyGetAssociationsMixin<AppUser>;
+    setAppUsers: Sequelize.HasManySetAssociationsMixin<AppUser, AppUserId>;
+    addAppUser: Sequelize.HasManyAddAssociationMixin<AppUser, AppUserId>;
+    addAppUsers: Sequelize.HasManyAddAssociationsMixin<AppUser, AppUserId>;
+    createAppUser: Sequelize.HasManyCreateAssociationMixin<AppUser>;
+    removeAppUser: Sequelize.HasManyRemoveAssociationMixin<AppUser, AppUserId>;
+    removeAppUsers: Sequelize.HasManyRemoveAssociationsMixin<AppUser, AppUserId>;
+    hasAppUser: Sequelize.HasManyHasAssociationMixin<AppUser, AppUserId>;
+    hasAppUsers: Sequelize.HasManyHasAssociationsMixin<AppUser, AppUserId>;
+    countAppUsers: Sequelize.HasManyCountAssociationsMixin;
+    platformUserPlaylists: PlatformUserPlaylist[];
+    getPlatformUserPlaylists: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylist>;
+    setPlatformUserPlaylists: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    addPlatformUserPlaylist: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    addPlatformUserPlaylists: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    createPlatformUserPlaylist: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylist>;
+    removePlatformUserPlaylist: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    removePlatformUserPlaylists: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    hasPlatformUserPlaylist: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    hasPlatformUserPlaylists: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    countPlatformUserPlaylists: 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 State;
+}

package/dist/State.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.State = void 0;
+const sequelize_1 = require("sequelize");
+class State extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return State.init({
+            id: {
+                autoIncrement: true,
+                autoIncrementIdentity: true,
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            description: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'state',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "state_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.State = State;

package/dist/TrackDeletionReason.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+export interface TrackDeletionReasonAttributes {
+    id: number;
+    description: string;
+}
+export type TrackDeletionReasonPk = "id";
+export type TrackDeletionReasonId = TrackDeletionReason[TrackDeletionReasonPk];
+export type TrackDeletionReasonCreationAttributes = TrackDeletionReasonAttributes;
+export declare class TrackDeletionReason extends Model<TrackDeletionReasonAttributes, TrackDeletionReasonCreationAttributes> implements TrackDeletionReasonAttributes {
+    id: number;
+    description: string;
+    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;
+    static initModel(sequelize: Sequelize.Sequelize): typeof TrackDeletionReason;
+}

package/dist/TrackDeletionReason.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackDeletionReason = void 0;
+const sequelize_1 = require("sequelize");
+class TrackDeletionReason extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return TrackDeletionReason.init({
+            id: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            description: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'track_deletion_reason',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "track_deletion_reason_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.TrackDeletionReason = TrackDeletionReason;

package/dist/UnmatchedAlbum.d.ts

@@ -0,0 +1,22 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+export interface UnmatchedAlbumAttributes {
+    id: string;
+    platformAlbumId: string;
+    createDate: Date;
+}
+export type UnmatchedAlbumPk = "id";
+export type UnmatchedAlbumId = UnmatchedAlbum[UnmatchedAlbumPk];
+export type UnmatchedAlbumOptionalAttributes = "id" | "createDate";
+export type UnmatchedAlbumCreationAttributes = Optional<UnmatchedAlbumAttributes, UnmatchedAlbumOptionalAttributes>;
+export declare class UnmatchedAlbum extends Model<UnmatchedAlbumAttributes, UnmatchedAlbumCreationAttributes> implements UnmatchedAlbumAttributes {
+    id: string;
+    platformAlbumId: string;
+    createDate: Date;
+    platformAlbum: PlatformAlbum;
+    getPlatformAlbum: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+    setPlatformAlbum: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    createPlatformAlbum: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UnmatchedAlbum;
+}

package/dist/UnmatchedAlbum.js

@@ -0,0 +1,70 @@
+"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.UnmatchedAlbum = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class UnmatchedAlbum extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return UnmatchedAlbum.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            platformAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                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'
+            }
+        }, {
+            sequelize,
+            tableName: 'unmatched_album',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "unmatched_album_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.UnmatchedAlbum = UnmatchedAlbum;

package/dist/UnmatchedArtist.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { Platform, PlatformId } from './Platform';
+export interface UnmatchedArtistAttributes {
+    id: string;
+    platformId: number;
+    externalArtistId: number;
+    createDate: Date;
+    updateDate: Date;
+}
+export type UnmatchedArtistPk = "id";
+export type UnmatchedArtistId = UnmatchedArtist[UnmatchedArtistPk];
+export type UnmatchedArtistOptionalAttributes = "id" | "createDate" | "updateDate";
+export type UnmatchedArtistCreationAttributes = Optional<UnmatchedArtistAttributes, UnmatchedArtistOptionalAttributes>;
+export declare class UnmatchedArtist extends Model<UnmatchedArtistAttributes, UnmatchedArtistCreationAttributes> implements UnmatchedArtistAttributes {
+    id: string;
+    platformId: number;
+    externalArtistId: number;
+    createDate: Date;
+    updateDate: Date;
+    platform: Platform;
+    getPlatform: Sequelize.BelongsToGetAssociationMixin<Platform>;
+    setPlatform: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+    createPlatform: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UnmatchedArtist;
+}

package/dist/UnmatchedArtist.js

@@ -0,0 +1,81 @@
+"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.UnmatchedArtist = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class UnmatchedArtist extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return UnmatchedArtist.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'
+                },
+                field: 'platform_id'
+            },
+            externalArtistId: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                field: 'external_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: 'unmatched_artist',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "unmatched_artist_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.UnmatchedArtist = UnmatchedArtist;

package/dist/UserContacts.d.ts

@@ -0,0 +1,46 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+export interface UserContactsAttributes {
+    appUserId: string;
+    contactId: string;
+    contactAppUserId?: string;
+    firstName?: string;
+    lastName?: string;
+    contactEmail1?: string;
+    contactEmail2?: string;
+    contactEmail3?: string;
+    contactPhone1?: string;
+    contactPhone1Type?: "mobile" | "work" | "home" | "main";
+    contactPhone2?: string;
+    contactPhone2Type?: "mobile" | "work" | "home" | "main";
+    contactPhone3?: string;
+    contactPhone3Type?: "mobile" | "work" | "home" | "main";
+    active?: boolean;
+}
+export type UserContactsPk = "contactId";
+export type UserContactsId = UserContacts[UserContactsPk];
+export type UserContactsOptionalAttributes = "contactId" | "contactAppUserId" | "firstName" | "lastName" | "contactEmail1" | "contactEmail2" | "contactEmail3" | "contactPhone1" | "contactPhone1Type" | "contactPhone2" | "contactPhone2Type" | "contactPhone3" | "contactPhone3Type" | "active";
+export type UserContactsCreationAttributes = Optional<UserContactsAttributes, UserContactsOptionalAttributes>;
+export declare class UserContacts extends Model<UserContactsAttributes, UserContactsCreationAttributes> implements UserContactsAttributes {
+    appUserId: string;
+    contactId: string;
+    contactAppUserId?: string;
+    firstName?: string;
+    lastName?: string;
+    contactEmail1?: string;
+    contactEmail2?: string;
+    contactEmail3?: string;
+    contactPhone1?: string;
+    contactPhone1Type?: "mobile" | "work" | "home" | "main";
+    contactPhone2?: string;
+    contactPhone2Type?: "mobile" | "work" | "home" | "main";
+    contactPhone3?: string;
+    contactPhone3Type?: "mobile" | "work" | "home" | "main";
+    active?: boolean;
+    appUser: AppUser;
+    getAppUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setAppUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createAppUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UserContacts;
+}