@earbug/db-models 0.0.1

package/dist/MetricsEvent.js

@@ -0,0 +1,117 @@
+"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.MetricsEvent = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class MetricsEvent extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return MetricsEvent.init({
+            eventType: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'event_type'
+            },
+            appUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                field: 'app_user_id'
+            },
+            sessionId: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'session_id'
+            },
+            devicePlatformId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                field: 'device_platform_id'
+            },
+            createdAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'created_at'
+            },
+            meta: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true
+            },
+            objectId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                field: 'object_id'
+            }
+        }, {
+            sequelize,
+            tableName: 'metrics_event',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "metrics_created_idx",
+                    fields: [
+                        { name: "created_at" },
+                    ]
+                },
+                {
+                    name: "metrics_dev_plat_idx",
+                    fields: [
+                        { name: "device_platform_id" },
+                    ]
+                },
+                {
+                    name: "metrics_object_idx",
+                    fields: [
+                        { name: "object_id" },
+                    ]
+                },
+                {
+                    name: "metrics_session_idx",
+                    fields: [
+                        { name: "session_id" },
+                    ]
+                },
+                {
+                    name: "metrics_status_idx",
+                    fields: []
+                },
+                {
+                    name: "metrics_type_idx",
+                    fields: [
+                        { name: "event_type" },
+                    ]
+                },
+                {
+                    name: "metrics_user_idx",
+                    fields: [
+                        { name: "app_user_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.MetricsEvent = MetricsEvent;

package/dist/NewsSite.d.ts

@@ -0,0 +1,21 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+export interface NewsSiteAttributes {
+    id: number;
+    name: string;
+    domain?: string;
+    scrapingBaseUrl: string;
+    active?: boolean;
+}
+export type NewsSitePk = "id";
+export type NewsSiteId = NewsSite[NewsSitePk];
+export type NewsSiteOptionalAttributes = "id" | "domain" | "active";
+export type NewsSiteCreationAttributes = Optional<NewsSiteAttributes, NewsSiteOptionalAttributes>;
+export declare class NewsSite extends Model<NewsSiteAttributes, NewsSiteCreationAttributes> implements NewsSiteAttributes {
+    id: number;
+    name: string;
+    domain?: string;
+    scrapingBaseUrl: string;
+    active?: boolean;
+    static initModel(sequelize: Sequelize.Sequelize): typeof NewsSite;
+}

package/dist/NewsSite.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewsSite = void 0;
+const sequelize_1 = require("sequelize");
+class NewsSite extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return NewsSite.init({
+            id: {
+                autoIncrement: true,
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                primaryKey: true
+            },
+            name: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: false,
+                unique: "news_site_name_unique"
+            },
+            domain: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: true
+            },
+            scrapingBaseUrl: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: false,
+                field: 'scraping_base_url'
+            },
+            active: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: true,
+                defaultValue: false
+            }
+        }, {
+            sequelize,
+            tableName: 'news_site',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "news_site_name_unique",
+                    unique: true,
+                    fields: [
+                        { name: "name" },
+                    ]
+                },
+                {
+                    name: "news_site_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.NewsSite = NewsSite;

package/dist/PauseStatusType.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+export interface PauseStatusTypeAttributes {
+    id: number;
+    description: string;
+}
+export type PauseStatusTypePk = "id";
+export type PauseStatusTypeId = PauseStatusType[PauseStatusTypePk];
+export type PauseStatusTypeCreationAttributes = PauseStatusTypeAttributes;
+export declare class PauseStatusType extends Model<PauseStatusTypeAttributes, PauseStatusTypeCreationAttributes> implements PauseStatusTypeAttributes {
+    id: number;
+    description: string;
+    jukeboxUsers: JukeboxUser[];
+    getJukeboxUsers: Sequelize.HasManyGetAssociationsMixin<JukeboxUser>;
+    setJukeboxUsers: Sequelize.HasManySetAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    addJukeboxUser: Sequelize.HasManyAddAssociationMixin<JukeboxUser, JukeboxUserId>;
+    addJukeboxUsers: Sequelize.HasManyAddAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    createJukeboxUser: Sequelize.HasManyCreateAssociationMixin<JukeboxUser>;
+    removeJukeboxUser: Sequelize.HasManyRemoveAssociationMixin<JukeboxUser, JukeboxUserId>;
+    removeJukeboxUsers: Sequelize.HasManyRemoveAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    hasJukeboxUser: Sequelize.HasManyHasAssociationMixin<JukeboxUser, JukeboxUserId>;
+    hasJukeboxUsers: Sequelize.HasManyHasAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    countJukeboxUsers: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PauseStatusType;
+}

package/dist/PauseStatusType.js

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

package/dist/Platform.d.ts

@@ -0,0 +1,127 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUserPlatformRelation, AppUserPlatformRelationId } from './AppUserPlatformRelation';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum';
+import type { PlatformUserAlbumTrack, PlatformUserAlbumTrackId } from './PlatformUserAlbumTrack';
+import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+import type { UnmatchedArtist, UnmatchedArtistId } from './UnmatchedArtist';
+export interface PlatformAttributes {
+    id: number;
+    name: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type PlatformPk = "id";
+export type PlatformId = Platform[PlatformPk];
+export type PlatformOptionalAttributes = "createDate" | "updateDate";
+export type PlatformCreationAttributes = Optional<PlatformAttributes, PlatformOptionalAttributes>;
+export declare class Platform extends Model<PlatformAttributes, PlatformCreationAttributes> implements PlatformAttributes {
+    id: number;
+    name: string;
+    createDate: Date;
+    updateDate: Date;
+    appUserPlatformRelations: AppUserPlatformRelation[];
+    getAppUserPlatformRelations: Sequelize.HasManyGetAssociationsMixin<AppUserPlatformRelation>;
+    setAppUserPlatformRelations: Sequelize.HasManySetAssociationsMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+    addAppUserPlatformRelation: Sequelize.HasManyAddAssociationMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+    addAppUserPlatformRelations: Sequelize.HasManyAddAssociationsMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+    createAppUserPlatformRelation: Sequelize.HasManyCreateAssociationMixin<AppUserPlatformRelation>;
+    removeAppUserPlatformRelation: Sequelize.HasManyRemoveAssociationMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+    removeAppUserPlatformRelations: Sequelize.HasManyRemoveAssociationsMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+    hasAppUserPlatformRelation: Sequelize.HasManyHasAssociationMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+    hasAppUserPlatformRelations: Sequelize.HasManyHasAssociationsMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+    countAppUserPlatformRelations: Sequelize.HasManyCountAssociationsMixin;
+    platformAlbums: PlatformAlbum[];
+    getPlatformAlbums: Sequelize.HasManyGetAssociationsMixin<PlatformAlbum>;
+    setPlatformAlbums: Sequelize.HasManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    addPlatformAlbum: Sequelize.HasManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    addPlatformAlbums: Sequelize.HasManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    createPlatformAlbum: Sequelize.HasManyCreateAssociationMixin<PlatformAlbum>;
+    removePlatformAlbum: Sequelize.HasManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    removePlatformAlbums: Sequelize.HasManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    hasPlatformAlbum: Sequelize.HasManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    hasPlatformAlbums: Sequelize.HasManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    countPlatformAlbums: Sequelize.HasManyCountAssociationsMixin;
+    platformArtists: PlatformArtist[];
+    getPlatformArtists: Sequelize.HasManyGetAssociationsMixin<PlatformArtist>;
+    setPlatformArtists: Sequelize.HasManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    addPlatformArtist: Sequelize.HasManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+    addPlatformArtists: Sequelize.HasManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    createPlatformArtist: Sequelize.HasManyCreateAssociationMixin<PlatformArtist>;
+    removePlatformArtist: Sequelize.HasManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+    removePlatformArtists: Sequelize.HasManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    hasPlatformArtist: Sequelize.HasManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+    hasPlatformArtists: Sequelize.HasManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    countPlatformArtists: Sequelize.HasManyCountAssociationsMixin;
+    platformGenres: PlatformGenre[];
+    getPlatformGenres: Sequelize.HasManyGetAssociationsMixin<PlatformGenre>;
+    setPlatformGenres: Sequelize.HasManySetAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    addPlatformGenre: Sequelize.HasManyAddAssociationMixin<PlatformGenre, PlatformGenreId>;
+    addPlatformGenres: Sequelize.HasManyAddAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    createPlatformGenre: Sequelize.HasManyCreateAssociationMixin<PlatformGenre>;
+    removePlatformGenre: Sequelize.HasManyRemoveAssociationMixin<PlatformGenre, PlatformGenreId>;
+    removePlatformGenres: Sequelize.HasManyRemoveAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    hasPlatformGenre: Sequelize.HasManyHasAssociationMixin<PlatformGenre, PlatformGenreId>;
+    hasPlatformGenres: Sequelize.HasManyHasAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    countPlatformGenres: Sequelize.HasManyCountAssociationsMixin;
+    platformTracks: PlatformTrack[];
+    getPlatformTracks: Sequelize.HasManyGetAssociationsMixin<PlatformTrack>;
+    setPlatformTracks: Sequelize.HasManySetAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    addPlatformTrack: Sequelize.HasManyAddAssociationMixin<PlatformTrack, PlatformTrackId>;
+    addPlatformTracks: Sequelize.HasManyAddAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrack: Sequelize.HasManyCreateAssociationMixin<PlatformTrack>;
+    removePlatformTrack: Sequelize.HasManyRemoveAssociationMixin<PlatformTrack, PlatformTrackId>;
+    removePlatformTracks: Sequelize.HasManyRemoveAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    hasPlatformTrack: Sequelize.HasManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
+    hasPlatformTracks: Sequelize.HasManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    countPlatformTracks: Sequelize.HasManyCountAssociationsMixin;
+    platformUserAlbums: PlatformUserAlbum[];
+    getPlatformUserAlbums: Sequelize.HasManyGetAssociationsMixin<PlatformUserAlbum>;
+    setPlatformUserAlbums: Sequelize.HasManySetAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    addPlatformUserAlbum: Sequelize.HasManyAddAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    addPlatformUserAlbums: Sequelize.HasManyAddAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    createPlatformUserAlbum: Sequelize.HasManyCreateAssociationMixin<PlatformUserAlbum>;
+    removePlatformUserAlbum: Sequelize.HasManyRemoveAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    removePlatformUserAlbums: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    hasPlatformUserAlbum: Sequelize.HasManyHasAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    hasPlatformUserAlbums: Sequelize.HasManyHasAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    countPlatformUserAlbums: 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;
+    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;
+    unmatchedArtists: UnmatchedArtist[];
+    getUnmatchedArtists: Sequelize.HasManyGetAssociationsMixin<UnmatchedArtist>;
+    setUnmatchedArtists: Sequelize.HasManySetAssociationsMixin<UnmatchedArtist, UnmatchedArtistId>;
+    addUnmatchedArtist: Sequelize.HasManyAddAssociationMixin<UnmatchedArtist, UnmatchedArtistId>;
+    addUnmatchedArtists: Sequelize.HasManyAddAssociationsMixin<UnmatchedArtist, UnmatchedArtistId>;
+    createUnmatchedArtist: Sequelize.HasManyCreateAssociationMixin<UnmatchedArtist>;
+    removeUnmatchedArtist: Sequelize.HasManyRemoveAssociationMixin<UnmatchedArtist, UnmatchedArtistId>;
+    removeUnmatchedArtists: Sequelize.HasManyRemoveAssociationsMixin<UnmatchedArtist, UnmatchedArtistId>;
+    hasUnmatchedArtist: Sequelize.HasManyHasAssociationMixin<UnmatchedArtist, UnmatchedArtistId>;
+    hasUnmatchedArtists: Sequelize.HasManyHasAssociationsMixin<UnmatchedArtist, UnmatchedArtistId>;
+    countUnmatchedArtists: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof Platform;
+}

package/dist/Platform.js

@@ -0,0 +1,80 @@
+"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.Platform = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class Platform extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return Platform.init({
+            id: {
+                autoIncrement: true,
+                autoIncrementIdentity: true,
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            name: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                unique: "uk_name"
+            },
+            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',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "external_source_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "uk_name",
+                    unique: true,
+                    fields: [
+                        { name: "name" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.Platform = Platform;