@earbug/db-models 0.0.41 → 0.0.43

package/models/UserMessages.ts

@@ -1,6 +1,7 @@
 import * as Sequelize from 'sequelize';
 import { DataTypes, Model, Optional } from 'sequelize';
 import type { AppUser, AppUserId } from './AppUser';
+import type { UserAbuseReports, UserAbuseReportsId } from './UserAbuseReports';
 
 export interface UserMessagesAttributes {
   senderId: string;
@@ -44,6 +45,18 @@ export class UserMessages extends Model<UserMessagesAttributes, UserMessagesCrea
   getSender!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
   setSender!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
   createSender!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // UserMessages hasMany UserAbuseReports via directMessageId
+  userAbuseReports!: UserAbuseReports[];
+  getUserAbuseReports!: Sequelize.HasManyGetAssociationsMixin<UserAbuseReports>;
+  setUserAbuseReports!: Sequelize.HasManySetAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  addUserAbuseReport!: Sequelize.HasManyAddAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  addUserAbuseReports!: Sequelize.HasManyAddAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  createUserAbuseReport!: Sequelize.HasManyCreateAssociationMixin<UserAbuseReports>;
+  removeUserAbuseReport!: Sequelize.HasManyRemoveAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  removeUserAbuseReports!: Sequelize.HasManyRemoveAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  hasUserAbuseReport!: Sequelize.HasManyHasAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  hasUserAbuseReports!: Sequelize.HasManyHasAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  countUserAbuseReports!: Sequelize.HasManyCountAssociationsMixin;
   // UserMessages belongsTo UserMessages via replyMessageId
   replyMessage!: UserMessages;
   getReplyMessage!: Sequelize.BelongsToGetAssociationMixin<UserMessages>;

package/models/Versus.ts

@@ -0,0 +1,425 @@
+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 { 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 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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,133 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { GuestUser, GuestUserId } from './GuestUser';
+import type { Versus, VersusId } from './Versus';
+
+export interface VersusCoCreatorAttributes {
+  versusId: string;
+  appUserId?: string;
+  guestUserId?: string;
+  invitedEmail?: string;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type VersusCoCreatorPk = "id";
+export type VersusCoCreatorId = VersusCoCreator[VersusCoCreatorPk];
+export type VersusCoCreatorOptionalAttributes = "appUserId" | "guestUserId" | "invitedEmail" | "id" | "createdAt" | "updatedAt";
+export type VersusCoCreatorCreationAttributes = Optional<VersusCoCreatorAttributes, VersusCoCreatorOptionalAttributes>;
+
+export class VersusCoCreator extends Model<VersusCoCreatorAttributes, VersusCoCreatorCreationAttributes> implements VersusCoCreatorAttributes {
+  versusId!: string;
+  appUserId?: string;
+  guestUserId?: string;
+  invitedEmail?: string;
+  id!: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+
+  // VersusCoCreator belongsTo AppUser via appUserId
+  appUser!: AppUser;
+  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // VersusCoCreator belongsTo GuestUser via guestUserId
+  guestUser!: GuestUser;
+  getGuestUser!: Sequelize.BelongsToGetAssociationMixin<GuestUser>;
+  setGuestUser!: Sequelize.BelongsToSetAssociationMixin<GuestUser, GuestUserId>;
+  createGuestUser!: Sequelize.BelongsToCreateAssociationMixin<GuestUser>;
+  // 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'
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'app_user_id'
+    },
+    guestUserId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'guest_user',
+        key: 'id'
+      },
+      field: 'guest_user_id'
+    },
+    invitedEmail: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'invited_email'
+    },
+    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_co_creator',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_versus_co_creator_app_user",
+        fields: [
+          { name: "app_user_id" },
+        ]
+      },
+      {
+        name: "idx_versus_co_creator_guest_user",
+        fields: [
+          { name: "guest_user_id" },
+        ]
+      },
+      {
+        name: "idx_versus_co_creator_versus",
+        fields: [
+          { name: "versus_id" },
+        ]
+      },
+      {
+        name: "versus_co_creator_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}