@earbug/db-models 0.0.62 → 0.0.63

package/models/CanonToPlatformGenreRelation.ts

@@ -0,0 +1,86 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+
+export interface CanonToPlatformGenreRelationAttributes {
+  canonGenreId: string;
+  platformGenreId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonToPlatformGenreRelationPk = "canonGenreId" | "platformGenreId";
+export type CanonToPlatformGenreRelationId = CanonToPlatformGenreRelation[CanonToPlatformGenreRelationPk];
+export type CanonToPlatformGenreRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonToPlatformGenreRelationCreationAttributes = Optional<CanonToPlatformGenreRelationAttributes, CanonToPlatformGenreRelationOptionalAttributes>;
+
+export class CanonToPlatformGenreRelation extends Model<CanonToPlatformGenreRelationAttributes, CanonToPlatformGenreRelationCreationAttributes> implements CanonToPlatformGenreRelationAttributes {
+  canonGenreId!: string;
+  platformGenreId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonToPlatformGenreRelation belongsTo CanonGenre via canonGenreId
+  canonGenre!: CanonGenre;
+  getCanonGenre!: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+  setCanonGenre!: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+  createCanonGenre!: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+  // CanonToPlatformGenreRelation belongsTo PlatformGenre via platformGenreId
+  platformGenre!: PlatformGenre;
+  getPlatformGenre!: Sequelize.BelongsToGetAssociationMixin<PlatformGenre>;
+  setPlatformGenre!: Sequelize.BelongsToSetAssociationMixin<PlatformGenre, PlatformGenreId>;
+  createPlatformGenre!: Sequelize.BelongsToCreateAssociationMixin<PlatformGenre>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonToPlatformGenreRelation {
+    return CanonToPlatformGenreRelation.init({
+    canonGenreId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_genre',
+        key: 'id'
+      },
+      field: 'canon_genre_id'
+    },
+    platformGenreId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_genre',
+        key: 'id'
+      },
+      field: 'platform_genre_id'
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'canon_to_platform_genre_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_to_platform_genre_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "canon_genre_id" },
+          { name: "platform_genre_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonToPlatformTrackRelation.ts

@@ -0,0 +1,92 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+
+export interface CanonToPlatformTrackRelationAttributes {
+  canonTrackId: string;
+  platformTrackId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonToPlatformTrackRelationPk = "canonTrackId" | "platformTrackId";
+export type CanonToPlatformTrackRelationId = CanonToPlatformTrackRelation[CanonToPlatformTrackRelationPk];
+export type CanonToPlatformTrackRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonToPlatformTrackRelationCreationAttributes = Optional<CanonToPlatformTrackRelationAttributes, CanonToPlatformTrackRelationOptionalAttributes>;
+
+export class CanonToPlatformTrackRelation extends Model<CanonToPlatformTrackRelationAttributes, CanonToPlatformTrackRelationCreationAttributes> implements CanonToPlatformTrackRelationAttributes {
+  canonTrackId!: string;
+  platformTrackId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonToPlatformTrackRelation belongsTo CanonTrack via canonTrackId
+  canonTrack!: CanonTrack;
+  getCanonTrack!: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
+  setCanonTrack!: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
+  createCanonTrack!: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+  // CanonToPlatformTrackRelation belongsTo PlatformTrack via platformTrackId
+  platformTrack!: PlatformTrack;
+  getPlatformTrack!: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+  setPlatformTrack!: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+  createPlatformTrack!: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonToPlatformTrackRelation {
+    return CanonToPlatformTrackRelation.init({
+    canonTrackId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_track',
+        key: 'id'
+      },
+      field: 'canon_track_id'
+    },
+    platformTrackId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_track',
+        key: 'id'
+      },
+      field: 'platform_track_id'
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'canon_to_platform_track_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_to_platform_track_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "canon_track_id" },
+          { name: "platform_track_id" },
+        ]
+      },
+      {
+        name: "idx_c2p_track_platform",
+        fields: [
+          { name: "platform_track_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonTrack.ts

@@ -0,0 +1,232 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { CanonAlbumTrackRelation, CanonAlbumTrackRelationId } from './CanonAlbumTrackRelation';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { CanonArtistTrackRelation, CanonArtistTrackRelationId } from './CanonArtistTrackRelation';
+import type { CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId } from './CanonToPlatformTrackRelation';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { RadioShowPlacement, RadioShowPlacementId } from './RadioShowPlacement';
+import type { Versus, VersusId } from './Versus';
+import type { VersusOption, VersusOptionId } from './VersusOption';
+
+export interface CanonTrackAttributes {
+  id: string;
+  name: string;
+  asciiName: string;
+  explicit: boolean;
+  discNumber?: number;
+  discTrackNumber?: number;
+  createDate: Date;
+  updateDate: Date;
+  durationMs: number;
+}
+
+export type CanonTrackPk = "id";
+export type CanonTrackId = CanonTrack[CanonTrackPk];
+export type CanonTrackOptionalAttributes = "id" | "discNumber" | "discTrackNumber" | "createDate" | "updateDate";
+export type CanonTrackCreationAttributes = Optional<CanonTrackAttributes, CanonTrackOptionalAttributes>;
+
+export class CanonTrack extends Model<CanonTrackAttributes, CanonTrackCreationAttributes> implements CanonTrackAttributes {
+  id!: string;
+  name!: string;
+  asciiName!: string;
+  explicit!: boolean;
+  discNumber?: number;
+  discTrackNumber?: number;
+  createDate!: Date;
+  updateDate!: Date;
+  durationMs!: number;
+
+  // CanonTrack belongsToMany CanonAlbum via canonTrackId and canonAlbumId
+  canonAlbumIdCanonAlbumCanonAlbumTrackRelations!: CanonAlbum[];
+  getCanonAlbumIdCanonAlbumCanonAlbumTrackRelations!: Sequelize.BelongsToManyGetAssociationsMixin<CanonAlbum>;
+  setCanonAlbumIdCanonAlbumCanonAlbumTrackRelations!: Sequelize.BelongsToManySetAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  addCanonAlbumIdCanonAlbumCanonAlbumTrackRelation!: Sequelize.BelongsToManyAddAssociationMixin<CanonAlbum, CanonAlbumId>;
+  addCanonAlbumIdCanonAlbumCanonAlbumTrackRelations!: Sequelize.BelongsToManyAddAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  createCanonAlbumIdCanonAlbumCanonAlbumTrackRelation!: Sequelize.BelongsToManyCreateAssociationMixin<CanonAlbum>;
+  removeCanonAlbumIdCanonAlbumCanonAlbumTrackRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonAlbum, CanonAlbumId>;
+  removeCanonAlbumIdCanonAlbumCanonAlbumTrackRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  hasCanonAlbumIdCanonAlbumCanonAlbumTrackRelation!: Sequelize.BelongsToManyHasAssociationMixin<CanonAlbum, CanonAlbumId>;
+  hasCanonAlbumIdCanonAlbumCanonAlbumTrackRelations!: Sequelize.BelongsToManyHasAssociationsMixin<CanonAlbum, CanonAlbumId>;
+  countCanonAlbumIdCanonAlbumCanonAlbumTrackRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonTrack hasMany CanonAlbumTrackRelation via canonTrackId
+  canonAlbumTrackRelations!: CanonAlbumTrackRelation[];
+  getCanonAlbumTrackRelations!: Sequelize.HasManyGetAssociationsMixin<CanonAlbumTrackRelation>;
+  setCanonAlbumTrackRelations!: Sequelize.HasManySetAssociationsMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  addCanonAlbumTrackRelation!: Sequelize.HasManyAddAssociationMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  addCanonAlbumTrackRelations!: Sequelize.HasManyAddAssociationsMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  createCanonAlbumTrackRelation!: Sequelize.HasManyCreateAssociationMixin<CanonAlbumTrackRelation>;
+  removeCanonAlbumTrackRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  removeCanonAlbumTrackRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  hasCanonAlbumTrackRelation!: Sequelize.HasManyHasAssociationMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  hasCanonAlbumTrackRelations!: Sequelize.HasManyHasAssociationsMixin<CanonAlbumTrackRelation, CanonAlbumTrackRelationId>;
+  countCanonAlbumTrackRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonTrack belongsToMany CanonArtist via canonTrackId and canonArtistId
+  canonArtistIdCanonArtistCanonArtistTrackRelations!: CanonArtist[];
+  getCanonArtistIdCanonArtistCanonArtistTrackRelations!: Sequelize.BelongsToManyGetAssociationsMixin<CanonArtist>;
+  setCanonArtistIdCanonArtistCanonArtistTrackRelations!: Sequelize.BelongsToManySetAssociationsMixin<CanonArtist, CanonArtistId>;
+  addCanonArtistIdCanonArtistCanonArtistTrackRelation!: Sequelize.BelongsToManyAddAssociationMixin<CanonArtist, CanonArtistId>;
+  addCanonArtistIdCanonArtistCanonArtistTrackRelations!: Sequelize.BelongsToManyAddAssociationsMixin<CanonArtist, CanonArtistId>;
+  createCanonArtistIdCanonArtistCanonArtistTrackRelation!: Sequelize.BelongsToManyCreateAssociationMixin<CanonArtist>;
+  removeCanonArtistIdCanonArtistCanonArtistTrackRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonArtist, CanonArtistId>;
+  removeCanonArtistIdCanonArtistCanonArtistTrackRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonArtist, CanonArtistId>;
+  hasCanonArtistIdCanonArtistCanonArtistTrackRelation!: Sequelize.BelongsToManyHasAssociationMixin<CanonArtist, CanonArtistId>;
+  hasCanonArtistIdCanonArtistCanonArtistTrackRelations!: Sequelize.BelongsToManyHasAssociationsMixin<CanonArtist, CanonArtistId>;
+  countCanonArtistIdCanonArtistCanonArtistTrackRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonTrack hasMany CanonArtistTrackRelation via canonTrackId
+  canonArtistTrackRelations!: CanonArtistTrackRelation[];
+  getCanonArtistTrackRelations!: Sequelize.HasManyGetAssociationsMixin<CanonArtistTrackRelation>;
+  setCanonArtistTrackRelations!: Sequelize.HasManySetAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  addCanonArtistTrackRelation!: Sequelize.HasManyAddAssociationMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  addCanonArtistTrackRelations!: Sequelize.HasManyAddAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  createCanonArtistTrackRelation!: Sequelize.HasManyCreateAssociationMixin<CanonArtistTrackRelation>;
+  removeCanonArtistTrackRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  removeCanonArtistTrackRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  hasCanonArtistTrackRelation!: Sequelize.HasManyHasAssociationMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  hasCanonArtistTrackRelations!: Sequelize.HasManyHasAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+  countCanonArtistTrackRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonTrack hasMany CanonToPlatformTrackRelation via canonTrackId
+  canonToPlatformTrackRelations!: CanonToPlatformTrackRelation[];
+  getCanonToPlatformTrackRelations!: Sequelize.HasManyGetAssociationsMixin<CanonToPlatformTrackRelation>;
+  setCanonToPlatformTrackRelations!: Sequelize.HasManySetAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  addCanonToPlatformTrackRelation!: Sequelize.HasManyAddAssociationMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  addCanonToPlatformTrackRelations!: Sequelize.HasManyAddAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  createCanonToPlatformTrackRelation!: Sequelize.HasManyCreateAssociationMixin<CanonToPlatformTrackRelation>;
+  removeCanonToPlatformTrackRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  removeCanonToPlatformTrackRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  hasCanonToPlatformTrackRelation!: Sequelize.HasManyHasAssociationMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  hasCanonToPlatformTrackRelations!: Sequelize.HasManyHasAssociationsMixin<CanonToPlatformTrackRelation, CanonToPlatformTrackRelationId>;
+  countCanonToPlatformTrackRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonTrack hasMany JukeboxQueueEntry via trackId
+  jukeboxQueueEntries!: JukeboxQueueEntry[];
+  getJukeboxQueueEntries!: Sequelize.HasManyGetAssociationsMixin<JukeboxQueueEntry>;
+  setJukeboxQueueEntries!: Sequelize.HasManySetAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  addJukeboxQueueEntry!: Sequelize.HasManyAddAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  addJukeboxQueueEntries!: Sequelize.HasManyAddAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  createJukeboxQueueEntry!: Sequelize.HasManyCreateAssociationMixin<JukeboxQueueEntry>;
+  removeJukeboxQueueEntry!: Sequelize.HasManyRemoveAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  removeJukeboxQueueEntries!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  hasJukeboxQueueEntry!: Sequelize.HasManyHasAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  hasJukeboxQueueEntries!: Sequelize.HasManyHasAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  countJukeboxQueueEntries!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonTrack belongsToMany PlatformTrack via canonTrackId and platformTrackId
+  platformTrackIdPlatformTracks!: PlatformTrack[];
+  getPlatformTrackIdPlatformTracks!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformTrack>;
+  setPlatformTrackIdPlatformTracks!: Sequelize.BelongsToManySetAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  addPlatformTrackIdPlatformTrack!: Sequelize.BelongsToManyAddAssociationMixin<PlatformTrack, PlatformTrackId>;
+  addPlatformTrackIdPlatformTracks!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  createPlatformTrackIdPlatformTrack!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformTrack>;
+  removePlatformTrackIdPlatformTrack!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformTrack, PlatformTrackId>;
+  removePlatformTrackIdPlatformTracks!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  hasPlatformTrackIdPlatformTrack!: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
+  hasPlatformTrackIdPlatformTracks!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
+  countPlatformTrackIdPlatformTracks!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonTrack hasMany RadioShowPlacement via canonTrackId
+  radioShowPlacements!: RadioShowPlacement[];
+  getRadioShowPlacements!: Sequelize.HasManyGetAssociationsMixin<RadioShowPlacement>;
+  setRadioShowPlacements!: Sequelize.HasManySetAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
+  addRadioShowPlacement!: Sequelize.HasManyAddAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
+  addRadioShowPlacements!: Sequelize.HasManyAddAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
+  createRadioShowPlacement!: Sequelize.HasManyCreateAssociationMixin<RadioShowPlacement>;
+  removeRadioShowPlacement!: Sequelize.HasManyRemoveAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
+  removeRadioShowPlacements!: Sequelize.HasManyRemoveAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
+  hasRadioShowPlacement!: Sequelize.HasManyHasAssociationMixin<RadioShowPlacement, RadioShowPlacementId>;
+  hasRadioShowPlacements!: Sequelize.HasManyHasAssociationsMixin<RadioShowPlacement, RadioShowPlacementId>;
+  countRadioShowPlacements!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonTrack hasMany Versus via canonTrackId
+  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;
+  // CanonTrack hasMany VersusOption via canonTrackId
+  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;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonTrack {
+    return CanonTrack.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    asciiName: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'ascii_name'
+    },
+    explicit: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false
+    },
+    discNumber: {
+      type: DataTypes.SMALLINT,
+      allowNull: true,
+      field: 'disc_number'
+    },
+    discTrackNumber: {
+      type: DataTypes.SMALLINT,
+      allowNull: true,
+      field: 'disc_track_number'
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    },
+    durationMs: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      field: 'duration_ms'
+    }
+  }, {
+    sequelize,
+    tableName: 'canon_track',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_track_lower_name_idx",
+        fields: [
+        ]
+      },
+      {
+        name: "platform_track_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/ConfigParam.ts

@@ -0,0 +1,62 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+
+export interface ConfigParamAttributes {
+  name: string;
+  value?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type ConfigParamPk = "name";
+export type ConfigParamId = ConfigParam[ConfigParamPk];
+export type ConfigParamOptionalAttributes = "value" | "createdAt" | "updatedAt";
+export type ConfigParamCreationAttributes = Optional<ConfigParamAttributes, ConfigParamOptionalAttributes>;
+
+export class ConfigParam extends Model<ConfigParamAttributes, ConfigParamCreationAttributes> implements ConfigParamAttributes {
+  name!: string;
+  value?: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof ConfigParam {
+    return ConfigParam.init({
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      primaryKey: true
+    },
+    value: {
+      type: DataTypes.TEXT,
+      allowNull: 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: 'config_param',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "config_param_pkey",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+    ]
+  });
+  }
+}