@earbug/db-models 0.0.41 → 0.0.43

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

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