@earbug/db-models 0.0.59 → 0.0.62

package/models/VersusEndMode.ts

@@ -1,66 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { Versus, VersusId } from './Versus';
-
-export interface VersusEndModeAttributes {
-  id: number;
-  description: string;
-}
-
-export type VersusEndModePk = "id";
-export type VersusEndModeId = VersusEndMode[VersusEndModePk];
-export type VersusEndModeCreationAttributes = VersusEndModeAttributes;
-
-export class VersusEndMode extends Model<VersusEndModeAttributes, VersusEndModeCreationAttributes> implements VersusEndModeAttributes {
-  id!: number;
-  description!: string;
-
-  // VersusEndMode hasMany Versus via versusEndModeId
-  versus!: Versus[];
-  getVersus!: Sequelize.HasManyGetAssociationsMixin<Versus>;
-  setVersus!: Sequelize.HasManySetAssociationsMixin<Versus, VersusId>;
-  addVersu!: Sequelize.HasManyAddAssociationMixin<Versus, VersusId>;
-  addVersus!: Sequelize.HasManyAddAssociationsMixin<Versus, VersusId>;
-  createVersu!: Sequelize.HasManyCreateAssociationMixin<Versus>;
-  removeVersu!: Sequelize.HasManyRemoveAssociationMixin<Versus, VersusId>;
-  removeVersus!: Sequelize.HasManyRemoveAssociationsMixin<Versus, VersusId>;
-  hasVersu!: Sequelize.HasManyHasAssociationMixin<Versus, VersusId>;
-  hasVersus!: Sequelize.HasManyHasAssociationsMixin<Versus, VersusId>;
-  countVersus!: Sequelize.HasManyCountAssociationsMixin;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof VersusEndMode {
-    return VersusEndMode.init({
-    id: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      primaryKey: true
-    },
-    description: {
-      type: DataTypes.STRING(64),
-      allowNull: false,
-      unique: "versus_end_mode_description_unique"
-    }
-  }, {
-    sequelize,
-    tableName: 'versus_end_mode',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "versus_end_mode_description_unique",
-        unique: true,
-        fields: [
-          { name: "description" },
-        ]
-      },
-      {
-        name: "versus_end_mode_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/VersusEndTimerDuration.ts

@@ -1,81 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { Versus, VersusId } from './Versus';
-
-export interface VersusEndTimerDurationAttributes {
-  id: number;
-  description: string;
-  durationHours: number;
-}
-
-export type VersusEndTimerDurationPk = "id";
-export type VersusEndTimerDurationId = VersusEndTimerDuration[VersusEndTimerDurationPk];
-export type VersusEndTimerDurationCreationAttributes = VersusEndTimerDurationAttributes;
-
-export class VersusEndTimerDuration extends Model<VersusEndTimerDurationAttributes, VersusEndTimerDurationCreationAttributes> implements VersusEndTimerDurationAttributes {
-  id!: number;
-  description!: string;
-  durationHours!: number;
-
-  // VersusEndTimerDuration hasMany Versus via versusEndTimerDurationId
-  versus!: Versus[];
-  getVersus!: Sequelize.HasManyGetAssociationsMixin<Versus>;
-  setVersus!: Sequelize.HasManySetAssociationsMixin<Versus, VersusId>;
-  addVersu!: Sequelize.HasManyAddAssociationMixin<Versus, VersusId>;
-  addVersus!: Sequelize.HasManyAddAssociationsMixin<Versus, VersusId>;
-  createVersu!: Sequelize.HasManyCreateAssociationMixin<Versus>;
-  removeVersu!: Sequelize.HasManyRemoveAssociationMixin<Versus, VersusId>;
-  removeVersus!: Sequelize.HasManyRemoveAssociationsMixin<Versus, VersusId>;
-  hasVersu!: Sequelize.HasManyHasAssociationMixin<Versus, VersusId>;
-  hasVersus!: Sequelize.HasManyHasAssociationsMixin<Versus, VersusId>;
-  countVersus!: Sequelize.HasManyCountAssociationsMixin;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof VersusEndTimerDuration {
-    return VersusEndTimerDuration.init({
-    id: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      primaryKey: true
-    },
-    description: {
-      type: DataTypes.STRING(64),
-      allowNull: false,
-      unique: "versus_end_timer_duration_description_unique"
-    },
-    durationHours: {
-      type: DataTypes.INTEGER,
-      allowNull: false,
-      unique: "versus_end_timer_duration_duration_hours_unique",
-      field: 'duration_hours'
-    }
-  }, {
-    sequelize,
-    tableName: 'versus_end_timer_duration',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "versus_end_timer_duration_description_unique",
-        unique: true,
-        fields: [
-          { name: "description" },
-        ]
-      },
-      {
-        name: "versus_end_timer_duration_duration_hours_unique",
-        unique: true,
-        fields: [
-          { name: "duration_hours" },
-        ]
-      },
-      {
-        name: "versus_end_timer_duration_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/VersusEndVoteThreshold.ts

@@ -1,67 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { Versus, VersusId } from './Versus';
-
-export interface VersusEndVoteThresholdAttributes {
-  id: number;
-  voteCount: number;
-}
-
-export type VersusEndVoteThresholdPk = "id";
-export type VersusEndVoteThresholdId = VersusEndVoteThreshold[VersusEndVoteThresholdPk];
-export type VersusEndVoteThresholdCreationAttributes = VersusEndVoteThresholdAttributes;
-
-export class VersusEndVoteThreshold extends Model<VersusEndVoteThresholdAttributes, VersusEndVoteThresholdCreationAttributes> implements VersusEndVoteThresholdAttributes {
-  id!: number;
-  voteCount!: number;
-
-  // VersusEndVoteThreshold hasMany Versus via versusEndVoteThresholdId
-  versus!: Versus[];
-  getVersus!: Sequelize.HasManyGetAssociationsMixin<Versus>;
-  setVersus!: Sequelize.HasManySetAssociationsMixin<Versus, VersusId>;
-  addVersu!: Sequelize.HasManyAddAssociationMixin<Versus, VersusId>;
-  addVersus!: Sequelize.HasManyAddAssociationsMixin<Versus, VersusId>;
-  createVersu!: Sequelize.HasManyCreateAssociationMixin<Versus>;
-  removeVersu!: Sequelize.HasManyRemoveAssociationMixin<Versus, VersusId>;
-  removeVersus!: Sequelize.HasManyRemoveAssociationsMixin<Versus, VersusId>;
-  hasVersu!: Sequelize.HasManyHasAssociationMixin<Versus, VersusId>;
-  hasVersus!: Sequelize.HasManyHasAssociationsMixin<Versus, VersusId>;
-  countVersus!: Sequelize.HasManyCountAssociationsMixin;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof VersusEndVoteThreshold {
-    return VersusEndVoteThreshold.init({
-    id: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      primaryKey: true
-    },
-    voteCount: {
-      type: DataTypes.INTEGER,
-      allowNull: false,
-      unique: "versus_end_vote_threshold_vote_count_unique",
-      field: 'vote_count'
-    }
-  }, {
-    sequelize,
-    tableName: 'versus_end_vote_threshold',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "versus_end_vote_threshold_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-      {
-        name: "versus_end_vote_threshold_vote_count_unique",
-        unique: true,
-        fields: [
-          { name: "vote_count" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/VersusEntityKind.ts

@@ -1,79 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { VersusOption, VersusOptionId } from './VersusOption';
-import type { VersusPublishIssue, VersusPublishIssueId } from './VersusPublishIssue';
-
-export interface VersusEntityKindAttributes {
-  id: number;
-  description: string;
-}
-
-export type VersusEntityKindPk = "id";
-export type VersusEntityKindId = VersusEntityKind[VersusEntityKindPk];
-export type VersusEntityKindCreationAttributes = VersusEntityKindAttributes;
-
-export class VersusEntityKind extends Model<VersusEntityKindAttributes, VersusEntityKindCreationAttributes> implements VersusEntityKindAttributes {
-  id!: number;
-  description!: string;
-
-  // VersusEntityKind hasMany VersusOption via entityKindId
-  versusOptions!: VersusOption[];
-  getVersusOptions!: Sequelize.HasManyGetAssociationsMixin<VersusOption>;
-  setVersusOptions!: Sequelize.HasManySetAssociationsMixin<VersusOption, VersusOptionId>;
-  addVersusOption!: Sequelize.HasManyAddAssociationMixin<VersusOption, VersusOptionId>;
-  addVersusOptions!: Sequelize.HasManyAddAssociationsMixin<VersusOption, VersusOptionId>;
-  createVersusOption!: Sequelize.HasManyCreateAssociationMixin<VersusOption>;
-  removeVersusOption!: Sequelize.HasManyRemoveAssociationMixin<VersusOption, VersusOptionId>;
-  removeVersusOptions!: Sequelize.HasManyRemoveAssociationsMixin<VersusOption, VersusOptionId>;
-  hasVersusOption!: Sequelize.HasManyHasAssociationMixin<VersusOption, VersusOptionId>;
-  hasVersusOptions!: Sequelize.HasManyHasAssociationsMixin<VersusOption, VersusOptionId>;
-  countVersusOptions!: Sequelize.HasManyCountAssociationsMixin;
-  // VersusEntityKind hasMany VersusPublishIssue via entityKindId
-  versusPublishIssues!: VersusPublishIssue[];
-  getVersusPublishIssues!: Sequelize.HasManyGetAssociationsMixin<VersusPublishIssue>;
-  setVersusPublishIssues!: Sequelize.HasManySetAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
-  addVersusPublishIssue!: Sequelize.HasManyAddAssociationMixin<VersusPublishIssue, VersusPublishIssueId>;
-  addVersusPublishIssues!: Sequelize.HasManyAddAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
-  createVersusPublishIssue!: Sequelize.HasManyCreateAssociationMixin<VersusPublishIssue>;
-  removeVersusPublishIssue!: Sequelize.HasManyRemoveAssociationMixin<VersusPublishIssue, VersusPublishIssueId>;
-  removeVersusPublishIssues!: Sequelize.HasManyRemoveAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
-  hasVersusPublishIssue!: Sequelize.HasManyHasAssociationMixin<VersusPublishIssue, VersusPublishIssueId>;
-  hasVersusPublishIssues!: Sequelize.HasManyHasAssociationsMixin<VersusPublishIssue, VersusPublishIssueId>;
-  countVersusPublishIssues!: Sequelize.HasManyCountAssociationsMixin;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof VersusEntityKind {
-    return VersusEntityKind.init({
-    id: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      primaryKey: true
-    },
-    description: {
-      type: DataTypes.STRING(32),
-      allowNull: false,
-      unique: "versus_entity_kind_description_unique"
-    }
-  }, {
-    sequelize,
-    tableName: 'versus_entity_kind',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "versus_entity_kind_description_unique",
-        unique: true,
-        fields: [
-          { name: "description" },
-        ]
-      },
-      {
-        name: "versus_entity_kind_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/VersusOption.ts

@@ -1,258 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { AppUser, AppUserId } from './AppUser';
-import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
-import type { CanonArtist, CanonArtistId } from './CanonArtist';
-import type { CanonTrack, CanonTrackId } from './CanonTrack';
-import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
-import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
-import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
-import type { Versus, VersusId } from './Versus';
-import type { VersusEntityKind, VersusEntityKindId } from './VersusEntityKind';
-
-export interface VersusOptionAttributes {
-  versusId: string;
-  entityKindId: number;
-  sortOrder: number;
-  canonTrackId?: string;
-  platformTrackId?: string;
-  canonAlbumId?: string;
-  platformAlbumId?: string;
-  canonArtistId?: string;
-  platformArtistId?: string;
-  voteScore?: number;
-  resultsScore?: number;
-  id: string;
-  createdAt: Date;
-  updatedAt: Date;
-  deleted: boolean;
-  appUserId?: string;
-}
-
-export type VersusOptionPk = "id";
-export type VersusOptionId = VersusOption[VersusOptionPk];
-export type VersusOptionOptionalAttributes = "canonTrackId" | "platformTrackId" | "canonAlbumId" | "platformAlbumId" | "canonArtistId" | "platformArtistId" | "voteScore" | "resultsScore" | "id" | "createdAt" | "updatedAt" | "appUserId";
-export type VersusOptionCreationAttributes = Optional<VersusOptionAttributes, VersusOptionOptionalAttributes>;
-
-export class VersusOption extends Model<VersusOptionAttributes, VersusOptionCreationAttributes> implements VersusOptionAttributes {
-  versusId!: string;
-  entityKindId!: number;
-  sortOrder!: number;
-  canonTrackId?: string;
-  platformTrackId?: string;
-  canonAlbumId?: string;
-  platformAlbumId?: string;
-  canonArtistId?: string;
-  platformArtistId?: string;
-  voteScore?: number;
-  resultsScore?: number;
-  id!: string;
-  createdAt!: Date;
-  updatedAt!: Date;
-  deleted!: boolean;
-  appUserId?: string;
-
-  // VersusOption belongsTo AppUser via appUserId
-  appUser!: AppUser;
-  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
-  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
-  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
-  // VersusOption belongsTo CanonAlbum via canonAlbumId
-  canonAlbum!: CanonAlbum;
-  getCanonAlbum!: Sequelize.BelongsToGetAssociationMixin<CanonAlbum>;
-  setCanonAlbum!: Sequelize.BelongsToSetAssociationMixin<CanonAlbum, CanonAlbumId>;
-  createCanonAlbum!: Sequelize.BelongsToCreateAssociationMixin<CanonAlbum>;
-  // VersusOption belongsTo CanonArtist via canonArtistId
-  canonArtist!: CanonArtist;
-  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
-  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
-  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
-  // VersusOption belongsTo CanonTrack via canonTrackId
-  canonTrack!: CanonTrack;
-  getCanonTrack!: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
-  setCanonTrack!: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
-  createCanonTrack!: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
-  // VersusOption belongsTo PlatformAlbum via platformAlbumId
-  platformAlbum!: PlatformAlbum;
-  getPlatformAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
-  setPlatformAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
-  createPlatformAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
-  // VersusOption belongsTo PlatformArtist via platformArtistId
-  platformArtist!: PlatformArtist;
-  getPlatformArtist!: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
-  setPlatformArtist!: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
-  createPlatformArtist!: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
-  // VersusOption belongsTo PlatformTrack via platformTrackId
-  platformTrack!: PlatformTrack;
-  getPlatformTrack!: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
-  setPlatformTrack!: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
-  createPlatformTrack!: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
-  // VersusOption belongsTo Versus via versusId
-  versu!: Versus;
-  getVersu!: Sequelize.BelongsToGetAssociationMixin<Versus>;
-  setVersu!: Sequelize.BelongsToSetAssociationMixin<Versus, VersusId>;
-  createVersu!: Sequelize.BelongsToCreateAssociationMixin<Versus>;
-  // VersusOption belongsTo VersusEntityKind via entityKindId
-  entityKind!: VersusEntityKind;
-  getEntityKind!: Sequelize.BelongsToGetAssociationMixin<VersusEntityKind>;
-  setEntityKind!: Sequelize.BelongsToSetAssociationMixin<VersusEntityKind, VersusEntityKindId>;
-  createEntityKind!: Sequelize.BelongsToCreateAssociationMixin<VersusEntityKind>;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof VersusOption {
-    return VersusOption.init({
-    versusId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'versus',
-        key: 'id'
-      },
-      field: 'versus_id'
-    },
-    entityKindId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      references: {
-        model: 'versus_entity_kind',
-        key: 'id'
-      },
-      field: 'entity_kind_id'
-    },
-    sortOrder: {
-      type: DataTypes.INTEGER,
-      allowNull: false,
-      field: 'sort_order'
-    },
-    canonTrackId: {
-      type: DataTypes.UUID,
-      allowNull: true,
-      references: {
-        model: 'canon_track',
-        key: 'id'
-      },
-      field: 'canon_track_id'
-    },
-    platformTrackId: {
-      type: DataTypes.UUID,
-      allowNull: true,
-      references: {
-        model: 'platform_track',
-        key: 'id'
-      },
-      field: 'platform_track_id'
-    },
-    canonAlbumId: {
-      type: DataTypes.UUID,
-      allowNull: true,
-      references: {
-        model: 'canon_album',
-        key: 'id'
-      },
-      field: 'canon_album_id'
-    },
-    platformAlbumId: {
-      type: DataTypes.UUID,
-      allowNull: true,
-      references: {
-        model: 'platform_album',
-        key: 'id'
-      },
-      field: 'platform_album_id'
-    },
-    canonArtistId: {
-      type: DataTypes.UUID,
-      allowNull: true,
-      references: {
-        model: 'canon_artist',
-        key: 'id'
-      },
-      field: 'canon_artist_id'
-    },
-    platformArtistId: {
-      type: DataTypes.UUID,
-      allowNull: true,
-      references: {
-        model: 'platform_artist',
-        key: 'id'
-      },
-      field: 'platform_artist_id'
-    },
-    voteScore: {
-      type: DataTypes.INTEGER,
-      allowNull: true,
-      field: 'vote_score'
-    },
-    resultsScore: {
-      type: DataTypes.SMALLINT,
-      allowNull: true,
-      field: 'results_score'
-    },
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: DataTypes.UUIDV4,
-      primaryKey: true
-    },
-    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'
-    },
-    deleted: {
-      type: DataTypes.BOOLEAN,
-      allowNull: false,
-      defaultValue: false
-    },
-    appUserId: {
-      type: DataTypes.UUID,
-      allowNull: true,
-      references: {
-        model: 'app_user',
-        key: 'id'
-      },
-      field: 'app_user_id'
-    }
-  }, {
-    sequelize,
-    tableName: 'versus_option',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "idx_versus_option_versus",
-        fields: [
-          { name: "versus_id" },
-        ]
-      },
-      {
-        name: "idx_versus_option_versus_deleted",
-        fields: [
-          { name: "versus_id" },
-          { name: "deleted" },
-        ]
-      },
-      {
-        name: "idx_versus_option_versus_sort",
-        fields: [
-          { name: "versus_id" },
-          { name: "sort_order" },
-        ]
-      },
-      {
-        name: "versus_option_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/VersusPublishIssue.ts

@@ -1,146 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
-import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
-import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
-import type { Versus, VersusId } from './Versus';
-import type { VersusEntityKind, VersusEntityKindId } from './VersusEntityKind';
-
-export interface VersusPublishIssueAttributes {
-  versusId: string;
-  entityKindId: number;
-  platformTrackId?: string;
-  platformAlbumId?: string;
-  platformArtistId?: string;
-  detail?: string;
-  id: string;
-  createdAt: Date;
-}
-
-export type VersusPublishIssuePk = "id";
-export type VersusPublishIssueId = VersusPublishIssue[VersusPublishIssuePk];
-export type VersusPublishIssueOptionalAttributes = "platformTrackId" | "platformAlbumId" | "platformArtistId" | "detail" | "id" | "createdAt";
-export type VersusPublishIssueCreationAttributes = Optional<VersusPublishIssueAttributes, VersusPublishIssueOptionalAttributes>;
-
-export class VersusPublishIssue extends Model<VersusPublishIssueAttributes, VersusPublishIssueCreationAttributes> implements VersusPublishIssueAttributes {
-  versusId!: string;
-  entityKindId!: number;
-  platformTrackId?: string;
-  platformAlbumId?: string;
-  platformArtistId?: string;
-  detail?: string;
-  id!: string;
-  createdAt!: Date;
-
-  // VersusPublishIssue belongsTo PlatformAlbum via platformAlbumId
-  platformAlbum!: PlatformAlbum;
-  getPlatformAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
-  setPlatformAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
-  createPlatformAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
-  // VersusPublishIssue belongsTo PlatformArtist via platformArtistId
-  platformArtist!: PlatformArtist;
-  getPlatformArtist!: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
-  setPlatformArtist!: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
-  createPlatformArtist!: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
-  // VersusPublishIssue belongsTo PlatformTrack via platformTrackId
-  platformTrack!: PlatformTrack;
-  getPlatformTrack!: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
-  setPlatformTrack!: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
-  createPlatformTrack!: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
-  // VersusPublishIssue belongsTo Versus via versusId
-  versu!: Versus;
-  getVersu!: Sequelize.BelongsToGetAssociationMixin<Versus>;
-  setVersu!: Sequelize.BelongsToSetAssociationMixin<Versus, VersusId>;
-  createVersu!: Sequelize.BelongsToCreateAssociationMixin<Versus>;
-  // VersusPublishIssue belongsTo VersusEntityKind via entityKindId
-  entityKind!: VersusEntityKind;
-  getEntityKind!: Sequelize.BelongsToGetAssociationMixin<VersusEntityKind>;
-  setEntityKind!: Sequelize.BelongsToSetAssociationMixin<VersusEntityKind, VersusEntityKindId>;
-  createEntityKind!: Sequelize.BelongsToCreateAssociationMixin<VersusEntityKind>;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof VersusPublishIssue {
-    return VersusPublishIssue.init({
-    versusId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'versus',
-        key: 'id'
-      },
-      field: 'versus_id'
-    },
-    entityKindId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      references: {
-        model: 'versus_entity_kind',
-        key: 'id'
-      },
-      field: 'entity_kind_id'
-    },
-    platformTrackId: {
-      type: DataTypes.UUID,
-      allowNull: true,
-      references: {
-        model: 'platform_track',
-        key: 'id'
-      },
-      field: 'platform_track_id'
-    },
-    platformAlbumId: {
-      type: DataTypes.UUID,
-      allowNull: true,
-      references: {
-        model: 'platform_album',
-        key: 'id'
-      },
-      field: 'platform_album_id'
-    },
-    platformArtistId: {
-      type: DataTypes.UUID,
-      allowNull: true,
-      references: {
-        model: 'platform_artist',
-        key: 'id'
-      },
-      field: 'platform_artist_id'
-    },
-    detail: {
-      type: DataTypes.TEXT,
-      allowNull: true
-    },
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: DataTypes.UUIDV4,
-      primaryKey: true
-    },
-    createdAt: {
-      type: DataTypes.DATE,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
-      field: 'created_at'
-    }
-  }, {
-    sequelize,
-    tableName: 'versus_publish_issue',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "idx_versus_publish_issue_versus",
-        fields: [
-          { name: "versus_id" },
-        ]
-      },
-      {
-        name: "versus_publish_issue_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}