@earbug/db-models 0.0.40 → 0.0.42

package/models/VersusOption.ts

@@ -0,0 +1,227 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+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;
+}
+
+export type VersusOptionPk = "id";
+export type VersusOptionId = VersusOption[VersusOptionPk];
+export type VersusOptionOptionalAttributes = "canonTrackId" | "platformTrackId" | "canonAlbumId" | "platformAlbumId" | "canonArtistId" | "platformArtistId" | "voteScore" | "resultsScore" | "id" | "createdAt" | "updatedAt";
+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;
+
+  // 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'
+    }
+  }, {
+    sequelize,
+    tableName: 'versus_option',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_versus_option_versus",
+        fields: [
+          { name: "versus_id" },
+        ]
+      },
+      {
+        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

@@ -0,0 +1,146 @@
+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" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/VersusQuestion.ts

@@ -0,0 +1,123 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { Versus, VersusId } from './Versus';
+import type { VersusQuestionVariableType, VersusQuestionVariableTypeId } from './VersusQuestionVariableType';
+import type { VersusVotingListType, VersusVotingListTypeId } from './VersusVotingListType';
+
+export interface VersusQuestionAttributes {
+  questionTemplate: string;
+  questionVariableTypeId: number;
+  votingListTypeId: number;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type VersusQuestionPk = "id";
+export type VersusQuestionId = VersusQuestion[VersusQuestionPk];
+export type VersusQuestionOptionalAttributes = "id" | "createdAt" | "updatedAt";
+export type VersusQuestionCreationAttributes = Optional<VersusQuestionAttributes, VersusQuestionOptionalAttributes>;
+
+export class VersusQuestion extends Model<VersusQuestionAttributes, VersusQuestionCreationAttributes> implements VersusQuestionAttributes {
+  questionTemplate!: string;
+  questionVariableTypeId!: number;
+  votingListTypeId!: number;
+  id!: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+
+  // VersusQuestion hasMany Versus via versusQuestionId
+  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;
+  // VersusQuestion belongsTo VersusQuestionVariableType via questionVariableTypeId
+  questionVariableType!: VersusQuestionVariableType;
+  getQuestionVariableType!: Sequelize.BelongsToGetAssociationMixin<VersusQuestionVariableType>;
+  setQuestionVariableType!: Sequelize.BelongsToSetAssociationMixin<VersusQuestionVariableType, VersusQuestionVariableTypeId>;
+  createQuestionVariableType!: Sequelize.BelongsToCreateAssociationMixin<VersusQuestionVariableType>;
+  // VersusQuestion belongsTo VersusVotingListType via votingListTypeId
+  votingListType!: VersusVotingListType;
+  getVotingListType!: Sequelize.BelongsToGetAssociationMixin<VersusVotingListType>;
+  setVotingListType!: Sequelize.BelongsToSetAssociationMixin<VersusVotingListType, VersusVotingListTypeId>;
+  createVotingListType!: Sequelize.BelongsToCreateAssociationMixin<VersusVotingListType>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof VersusQuestion {
+    return VersusQuestion.init({
+    questionTemplate: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'question_template'
+    },
+    questionVariableTypeId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'versus_question_variable_type',
+        key: 'id'
+      },
+      field: 'question_variable_type_id'
+    },
+    votingListTypeId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'versus_voting_list_type',
+        key: 'id'
+      },
+      field: 'voting_list_type_id'
+    },
+    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'
+    }
+  }, {
+    sequelize,
+    tableName: 'versus_question',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_versus_question_variable_type",
+        fields: [
+          { name: "question_variable_type_id" },
+        ]
+      },
+      {
+        name: "idx_versus_question_voting_list",
+        fields: [
+          { name: "voting_list_type_id" },
+        ]
+      },
+      {
+        name: "versus_question_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/VersusQuestionVariableType.ts

@@ -0,0 +1,66 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { VersusQuestion, VersusQuestionId } from './VersusQuestion';
+
+export interface VersusQuestionVariableTypeAttributes {
+  id: number;
+  description: string;
+}
+
+export type VersusQuestionVariableTypePk = "id";
+export type VersusQuestionVariableTypeId = VersusQuestionVariableType[VersusQuestionVariableTypePk];
+export type VersusQuestionVariableTypeCreationAttributes = VersusQuestionVariableTypeAttributes;
+
+export class VersusQuestionVariableType extends Model<VersusQuestionVariableTypeAttributes, VersusQuestionVariableTypeCreationAttributes> implements VersusQuestionVariableTypeAttributes {
+  id!: number;
+  description!: string;
+
+  // VersusQuestionVariableType hasMany VersusQuestion via questionVariableTypeId
+  versusQuestions!: VersusQuestion[];
+  getVersusQuestions!: Sequelize.HasManyGetAssociationsMixin<VersusQuestion>;
+  setVersusQuestions!: Sequelize.HasManySetAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  addVersusQuestion!: Sequelize.HasManyAddAssociationMixin<VersusQuestion, VersusQuestionId>;
+  addVersusQuestions!: Sequelize.HasManyAddAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  createVersusQuestion!: Sequelize.HasManyCreateAssociationMixin<VersusQuestion>;
+  removeVersusQuestion!: Sequelize.HasManyRemoveAssociationMixin<VersusQuestion, VersusQuestionId>;
+  removeVersusQuestions!: Sequelize.HasManyRemoveAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  hasVersusQuestion!: Sequelize.HasManyHasAssociationMixin<VersusQuestion, VersusQuestionId>;
+  hasVersusQuestions!: Sequelize.HasManyHasAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  countVersusQuestions!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof VersusQuestionVariableType {
+    return VersusQuestionVariableType.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.STRING(64),
+      allowNull: false,
+      unique: "versus_question_variable_type_description_unique"
+    }
+  }, {
+    sequelize,
+    tableName: 'versus_question_variable_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "versus_question_variable_type_description_unique",
+        unique: true,
+        fields: [
+          { name: "description" },
+        ]
+      },
+      {
+        name: "versus_question_variable_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/VersusVotingListType.ts

@@ -0,0 +1,66 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { VersusQuestion, VersusQuestionId } from './VersusQuestion';
+
+export interface VersusVotingListTypeAttributes {
+  id: number;
+  description: string;
+}
+
+export type VersusVotingListTypePk = "id";
+export type VersusVotingListTypeId = VersusVotingListType[VersusVotingListTypePk];
+export type VersusVotingListTypeCreationAttributes = VersusVotingListTypeAttributes;
+
+export class VersusVotingListType extends Model<VersusVotingListTypeAttributes, VersusVotingListTypeCreationAttributes> implements VersusVotingListTypeAttributes {
+  id!: number;
+  description!: string;
+
+  // VersusVotingListType hasMany VersusQuestion via votingListTypeId
+  versusQuestions!: VersusQuestion[];
+  getVersusQuestions!: Sequelize.HasManyGetAssociationsMixin<VersusQuestion>;
+  setVersusQuestions!: Sequelize.HasManySetAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  addVersusQuestion!: Sequelize.HasManyAddAssociationMixin<VersusQuestion, VersusQuestionId>;
+  addVersusQuestions!: Sequelize.HasManyAddAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  createVersusQuestion!: Sequelize.HasManyCreateAssociationMixin<VersusQuestion>;
+  removeVersusQuestion!: Sequelize.HasManyRemoveAssociationMixin<VersusQuestion, VersusQuestionId>;
+  removeVersusQuestions!: Sequelize.HasManyRemoveAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  hasVersusQuestion!: Sequelize.HasManyHasAssociationMixin<VersusQuestion, VersusQuestionId>;
+  hasVersusQuestions!: Sequelize.HasManyHasAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  countVersusQuestions!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof VersusVotingListType {
+    return VersusVotingListType.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.STRING(64),
+      allowNull: false,
+      unique: "versus_voting_list_type_description_unique"
+    }
+  }, {
+    sequelize,
+    tableName: 'versus_voting_list_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "versus_voting_list_type_description_unique",
+        unique: true,
+        fields: [
+          { name: "description" },
+        ]
+      },
+      {
+        name: "versus_voting_list_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/VersusVotingMode.ts

@@ -0,0 +1,66 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { Versus, VersusId } from './Versus';
+
+export interface VersusVotingModeAttributes {
+  id: number;
+  description: string;
+}
+
+export type VersusVotingModePk = "id";
+export type VersusVotingModeId = VersusVotingMode[VersusVotingModePk];
+export type VersusVotingModeCreationAttributes = VersusVotingModeAttributes;
+
+export class VersusVotingMode extends Model<VersusVotingModeAttributes, VersusVotingModeCreationAttributes> implements VersusVotingModeAttributes {
+  id!: number;
+  description!: string;
+
+  // VersusVotingMode hasMany Versus via versusVotingModeId
+  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 VersusVotingMode {
+    return VersusVotingMode.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.STRING(64),
+      allowNull: false,
+      unique: "versus_voting_mode_description_unique"
+    }
+  }, {
+    sequelize,
+    tableName: 'versus_voting_mode',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "versus_voting_mode_description_unique",
+        unique: true,
+        fields: [
+          { name: "description" },
+        ]
+      },
+      {
+        name: "versus_voting_mode_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}