@earbug/db-models 0.0.60 → 0.0.62

package/models/Versus.ts

@@ -1,438 +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 { CanonGenre, CanonGenreId } from './CanonGenre';
-import type { CanonTrack, CanonTrackId } from './CanonTrack';
-import type { GuestUser, GuestUserId } from './GuestUser';
-import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
-import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
-import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
-import type { VersusAccessType, VersusAccessTypeId } from './VersusAccessType';
-import type { VersusCoCreator, VersusCoCreatorId } from './VersusCoCreator';
-import type { VersusCreatorScope, VersusCreatorScopeId } from './VersusCreatorScope';
-import type { VersusEndMode, VersusEndModeId } from './VersusEndMode';
-import type { VersusEndTimerDuration, VersusEndTimerDurationId } from './VersusEndTimerDuration';
-import type { VersusEndVoteThreshold, VersusEndVoteThresholdId } from './VersusEndVoteThreshold';
-import type { VersusOption, VersusOptionId } from './VersusOption';
-import type { VersusPublishIssue, VersusPublishIssueId } from './VersusPublishIssue';
-import type { VersusQuestion, VersusQuestionId } from './VersusQuestion';
-import type { VersusVote, VersusVoteId } from './VersusVote';
-import type { VersusVotingMode, VersusVotingModeId } from './VersusVotingMode';
-
-export interface VersusAttributes {
-  versusQuestionId: string;
-  canonTrackId?: string;
-  platformTrackId?: string;
-  canonAlbumId?: string;
-  platformAlbumId?: string;
-  canonArtistId?: string;
-  platformArtistId?: string;
-  canonGenreId?: string;
-  themeText?: string;
-  versusAccessTypeId: number;
-  versusCreatorScopeId: number;
-  versusVotingModeId: number;
-  versusEndModeId: number;
-  versusEndVoteThresholdId?: number;
-  versusEndTimerDurationId?: number;
-  startsAt?: Date;
-  endsAt?: Date;
-  creatorUserId: string;
-  publishedAt?: Date;
-  id: string;
-  publishRequested: boolean;
-  deleted: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-export type VersusPk = "id";
-export type VersusId = Versus[VersusPk];
-export type VersusOptionalAttributes = "canonTrackId" | "platformTrackId" | "canonAlbumId" | "platformAlbumId" | "canonArtistId" | "platformArtistId" | "canonGenreId" | "themeText" | "versusEndVoteThresholdId" | "versusEndTimerDurationId" | "startsAt" | "endsAt" | "publishedAt" | "id" | "createdAt" | "updatedAt";
-export type VersusCreationAttributes = Optional<VersusAttributes, VersusOptionalAttributes>;
-
-export class Versus extends Model<VersusAttributes, VersusCreationAttributes> implements VersusAttributes {
-  versusQuestionId!: string;
-  canonTrackId?: string;
-  platformTrackId?: string;
-  canonAlbumId?: string;
-  platformAlbumId?: string;
-  canonArtistId?: string;
-  platformArtistId?: string;
-  canonGenreId?: string;
-  themeText?: string;
-  versusAccessTypeId!: number;
-  versusCreatorScopeId!: number;
-  versusVotingModeId!: number;
-  versusEndModeId!: number;
-  versusEndVoteThresholdId?: number;
-  versusEndTimerDurationId?: number;
-  startsAt?: Date;
-  endsAt?: Date;
-  creatorUserId!: string;
-  publishedAt?: Date;
-  id!: string;
-  publishRequested!: boolean;
-  deleted!: boolean;
-  createdAt!: Date;
-  updatedAt!: Date;
-
-  // Versus belongsTo AppUser via creatorUserId
-  creatorUser!: AppUser;
-  getCreatorUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
-  setCreatorUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
-  createCreatorUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
-  // Versus belongsTo CanonAlbum via canonAlbumId
-  canonAlbum!: CanonAlbum;
-  getCanonAlbum!: Sequelize.BelongsToGetAssociationMixin<CanonAlbum>;
-  setCanonAlbum!: Sequelize.BelongsToSetAssociationMixin<CanonAlbum, CanonAlbumId>;
-  createCanonAlbum!: Sequelize.BelongsToCreateAssociationMixin<CanonAlbum>;
-  // Versus belongsTo CanonArtist via canonArtistId
-  canonArtist!: CanonArtist;
-  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
-  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
-  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
-  // Versus belongsTo CanonGenre via canonGenreId
-  canonGenre!: CanonGenre;
-  getCanonGenre!: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
-  setCanonGenre!: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
-  createCanonGenre!: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
-  // Versus belongsTo CanonTrack via canonTrackId
-  canonTrack!: CanonTrack;
-  getCanonTrack!: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
-  setCanonTrack!: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
-  createCanonTrack!: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
-  // Versus belongsTo PlatformAlbum via platformAlbumId
-  platformAlbum!: PlatformAlbum;
-  getPlatformAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
-  setPlatformAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
-  createPlatformAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
-  // Versus belongsTo PlatformArtist via platformArtistId
-  platformArtist!: PlatformArtist;
-  getPlatformArtist!: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
-  setPlatformArtist!: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
-  createPlatformArtist!: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
-  // Versus belongsTo PlatformTrack via platformTrackId
-  platformTrack!: PlatformTrack;
-  getPlatformTrack!: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
-  setPlatformTrack!: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
-  createPlatformTrack!: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
-  // Versus hasMany GuestUser via versusId
-  guestUsers!: GuestUser[];
-  getGuestUsers!: Sequelize.HasManyGetAssociationsMixin<GuestUser>;
-  setGuestUsers!: Sequelize.HasManySetAssociationsMixin<GuestUser, GuestUserId>;
-  addGuestUser!: Sequelize.HasManyAddAssociationMixin<GuestUser, GuestUserId>;
-  addGuestUsers!: Sequelize.HasManyAddAssociationsMixin<GuestUser, GuestUserId>;
-  createGuestUser!: Sequelize.HasManyCreateAssociationMixin<GuestUser>;
-  removeGuestUser!: Sequelize.HasManyRemoveAssociationMixin<GuestUser, GuestUserId>;
-  removeGuestUsers!: Sequelize.HasManyRemoveAssociationsMixin<GuestUser, GuestUserId>;
-  hasGuestUser!: Sequelize.HasManyHasAssociationMixin<GuestUser, GuestUserId>;
-  hasGuestUsers!: Sequelize.HasManyHasAssociationsMixin<GuestUser, GuestUserId>;
-  countGuestUsers!: Sequelize.HasManyCountAssociationsMixin;
-  // Versus hasMany VersusCoCreator via versusId
-  versusCoCreators!: VersusCoCreator[];
-  getVersusCoCreators!: Sequelize.HasManyGetAssociationsMixin<VersusCoCreator>;
-  setVersusCoCreators!: Sequelize.HasManySetAssociationsMixin<VersusCoCreator, VersusCoCreatorId>;
-  addVersusCoCreator!: Sequelize.HasManyAddAssociationMixin<VersusCoCreator, VersusCoCreatorId>;
-  addVersusCoCreators!: Sequelize.HasManyAddAssociationsMixin<VersusCoCreator, VersusCoCreatorId>;
-  createVersusCoCreator!: Sequelize.HasManyCreateAssociationMixin<VersusCoCreator>;
-  removeVersusCoCreator!: Sequelize.HasManyRemoveAssociationMixin<VersusCoCreator, VersusCoCreatorId>;
-  removeVersusCoCreators!: Sequelize.HasManyRemoveAssociationsMixin<VersusCoCreator, VersusCoCreatorId>;
-  hasVersusCoCreator!: Sequelize.HasManyHasAssociationMixin<VersusCoCreator, VersusCoCreatorId>;
-  hasVersusCoCreators!: Sequelize.HasManyHasAssociationsMixin<VersusCoCreator, VersusCoCreatorId>;
-  countVersusCoCreators!: Sequelize.HasManyCountAssociationsMixin;
-  // Versus hasMany VersusOption via versusId
-  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;
-  // Versus hasMany VersusPublishIssue via versusId
-  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;
-  // Versus hasMany VersusVote via versusId
-  versusVotes!: VersusVote[];
-  getVersusVotes!: Sequelize.HasManyGetAssociationsMixin<VersusVote>;
-  setVersusVotes!: Sequelize.HasManySetAssociationsMixin<VersusVote, VersusVoteId>;
-  addVersusVote!: Sequelize.HasManyAddAssociationMixin<VersusVote, VersusVoteId>;
-  addVersusVotes!: Sequelize.HasManyAddAssociationsMixin<VersusVote, VersusVoteId>;
-  createVersusVote!: Sequelize.HasManyCreateAssociationMixin<VersusVote>;
-  removeVersusVote!: Sequelize.HasManyRemoveAssociationMixin<VersusVote, VersusVoteId>;
-  removeVersusVotes!: Sequelize.HasManyRemoveAssociationsMixin<VersusVote, VersusVoteId>;
-  hasVersusVote!: Sequelize.HasManyHasAssociationMixin<VersusVote, VersusVoteId>;
-  hasVersusVotes!: Sequelize.HasManyHasAssociationsMixin<VersusVote, VersusVoteId>;
-  countVersusVotes!: Sequelize.HasManyCountAssociationsMixin;
-  // Versus belongsTo VersusAccessType via versusAccessTypeId
-  versusAccessType!: VersusAccessType;
-  getVersusAccessType!: Sequelize.BelongsToGetAssociationMixin<VersusAccessType>;
-  setVersusAccessType!: Sequelize.BelongsToSetAssociationMixin<VersusAccessType, VersusAccessTypeId>;
-  createVersusAccessType!: Sequelize.BelongsToCreateAssociationMixin<VersusAccessType>;
-  // Versus belongsTo VersusCreatorScope via versusCreatorScopeId
-  versusCreatorScope!: VersusCreatorScope;
-  getVersusCreatorScope!: Sequelize.BelongsToGetAssociationMixin<VersusCreatorScope>;
-  setVersusCreatorScope!: Sequelize.BelongsToSetAssociationMixin<VersusCreatorScope, VersusCreatorScopeId>;
-  createVersusCreatorScope!: Sequelize.BelongsToCreateAssociationMixin<VersusCreatorScope>;
-  // Versus belongsTo VersusEndMode via versusEndModeId
-  versusEndMode!: VersusEndMode;
-  getVersusEndMode!: Sequelize.BelongsToGetAssociationMixin<VersusEndMode>;
-  setVersusEndMode!: Sequelize.BelongsToSetAssociationMixin<VersusEndMode, VersusEndModeId>;
-  createVersusEndMode!: Sequelize.BelongsToCreateAssociationMixin<VersusEndMode>;
-  // Versus belongsTo VersusEndTimerDuration via versusEndTimerDurationId
-  versusEndTimerDuration!: VersusEndTimerDuration;
-  getVersusEndTimerDuration!: Sequelize.BelongsToGetAssociationMixin<VersusEndTimerDuration>;
-  setVersusEndTimerDuration!: Sequelize.BelongsToSetAssociationMixin<VersusEndTimerDuration, VersusEndTimerDurationId>;
-  createVersusEndTimerDuration!: Sequelize.BelongsToCreateAssociationMixin<VersusEndTimerDuration>;
-  // Versus belongsTo VersusEndVoteThreshold via versusEndVoteThresholdId
-  versusEndVoteThreshold!: VersusEndVoteThreshold;
-  getVersusEndVoteThreshold!: Sequelize.BelongsToGetAssociationMixin<VersusEndVoteThreshold>;
-  setVersusEndVoteThreshold!: Sequelize.BelongsToSetAssociationMixin<VersusEndVoteThreshold, VersusEndVoteThresholdId>;
-  createVersusEndVoteThreshold!: Sequelize.BelongsToCreateAssociationMixin<VersusEndVoteThreshold>;
-  // Versus belongsTo VersusQuestion via versusQuestionId
-  versusQuestion!: VersusQuestion;
-  getVersusQuestion!: Sequelize.BelongsToGetAssociationMixin<VersusQuestion>;
-  setVersusQuestion!: Sequelize.BelongsToSetAssociationMixin<VersusQuestion, VersusQuestionId>;
-  createVersusQuestion!: Sequelize.BelongsToCreateAssociationMixin<VersusQuestion>;
-  // Versus belongsTo VersusVotingMode via versusVotingModeId
-  versusVotingMode!: VersusVotingMode;
-  getVersusVotingMode!: Sequelize.BelongsToGetAssociationMixin<VersusVotingMode>;
-  setVersusVotingMode!: Sequelize.BelongsToSetAssociationMixin<VersusVotingMode, VersusVotingModeId>;
-  createVersusVotingMode!: Sequelize.BelongsToCreateAssociationMixin<VersusVotingMode>;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof Versus {
-    return Versus.init({
-    versusQuestionId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'versus_question',
-        key: 'id'
-      },
-      field: 'versus_question_id'
-    },
-    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'
-    },
-    canonGenreId: {
-      type: DataTypes.UUID,
-      allowNull: true,
-      references: {
-        model: 'canon_genre',
-        key: 'id'
-      },
-      field: 'canon_genre_id'
-    },
-    themeText: {
-      type: DataTypes.STRING(100),
-      allowNull: true,
-      field: 'theme_text'
-    },
-    versusAccessTypeId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      references: {
-        model: 'versus_access_type',
-        key: 'id'
-      },
-      field: 'versus_access_type_id'
-    },
-    versusCreatorScopeId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      references: {
-        model: 'versus_creator_scope',
-        key: 'id'
-      },
-      field: 'versus_creator_scope_id'
-    },
-    versusVotingModeId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      references: {
-        model: 'versus_voting_mode',
-        key: 'id'
-      },
-      field: 'versus_voting_mode_id'
-    },
-    versusEndModeId: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      references: {
-        model: 'versus_end_mode',
-        key: 'id'
-      },
-      field: 'versus_end_mode_id'
-    },
-    versusEndVoteThresholdId: {
-      type: DataTypes.SMALLINT,
-      allowNull: true,
-      references: {
-        model: 'versus_end_vote_threshold',
-        key: 'id'
-      },
-      field: 'versus_end_vote_threshold_id'
-    },
-    versusEndTimerDurationId: {
-      type: DataTypes.SMALLINT,
-      allowNull: true,
-      references: {
-        model: 'versus_end_timer_duration',
-        key: 'id'
-      },
-      field: 'versus_end_timer_duration_id'
-    },
-    startsAt: {
-      type: DataTypes.DATE,
-      allowNull: true,
-      field: 'starts_at'
-    },
-    endsAt: {
-      type: DataTypes.DATE,
-      allowNull: true,
-      field: 'ends_at'
-    },
-    creatorUserId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'app_user',
-        key: 'id'
-      },
-      field: 'creator_user_id'
-    },
-    publishedAt: {
-      type: DataTypes.DATE,
-      allowNull: true,
-      field: 'published_at'
-    },
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: DataTypes.UUIDV4,
-      primaryKey: true
-    },
-    publishRequested: {
-      type: DataTypes.BOOLEAN,
-      allowNull: false,
-      defaultValue: false,
-      field: 'publish_requested'
-    },
-    deleted: {
-      type: DataTypes.BOOLEAN,
-      allowNull: false,
-      defaultValue: false
-    },
-    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',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "idx_versus_creator_user",
-        fields: [
-          { name: "creator_user_id" },
-        ]
-      },
-      {
-        name: "idx_versus_deleted",
-        fields: [
-          { name: "deleted" },
-        ]
-      },
-      {
-        name: "idx_versus_question",
-        fields: [
-          { name: "versus_question_id" },
-        ]
-      },
-      {
-        name: "versus_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/VersusAccessType.ts

@@ -1,66 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { Versus, VersusId } from './Versus';
-
-export interface VersusAccessTypeAttributes {
-  id: number;
-  description: string;
-}
-
-export type VersusAccessTypePk = "id";
-export type VersusAccessTypeId = VersusAccessType[VersusAccessTypePk];
-export type VersusAccessTypeCreationAttributes = VersusAccessTypeAttributes;
-
-export class VersusAccessType extends Model<VersusAccessTypeAttributes, VersusAccessTypeCreationAttributes> implements VersusAccessTypeAttributes {
-  id!: number;
-  description!: string;
-
-  // VersusAccessType hasMany Versus via versusAccessTypeId
-  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 VersusAccessType {
-    return VersusAccessType.init({
-    id: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      primaryKey: true
-    },
-    description: {
-      type: DataTypes.STRING(64),
-      allowNull: false,
-      unique: "versus_access_type_description_unique"
-    }
-  }, {
-    sequelize,
-    tableName: 'versus_access_type',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "versus_access_type_description_unique",
-        unique: true,
-        fields: [
-          { name: "description" },
-        ]
-      },
-      {
-        name: "versus_access_type_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/VersusCoCreator.ts

@@ -1,111 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { AppUser, AppUserId } from './AppUser';
-import type { Versus, VersusId } from './Versus';
-
-export interface VersusCoCreatorAttributes {
-  versusId: string;
-  id: string;
-  createdAt: Date;
-  updatedAt: Date;
-  appUserId: string;
-}
-
-export type VersusCoCreatorPk = "id";
-export type VersusCoCreatorId = VersusCoCreator[VersusCoCreatorPk];
-export type VersusCoCreatorOptionalAttributes = "id" | "createdAt" | "updatedAt";
-export type VersusCoCreatorCreationAttributes = Optional<VersusCoCreatorAttributes, VersusCoCreatorOptionalAttributes>;
-
-export class VersusCoCreator extends Model<VersusCoCreatorAttributes, VersusCoCreatorCreationAttributes> implements VersusCoCreatorAttributes {
-  versusId!: string;
-  id!: string;
-  createdAt!: Date;
-  updatedAt!: Date;
-  appUserId!: string;
-
-  // VersusCoCreator belongsTo AppUser via appUserId
-  appUser!: AppUser;
-  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
-  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
-  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
-  // VersusCoCreator belongsTo Versus via versusId
-  versu!: Versus;
-  getVersu!: Sequelize.BelongsToGetAssociationMixin<Versus>;
-  setVersu!: Sequelize.BelongsToSetAssociationMixin<Versus, VersusId>;
-  createVersu!: Sequelize.BelongsToCreateAssociationMixin<Versus>;
-
-  static initModel(sequelize: Sequelize.Sequelize): typeof VersusCoCreator {
-    return VersusCoCreator.init({
-    versusId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'versus',
-        key: 'id'
-      },
-      field: 'versus_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'
-    },
-    appUserId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'app_user',
-        key: 'id'
-      },
-      field: 'app_user_id'
-    }
-  }, {
-    sequelize,
-    tableName: 'versus_co_creator',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "idx_versus_co_creator_app_user",
-        fields: [
-          { name: "app_user_id" },
-        ]
-      },
-      {
-        name: "idx_versus_co_creator_versus",
-        fields: [
-          { name: "versus_id" },
-        ]
-      },
-      {
-        name: "uk_versus_co_creator_versus_app_user",
-        unique: true,
-        fields: [
-          { name: "versus_id" },
-          { name: "app_user_id" },
-        ]
-      },
-      {
-        name: "versus_co_creator_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}

package/models/VersusCreatorScope.ts

@@ -1,66 +0,0 @@
-import * as Sequelize from 'sequelize';
-import { DataTypes, Model, Optional } from 'sequelize';
-import type { Versus, VersusId } from './Versus';
-
-export interface VersusCreatorScopeAttributes {
-  id: number;
-  description: string;
-}
-
-export type VersusCreatorScopePk = "id";
-export type VersusCreatorScopeId = VersusCreatorScope[VersusCreatorScopePk];
-export type VersusCreatorScopeCreationAttributes = VersusCreatorScopeAttributes;
-
-export class VersusCreatorScope extends Model<VersusCreatorScopeAttributes, VersusCreatorScopeCreationAttributes> implements VersusCreatorScopeAttributes {
-  id!: number;
-  description!: string;
-
-  // VersusCreatorScope hasMany Versus via versusCreatorScopeId
-  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 VersusCreatorScope {
-    return VersusCreatorScope.init({
-    id: {
-      type: DataTypes.SMALLINT,
-      allowNull: false,
-      primaryKey: true
-    },
-    description: {
-      type: DataTypes.STRING(64),
-      allowNull: false,
-      unique: "versus_creator_scope_description_unique"
-    }
-  }, {
-    sequelize,
-    tableName: 'versus_creator_scope',
-    schema: 'eb',
-    timestamps: false,
-    indexes: [
-      {
-        name: "versus_creator_scope_description_unique",
-        unique: true,
-        fields: [
-          { name: "description" },
-        ]
-      },
-      {
-        name: "versus_creator_scope_pkey",
-        unique: true,
-        fields: [
-          { name: "id" },
-        ]
-      },
-    ]
-  });
-  }
-}