@earbug/db-models 0.0.62 → 0.0.63

package/models/AppUserDevice.ts

@@ -0,0 +1,101 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+
+export interface AppUserDeviceAttributes {
+  id: string;
+  appUserId: string;
+  devicePlatformId: number;
+  endpointArn: string;
+  createdAt: Date;
+  platformApplicationArn?: string;
+}
+
+export type AppUserDevicePk = "id";
+export type AppUserDeviceId = AppUserDevice[AppUserDevicePk];
+export type AppUserDeviceOptionalAttributes = "id" | "createdAt" | "platformApplicationArn";
+export type AppUserDeviceCreationAttributes = Optional<AppUserDeviceAttributes, AppUserDeviceOptionalAttributes>;
+
+export class AppUserDevice extends Model<AppUserDeviceAttributes, AppUserDeviceCreationAttributes> implements AppUserDeviceAttributes {
+  id!: string;
+  appUserId!: string;
+  devicePlatformId!: number;
+  endpointArn!: string;
+  createdAt!: Date;
+  platformApplicationArn?: string;
+
+  // AppUserDevice belongsTo AppUser via appUserId
+  appUser!: AppUser;
+  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof AppUserDevice {
+    return AppUserDevice.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'app_user_id'
+    },
+    devicePlatformId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      field: 'device_platform_id'
+    },
+    endpointArn: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "unique_app_user_device_endpoint_arn",
+      field: 'endpoint_arn'
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    },
+    platformApplicationArn: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'platform_application_arn'
+    }
+  }, {
+    sequelize,
+    tableName: 'app_user_device',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "app_user_device_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "idx_app_user_device_user",
+        fields: [
+          { name: "app_user_id" },
+        ]
+      },
+      {
+        name: "unique_app_user_device_endpoint_arn",
+        unique: true,
+        fields: [
+          { name: "endpoint_arn" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/AppUserDeviceClassicBackup20260906.ts

@@ -0,0 +1,66 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+
+export interface AppUserDeviceClassicBackup20260906Attributes {
+  id?: string;
+  appUserId?: string;
+  devicePlatformId?: number;
+  endpointArn?: string;
+  createdAt?: Date;
+  platformApplicationArn?: string;
+}
+
+export type AppUserDeviceClassicBackup20260906Pk = "id";
+export type AppUserDeviceClassicBackup20260906Id = AppUserDeviceClassicBackup20260906[AppUserDeviceClassicBackup20260906Pk];
+export type AppUserDeviceClassicBackup20260906OptionalAttributes = "id" | "appUserId" | "devicePlatformId" | "endpointArn" | "createdAt" | "platformApplicationArn";
+export type AppUserDeviceClassicBackup20260906CreationAttributes = Optional<AppUserDeviceClassicBackup20260906Attributes, AppUserDeviceClassicBackup20260906OptionalAttributes>;
+
+export class AppUserDeviceClassicBackup20260906 extends Model<AppUserDeviceClassicBackup20260906Attributes, AppUserDeviceClassicBackup20260906CreationAttributes> implements AppUserDeviceClassicBackup20260906Attributes {
+  id?: string;
+  appUserId?: string;
+  devicePlatformId?: number;
+  endpointArn?: string;
+  createdAt?: Date;
+  platformApplicationArn?: string;
+
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof AppUserDeviceClassicBackup20260906 {
+    return AppUserDeviceClassicBackup20260906.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      primaryKey: true
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      field: 'app_user_id'
+    },
+    devicePlatformId: {
+      type: DataTypes.SMALLINT,
+      allowNull: true,
+      field: 'device_platform_id'
+    },
+    endpointArn: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'endpoint_arn'
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'created_at'
+    },
+    platformApplicationArn: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'platform_application_arn'
+    }
+  }, {
+    sequelize,
+    tableName: 'app_user_device_classic_backup_20260906',
+    schema: 'eb',
+    timestamps: false
+  });
+  }
+}

package/models/AppUserFollowRelation.ts

@@ -0,0 +1,128 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+
+export interface AppUserFollowRelationAttributes {
+  id: string;
+  appUserId: string;
+  followingAppUserId: string;
+  stateId: number;
+  isBlocked: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type AppUserFollowRelationPk = "id";
+export type AppUserFollowRelationId = AppUserFollowRelation[AppUserFollowRelationPk];
+export type AppUserFollowRelationOptionalAttributes = "id" | "stateId" | "createdAt" | "updatedAt";
+export type AppUserFollowRelationCreationAttributes = Optional<AppUserFollowRelationAttributes, AppUserFollowRelationOptionalAttributes>;
+
+export class AppUserFollowRelation extends Model<AppUserFollowRelationAttributes, AppUserFollowRelationCreationAttributes> implements AppUserFollowRelationAttributes {
+  id!: string;
+  appUserId!: string;
+  followingAppUserId!: string;
+  stateId!: number;
+  isBlocked!: boolean;
+  createdAt!: Date;
+  updatedAt!: Date;
+
+  // AppUserFollowRelation belongsTo AppUser via appUserId
+  appUser!: AppUser;
+  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // AppUserFollowRelation belongsTo AppUser via followingAppUserId
+  followingAppUser!: AppUser;
+  getFollowingAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setFollowingAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createFollowingAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof AppUserFollowRelation {
+    return AppUserFollowRelation.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      unique: "unique_app_user_followers",
+      field: 'app_user_id'
+    },
+    followingAppUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      unique: "unique_app_user_followers",
+      field: 'following_app_user_id'
+    },
+    stateId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      field: 'state_id'
+    },
+    isBlocked: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: false,
+      field: 'is_blocked'
+    },
+    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: 'app_user_follow_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "app_user_follow_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "app_user_id",
+        fields: [
+          { name: "app_user_id" },
+        ]
+      },
+      {
+        name: "idx_follow_relation_following",
+        fields: [
+          { name: "following_app_user_id" },
+        ]
+      },
+      {
+        name: "unique_app_user_followers",
+        unique: true,
+        fields: [
+          { name: "app_user_id" },
+          { name: "following_app_user_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/AppUserPlatformRelation.ts

@@ -0,0 +1,150 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { Platform, PlatformId } from './Platform';
+
+export interface AppUserPlatformRelationAttributes {
+  id: string;
+  appUserId: string;
+  platformId: number;
+  externalUserId?: string;
+  createDate: Date;
+  updateDate: Date;
+  accessToken?: string;
+  refreshToken?: string;
+  expirationDate: Date;
+  stateId: number;
+  countryCode: string;
+}
+
+export type AppUserPlatformRelationPk = "id";
+export type AppUserPlatformRelationId = AppUserPlatformRelation[AppUserPlatformRelationPk];
+export type AppUserPlatformRelationOptionalAttributes = "id" | "externalUserId" | "createDate" | "updateDate" | "accessToken" | "refreshToken" | "stateId";
+export type AppUserPlatformRelationCreationAttributes = Optional<AppUserPlatformRelationAttributes, AppUserPlatformRelationOptionalAttributes>;
+
+export class AppUserPlatformRelation extends Model<AppUserPlatformRelationAttributes, AppUserPlatformRelationCreationAttributes> implements AppUserPlatformRelationAttributes {
+  id!: string;
+  appUserId!: string;
+  platformId!: number;
+  externalUserId?: string;
+  createDate!: Date;
+  updateDate!: Date;
+  accessToken?: string;
+  refreshToken?: string;
+  expirationDate!: Date;
+  stateId!: number;
+  countryCode!: string;
+
+  // AppUserPlatformRelation belongsTo AppUser via appUserId
+  appUser!: AppUser;
+  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // AppUserPlatformRelation belongsTo Platform via platformId
+  platform!: Platform;
+  getPlatform!: Sequelize.BelongsToGetAssociationMixin<Platform>;
+  setPlatform!: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+  createPlatform!: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof AppUserPlatformRelation {
+    return AppUserPlatformRelation.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      unique: "uk_platform_relation_app_user_id",
+      field: 'app_user_id'
+    },
+    platformId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'platform',
+        key: 'id'
+      },
+      field: 'platform_id'
+    },
+    externalUserId: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'external_user_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'
+    },
+    accessToken: {
+      type: DataTypes.STRING,
+      allowNull: true,
+      field: 'access_token'
+    },
+    refreshToken: {
+      type: DataTypes.STRING,
+      allowNull: true,
+      field: 'refresh_token'
+    },
+    expirationDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      field: 'expiration_date'
+    },
+    stateId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      field: 'state_id'
+    },
+    countryCode: {
+      type: DataTypes.STRING(2),
+      allowNull: false,
+      field: 'country_code'
+    }
+  }, {
+    sequelize,
+    tableName: 'app_user_platform_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "app_user_platform_relation_app_user_id_platform_id_idx",
+        unique: true,
+        fields: [
+          { name: "app_user_id" },
+          { name: "platform_id" },
+        ]
+      },
+      {
+        name: "app_user_platform_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "uk_platform_relation_app_user_id",
+        unique: true,
+        fields: [
+          { name: "app_user_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonAlbum.ts

@@ -0,0 +1,229 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId } from './CanonAlbumExternalReferenceRelation';
+import type { CanonAlbumTrackRelation, CanonAlbumTrackRelationId } from './CanonAlbumTrackRelation';
+import type { CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId } from './CanonToPlatformAlbumRelation';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { Versus, VersusId } from './Versus';
+import type { VersusOption, VersusOptionId } from './VersusOption';
+
+export interface CanonAlbumAttributes {
+  id: string;
+  name: string;
+  asciiName: string;
+  releaseDate?: string;
+  noOfDisc?: number;
+  createDate: Date;
+  updateDate: Date;
+  hasPhoto?: boolean;
+  hasThumbnailPhoto?: boolean;
+  description?: string;
+  images?: object;
+  lastImageHarvestAttempt?: Date;
+}
+
+export type CanonAlbumPk = "id";
+export type CanonAlbumId = CanonAlbum[CanonAlbumPk];
+export type CanonAlbumOptionalAttributes = "id" | "releaseDate" | "noOfDisc" | "createDate" | "updateDate" | "hasPhoto" | "hasThumbnailPhoto" | "description" | "images" | "lastImageHarvestAttempt";
+export type CanonAlbumCreationAttributes = Optional<CanonAlbumAttributes, CanonAlbumOptionalAttributes>;
+
+export class CanonAlbum extends Model<CanonAlbumAttributes, CanonAlbumCreationAttributes> implements CanonAlbumAttributes {
+  id!: string;
+  name!: string;
+  asciiName!: string;
+  releaseDate?: string;
+  noOfDisc?: number;
+  createDate!: Date;
+  updateDate!: Date;
+  hasPhoto?: boolean;
+  hasThumbnailPhoto?: boolean;
+  description?: string;
+  images?: object;
+  lastImageHarvestAttempt?: Date;
+
+  // CanonAlbum hasMany CanonAlbumExternalReferenceRelation via canonAlbumId
+  canonAlbumExternalReferenceRelations!: CanonAlbumExternalReferenceRelation[];
+  getCanonAlbumExternalReferenceRelations!: Sequelize.HasManyGetAssociationsMixin<CanonAlbumExternalReferenceRelation>;
+  setCanonAlbumExternalReferenceRelations!: Sequelize.HasManySetAssociationsMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  addCanonAlbumExternalReferenceRelation!: Sequelize.HasManyAddAssociationMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  addCanonAlbumExternalReferenceRelations!: Sequelize.HasManyAddAssociationsMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  createCanonAlbumExternalReferenceRelation!: Sequelize.HasManyCreateAssociationMixin<CanonAlbumExternalReferenceRelation>;
+  removeCanonAlbumExternalReferenceRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  removeCanonAlbumExternalReferenceRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  hasCanonAlbumExternalReferenceRelation!: Sequelize.HasManyHasAssociationMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  hasCanonAlbumExternalReferenceRelations!: Sequelize.HasManyHasAssociationsMixin<CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId>;
+  countCanonAlbumExternalReferenceRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonAlbum hasMany CanonAlbumTrackRelation via canonAlbumId
+  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;
+  // CanonAlbum hasMany CanonToPlatformAlbumRelation via canonAlbumId
+  canonToPlatformAlbumRelations!: CanonToPlatformAlbumRelation[];
+  getCanonToPlatformAlbumRelations!: Sequelize.HasManyGetAssociationsMixin<CanonToPlatformAlbumRelation>;
+  setCanonToPlatformAlbumRelations!: Sequelize.HasManySetAssociationsMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  addCanonToPlatformAlbumRelation!: Sequelize.HasManyAddAssociationMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  addCanonToPlatformAlbumRelations!: Sequelize.HasManyAddAssociationsMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  createCanonToPlatformAlbumRelation!: Sequelize.HasManyCreateAssociationMixin<CanonToPlatformAlbumRelation>;
+  removeCanonToPlatformAlbumRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  removeCanonToPlatformAlbumRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  hasCanonToPlatformAlbumRelation!: Sequelize.HasManyHasAssociationMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  hasCanonToPlatformAlbumRelations!: Sequelize.HasManyHasAssociationsMixin<CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId>;
+  countCanonToPlatformAlbumRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonAlbum belongsToMany CanonTrack via canonAlbumId and canonTrackId
+  canonTrackIdCanonTracks!: CanonTrack[];
+  getCanonTrackIdCanonTracks!: Sequelize.BelongsToManyGetAssociationsMixin<CanonTrack>;
+  setCanonTrackIdCanonTracks!: Sequelize.BelongsToManySetAssociationsMixin<CanonTrack, CanonTrackId>;
+  addCanonTrackIdCanonTrack!: Sequelize.BelongsToManyAddAssociationMixin<CanonTrack, CanonTrackId>;
+  addCanonTrackIdCanonTracks!: Sequelize.BelongsToManyAddAssociationsMixin<CanonTrack, CanonTrackId>;
+  createCanonTrackIdCanonTrack!: Sequelize.BelongsToManyCreateAssociationMixin<CanonTrack>;
+  removeCanonTrackIdCanonTrack!: Sequelize.BelongsToManyRemoveAssociationMixin<CanonTrack, CanonTrackId>;
+  removeCanonTrackIdCanonTracks!: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonTrack, CanonTrackId>;
+  hasCanonTrackIdCanonTrack!: Sequelize.BelongsToManyHasAssociationMixin<CanonTrack, CanonTrackId>;
+  hasCanonTrackIdCanonTracks!: Sequelize.BelongsToManyHasAssociationsMixin<CanonTrack, CanonTrackId>;
+  countCanonTrackIdCanonTracks!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonAlbum belongsToMany ExternalReference via canonAlbumId and externalReferenceId
+  externalReferenceIdExternalReferences!: ExternalReference[];
+  getExternalReferenceIdExternalReferences!: Sequelize.BelongsToManyGetAssociationsMixin<ExternalReference>;
+  setExternalReferenceIdExternalReferences!: Sequelize.BelongsToManySetAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  addExternalReferenceIdExternalReference!: Sequelize.BelongsToManyAddAssociationMixin<ExternalReference, ExternalReferenceId>;
+  addExternalReferenceIdExternalReferences!: Sequelize.BelongsToManyAddAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  createExternalReferenceIdExternalReference!: Sequelize.BelongsToManyCreateAssociationMixin<ExternalReference>;
+  removeExternalReferenceIdExternalReference!: Sequelize.BelongsToManyRemoveAssociationMixin<ExternalReference, ExternalReferenceId>;
+  removeExternalReferenceIdExternalReferences!: Sequelize.BelongsToManyRemoveAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  hasExternalReferenceIdExternalReference!: Sequelize.BelongsToManyHasAssociationMixin<ExternalReference, ExternalReferenceId>;
+  hasExternalReferenceIdExternalReferences!: Sequelize.BelongsToManyHasAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  countExternalReferenceIdExternalReferences!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonAlbum belongsToMany PlatformAlbum via canonAlbumId and platformAlbumId
+  platformAlbumIdPlatformAlbums!: PlatformAlbum[];
+  getPlatformAlbumIdPlatformAlbums!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+  setPlatformAlbumIdPlatformAlbums!: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  addPlatformAlbumIdPlatformAlbum!: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  addPlatformAlbumIdPlatformAlbums!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  createPlatformAlbumIdPlatformAlbum!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+  removePlatformAlbumIdPlatformAlbum!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  removePlatformAlbumIdPlatformAlbums!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  hasPlatformAlbumIdPlatformAlbum!: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  hasPlatformAlbumIdPlatformAlbums!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  countPlatformAlbumIdPlatformAlbums!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonAlbum hasMany Versus via canonAlbumId
+  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;
+  // CanonAlbum hasMany VersusOption via canonAlbumId
+  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 CanonAlbum {
+    return CanonAlbum.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'
+    },
+    releaseDate: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'release_date'
+    },
+    noOfDisc: {
+      type: DataTypes.SMALLINT,
+      allowNull: true,
+      field: 'no_of_disc'
+    },
+    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'
+    },
+    hasPhoto: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      defaultValue: false,
+      field: 'has_photo'
+    },
+    hasThumbnailPhoto: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      defaultValue: false,
+      field: 'has_thumbnail_photo'
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: true
+    },
+    images: {
+      type: DataTypes.JSONB,
+      allowNull: true
+    },
+    lastImageHarvestAttempt: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'last_image_harvest_attempt'
+    }
+  }, {
+    sequelize,
+    tableName: 'canon_album',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_album_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "eb_canon_album_last_image_harvest_attempt",
+        fields: [
+          { name: "last_image_harvest_attempt" },
+        ]
+      },
+    ]
+  });
+  }
+}