@earbug/db-models 0.0.62 → 0.0.63

package/models/JukeboxTerminationCondition.ts

@@ -0,0 +1,60 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+
+export interface JukeboxTerminationConditionAttributes {
+  id: number;
+  description: string;
+}
+
+export type JukeboxTerminationConditionPk = "id";
+export type JukeboxTerminationConditionId = JukeboxTerminationCondition[JukeboxTerminationConditionPk];
+export type JukeboxTerminationConditionCreationAttributes = JukeboxTerminationConditionAttributes;
+
+export class JukeboxTerminationCondition extends Model<JukeboxTerminationConditionAttributes, JukeboxTerminationConditionCreationAttributes> implements JukeboxTerminationConditionAttributes {
+  id!: number;
+  description!: string;
+
+  // JukeboxTerminationCondition hasMany JukeboxSession via terminationConditionId
+  jukeboxSessions!: JukeboxSession[];
+  getJukeboxSessions!: Sequelize.HasManyGetAssociationsMixin<JukeboxSession>;
+  setJukeboxSessions!: Sequelize.HasManySetAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  addJukeboxSession!: Sequelize.HasManyAddAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  addJukeboxSessions!: Sequelize.HasManyAddAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.HasManyCreateAssociationMixin<JukeboxSession>;
+  removeJukeboxSession!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  removeJukeboxSessions!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  hasJukeboxSession!: Sequelize.HasManyHasAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  hasJukeboxSessions!: Sequelize.HasManyHasAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  countJukeboxSessions!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxTerminationCondition {
+    return JukeboxTerminationCondition.init({
+    id: {
+      autoIncrement: true,
+      autoIncrementIdentity: true,
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_termination_condition',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_termination_condition_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxType.ts

@@ -0,0 +1,60 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+
+export interface JukeboxTypeAttributes {
+  id: number;
+  description: string;
+}
+
+export type JukeboxTypePk = "id";
+export type JukeboxTypeId = JukeboxType[JukeboxTypePk];
+export type JukeboxTypeCreationAttributes = JukeboxTypeAttributes;
+
+export class JukeboxType extends Model<JukeboxTypeAttributes, JukeboxTypeCreationAttributes> implements JukeboxTypeAttributes {
+  id!: number;
+  description!: string;
+
+  // JukeboxType hasMany JukeboxSession via typeId
+  jukeboxSessions!: JukeboxSession[];
+  getJukeboxSessions!: Sequelize.HasManyGetAssociationsMixin<JukeboxSession>;
+  setJukeboxSessions!: Sequelize.HasManySetAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  addJukeboxSession!: Sequelize.HasManyAddAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  addJukeboxSessions!: Sequelize.HasManyAddAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.HasManyCreateAssociationMixin<JukeboxSession>;
+  removeJukeboxSession!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  removeJukeboxSessions!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  hasJukeboxSession!: Sequelize.HasManyHasAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  hasJukeboxSessions!: Sequelize.HasManyHasAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  countJukeboxSessions!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxType {
+    return JukeboxType.init({
+    id: {
+      autoIncrement: true,
+      autoIncrementIdentity: true,
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxUser.ts

@@ -0,0 +1,182 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+import type { JukeboxUserType, JukeboxUserTypeId } from './JukeboxUserType';
+import type { PauseStatusType, PauseStatusTypeId } from './PauseStatusType';
+
+export interface JukeboxUserAttributes {
+  id: string;
+  jukeboxSessionId: string;
+  appUserId: string;
+  createdAt: Date;
+  updatedAt: Date;
+  enterDate: Date;
+  exitDate?: Date;
+  jukeboxUserTypeId: number;
+  pauseStatusTypeId: number;
+  pausedQueueEntryId?: string;
+}
+
+export type JukeboxUserPk = "id";
+export type JukeboxUserId = JukeboxUser[JukeboxUserPk];
+export type JukeboxUserOptionalAttributes = "id" | "createdAt" | "updatedAt" | "enterDate" | "exitDate" | "jukeboxUserTypeId" | "pauseStatusTypeId" | "pausedQueueEntryId";
+export type JukeboxUserCreationAttributes = Optional<JukeboxUserAttributes, JukeboxUserOptionalAttributes>;
+
+export class JukeboxUser extends Model<JukeboxUserAttributes, JukeboxUserCreationAttributes> implements JukeboxUserAttributes {
+  id!: string;
+  jukeboxSessionId!: string;
+  appUserId!: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+  enterDate!: Date;
+  exitDate?: Date;
+  jukeboxUserTypeId!: number;
+  pauseStatusTypeId!: number;
+  pausedQueueEntryId?: string;
+
+  // JukeboxUser belongsTo AppUser via appUserId
+  appUser!: AppUser;
+  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // JukeboxUser belongsTo JukeboxQueueEntry via pausedQueueEntryId
+  pausedQueueEntry!: JukeboxQueueEntry;
+  getPausedQueueEntry!: Sequelize.BelongsToGetAssociationMixin<JukeboxQueueEntry>;
+  setPausedQueueEntry!: Sequelize.BelongsToSetAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  createPausedQueueEntry!: Sequelize.BelongsToCreateAssociationMixin<JukeboxQueueEntry>;
+  // JukeboxUser belongsTo JukeboxSession via jukeboxSessionId
+  jukeboxSession!: JukeboxSession;
+  getJukeboxSession!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+  setJukeboxSession!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+  // JukeboxUser belongsTo JukeboxUserType via jukeboxUserTypeId
+  jukeboxUserType!: JukeboxUserType;
+  getJukeboxUserType!: Sequelize.BelongsToGetAssociationMixin<JukeboxUserType>;
+  setJukeboxUserType!: Sequelize.BelongsToSetAssociationMixin<JukeboxUserType, JukeboxUserTypeId>;
+  createJukeboxUserType!: Sequelize.BelongsToCreateAssociationMixin<JukeboxUserType>;
+  // JukeboxUser belongsTo PauseStatusType via pauseStatusTypeId
+  pauseStatusType!: PauseStatusType;
+  getPauseStatusType!: Sequelize.BelongsToGetAssociationMixin<PauseStatusType>;
+  setPauseStatusType!: Sequelize.BelongsToSetAssociationMixin<PauseStatusType, PauseStatusTypeId>;
+  createPauseStatusType!: Sequelize.BelongsToCreateAssociationMixin<PauseStatusType>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxUser {
+    return JukeboxUser.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    jukeboxSessionId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      unique: "unique_jukebox_user_id",
+      field: 'jukebox_session_id'
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      unique: "unique_jukebox_user_id",
+      field: 'app_user_id'
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    },
+    updatedAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'updated_at'
+    },
+    enterDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'enter_date'
+    },
+    exitDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'exit_date'
+    },
+    jukeboxUserTypeId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      references: {
+        model: 'jukebox_user_type',
+        key: 'id'
+      },
+      field: 'jukebox_user_type_id'
+    },
+    pauseStatusTypeId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      references: {
+        model: 'pause_status_type',
+        key: 'id'
+      },
+      field: 'pause_status_type_id'
+    },
+    pausedQueueEntryId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'jukebox_queue_entry',
+        key: 'id'
+      },
+      field: 'paused_queue_entry_id'
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_user',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_jukebox_user_app_user",
+        fields: [
+          { name: "app_user_id" },
+        ]
+      },
+      {
+        name: "idx_jukebox_user_one_active_per_user",
+        unique: true,
+        fields: [
+          { name: "app_user_id" },
+        ]
+      },
+      {
+        name: "jukebox_user_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "unique_jukebox_user_id",
+        unique: true,
+        fields: [
+          { name: "jukebox_session_id" },
+          { name: "app_user_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxUserType.ts

@@ -0,0 +1,58 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+
+export interface JukeboxUserTypeAttributes {
+  id: number;
+  description: string;
+}
+
+export type JukeboxUserTypePk = "id";
+export type JukeboxUserTypeId = JukeboxUserType[JukeboxUserTypePk];
+export type JukeboxUserTypeCreationAttributes = JukeboxUserTypeAttributes;
+
+export class JukeboxUserType extends Model<JukeboxUserTypeAttributes, JukeboxUserTypeCreationAttributes> implements JukeboxUserTypeAttributes {
+  id!: number;
+  description!: string;
+
+  // JukeboxUserType hasMany JukeboxUser via jukeboxUserTypeId
+  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 JukeboxUserType {
+    return JukeboxUserType.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.STRING(255),
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_user_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_user_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/KnexMigrations.ts

@@ -0,0 +1,60 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+
+export interface KnexMigrationsAttributes {
+  id: number;
+  name?: string;
+  batch?: number;
+  migrationTime?: Date;
+}
+
+export type KnexMigrationsPk = "id";
+export type KnexMigrationsId = KnexMigrations[KnexMigrationsPk];
+export type KnexMigrationsOptionalAttributes = "id" | "name" | "batch" | "migrationTime";
+export type KnexMigrationsCreationAttributes = Optional<KnexMigrationsAttributes, KnexMigrationsOptionalAttributes>;
+
+export class KnexMigrations extends Model<KnexMigrationsAttributes, KnexMigrationsCreationAttributes> implements KnexMigrationsAttributes {
+  id!: number;
+  name?: string;
+  batch?: number;
+  migrationTime?: Date;
+
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof KnexMigrations {
+    return KnexMigrations.init({
+    id: {
+      autoIncrement: true,
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.STRING(255),
+      allowNull: true
+    },
+    batch: {
+      type: DataTypes.INTEGER,
+      allowNull: true
+    },
+    migrationTime: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'migration_time'
+    }
+  }, {
+    sequelize,
+    tableName: 'knex_migrations',
+    schema: 'public',
+    timestamps: false,
+    indexes: [
+      {
+        name: "knex_migrations_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/KnexMigrationsLock.ts

@@ -0,0 +1,48 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+
+export interface KnexMigrationsLockAttributes {
+  index: number;
+  isLocked?: number;
+}
+
+export type KnexMigrationsLockPk = "index";
+export type KnexMigrationsLockId = KnexMigrationsLock[KnexMigrationsLockPk];
+export type KnexMigrationsLockOptionalAttributes = "index" | "isLocked";
+export type KnexMigrationsLockCreationAttributes = Optional<KnexMigrationsLockAttributes, KnexMigrationsLockOptionalAttributes>;
+
+export class KnexMigrationsLock extends Model<KnexMigrationsLockAttributes, KnexMigrationsLockCreationAttributes> implements KnexMigrationsLockAttributes {
+  index!: number;
+  isLocked?: number;
+
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof KnexMigrationsLock {
+    return KnexMigrationsLock.init({
+    index: {
+      autoIncrement: true,
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      primaryKey: true
+    },
+    isLocked: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+      field: 'is_locked'
+    }
+  }, {
+    sequelize,
+    tableName: 'knex_migrations_lock',
+    schema: 'public',
+    timestamps: false,
+    indexes: [
+      {
+        name: "knex_migrations_lock_pkey",
+        unique: true,
+        fields: [
+          { name: "index" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/MerchItem.ts

@@ -0,0 +1,198 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { MerchPlatform, MerchPlatformId } from './MerchPlatform';
+import type { MerchType, MerchTypeId } from './MerchType';
+import type { UserBookmarks, UserBookmarksId } from './UserBookmarks';
+import type { UserComments, UserCommentsId } from './UserComments';
+import type { UserLikes, UserLikesId } from './UserLikes';
+
+export interface MerchItemAttributes {
+  id: string;
+  canonArtistId: string;
+  merchTypeId: string;
+  merchPlatformId: string;
+  merchItemPlatformId: string;
+  title: string;
+  description: string;
+  photo?: string;
+  popularity?: number;
+  inactive?: boolean;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type MerchItemPk = "id";
+export type MerchItemId = MerchItem[MerchItemPk];
+export type MerchItemOptionalAttributes = "id" | "photo" | "popularity" | "inactive" | "createDate" | "updateDate";
+export type MerchItemCreationAttributes = Optional<MerchItemAttributes, MerchItemOptionalAttributes>;
+
+export class MerchItem extends Model<MerchItemAttributes, MerchItemCreationAttributes> implements MerchItemAttributes {
+  id!: string;
+  canonArtistId!: string;
+  merchTypeId!: string;
+  merchPlatformId!: string;
+  merchItemPlatformId!: string;
+  title!: string;
+  description!: string;
+  photo?: string;
+  popularity?: number;
+  inactive?: boolean;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // MerchItem belongsTo CanonArtist via canonArtistId
+  canonArtist!: CanonArtist;
+  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+  // MerchItem hasMany UserBookmarks via merchItemId
+  userBookmarks!: UserBookmarks[];
+  getUserBookmarks!: Sequelize.HasManyGetAssociationsMixin<UserBookmarks>;
+  setUserBookmarks!: Sequelize.HasManySetAssociationsMixin<UserBookmarks, UserBookmarksId>;
+  addUserBookmark!: Sequelize.HasManyAddAssociationMixin<UserBookmarks, UserBookmarksId>;
+  addUserBookmarks!: Sequelize.HasManyAddAssociationsMixin<UserBookmarks, UserBookmarksId>;
+  createUserBookmark!: Sequelize.HasManyCreateAssociationMixin<UserBookmarks>;
+  removeUserBookmark!: Sequelize.HasManyRemoveAssociationMixin<UserBookmarks, UserBookmarksId>;
+  removeUserBookmarks!: Sequelize.HasManyRemoveAssociationsMixin<UserBookmarks, UserBookmarksId>;
+  hasUserBookmark!: Sequelize.HasManyHasAssociationMixin<UserBookmarks, UserBookmarksId>;
+  hasUserBookmarks!: Sequelize.HasManyHasAssociationsMixin<UserBookmarks, UserBookmarksId>;
+  countUserBookmarks!: Sequelize.HasManyCountAssociationsMixin;
+  // MerchItem hasMany UserComments via merchItemId
+  userComments!: UserComments[];
+  getUserComments!: Sequelize.HasManyGetAssociationsMixin<UserComments>;
+  setUserComments!: Sequelize.HasManySetAssociationsMixin<UserComments, UserCommentsId>;
+  addUserComment!: Sequelize.HasManyAddAssociationMixin<UserComments, UserCommentsId>;
+  addUserComments!: Sequelize.HasManyAddAssociationsMixin<UserComments, UserCommentsId>;
+  createUserComment!: Sequelize.HasManyCreateAssociationMixin<UserComments>;
+  removeUserComment!: Sequelize.HasManyRemoveAssociationMixin<UserComments, UserCommentsId>;
+  removeUserComments!: Sequelize.HasManyRemoveAssociationsMixin<UserComments, UserCommentsId>;
+  hasUserComment!: Sequelize.HasManyHasAssociationMixin<UserComments, UserCommentsId>;
+  hasUserComments!: Sequelize.HasManyHasAssociationsMixin<UserComments, UserCommentsId>;
+  countUserComments!: Sequelize.HasManyCountAssociationsMixin;
+  // MerchItem hasMany UserLikes via merchItemId
+  userLikes!: UserLikes[];
+  getUserLikes!: Sequelize.HasManyGetAssociationsMixin<UserLikes>;
+  setUserLikes!: Sequelize.HasManySetAssociationsMixin<UserLikes, UserLikesId>;
+  addUserLike!: Sequelize.HasManyAddAssociationMixin<UserLikes, UserLikesId>;
+  addUserLikes!: Sequelize.HasManyAddAssociationsMixin<UserLikes, UserLikesId>;
+  createUserLike!: Sequelize.HasManyCreateAssociationMixin<UserLikes>;
+  removeUserLike!: Sequelize.HasManyRemoveAssociationMixin<UserLikes, UserLikesId>;
+  removeUserLikes!: Sequelize.HasManyRemoveAssociationsMixin<UserLikes, UserLikesId>;
+  hasUserLike!: Sequelize.HasManyHasAssociationMixin<UserLikes, UserLikesId>;
+  hasUserLikes!: Sequelize.HasManyHasAssociationsMixin<UserLikes, UserLikesId>;
+  countUserLikes!: Sequelize.HasManyCountAssociationsMixin;
+  // MerchItem belongsTo MerchPlatform via merchPlatformId
+  merchPlatform!: MerchPlatform;
+  getMerchPlatform!: Sequelize.BelongsToGetAssociationMixin<MerchPlatform>;
+  setMerchPlatform!: Sequelize.BelongsToSetAssociationMixin<MerchPlatform, MerchPlatformId>;
+  createMerchPlatform!: Sequelize.BelongsToCreateAssociationMixin<MerchPlatform>;
+  // MerchItem belongsTo MerchType via merchTypeId
+  merchType!: MerchType;
+  getMerchType!: Sequelize.BelongsToGetAssociationMixin<MerchType>;
+  setMerchType!: Sequelize.BelongsToSetAssociationMixin<MerchType, MerchTypeId>;
+  createMerchType!: Sequelize.BelongsToCreateAssociationMixin<MerchType>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof MerchItem {
+    return MerchItem.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    canonArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'canon_artist',
+        key: 'id'
+      },
+      field: 'canon_artist_id'
+    },
+    merchTypeId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'merch_type',
+        key: 'id'
+      },
+      field: 'merch_type_id'
+    },
+    merchPlatformId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'merch_platform',
+        key: 'id'
+      },
+      field: 'merch_platform_id'
+    },
+    merchItemPlatformId: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'merch_item_platform_id'
+    },
+    title: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    photo: {
+      type: DataTypes.TEXT,
+      allowNull: true
+    },
+    popularity: {
+      type: DataTypes.SMALLINT,
+      allowNull: true
+    },
+    inactive: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      defaultValue: false
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'merch_item',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_merch_item_artist",
+        fields: [
+          { name: "canon_artist_id" },
+        ]
+      },
+      {
+        name: "idx_merch_item_artist_create_date",
+        fields: [
+          { name: "canon_artist_id" },
+          { name: "create_date", order: "DESC" },
+        ]
+      },
+      {
+        name: "merch_item_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}