@earbug/db-models 0.0.1

package/dist/PlatformAlbum.d.ts

@@ -0,0 +1,232 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { CanonAlbumGenreRelation, CanonAlbumGenreRelationId } from './CanonAlbumGenreRelation';
+import type { CanonAlbumLabelRelation, CanonAlbumLabelRelationId } from './CanonAlbumLabelRelation';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { CanonArtistAlbumRelation, CanonArtistAlbumRelationId } from './CanonArtistAlbumRelation';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { CanonLabel, CanonLabelId } from './CanonLabel';
+import type { CanonToPlatformAlbumRelation, CanonToPlatformAlbumRelationId } from './CanonToPlatformAlbumRelation';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId } from './PlatformAlbumGenreRelation';
+import type { PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId } from './PlatformAlbumTrackRelation';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId } from './PlatformArtistAlbumRelation';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum';
+import type { UnmatchedAlbum, UnmatchedAlbumId } from './UnmatchedAlbum';
+export interface PlatformAlbumAttributes {
+    id: string;
+    platformId: number;
+    externalAlbumId: string;
+    name: string;
+    asciiName: string;
+    albumType?: string;
+    releaseDate?: string;
+    popularity?: number;
+    recordLabel?: string;
+    createDate: Date;
+    updateDate: Date;
+    images?: object;
+}
+export type PlatformAlbumPk = "id";
+export type PlatformAlbumId = PlatformAlbum[PlatformAlbumPk];
+export type PlatformAlbumOptionalAttributes = "id" | "albumType" | "releaseDate" | "popularity" | "recordLabel" | "createDate" | "updateDate" | "images";
+export type PlatformAlbumCreationAttributes = Optional<PlatformAlbumAttributes, PlatformAlbumOptionalAttributes>;
+export declare class PlatformAlbum extends Model<PlatformAlbumAttributes, PlatformAlbumCreationAttributes> implements PlatformAlbumAttributes {
+    id: string;
+    platformId: number;
+    externalAlbumId: string;
+    name: string;
+    asciiName: string;
+    albumType?: string;
+    releaseDate?: string;
+    popularity?: number;
+    recordLabel?: string;
+    createDate: Date;
+    updateDate: Date;
+    images?: object;
+    platform: Platform;
+    getPlatform: Sequelize.BelongsToGetAssociationMixin<Platform>;
+    setPlatform: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+    createPlatform: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+    canonAlbumIdCanonAlbumCanonToPlatformAlbumRelations: CanonAlbum[];
+    getCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelations: Sequelize.BelongsToManyGetAssociationsMixin<CanonAlbum>;
+    setCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelations: Sequelize.BelongsToManySetAssociationsMixin<CanonAlbum, CanonAlbumId>;
+    addCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelation: Sequelize.BelongsToManyAddAssociationMixin<CanonAlbum, CanonAlbumId>;
+    addCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelations: Sequelize.BelongsToManyAddAssociationsMixin<CanonAlbum, CanonAlbumId>;
+    createCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelation: Sequelize.BelongsToManyCreateAssociationMixin<CanonAlbum>;
+    removeCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelation: Sequelize.BelongsToManyRemoveAssociationMixin<CanonAlbum, CanonAlbumId>;
+    removeCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonAlbum, CanonAlbumId>;
+    hasCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelation: Sequelize.BelongsToManyHasAssociationMixin<CanonAlbum, CanonAlbumId>;
+    hasCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelations: Sequelize.BelongsToManyHasAssociationsMixin<CanonAlbum, CanonAlbumId>;
+    countCanonAlbumIdCanonAlbumCanonToPlatformAlbumRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonAlbumGenreRelations: CanonAlbumGenreRelation[];
+    getCanonAlbumGenreRelations: Sequelize.HasManyGetAssociationsMixin<CanonAlbumGenreRelation>;
+    setCanonAlbumGenreRelations: Sequelize.HasManySetAssociationsMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    addCanonAlbumGenreRelation: Sequelize.HasManyAddAssociationMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    addCanonAlbumGenreRelations: Sequelize.HasManyAddAssociationsMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    createCanonAlbumGenreRelation: Sequelize.HasManyCreateAssociationMixin<CanonAlbumGenreRelation>;
+    removeCanonAlbumGenreRelation: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    removeCanonAlbumGenreRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    hasCanonAlbumGenreRelation: Sequelize.HasManyHasAssociationMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    hasCanonAlbumGenreRelations: Sequelize.HasManyHasAssociationsMixin<CanonAlbumGenreRelation, CanonAlbumGenreRelationId>;
+    countCanonAlbumGenreRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonAlbumLabelRelations: CanonAlbumLabelRelation[];
+    getCanonAlbumLabelRelations: Sequelize.HasManyGetAssociationsMixin<CanonAlbumLabelRelation>;
+    setCanonAlbumLabelRelations: Sequelize.HasManySetAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    addCanonAlbumLabelRelation: Sequelize.HasManyAddAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    addCanonAlbumLabelRelations: Sequelize.HasManyAddAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    createCanonAlbumLabelRelation: Sequelize.HasManyCreateAssociationMixin<CanonAlbumLabelRelation>;
+    removeCanonAlbumLabelRelation: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    removeCanonAlbumLabelRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    hasCanonAlbumLabelRelation: Sequelize.HasManyHasAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    hasCanonAlbumLabelRelations: Sequelize.HasManyHasAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+    countCanonAlbumLabelRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonArtistIdCanonArtists: CanonArtist[];
+    getCanonArtistIdCanonArtists: Sequelize.BelongsToManyGetAssociationsMixin<CanonArtist>;
+    setCanonArtistIdCanonArtists: Sequelize.BelongsToManySetAssociationsMixin<CanonArtist, CanonArtistId>;
+    addCanonArtistIdCanonArtist: Sequelize.BelongsToManyAddAssociationMixin<CanonArtist, CanonArtistId>;
+    addCanonArtistIdCanonArtists: Sequelize.BelongsToManyAddAssociationsMixin<CanonArtist, CanonArtistId>;
+    createCanonArtistIdCanonArtist: Sequelize.BelongsToManyCreateAssociationMixin<CanonArtist>;
+    removeCanonArtistIdCanonArtist: Sequelize.BelongsToManyRemoveAssociationMixin<CanonArtist, CanonArtistId>;
+    removeCanonArtistIdCanonArtists: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonArtist, CanonArtistId>;
+    hasCanonArtistIdCanonArtist: Sequelize.BelongsToManyHasAssociationMixin<CanonArtist, CanonArtistId>;
+    hasCanonArtistIdCanonArtists: Sequelize.BelongsToManyHasAssociationsMixin<CanonArtist, CanonArtistId>;
+    countCanonArtistIdCanonArtists: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonArtistAlbumRelations: CanonArtistAlbumRelation[];
+    getCanonArtistAlbumRelations: Sequelize.HasManyGetAssociationsMixin<CanonArtistAlbumRelation>;
+    setCanonArtistAlbumRelations: Sequelize.HasManySetAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    addCanonArtistAlbumRelation: Sequelize.HasManyAddAssociationMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    addCanonArtistAlbumRelations: Sequelize.HasManyAddAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    createCanonArtistAlbumRelation: Sequelize.HasManyCreateAssociationMixin<CanonArtistAlbumRelation>;
+    removeCanonArtistAlbumRelation: Sequelize.HasManyRemoveAssociationMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    removeCanonArtistAlbumRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    hasCanonArtistAlbumRelation: Sequelize.HasManyHasAssociationMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    hasCanonArtistAlbumRelations: Sequelize.HasManyHasAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
+    countCanonArtistAlbumRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonGenreIdCanonGenres: CanonGenre[];
+    getCanonGenreIdCanonGenres: Sequelize.BelongsToManyGetAssociationsMixin<CanonGenre>;
+    setCanonGenreIdCanonGenres: Sequelize.BelongsToManySetAssociationsMixin<CanonGenre, CanonGenreId>;
+    addCanonGenreIdCanonGenre: Sequelize.BelongsToManyAddAssociationMixin<CanonGenre, CanonGenreId>;
+    addCanonGenreIdCanonGenres: Sequelize.BelongsToManyAddAssociationsMixin<CanonGenre, CanonGenreId>;
+    createCanonGenreIdCanonGenre: Sequelize.BelongsToManyCreateAssociationMixin<CanonGenre>;
+    removeCanonGenreIdCanonGenre: Sequelize.BelongsToManyRemoveAssociationMixin<CanonGenre, CanonGenreId>;
+    removeCanonGenreIdCanonGenres: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonGenre, CanonGenreId>;
+    hasCanonGenreIdCanonGenre: Sequelize.BelongsToManyHasAssociationMixin<CanonGenre, CanonGenreId>;
+    hasCanonGenreIdCanonGenres: Sequelize.BelongsToManyHasAssociationsMixin<CanonGenre, CanonGenreId>;
+    countCanonGenreIdCanonGenres: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonLabelIdCanonLabels: CanonLabel[];
+    getCanonLabelIdCanonLabels: Sequelize.BelongsToManyGetAssociationsMixin<CanonLabel>;
+    setCanonLabelIdCanonLabels: Sequelize.BelongsToManySetAssociationsMixin<CanonLabel, CanonLabelId>;
+    addCanonLabelIdCanonLabel: Sequelize.BelongsToManyAddAssociationMixin<CanonLabel, CanonLabelId>;
+    addCanonLabelIdCanonLabels: Sequelize.BelongsToManyAddAssociationsMixin<CanonLabel, CanonLabelId>;
+    createCanonLabelIdCanonLabel: Sequelize.BelongsToManyCreateAssociationMixin<CanonLabel>;
+    removeCanonLabelIdCanonLabel: Sequelize.BelongsToManyRemoveAssociationMixin<CanonLabel, CanonLabelId>;
+    removeCanonLabelIdCanonLabels: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonLabel, CanonLabelId>;
+    hasCanonLabelIdCanonLabel: Sequelize.BelongsToManyHasAssociationMixin<CanonLabel, CanonLabelId>;
+    hasCanonLabelIdCanonLabels: Sequelize.BelongsToManyHasAssociationsMixin<CanonLabel, CanonLabelId>;
+    countCanonLabelIdCanonLabels: Sequelize.BelongsToManyCountAssociationsMixin;
+    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;
+    platformAlbumGenreRelations: PlatformAlbumGenreRelation[];
+    getPlatformAlbumGenreRelations: Sequelize.HasManyGetAssociationsMixin<PlatformAlbumGenreRelation>;
+    setPlatformAlbumGenreRelations: Sequelize.HasManySetAssociationsMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    addPlatformAlbumGenreRelation: Sequelize.HasManyAddAssociationMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    addPlatformAlbumGenreRelations: Sequelize.HasManyAddAssociationsMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    createPlatformAlbumGenreRelation: Sequelize.HasManyCreateAssociationMixin<PlatformAlbumGenreRelation>;
+    removePlatformAlbumGenreRelation: Sequelize.HasManyRemoveAssociationMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    removePlatformAlbumGenreRelations: Sequelize.HasManyRemoveAssociationsMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    hasPlatformAlbumGenreRelation: Sequelize.HasManyHasAssociationMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    hasPlatformAlbumGenreRelations: Sequelize.HasManyHasAssociationsMixin<PlatformAlbumGenreRelation, PlatformAlbumGenreRelationId>;
+    countPlatformAlbumGenreRelations: Sequelize.HasManyCountAssociationsMixin;
+    platformAlbumTrackRelations: PlatformAlbumTrackRelation[];
+    getPlatformAlbumTrackRelations: Sequelize.HasManyGetAssociationsMixin<PlatformAlbumTrackRelation>;
+    setPlatformAlbumTrackRelations: Sequelize.HasManySetAssociationsMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    addPlatformAlbumTrackRelation: Sequelize.HasManyAddAssociationMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    addPlatformAlbumTrackRelations: Sequelize.HasManyAddAssociationsMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    createPlatformAlbumTrackRelation: Sequelize.HasManyCreateAssociationMixin<PlatformAlbumTrackRelation>;
+    removePlatformAlbumTrackRelation: Sequelize.HasManyRemoveAssociationMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    removePlatformAlbumTrackRelations: Sequelize.HasManyRemoveAssociationsMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    hasPlatformAlbumTrackRelation: Sequelize.HasManyHasAssociationMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    hasPlatformAlbumTrackRelations: Sequelize.HasManyHasAssociationsMixin<PlatformAlbumTrackRelation, PlatformAlbumTrackRelationId>;
+    countPlatformAlbumTrackRelations: Sequelize.HasManyCountAssociationsMixin;
+    platformArtistIdPlatformArtistPlatformArtistAlbumRelations: PlatformArtist[];
+    getPlatformArtistIdPlatformArtistPlatformArtistAlbumRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+    setPlatformArtistIdPlatformArtistPlatformArtistAlbumRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    addPlatformArtistIdPlatformArtistPlatformArtistAlbumRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+    addPlatformArtistIdPlatformArtistPlatformArtistAlbumRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    createPlatformArtistIdPlatformArtistPlatformArtistAlbumRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+    removePlatformArtistIdPlatformArtistPlatformArtistAlbumRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+    removePlatformArtistIdPlatformArtistPlatformArtistAlbumRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    hasPlatformArtistIdPlatformArtistPlatformArtistAlbumRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+    hasPlatformArtistIdPlatformArtistPlatformArtistAlbumRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+    countPlatformArtistIdPlatformArtistPlatformArtistAlbumRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformArtistAlbumRelations: PlatformArtistAlbumRelation[];
+    getPlatformArtistAlbumRelations: Sequelize.HasManyGetAssociationsMixin<PlatformArtistAlbumRelation>;
+    setPlatformArtistAlbumRelations: Sequelize.HasManySetAssociationsMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+    addPlatformArtistAlbumRelation: Sequelize.HasManyAddAssociationMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+    addPlatformArtistAlbumRelations: Sequelize.HasManyAddAssociationsMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+    createPlatformArtistAlbumRelation: Sequelize.HasManyCreateAssociationMixin<PlatformArtistAlbumRelation>;
+    removePlatformArtistAlbumRelation: Sequelize.HasManyRemoveAssociationMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+    removePlatformArtistAlbumRelations: Sequelize.HasManyRemoveAssociationsMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+    hasPlatformArtistAlbumRelation: Sequelize.HasManyHasAssociationMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+    hasPlatformArtistAlbumRelations: Sequelize.HasManyHasAssociationsMixin<PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId>;
+    countPlatformArtistAlbumRelations: Sequelize.HasManyCountAssociationsMixin;
+    platformGenreIdPlatformGenrePlatformAlbumGenreRelations: PlatformGenre[];
+    getPlatformGenreIdPlatformGenrePlatformAlbumGenreRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformGenre>;
+    setPlatformGenreIdPlatformGenrePlatformAlbumGenreRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    addPlatformGenreIdPlatformGenrePlatformAlbumGenreRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformGenre, PlatformGenreId>;
+    addPlatformGenreIdPlatformGenrePlatformAlbumGenreRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    createPlatformGenreIdPlatformGenrePlatformAlbumGenreRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformGenre>;
+    removePlatformGenreIdPlatformGenrePlatformAlbumGenreRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformGenre, PlatformGenreId>;
+    removePlatformGenreIdPlatformGenrePlatformAlbumGenreRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    hasPlatformGenreIdPlatformGenrePlatformAlbumGenreRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformGenre, PlatformGenreId>;
+    hasPlatformGenreIdPlatformGenrePlatformAlbumGenreRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    countPlatformGenreIdPlatformGenrePlatformAlbumGenreRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformTrackIdPlatformTrackPlatformAlbumTrackRelations: PlatformTrack[];
+    getPlatformTrackIdPlatformTrackPlatformAlbumTrackRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformTrack>;
+    setPlatformTrackIdPlatformTrackPlatformAlbumTrackRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    addPlatformTrackIdPlatformTrackPlatformAlbumTrackRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformTrack, PlatformTrackId>;
+    addPlatformTrackIdPlatformTrackPlatformAlbumTrackRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrackIdPlatformTrackPlatformAlbumTrackRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformTrack>;
+    removePlatformTrackIdPlatformTrackPlatformAlbumTrackRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformTrack, PlatformTrackId>;
+    removePlatformTrackIdPlatformTrackPlatformAlbumTrackRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    hasPlatformTrackIdPlatformTrackPlatformAlbumTrackRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
+    hasPlatformTrackIdPlatformTrackPlatformAlbumTrackRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    countPlatformTrackIdPlatformTrackPlatformAlbumTrackRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformUserAlbums: PlatformUserAlbum[];
+    getPlatformUserAlbums: Sequelize.HasManyGetAssociationsMixin<PlatformUserAlbum>;
+    setPlatformUserAlbums: Sequelize.HasManySetAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    addPlatformUserAlbum: Sequelize.HasManyAddAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    addPlatformUserAlbums: Sequelize.HasManyAddAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    createPlatformUserAlbum: Sequelize.HasManyCreateAssociationMixin<PlatformUserAlbum>;
+    removePlatformUserAlbum: Sequelize.HasManyRemoveAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    removePlatformUserAlbums: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    hasPlatformUserAlbum: Sequelize.HasManyHasAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    hasPlatformUserAlbums: Sequelize.HasManyHasAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    countPlatformUserAlbums: Sequelize.HasManyCountAssociationsMixin;
+    unmatchedAlbums: UnmatchedAlbum[];
+    getUnmatchedAlbums: Sequelize.HasManyGetAssociationsMixin<UnmatchedAlbum>;
+    setUnmatchedAlbums: Sequelize.HasManySetAssociationsMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+    addUnmatchedAlbum: Sequelize.HasManyAddAssociationMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+    addUnmatchedAlbums: Sequelize.HasManyAddAssociationsMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+    createUnmatchedAlbum: Sequelize.HasManyCreateAssociationMixin<UnmatchedAlbum>;
+    removeUnmatchedAlbum: Sequelize.HasManyRemoveAssociationMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+    removeUnmatchedAlbums: Sequelize.HasManyRemoveAssociationsMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+    hasUnmatchedAlbum: Sequelize.HasManyHasAssociationMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+    hasUnmatchedAlbums: Sequelize.HasManyHasAssociationsMixin<UnmatchedAlbum, UnmatchedAlbumId>;
+    countUnmatchedAlbums: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformAlbum;
+}

package/dist/PlatformAlbum.js

@@ -0,0 +1,123 @@
+"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.PlatformAlbum = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class PlatformAlbum extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlatformAlbum.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            platformId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'platform',
+                    key: 'id'
+                },
+                unique: "uk_platform_id_external_album_id",
+                field: 'platform_id'
+            },
+            externalAlbumId: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                unique: "uk_platform_id_external_album_id",
+                field: 'external_album_id'
+            },
+            name: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            asciiName: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'ascii_name'
+            },
+            albumType: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 'album_type'
+            },
+            releaseDate: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 'release_date'
+            },
+            popularity: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: true
+            },
+            recordLabel: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 'record_label'
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            },
+            images: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true
+            }
+        }, {
+            sequelize,
+            tableName: 'platform_album',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "platform_album_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "uk_platform_id_external_album_id",
+                    unique: true,
+                    fields: [
+                        { name: "platform_id" },
+                        { name: "external_album_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.PlatformAlbum = PlatformAlbum;

package/dist/PlatformAlbumGenreRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+export interface PlatformAlbumGenreRelationAttributes {
+    platformAlbumId: string;
+    platformGenreId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type PlatformAlbumGenreRelationPk = "platformAlbumId" | "platformGenreId";
+export type PlatformAlbumGenreRelationId = PlatformAlbumGenreRelation[PlatformAlbumGenreRelationPk];
+export type PlatformAlbumGenreRelationOptionalAttributes = "createDate" | "updateDate";
+export type PlatformAlbumGenreRelationCreationAttributes = Optional<PlatformAlbumGenreRelationAttributes, PlatformAlbumGenreRelationOptionalAttributes>;
+export declare class PlatformAlbumGenreRelation extends Model<PlatformAlbumGenreRelationAttributes, PlatformAlbumGenreRelationCreationAttributes> implements PlatformAlbumGenreRelationAttributes {
+    platformAlbumId: string;
+    platformGenreId: string;
+    createDate: Date;
+    updateDate: Date;
+    platformAlbum: PlatformAlbum;
+    getPlatformAlbum: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+    setPlatformAlbum: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    createPlatformAlbum: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+    platformGenre: PlatformGenre;
+    getPlatformGenre: Sequelize.BelongsToGetAssociationMixin<PlatformGenre>;
+    setPlatformGenre: Sequelize.BelongsToSetAssociationMixin<PlatformGenre, PlatformGenreId>;
+    createPlatformGenre: Sequelize.BelongsToCreateAssociationMixin<PlatformGenre>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformAlbumGenreRelation;
+}

package/dist/PlatformAlbumGenreRelation.js

@@ -0,0 +1,82 @@
+"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.PlatformAlbumGenreRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class PlatformAlbumGenreRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlatformAlbumGenreRelation.init({
+            platformAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'platform_album',
+                    key: 'id'
+                },
+                field: 'platform_album_id'
+            },
+            platformGenreId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'platform_genre',
+                    key: 'id'
+                },
+                field: 'platform_genre_id'
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            }
+        }, {
+            sequelize,
+            tableName: 'platform_album_genre_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "platform_album_genre_relation_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "platform_album_id" },
+                        { name: "platform_genre_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.PlatformAlbumGenreRelation = PlatformAlbumGenreRelation;

package/dist/PlatformAlbumTrackRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+export interface PlatformAlbumTrackRelationAttributes {
+    platformAlbumId: string;
+    platformTrackId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type PlatformAlbumTrackRelationPk = "platformAlbumId" | "platformTrackId";
+export type PlatformAlbumTrackRelationId = PlatformAlbumTrackRelation[PlatformAlbumTrackRelationPk];
+export type PlatformAlbumTrackRelationOptionalAttributes = "createDate" | "updateDate";
+export type PlatformAlbumTrackRelationCreationAttributes = Optional<PlatformAlbumTrackRelationAttributes, PlatformAlbumTrackRelationOptionalAttributes>;
+export declare class PlatformAlbumTrackRelation extends Model<PlatformAlbumTrackRelationAttributes, PlatformAlbumTrackRelationCreationAttributes> implements PlatformAlbumTrackRelationAttributes {
+    platformAlbumId: string;
+    platformTrackId: string;
+    createDate: Date;
+    updateDate: Date;
+    platformAlbum: PlatformAlbum;
+    getPlatformAlbum: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+    setPlatformAlbum: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    createPlatformAlbum: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+    platformTrack: PlatformTrack;
+    getPlatformTrack: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+    setPlatformTrack: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrack: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformAlbumTrackRelation;
+}

package/dist/PlatformAlbumTrackRelation.js

@@ -0,0 +1,82 @@
+"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.PlatformAlbumTrackRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class PlatformAlbumTrackRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlatformAlbumTrackRelation.init({
+            platformAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'platform_album',
+                    key: 'id'
+                },
+                field: 'platform_album_id'
+            },
+            platformTrackId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'platform_track',
+                    key: 'id'
+                },
+                field: 'platform_track_id'
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            }
+        }, {
+            sequelize,
+            tableName: 'platform_album_track_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "platform_album_track_relation_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "platform_album_id" },
+                        { name: "platform_track_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.PlatformAlbumTrackRelation = PlatformAlbumTrackRelation;