@earbug/db-models 0.0.40 → 0.0.42

package/dist/VersusCreatorScope.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } 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 declare class VersusCreatorScope extends Model<VersusCreatorScopeAttributes, VersusCreatorScopeCreationAttributes> implements VersusCreatorScopeAttributes {
+    id: number;
+    description: string;
+    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;
+}

package/dist/VersusCreatorScope.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersusCreatorScope = void 0;
+const sequelize_1 = require("sequelize");
+class VersusCreatorScope extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return VersusCreatorScope.init({
+            id: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            description: {
+                type: sequelize_1.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" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.VersusCreatorScope = VersusCreatorScope;

package/dist/VersusEndMode.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } 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 declare class VersusEndMode extends Model<VersusEndModeAttributes, VersusEndModeCreationAttributes> implements VersusEndModeAttributes {
+    id: number;
+    description: string;
+    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;
+}

package/dist/VersusEndMode.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersusEndMode = void 0;
+const sequelize_1 = require("sequelize");
+class VersusEndMode extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return VersusEndMode.init({
+            id: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            description: {
+                type: sequelize_1.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" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.VersusEndMode = VersusEndMode;

package/dist/VersusEndTimerDuration.d.ts

@@ -0,0 +1,28 @@
+import * as Sequelize from 'sequelize';
+import { Model } 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 declare class VersusEndTimerDuration extends Model<VersusEndTimerDurationAttributes, VersusEndTimerDurationCreationAttributes> implements VersusEndTimerDurationAttributes {
+    id: number;
+    description: string;
+    durationHours: number;
+    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;
+}

package/dist/VersusEndTimerDuration.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersusEndTimerDuration = void 0;
+const sequelize_1 = require("sequelize");
+class VersusEndTimerDuration extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return VersusEndTimerDuration.init({
+            id: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            description: {
+                type: sequelize_1.DataTypes.STRING(64),
+                allowNull: false,
+                unique: "versus_end_timer_duration_description_unique"
+            },
+            durationHours: {
+                type: sequelize_1.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" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.VersusEndTimerDuration = VersusEndTimerDuration;

package/dist/VersusEndVoteThreshold.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } 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 declare class VersusEndVoteThreshold extends Model<VersusEndVoteThresholdAttributes, VersusEndVoteThresholdCreationAttributes> implements VersusEndVoteThresholdAttributes {
+    id: number;
+    voteCount: number;
+    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;
+}

package/dist/VersusEndVoteThreshold.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersusEndVoteThreshold = void 0;
+const sequelize_1 = require("sequelize");
+class VersusEndVoteThreshold extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return VersusEndVoteThreshold.init({
+            id: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            voteCount: {
+                type: sequelize_1.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" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.VersusEndVoteThreshold = VersusEndVoteThreshold;

package/dist/VersusEntityKind.d.ts

@@ -0,0 +1,38 @@
+import * as Sequelize from 'sequelize';
+import { Model } 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 declare class VersusEntityKind extends Model<VersusEntityKindAttributes, VersusEntityKindCreationAttributes> implements VersusEntityKindAttributes {
+    id: number;
+    description: string;
+    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;
+    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;
+}

package/dist/VersusEntityKind.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersusEntityKind = void 0;
+const sequelize_1 = require("sequelize");
+class VersusEntityKind extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return VersusEntityKind.init({
+            id: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            description: {
+                type: sequelize_1.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" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.VersusEntityKind = VersusEntityKind;

package/dist/VersusOption.d.ts

@@ -0,0 +1,79 @@
+import * as Sequelize from 'sequelize';
+import { 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 declare 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;
+    canonAlbum: CanonAlbum;
+    getCanonAlbum: Sequelize.BelongsToGetAssociationMixin<CanonAlbum>;
+    setCanonAlbum: Sequelize.BelongsToSetAssociationMixin<CanonAlbum, CanonAlbumId>;
+    createCanonAlbum: Sequelize.BelongsToCreateAssociationMixin<CanonAlbum>;
+    canonArtist: CanonArtist;
+    getCanonArtist: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+    setCanonArtist: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+    createCanonArtist: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+    canonTrack: CanonTrack;
+    getCanonTrack: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
+    setCanonTrack: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
+    createCanonTrack: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+    platformAlbum: PlatformAlbum;
+    getPlatformAlbum: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+    setPlatformAlbum: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    createPlatformAlbum: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+    platformArtist: PlatformArtist;
+    getPlatformArtist: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+    setPlatformArtist: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+    createPlatformArtist: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+    platformTrack: PlatformTrack;
+    getPlatformTrack: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+    setPlatformTrack: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrack: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+    versu: Versus;
+    getVersu: Sequelize.BelongsToGetAssociationMixin<Versus>;
+    setVersu: Sequelize.BelongsToSetAssociationMixin<Versus, VersusId>;
+    createVersu: Sequelize.BelongsToCreateAssociationMixin<Versus>;
+    entityKind: VersusEntityKind;
+    getEntityKind: Sequelize.BelongsToGetAssociationMixin<VersusEntityKind>;
+    setEntityKind: Sequelize.BelongsToSetAssociationMixin<VersusEntityKind, VersusEntityKindId>;
+    createEntityKind: Sequelize.BelongsToCreateAssociationMixin<VersusEntityKind>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof VersusOption;
+}

package/dist/VersusOption.js

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersusOption = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class VersusOption extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return VersusOption.init({
+            versusId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'versus',
+                    key: 'id'
+                },
+                field: 'versus_id'
+            },
+            entityKindId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'versus_entity_kind',
+                    key: 'id'
+                },
+                field: 'entity_kind_id'
+            },
+            sortOrder: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                field: 'sort_order'
+            },
+            canonTrackId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'canon_track',
+                    key: 'id'
+                },
+                field: 'canon_track_id'
+            },
+            platformTrackId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'platform_track',
+                    key: 'id'
+                },
+                field: 'platform_track_id'
+            },
+            canonAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'canon_album',
+                    key: 'id'
+                },
+                field: 'canon_album_id'
+            },
+            platformAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'platform_album',
+                    key: 'id'
+                },
+                field: 'platform_album_id'
+            },
+            canonArtistId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'canon_artist',
+                    key: 'id'
+                },
+                field: 'canon_artist_id'
+            },
+            platformArtistId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'platform_artist',
+                    key: 'id'
+                },
+                field: 'platform_artist_id'
+            },
+            voteScore: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: true,
+                field: 'vote_score'
+            },
+            resultsScore: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: true,
+                field: 'results_score'
+            },
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            createdAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'created_at'
+            },
+            updatedAt: {
+                type: sequelize_1.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" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.VersusOption = VersusOption;