@earbug/db-models 0.0.40 → 0.0.42

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" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/VersusCreatorScope.ts

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

package/models/VersusEndMode.ts

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

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

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

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