@earbug/db-models 0.0.1

package/models/CanonAlbum.ts

@@ -0,0 +1,216 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonAlbumExternalReferenceRelation, CanonAlbumExternalReferenceRelationId } from './CanonAlbumExternalReferenceRelation';
+import type { CanonAlbumImageHarvested, CanonAlbumImageHarvestedId } from './CanonAlbumImageHarvested';
+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';
+
+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 CanonAlbumImageHarvested via canonAlbumId
+  canonAlbumImageHarvesteds!: CanonAlbumImageHarvested[];
+  getCanonAlbumImageHarvesteds!: Sequelize.HasManyGetAssociationsMixin<CanonAlbumImageHarvested>;
+  setCanonAlbumImageHarvesteds!: Sequelize.HasManySetAssociationsMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+  addCanonAlbumImageHarvested!: Sequelize.HasManyAddAssociationMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+  addCanonAlbumImageHarvesteds!: Sequelize.HasManyAddAssociationsMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+  createCanonAlbumImageHarvested!: Sequelize.HasManyCreateAssociationMixin<CanonAlbumImageHarvested>;
+  removeCanonAlbumImageHarvested!: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+  removeCanonAlbumImageHarvesteds!: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+  hasCanonAlbumImageHarvested!: Sequelize.HasManyHasAssociationMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+  hasCanonAlbumImageHarvesteds!: Sequelize.HasManyHasAssociationsMixin<CanonAlbumImageHarvested, CanonAlbumImageHarvestedId>;
+  countCanonAlbumImageHarvesteds!: 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;
+
+  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" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonAlbumExternalReferenceRelation.ts

@@ -0,0 +1,92 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+
+export interface CanonAlbumExternalReferenceRelationAttributes {
+  canonAlbumId: string;
+  externalReferenceId: string;
+  url: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonAlbumExternalReferenceRelationPk = "canonAlbumId" | "externalReferenceId";
+export type CanonAlbumExternalReferenceRelationId = CanonAlbumExternalReferenceRelation[CanonAlbumExternalReferenceRelationPk];
+export type CanonAlbumExternalReferenceRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonAlbumExternalReferenceRelationCreationAttributes = Optional<CanonAlbumExternalReferenceRelationAttributes, CanonAlbumExternalReferenceRelationOptionalAttributes>;
+
+export class CanonAlbumExternalReferenceRelation extends Model<CanonAlbumExternalReferenceRelationAttributes, CanonAlbumExternalReferenceRelationCreationAttributes> implements CanonAlbumExternalReferenceRelationAttributes {
+  canonAlbumId!: string;
+  externalReferenceId!: string;
+  url!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonAlbumExternalReferenceRelation belongsTo CanonAlbum via canonAlbumId
+  canonAlbum!: CanonAlbum;
+  getCanonAlbum!: Sequelize.BelongsToGetAssociationMixin<CanonAlbum>;
+  setCanonAlbum!: Sequelize.BelongsToSetAssociationMixin<CanonAlbum, CanonAlbumId>;
+  createCanonAlbum!: Sequelize.BelongsToCreateAssociationMixin<CanonAlbum>;
+  // CanonAlbumExternalReferenceRelation belongsTo ExternalReference via externalReferenceId
+  externalReference!: ExternalReference;
+  getExternalReference!: Sequelize.BelongsToGetAssociationMixin<ExternalReference>;
+  setExternalReference!: Sequelize.BelongsToSetAssociationMixin<ExternalReference, ExternalReferenceId>;
+  createExternalReference!: Sequelize.BelongsToCreateAssociationMixin<ExternalReference>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonAlbumExternalReferenceRelation {
+    return CanonAlbumExternalReferenceRelation.init({
+    canonAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_album',
+        key: 'id'
+      },
+      field: 'canon_album_id'
+    },
+    externalReferenceId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'external_reference',
+        key: 'id'
+      },
+      field: 'external_reference_id'
+    },
+    url: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    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_album_external_reference_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_album_external_reference_relation_pk",
+        unique: true,
+        fields: [
+          { name: "canon_album_id" },
+          { name: "external_reference_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonAlbumGenreRelation.ts

@@ -0,0 +1,86 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+
+export interface CanonAlbumGenreRelationAttributes {
+  canonAlbumId: string;
+  canonGenreId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonAlbumGenreRelationPk = "canonAlbumId" | "canonGenreId";
+export type CanonAlbumGenreRelationId = CanonAlbumGenreRelation[CanonAlbumGenreRelationPk];
+export type CanonAlbumGenreRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonAlbumGenreRelationCreationAttributes = Optional<CanonAlbumGenreRelationAttributes, CanonAlbumGenreRelationOptionalAttributes>;
+
+export class CanonAlbumGenreRelation extends Model<CanonAlbumGenreRelationAttributes, CanonAlbumGenreRelationCreationAttributes> implements CanonAlbumGenreRelationAttributes {
+  canonAlbumId!: string;
+  canonGenreId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonAlbumGenreRelation belongsTo CanonGenre via canonGenreId
+  canonGenre!: CanonGenre;
+  getCanonGenre!: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+  setCanonGenre!: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+  createCanonGenre!: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+  // CanonAlbumGenreRelation belongsTo PlatformAlbum via canonAlbumId
+  canonAlbum!: PlatformAlbum;
+  getCanonAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+  setCanonAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  createCanonAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonAlbumGenreRelation {
+    return CanonAlbumGenreRelation.init({
+    canonAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_album',
+        key: 'id'
+      },
+      field: 'canon_album_id'
+    },
+    canonGenreId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_genre',
+        key: 'id'
+      },
+      field: 'canon_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_album_genre_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_album_genre_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "canon_album_id" },
+          { name: "canon_genre_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonAlbumImageHarvested.ts

@@ -0,0 +1,106 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+
+export interface CanonAlbumImageHarvestedAttributes {
+  id: string;
+  canonAlbumId: string;
+  priority?: number;
+  url?: string;
+  dateHarvested: Date;
+  storageKey: string;
+  harvestMethod?: string;
+}
+
+export type CanonAlbumImageHarvestedPk = "id";
+export type CanonAlbumImageHarvestedId = CanonAlbumImageHarvested[CanonAlbumImageHarvestedPk];
+export type CanonAlbumImageHarvestedOptionalAttributes = "id" | "priority" | "url" | "harvestMethod";
+export type CanonAlbumImageHarvestedCreationAttributes = Optional<CanonAlbumImageHarvestedAttributes, CanonAlbumImageHarvestedOptionalAttributes>;
+
+export class CanonAlbumImageHarvested extends Model<CanonAlbumImageHarvestedAttributes, CanonAlbumImageHarvestedCreationAttributes> implements CanonAlbumImageHarvestedAttributes {
+  id!: string;
+  canonAlbumId!: string;
+  priority?: number;
+  url?: string;
+  dateHarvested!: Date;
+  storageKey!: string;
+  harvestMethod?: string;
+
+  // CanonAlbumImageHarvested belongsTo CanonAlbum via canonAlbumId
+  canonAlbum!: CanonAlbum;
+  getCanonAlbum!: Sequelize.BelongsToGetAssociationMixin<CanonAlbum>;
+  setCanonAlbum!: Sequelize.BelongsToSetAssociationMixin<CanonAlbum, CanonAlbumId>;
+  createCanonAlbum!: Sequelize.BelongsToCreateAssociationMixin<CanonAlbum>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonAlbumImageHarvested {
+    return CanonAlbumImageHarvested.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    canonAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'canon_album',
+        key: 'id'
+      },
+      field: 'canon_album_id'
+    },
+    priority: {
+      type: DataTypes.DECIMAL,
+      allowNull: true,
+      defaultValue: 0
+    },
+    url: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      unique: "canon_album_image_harvested_url_unique"
+    },
+    dateHarvested: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      field: 'date_harvested'
+    },
+    storageKey: {
+      type: DataTypes.STRING(255),
+      allowNull: false,
+      field: 'storage_key'
+    },
+    harvestMethod: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      field: 'harvest_method'
+    }
+  }, {
+    sequelize,
+    tableName: 'canon_album_image_harvested',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_album_image_harvested_canon_album_id_index",
+        fields: [
+          { name: "canon_album_id" },
+        ]
+      },
+      {
+        name: "canon_album_image_harvested_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "canon_album_image_harvested_url_unique",
+        unique: true,
+        fields: [
+          { name: "url" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonAlbumLabelRelation.ts

@@ -0,0 +1,86 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonLabel, CanonLabelId } from './CanonLabel';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+
+export interface CanonAlbumLabelRelationAttributes {
+  canonAlbumId: string;
+  canonLabelId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonAlbumLabelRelationPk = "canonAlbumId" | "canonLabelId";
+export type CanonAlbumLabelRelationId = CanonAlbumLabelRelation[CanonAlbumLabelRelationPk];
+export type CanonAlbumLabelRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonAlbumLabelRelationCreationAttributes = Optional<CanonAlbumLabelRelationAttributes, CanonAlbumLabelRelationOptionalAttributes>;
+
+export class CanonAlbumLabelRelation extends Model<CanonAlbumLabelRelationAttributes, CanonAlbumLabelRelationCreationAttributes> implements CanonAlbumLabelRelationAttributes {
+  canonAlbumId!: string;
+  canonLabelId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonAlbumLabelRelation belongsTo CanonLabel via canonLabelId
+  canonLabel!: CanonLabel;
+  getCanonLabel!: Sequelize.BelongsToGetAssociationMixin<CanonLabel>;
+  setCanonLabel!: Sequelize.BelongsToSetAssociationMixin<CanonLabel, CanonLabelId>;
+  createCanonLabel!: Sequelize.BelongsToCreateAssociationMixin<CanonLabel>;
+  // CanonAlbumLabelRelation belongsTo PlatformAlbum via canonAlbumId
+  canonAlbum!: PlatformAlbum;
+  getCanonAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+  setCanonAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  createCanonAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonAlbumLabelRelation {
+    return CanonAlbumLabelRelation.init({
+    canonAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_album',
+        key: 'id'
+      },
+      field: 'canon_album_id'
+    },
+    canonLabelId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_label',
+        key: 'id'
+      },
+      field: 'canon_label_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_album_label_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_album_label_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "canon_album_id" },
+          { name: "canon_label_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonAlbumTrackRelation.ts

@@ -0,0 +1,86 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { CanonTrack, CanonTrackId } from './CanonTrack';
+
+export interface CanonAlbumTrackRelationAttributes {
+  canonAlbumId: string;
+  canonTrackId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonAlbumTrackRelationPk = "canonAlbumId" | "canonTrackId";
+export type CanonAlbumTrackRelationId = CanonAlbumTrackRelation[CanonAlbumTrackRelationPk];
+export type CanonAlbumTrackRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonAlbumTrackRelationCreationAttributes = Optional<CanonAlbumTrackRelationAttributes, CanonAlbumTrackRelationOptionalAttributes>;
+
+export class CanonAlbumTrackRelation extends Model<CanonAlbumTrackRelationAttributes, CanonAlbumTrackRelationCreationAttributes> implements CanonAlbumTrackRelationAttributes {
+  canonAlbumId!: string;
+  canonTrackId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonAlbumTrackRelation belongsTo CanonAlbum via canonAlbumId
+  canonAlbum!: CanonAlbum;
+  getCanonAlbum!: Sequelize.BelongsToGetAssociationMixin<CanonAlbum>;
+  setCanonAlbum!: Sequelize.BelongsToSetAssociationMixin<CanonAlbum, CanonAlbumId>;
+  createCanonAlbum!: Sequelize.BelongsToCreateAssociationMixin<CanonAlbum>;
+  // CanonAlbumTrackRelation belongsTo CanonTrack via canonTrackId
+  canonTrack!: CanonTrack;
+  getCanonTrack!: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
+  setCanonTrack!: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
+  createCanonTrack!: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonAlbumTrackRelation {
+    return CanonAlbumTrackRelation.init({
+    canonAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_album',
+        key: 'id'
+      },
+      field: 'canon_album_id'
+    },
+    canonTrackId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_track',
+        key: 'id'
+      },
+      field: 'canon_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_album_track_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_album_track_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "canon_album_id" },
+          { name: "canon_track_id" },
+        ]
+      },
+    ]
+  });
+  }
+}