@earbug/db-models 0.0.1

package/dist/PlatformArtist.d.ts

@@ -0,0 +1,225 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId } from './CanonArtistExternalReferenceRelation';
+import type { CanonArtistGenreRelation, CanonArtistGenreRelationId } from './CanonArtistGenreRelation';
+import type { CanonArtistMemberRelation, CanonArtistMemberRelationId } from './CanonArtistMemberRelation';
+import type { CanonArtistTrackRelation, CanonArtistTrackRelationId } from './CanonArtistTrackRelation';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { CanonMember, CanonMemberId } from './CanonMember';
+import type { CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId } from './CanonToPlatformArtistRelation';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformArtistAlbumRelation, PlatformArtistAlbumRelationId } from './PlatformArtistAlbumRelation';
+import type { PlatformArtistGenreRelation, PlatformArtistGenreRelationId } from './PlatformArtistGenreRelation';
+import type { PlatformArtistTrackRelation, PlatformArtistTrackRelationId } from './PlatformArtistTrackRelation';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+export interface PlatformArtistAttributes {
+    id: string;
+    externalArtistId: string;
+    platformId: number;
+    name: string;
+    asciiName: string;
+    externalUri?: string;
+    createDate: Date;
+    updateDate: Date;
+    genres?: string[];
+}
+export type PlatformArtistPk = "id";
+export type PlatformArtistId = PlatformArtist[PlatformArtistPk];
+export type PlatformArtistOptionalAttributes = "id" | "externalUri" | "createDate" | "updateDate" | "genres";
+export type PlatformArtistCreationAttributes = Optional<PlatformArtistAttributes, PlatformArtistOptionalAttributes>;
+export declare class PlatformArtist extends Model<PlatformArtistAttributes, PlatformArtistCreationAttributes> implements PlatformArtistAttributes {
+    id: string;
+    externalArtistId: string;
+    platformId: number;
+    name: string;
+    asciiName: string;
+    externalUri?: string;
+    createDate: Date;
+    updateDate: Date;
+    genres?: string[];
+    platform: Platform;
+    getPlatform: Sequelize.BelongsToGetAssociationMixin<Platform>;
+    setPlatform: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+    createPlatform: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+    canonArtistIdCanonArtistCanonToPlatformArtistRelations: CanonArtist[];
+    getCanonArtistIdCanonArtistCanonToPlatformArtistRelations: Sequelize.BelongsToManyGetAssociationsMixin<CanonArtist>;
+    setCanonArtistIdCanonArtistCanonToPlatformArtistRelations: Sequelize.BelongsToManySetAssociationsMixin<CanonArtist, CanonArtistId>;
+    addCanonArtistIdCanonArtistCanonToPlatformArtistRelation: Sequelize.BelongsToManyAddAssociationMixin<CanonArtist, CanonArtistId>;
+    addCanonArtistIdCanonArtistCanonToPlatformArtistRelations: Sequelize.BelongsToManyAddAssociationsMixin<CanonArtist, CanonArtistId>;
+    createCanonArtistIdCanonArtistCanonToPlatformArtistRelation: Sequelize.BelongsToManyCreateAssociationMixin<CanonArtist>;
+    removeCanonArtistIdCanonArtistCanonToPlatformArtistRelation: Sequelize.BelongsToManyRemoveAssociationMixin<CanonArtist, CanonArtistId>;
+    removeCanonArtistIdCanonArtistCanonToPlatformArtistRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonArtist, CanonArtistId>;
+    hasCanonArtistIdCanonArtistCanonToPlatformArtistRelation: Sequelize.BelongsToManyHasAssociationMixin<CanonArtist, CanonArtistId>;
+    hasCanonArtistIdCanonArtistCanonToPlatformArtistRelations: Sequelize.BelongsToManyHasAssociationsMixin<CanonArtist, CanonArtistId>;
+    countCanonArtistIdCanonArtistCanonToPlatformArtistRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonArtistExternalReferenceRelations: CanonArtistExternalReferenceRelation[];
+    getCanonArtistExternalReferenceRelations: Sequelize.HasManyGetAssociationsMixin<CanonArtistExternalReferenceRelation>;
+    setCanonArtistExternalReferenceRelations: Sequelize.HasManySetAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    addCanonArtistExternalReferenceRelation: Sequelize.HasManyAddAssociationMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    addCanonArtistExternalReferenceRelations: Sequelize.HasManyAddAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    createCanonArtistExternalReferenceRelation: Sequelize.HasManyCreateAssociationMixin<CanonArtistExternalReferenceRelation>;
+    removeCanonArtistExternalReferenceRelation: Sequelize.HasManyRemoveAssociationMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    removeCanonArtistExternalReferenceRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    hasCanonArtistExternalReferenceRelation: Sequelize.HasManyHasAssociationMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    hasCanonArtistExternalReferenceRelations: Sequelize.HasManyHasAssociationsMixin<CanonArtistExternalReferenceRelation, CanonArtistExternalReferenceRelationId>;
+    countCanonArtistExternalReferenceRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonArtistGenreRelations: CanonArtistGenreRelation[];
+    getCanonArtistGenreRelations: Sequelize.HasManyGetAssociationsMixin<CanonArtistGenreRelation>;
+    setCanonArtistGenreRelations: Sequelize.HasManySetAssociationsMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    addCanonArtistGenreRelation: Sequelize.HasManyAddAssociationMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    addCanonArtistGenreRelations: Sequelize.HasManyAddAssociationsMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    createCanonArtistGenreRelation: Sequelize.HasManyCreateAssociationMixin<CanonArtistGenreRelation>;
+    removeCanonArtistGenreRelation: Sequelize.HasManyRemoveAssociationMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    removeCanonArtistGenreRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    hasCanonArtistGenreRelation: Sequelize.HasManyHasAssociationMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    hasCanonArtistGenreRelations: Sequelize.HasManyHasAssociationsMixin<CanonArtistGenreRelation, CanonArtistGenreRelationId>;
+    countCanonArtistGenreRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonArtistMemberRelations: CanonArtistMemberRelation[];
+    getCanonArtistMemberRelations: Sequelize.HasManyGetAssociationsMixin<CanonArtistMemberRelation>;
+    setCanonArtistMemberRelations: Sequelize.HasManySetAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    addCanonArtistMemberRelation: Sequelize.HasManyAddAssociationMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    addCanonArtistMemberRelations: Sequelize.HasManyAddAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    createCanonArtistMemberRelation: Sequelize.HasManyCreateAssociationMixin<CanonArtistMemberRelation>;
+    removeCanonArtistMemberRelation: Sequelize.HasManyRemoveAssociationMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    removeCanonArtistMemberRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    hasCanonArtistMemberRelation: Sequelize.HasManyHasAssociationMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    hasCanonArtistMemberRelations: Sequelize.HasManyHasAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+    countCanonArtistMemberRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonArtistTrackRelations: CanonArtistTrackRelation[];
+    getCanonArtistTrackRelations: Sequelize.HasManyGetAssociationsMixin<CanonArtistTrackRelation>;
+    setCanonArtistTrackRelations: Sequelize.HasManySetAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    addCanonArtistTrackRelation: Sequelize.HasManyAddAssociationMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    addCanonArtistTrackRelations: Sequelize.HasManyAddAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    createCanonArtistTrackRelation: Sequelize.HasManyCreateAssociationMixin<CanonArtistTrackRelation>;
+    removeCanonArtistTrackRelation: Sequelize.HasManyRemoveAssociationMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    removeCanonArtistTrackRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    hasCanonArtistTrackRelation: Sequelize.HasManyHasAssociationMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    hasCanonArtistTrackRelations: Sequelize.HasManyHasAssociationsMixin<CanonArtistTrackRelation, CanonArtistTrackRelationId>;
+    countCanonArtistTrackRelations: Sequelize.HasManyCountAssociationsMixin;
+    canonGenreIdCanonGenreCanonArtistGenreRelations: CanonGenre[];
+    getCanonGenreIdCanonGenreCanonArtistGenreRelations: Sequelize.BelongsToManyGetAssociationsMixin<CanonGenre>;
+    setCanonGenreIdCanonGenreCanonArtistGenreRelations: Sequelize.BelongsToManySetAssociationsMixin<CanonGenre, CanonGenreId>;
+    addCanonGenreIdCanonGenreCanonArtistGenreRelation: Sequelize.BelongsToManyAddAssociationMixin<CanonGenre, CanonGenreId>;
+    addCanonGenreIdCanonGenreCanonArtistGenreRelations: Sequelize.BelongsToManyAddAssociationsMixin<CanonGenre, CanonGenreId>;
+    createCanonGenreIdCanonGenreCanonArtistGenreRelation: Sequelize.BelongsToManyCreateAssociationMixin<CanonGenre>;
+    removeCanonGenreIdCanonGenreCanonArtistGenreRelation: Sequelize.BelongsToManyRemoveAssociationMixin<CanonGenre, CanonGenreId>;
+    removeCanonGenreIdCanonGenreCanonArtistGenreRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonGenre, CanonGenreId>;
+    hasCanonGenreIdCanonGenreCanonArtistGenreRelation: Sequelize.BelongsToManyHasAssociationMixin<CanonGenre, CanonGenreId>;
+    hasCanonGenreIdCanonGenreCanonArtistGenreRelations: Sequelize.BelongsToManyHasAssociationsMixin<CanonGenre, CanonGenreId>;
+    countCanonGenreIdCanonGenreCanonArtistGenreRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonMemberIdCanonMembers: CanonMember[];
+    getCanonMemberIdCanonMembers: Sequelize.BelongsToManyGetAssociationsMixin<CanonMember>;
+    setCanonMemberIdCanonMembers: Sequelize.BelongsToManySetAssociationsMixin<CanonMember, CanonMemberId>;
+    addCanonMemberIdCanonMember: Sequelize.BelongsToManyAddAssociationMixin<CanonMember, CanonMemberId>;
+    addCanonMemberIdCanonMembers: Sequelize.BelongsToManyAddAssociationsMixin<CanonMember, CanonMemberId>;
+    createCanonMemberIdCanonMember: Sequelize.BelongsToManyCreateAssociationMixin<CanonMember>;
+    removeCanonMemberIdCanonMember: Sequelize.BelongsToManyRemoveAssociationMixin<CanonMember, CanonMemberId>;
+    removeCanonMemberIdCanonMembers: Sequelize.BelongsToManyRemoveAssociationsMixin<CanonMember, CanonMemberId>;
+    hasCanonMemberIdCanonMember: Sequelize.BelongsToManyHasAssociationMixin<CanonMember, CanonMemberId>;
+    hasCanonMemberIdCanonMembers: Sequelize.BelongsToManyHasAssociationsMixin<CanonMember, CanonMemberId>;
+    countCanonMemberIdCanonMembers: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonToPlatformArtistRelations: CanonToPlatformArtistRelation[];
+    getCanonToPlatformArtistRelations: Sequelize.HasManyGetAssociationsMixin<CanonToPlatformArtistRelation>;
+    setCanonToPlatformArtistRelations: Sequelize.HasManySetAssociationsMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    addCanonToPlatformArtistRelation: Sequelize.HasManyAddAssociationMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    addCanonToPlatformArtistRelations: Sequelize.HasManyAddAssociationsMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    createCanonToPlatformArtistRelation: Sequelize.HasManyCreateAssociationMixin<CanonToPlatformArtistRelation>;
+    removeCanonToPlatformArtistRelation: Sequelize.HasManyRemoveAssociationMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    removeCanonToPlatformArtistRelations: Sequelize.HasManyRemoveAssociationsMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    hasCanonToPlatformArtistRelation: Sequelize.HasManyHasAssociationMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    hasCanonToPlatformArtistRelations: Sequelize.HasManyHasAssociationsMixin<CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId>;
+    countCanonToPlatformArtistRelations: Sequelize.HasManyCountAssociationsMixin;
+    externalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations: ExternalReference[];
+    getExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations: Sequelize.BelongsToManyGetAssociationsMixin<ExternalReference>;
+    setExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations: Sequelize.BelongsToManySetAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    addExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelation: Sequelize.BelongsToManyAddAssociationMixin<ExternalReference, ExternalReferenceId>;
+    addExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations: Sequelize.BelongsToManyAddAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    createExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelation: Sequelize.BelongsToManyCreateAssociationMixin<ExternalReference>;
+    removeExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelation: Sequelize.BelongsToManyRemoveAssociationMixin<ExternalReference, ExternalReferenceId>;
+    removeExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    hasExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelation: Sequelize.BelongsToManyHasAssociationMixin<ExternalReference, ExternalReferenceId>;
+    hasExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations: Sequelize.BelongsToManyHasAssociationsMixin<ExternalReference, ExternalReferenceId>;
+    countExternalReferenceIdExternalReferenceCanonArtistExternalReferenceRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformAlbumIdPlatformAlbumPlatformArtistAlbumRelations: PlatformAlbum[];
+    getPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+    setPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    addPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    addPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    createPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+    removePlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    removePlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    hasPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    hasPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+    countPlatformAlbumIdPlatformAlbumPlatformArtistAlbumRelations: 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;
+    platformArtistGenreRelations: PlatformArtistGenreRelation[];
+    getPlatformArtistGenreRelations: Sequelize.HasManyGetAssociationsMixin<PlatformArtistGenreRelation>;
+    setPlatformArtistGenreRelations: Sequelize.HasManySetAssociationsMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    addPlatformArtistGenreRelation: Sequelize.HasManyAddAssociationMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    addPlatformArtistGenreRelations: Sequelize.HasManyAddAssociationsMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    createPlatformArtistGenreRelation: Sequelize.HasManyCreateAssociationMixin<PlatformArtistGenreRelation>;
+    removePlatformArtistGenreRelation: Sequelize.HasManyRemoveAssociationMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    removePlatformArtistGenreRelations: Sequelize.HasManyRemoveAssociationsMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    hasPlatformArtistGenreRelation: Sequelize.HasManyHasAssociationMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    hasPlatformArtistGenreRelations: Sequelize.HasManyHasAssociationsMixin<PlatformArtistGenreRelation, PlatformArtistGenreRelationId>;
+    countPlatformArtistGenreRelations: Sequelize.HasManyCountAssociationsMixin;
+    platformArtistTrackRelations: PlatformArtistTrackRelation[];
+    getPlatformArtistTrackRelations: Sequelize.HasManyGetAssociationsMixin<PlatformArtistTrackRelation>;
+    setPlatformArtistTrackRelations: Sequelize.HasManySetAssociationsMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    addPlatformArtistTrackRelation: Sequelize.HasManyAddAssociationMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    addPlatformArtistTrackRelations: Sequelize.HasManyAddAssociationsMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    createPlatformArtistTrackRelation: Sequelize.HasManyCreateAssociationMixin<PlatformArtistTrackRelation>;
+    removePlatformArtistTrackRelation: Sequelize.HasManyRemoveAssociationMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    removePlatformArtistTrackRelations: Sequelize.HasManyRemoveAssociationsMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    hasPlatformArtistTrackRelation: Sequelize.HasManyHasAssociationMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    hasPlatformArtistTrackRelations: Sequelize.HasManyHasAssociationsMixin<PlatformArtistTrackRelation, PlatformArtistTrackRelationId>;
+    countPlatformArtistTrackRelations: Sequelize.HasManyCountAssociationsMixin;
+    platformGenreIdPlatformGenrePlatformArtistGenreRelations: PlatformGenre[];
+    getPlatformGenreIdPlatformGenrePlatformArtistGenreRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformGenre>;
+    setPlatformGenreIdPlatformGenrePlatformArtistGenreRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    addPlatformGenreIdPlatformGenrePlatformArtistGenreRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformGenre, PlatformGenreId>;
+    addPlatformGenreIdPlatformGenrePlatformArtistGenreRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    createPlatformGenreIdPlatformGenrePlatformArtistGenreRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformGenre>;
+    removePlatformGenreIdPlatformGenrePlatformArtistGenreRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformGenre, PlatformGenreId>;
+    removePlatformGenreIdPlatformGenrePlatformArtistGenreRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    hasPlatformGenreIdPlatformGenrePlatformArtistGenreRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformGenre, PlatformGenreId>;
+    hasPlatformGenreIdPlatformGenrePlatformArtistGenreRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformGenre, PlatformGenreId>;
+    countPlatformGenreIdPlatformGenrePlatformArtistGenreRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    canonTrackIdPlatformTracks: PlatformTrack[];
+    getCanonTrackIdPlatformTracks: Sequelize.BelongsToManyGetAssociationsMixin<PlatformTrack>;
+    setCanonTrackIdPlatformTracks: Sequelize.BelongsToManySetAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    addCanonTrackIdPlatformTrack: Sequelize.BelongsToManyAddAssociationMixin<PlatformTrack, PlatformTrackId>;
+    addCanonTrackIdPlatformTracks: Sequelize.BelongsToManyAddAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    createCanonTrackIdPlatformTrack: Sequelize.BelongsToManyCreateAssociationMixin<PlatformTrack>;
+    removeCanonTrackIdPlatformTrack: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformTrack, PlatformTrackId>;
+    removeCanonTrackIdPlatformTracks: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    hasCanonTrackIdPlatformTrack: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
+    hasCanonTrackIdPlatformTracks: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    countCanonTrackIdPlatformTracks: Sequelize.BelongsToManyCountAssociationsMixin;
+    platformTrackIdPlatformTrackPlatformArtistTrackRelations: PlatformTrack[];
+    getPlatformTrackIdPlatformTrackPlatformArtistTrackRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformTrack>;
+    setPlatformTrackIdPlatformTrackPlatformArtistTrackRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    addPlatformTrackIdPlatformTrackPlatformArtistTrackRelation: Sequelize.BelongsToManyAddAssociationMixin<PlatformTrack, PlatformTrackId>;
+    addPlatformTrackIdPlatformTrackPlatformArtistTrackRelations: Sequelize.BelongsToManyAddAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrackIdPlatformTrackPlatformArtistTrackRelation: Sequelize.BelongsToManyCreateAssociationMixin<PlatformTrack>;
+    removePlatformTrackIdPlatformTrackPlatformArtistTrackRelation: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformTrack, PlatformTrackId>;
+    removePlatformTrackIdPlatformTrackPlatformArtistTrackRelations: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    hasPlatformTrackIdPlatformTrackPlatformArtistTrackRelation: Sequelize.BelongsToManyHasAssociationMixin<PlatformTrack, PlatformTrackId>;
+    hasPlatformTrackIdPlatformTrackPlatformArtistTrackRelations: Sequelize.BelongsToManyHasAssociationsMixin<PlatformTrack, PlatformTrackId>;
+    countPlatformTrackIdPlatformTrackPlatformArtistTrackRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformArtist;
+}

package/dist/PlatformArtist.js

@@ -0,0 +1,109 @@
+"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.PlatformArtist = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class PlatformArtist extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlatformArtist.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            externalArtistId: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                unique: "uk_platform_id_external_artist_id",
+                field: 'external_artist_id'
+            },
+            platformId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                references: {
+                    model: 'platform',
+                    key: 'id'
+                },
+                unique: "uk_platform_id_external_artist_id",
+                field: 'platform_id'
+            },
+            name: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            },
+            asciiName: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'ascii_name'
+            },
+            externalUri: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 'external_uri'
+            },
+            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'
+            },
+            genres: {
+                type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.TEXT),
+                allowNull: true
+            }
+        }, {
+            sequelize,
+            tableName: 'platform_artist',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "platform_artist_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "uk_platform_id_external_artist_id",
+                    unique: true,
+                    fields: [
+                        { name: "platform_id" },
+                        { name: "external_artist_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.PlatformArtist = PlatformArtist;

package/dist/PlatformArtistAlbumRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+export interface PlatformArtistAlbumRelationAttributes {
+    platformArtistId: string;
+    platformAlbumId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type PlatformArtistAlbumRelationPk = "platformArtistId" | "platformAlbumId";
+export type PlatformArtistAlbumRelationId = PlatformArtistAlbumRelation[PlatformArtistAlbumRelationPk];
+export type PlatformArtistAlbumRelationOptionalAttributes = "createDate" | "updateDate";
+export type PlatformArtistAlbumRelationCreationAttributes = Optional<PlatformArtistAlbumRelationAttributes, PlatformArtistAlbumRelationOptionalAttributes>;
+export declare class PlatformArtistAlbumRelation extends Model<PlatformArtistAlbumRelationAttributes, PlatformArtistAlbumRelationCreationAttributes> implements PlatformArtistAlbumRelationAttributes {
+    platformArtistId: string;
+    platformAlbumId: string;
+    createDate: Date;
+    updateDate: Date;
+    platformAlbum: PlatformAlbum;
+    getPlatformAlbum: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+    setPlatformAlbum: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+    createPlatformAlbum: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+    platformArtist: PlatformArtist;
+    getPlatformArtist: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+    setPlatformArtist: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+    createPlatformArtist: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformArtistAlbumRelation;
+}

package/dist/PlatformArtistAlbumRelation.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.PlatformArtistAlbumRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class PlatformArtistAlbumRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlatformArtistAlbumRelation.init({
+            platformArtistId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'platform_artist',
+                    key: 'id'
+                },
+                field: 'platform_artist_id'
+            },
+            platformAlbumId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'platform_album',
+                    key: 'id'
+                },
+                field: 'platform_album_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_artist_album_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "platform_artist_album_relation_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "platform_artist_id" },
+                        { name: "platform_album_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.PlatformArtistAlbumRelation = PlatformArtistAlbumRelation;

package/dist/PlatformArtistGenreRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformGenre, PlatformGenreId } from './PlatformGenre';
+export interface PlatformArtistGenreRelationAttributes {
+    platformArtistId: string;
+    platformGenreId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type PlatformArtistGenreRelationPk = "platformArtistId" | "platformGenreId";
+export type PlatformArtistGenreRelationId = PlatformArtistGenreRelation[PlatformArtistGenreRelationPk];
+export type PlatformArtistGenreRelationOptionalAttributes = "createDate" | "updateDate";
+export type PlatformArtistGenreRelationCreationAttributes = Optional<PlatformArtistGenreRelationAttributes, PlatformArtistGenreRelationOptionalAttributes>;
+export declare class PlatformArtistGenreRelation extends Model<PlatformArtistGenreRelationAttributes, PlatformArtistGenreRelationCreationAttributes> implements PlatformArtistGenreRelationAttributes {
+    platformArtistId: string;
+    platformGenreId: string;
+    createDate: Date;
+    updateDate: Date;
+    platformArtist: PlatformArtist;
+    getPlatformArtist: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+    setPlatformArtist: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+    createPlatformArtist: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+    platformGenre: PlatformGenre;
+    getPlatformGenre: Sequelize.BelongsToGetAssociationMixin<PlatformGenre>;
+    setPlatformGenre: Sequelize.BelongsToSetAssociationMixin<PlatformGenre, PlatformGenreId>;
+    createPlatformGenre: Sequelize.BelongsToCreateAssociationMixin<PlatformGenre>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformArtistGenreRelation;
+}

package/dist/PlatformArtistGenreRelation.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.PlatformArtistGenreRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class PlatformArtistGenreRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return PlatformArtistGenreRelation.init({
+            platformArtistId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'platform_artist',
+                    key: 'id'
+                },
+                field: 'platform_artist_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_artist_genre_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "platform_artist_genre_relation_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "platform_artist_id" },
+                        { name: "platform_genre_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.PlatformArtistGenreRelation = PlatformArtistGenreRelation;

package/dist/PlatformArtistTrackRelation.d.ts

@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+export interface PlatformArtistTrackRelationAttributes {
+    platformArtistId: string;
+    platformTrackId: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type PlatformArtistTrackRelationPk = "platformArtistId" | "platformTrackId";
+export type PlatformArtistTrackRelationId = PlatformArtistTrackRelation[PlatformArtistTrackRelationPk];
+export type PlatformArtistTrackRelationOptionalAttributes = "createDate" | "updateDate";
+export type PlatformArtistTrackRelationCreationAttributes = Optional<PlatformArtistTrackRelationAttributes, PlatformArtistTrackRelationOptionalAttributes>;
+export declare class PlatformArtistTrackRelation extends Model<PlatformArtistTrackRelationAttributes, PlatformArtistTrackRelationCreationAttributes> implements PlatformArtistTrackRelationAttributes {
+    platformArtistId: string;
+    platformTrackId: string;
+    createDate: Date;
+    updateDate: Date;
+    platformArtist: PlatformArtist;
+    getPlatformArtist: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+    setPlatformArtist: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+    createPlatformArtist: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+    platformTrack: PlatformTrack;
+    getPlatformTrack: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+    setPlatformTrack: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrack: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof PlatformArtistTrackRelation;
+}