@earbug/db-models 0.0.62 → 0.0.63

package/models/PlatformUserAlbum.ts

@@ -0,0 +1,152 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+import type { PlatformUserAlbumTrack, PlatformUserAlbumTrackId } from './PlatformUserAlbumTrack';
+
+export interface PlatformUserAlbumAttributes {
+  id: string;
+  appUserId: string;
+  platformId: number;
+  externalUserAlbumId: string;
+  platformAlbumId: string;
+  createdAt: Date;
+  updatedAt: Date;
+  stateId: number;
+}
+
+export type PlatformUserAlbumPk = "id";
+export type PlatformUserAlbumId = PlatformUserAlbum[PlatformUserAlbumPk];
+export type PlatformUserAlbumOptionalAttributes = "id" | "createdAt" | "updatedAt" | "stateId";
+export type PlatformUserAlbumCreationAttributes = Optional<PlatformUserAlbumAttributes, PlatformUserAlbumOptionalAttributes>;
+
+export class PlatformUserAlbum extends Model<PlatformUserAlbumAttributes, PlatformUserAlbumCreationAttributes> implements PlatformUserAlbumAttributes {
+  id!: string;
+  appUserId!: string;
+  platformId!: number;
+  externalUserAlbumId!: string;
+  platformAlbumId!: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+  stateId!: number;
+
+  // PlatformUserAlbum belongsTo AppUser via appUserId
+  appUser!: AppUser;
+  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // PlatformUserAlbum belongsTo Platform via platformId
+  platform!: Platform;
+  getPlatform!: Sequelize.BelongsToGetAssociationMixin<Platform>;
+  setPlatform!: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+  createPlatform!: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+  // PlatformUserAlbum belongsTo PlatformAlbum via platformAlbumId
+  platformAlbum!: PlatformAlbum;
+  getPlatformAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+  setPlatformAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  createPlatformAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+  // PlatformUserAlbum hasMany PlatformUserAlbumTrack via platformUserAlbumId
+  platformUserAlbumTracks!: PlatformUserAlbumTrack[];
+  getPlatformUserAlbumTracks!: Sequelize.HasManyGetAssociationsMixin<PlatformUserAlbumTrack>;
+  setPlatformUserAlbumTracks!: Sequelize.HasManySetAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  addPlatformUserAlbumTrack!: Sequelize.HasManyAddAssociationMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  addPlatformUserAlbumTracks!: Sequelize.HasManyAddAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  createPlatformUserAlbumTrack!: Sequelize.HasManyCreateAssociationMixin<PlatformUserAlbumTrack>;
+  removePlatformUserAlbumTrack!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  removePlatformUserAlbumTracks!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  hasPlatformUserAlbumTrack!: Sequelize.HasManyHasAssociationMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  hasPlatformUserAlbumTracks!: Sequelize.HasManyHasAssociationsMixin<PlatformUserAlbumTrack, PlatformUserAlbumTrackId>;
+  countPlatformUserAlbumTracks!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof PlatformUserAlbum {
+    return PlatformUserAlbum.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      unique: "platform_user_album_app_user_id_platform_album_id_unique",
+      field: 'app_user_id'
+    },
+    platformId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'platform',
+        key: 'id'
+      },
+      field: 'platform_id'
+    },
+    externalUserAlbumId: {
+      type: DataTypes.STRING(255),
+      allowNull: false,
+      field: 'external_user_album_id'
+    },
+    platformAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'platform_album',
+        key: 'id'
+      },
+      unique: "platform_user_album_app_user_id_platform_album_id_unique",
+      field: 'platform_album_id'
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    },
+    updatedAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'updated_at'
+    },
+    stateId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      field: 'state_id'
+    }
+  }, {
+    sequelize,
+    tableName: 'platform_user_album',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "platform_user_album_app_user_id_index",
+        fields: [
+          { name: "app_user_id" },
+        ]
+      },
+      {
+        name: "platform_user_album_app_user_id_platform_album_id_unique",
+        unique: true,
+        fields: [
+          { name: "app_user_id" },
+          { name: "platform_album_id" },
+        ]
+      },
+      {
+        name: "platform_user_album_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/PlatformUserAlbumTrack.ts

@@ -0,0 +1,138 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
+import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum';
+
+export interface PlatformUserAlbumTrackAttributes {
+  id: string;
+  platformUserAlbumId: string;
+  platformId: number;
+  externalUserAlbumTrackId: string;
+  platformTrackId: string;
+  createdAt: Date;
+  updatedAt: Date;
+  stateId: number;
+}
+
+export type PlatformUserAlbumTrackPk = "id";
+export type PlatformUserAlbumTrackId = PlatformUserAlbumTrack[PlatformUserAlbumTrackPk];
+export type PlatformUserAlbumTrackOptionalAttributes = "id" | "createdAt" | "updatedAt";
+export type PlatformUserAlbumTrackCreationAttributes = Optional<PlatformUserAlbumTrackAttributes, PlatformUserAlbumTrackOptionalAttributes>;
+
+export class PlatformUserAlbumTrack extends Model<PlatformUserAlbumTrackAttributes, PlatformUserAlbumTrackCreationAttributes> implements PlatformUserAlbumTrackAttributes {
+  id!: string;
+  platformUserAlbumId!: string;
+  platformId!: number;
+  externalUserAlbumTrackId!: string;
+  platformTrackId!: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+  stateId!: number;
+
+  // PlatformUserAlbumTrack belongsTo Platform via platformId
+  platform!: Platform;
+  getPlatform!: Sequelize.BelongsToGetAssociationMixin<Platform>;
+  setPlatform!: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+  createPlatform!: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+  // PlatformUserAlbumTrack belongsTo PlatformTrack via platformTrackId
+  platformTrack!: PlatformTrack;
+  getPlatformTrack!: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+  setPlatformTrack!: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+  createPlatformTrack!: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+  // PlatformUserAlbumTrack belongsTo PlatformUserAlbum via platformUserAlbumId
+  platformUserAlbum!: PlatformUserAlbum;
+  getPlatformUserAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformUserAlbum>;
+  setPlatformUserAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  createPlatformUserAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformUserAlbum>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof PlatformUserAlbumTrack {
+    return PlatformUserAlbumTrack.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    platformUserAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'platform_user_album',
+        key: 'id'
+      },
+      unique: "platform_user_album_track_platform_user_album_id_platform_track",
+      field: 'platform_user_album_id'
+    },
+    platformId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'platform',
+        key: 'id'
+      },
+      field: 'platform_id'
+    },
+    externalUserAlbumTrackId: {
+      type: DataTypes.STRING(255),
+      allowNull: false,
+      field: 'external_user_album_track_id'
+    },
+    platformTrackId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'platform_track',
+        key: 'id'
+      },
+      unique: "platform_user_album_track_platform_user_album_id_platform_track",
+      field: 'platform_track_id'
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    },
+    updatedAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'updated_at'
+    },
+    stateId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      field: 'state_id'
+    }
+  }, {
+    sequelize,
+    tableName: 'platform_user_album_track',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "platform_user_album_track_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "platform_user_album_track_platform_user_album_id_index",
+        fields: [
+          { name: "platform_user_album_id" },
+        ]
+      },
+      {
+        name: "platform_user_album_track_platform_user_album_id_platform_track",
+        unique: true,
+        fields: [
+          { name: "platform_user_album_id" },
+          { name: "platform_track_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/PlatformUserPlaylist.ts

@@ -0,0 +1,260 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { Platform, PlatformId } from './Platform';
+import type { PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId } from './PlatformUserPlaylistArtistAffinity';
+import type { PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId } from './PlatformUserPlaylistGenreAffinity';
+import type { PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId } from './PlatformUserPlaylistTrack';
+import type { State, StateId } from './State';
+import type { UserAbuseReports, UserAbuseReportsId } from './UserAbuseReports';
+import type { UserBookmarks, UserBookmarksId } from './UserBookmarks';
+import type { UserComments, UserCommentsId } from './UserComments';
+import type { UserLikes, UserLikesId } from './UserLikes';
+
+export interface PlatformUserPlaylistAttributes {
+  id: string;
+  appUserId: string;
+  platformId: number;
+  externalPlaylistId: string;
+  name: string;
+  description?: string;
+  public?: boolean;
+  snapshotId: string;
+  collaborative: boolean;
+  createDate: Date;
+  updateDate: Date;
+  stateId: number;
+  earbugAccessControlPreference: string;
+}
+
+export type PlatformUserPlaylistPk = "id";
+export type PlatformUserPlaylistId = PlatformUserPlaylist[PlatformUserPlaylistPk];
+export type PlatformUserPlaylistOptionalAttributes = "id" | "description" | "public" | "createDate" | "updateDate" | "stateId" | "earbugAccessControlPreference";
+export type PlatformUserPlaylistCreationAttributes = Optional<PlatformUserPlaylistAttributes, PlatformUserPlaylistOptionalAttributes>;
+
+export class PlatformUserPlaylist extends Model<PlatformUserPlaylistAttributes, PlatformUserPlaylistCreationAttributes> implements PlatformUserPlaylistAttributes {
+  id!: string;
+  appUserId!: string;
+  platformId!: number;
+  externalPlaylistId!: string;
+  name!: string;
+  description?: string;
+  public?: boolean;
+  snapshotId!: string;
+  collaborative!: boolean;
+  createDate!: Date;
+  updateDate!: Date;
+  stateId!: number;
+  earbugAccessControlPreference!: string;
+
+  // PlatformUserPlaylist belongsTo AppUser via appUserId
+  appUser!: AppUser;
+  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // PlatformUserPlaylist belongsTo Platform via platformId
+  platform!: Platform;
+  getPlatform!: Sequelize.BelongsToGetAssociationMixin<Platform>;
+  setPlatform!: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+  createPlatform!: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+  // PlatformUserPlaylist hasMany PlatformUserPlaylistArtistAffinity via platformUserPlaylistId
+  platformUserPlaylistArtistAffinities!: PlatformUserPlaylistArtistAffinity[];
+  getPlatformUserPlaylistArtistAffinities!: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylistArtistAffinity>;
+  setPlatformUserPlaylistArtistAffinities!: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  addPlatformUserPlaylistArtistAffinity!: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  addPlatformUserPlaylistArtistAffinities!: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  createPlatformUserPlaylistArtistAffinity!: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylistArtistAffinity>;
+  removePlatformUserPlaylistArtistAffinity!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  removePlatformUserPlaylistArtistAffinities!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  hasPlatformUserPlaylistArtistAffinity!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  hasPlatformUserPlaylistArtistAffinities!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  countPlatformUserPlaylistArtistAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformUserPlaylist hasMany PlatformUserPlaylistGenreAffinity via platformUserPlaylistId
+  platformUserPlaylistGenreAffinities!: PlatformUserPlaylistGenreAffinity[];
+  getPlatformUserPlaylistGenreAffinities!: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylistGenreAffinity>;
+  setPlatformUserPlaylistGenreAffinities!: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  addPlatformUserPlaylistGenreAffinity!: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  addPlatformUserPlaylistGenreAffinities!: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  createPlatformUserPlaylistGenreAffinity!: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylistGenreAffinity>;
+  removePlatformUserPlaylistGenreAffinity!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  removePlatformUserPlaylistGenreAffinities!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  hasPlatformUserPlaylistGenreAffinity!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  hasPlatformUserPlaylistGenreAffinities!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  countPlatformUserPlaylistGenreAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformUserPlaylist hasMany PlatformUserPlaylistTrack via platformUserPlaylistId
+  platformUserPlaylistTracks!: PlatformUserPlaylistTrack[];
+  getPlatformUserPlaylistTracks!: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylistTrack>;
+  setPlatformUserPlaylistTracks!: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  addPlatformUserPlaylistTrack!: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  addPlatformUserPlaylistTracks!: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  createPlatformUserPlaylistTrack!: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylistTrack>;
+  removePlatformUserPlaylistTrack!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  removePlatformUserPlaylistTracks!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  hasPlatformUserPlaylistTrack!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  hasPlatformUserPlaylistTracks!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  countPlatformUserPlaylistTracks!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformUserPlaylist hasMany UserAbuseReports via playlistId
+  userAbuseReports!: UserAbuseReports[];
+  getUserAbuseReports!: Sequelize.HasManyGetAssociationsMixin<UserAbuseReports>;
+  setUserAbuseReports!: Sequelize.HasManySetAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  addUserAbuseReport!: Sequelize.HasManyAddAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  addUserAbuseReports!: Sequelize.HasManyAddAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  createUserAbuseReport!: Sequelize.HasManyCreateAssociationMixin<UserAbuseReports>;
+  removeUserAbuseReport!: Sequelize.HasManyRemoveAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  removeUserAbuseReports!: Sequelize.HasManyRemoveAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  hasUserAbuseReport!: Sequelize.HasManyHasAssociationMixin<UserAbuseReports, UserAbuseReportsId>;
+  hasUserAbuseReports!: Sequelize.HasManyHasAssociationsMixin<UserAbuseReports, UserAbuseReportsId>;
+  countUserAbuseReports!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformUserPlaylist hasMany UserBookmarks via playlistId
+  userBookmarks!: UserBookmarks[];
+  getUserBookmarks!: Sequelize.HasManyGetAssociationsMixin<UserBookmarks>;
+  setUserBookmarks!: Sequelize.HasManySetAssociationsMixin<UserBookmarks, UserBookmarksId>;
+  addUserBookmark!: Sequelize.HasManyAddAssociationMixin<UserBookmarks, UserBookmarksId>;
+  addUserBookmarks!: Sequelize.HasManyAddAssociationsMixin<UserBookmarks, UserBookmarksId>;
+  createUserBookmark!: Sequelize.HasManyCreateAssociationMixin<UserBookmarks>;
+  removeUserBookmark!: Sequelize.HasManyRemoveAssociationMixin<UserBookmarks, UserBookmarksId>;
+  removeUserBookmarks!: Sequelize.HasManyRemoveAssociationsMixin<UserBookmarks, UserBookmarksId>;
+  hasUserBookmark!: Sequelize.HasManyHasAssociationMixin<UserBookmarks, UserBookmarksId>;
+  hasUserBookmarks!: Sequelize.HasManyHasAssociationsMixin<UserBookmarks, UserBookmarksId>;
+  countUserBookmarks!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformUserPlaylist hasMany UserComments via playlistId
+  userComments!: UserComments[];
+  getUserComments!: Sequelize.HasManyGetAssociationsMixin<UserComments>;
+  setUserComments!: Sequelize.HasManySetAssociationsMixin<UserComments, UserCommentsId>;
+  addUserComment!: Sequelize.HasManyAddAssociationMixin<UserComments, UserCommentsId>;
+  addUserComments!: Sequelize.HasManyAddAssociationsMixin<UserComments, UserCommentsId>;
+  createUserComment!: Sequelize.HasManyCreateAssociationMixin<UserComments>;
+  removeUserComment!: Sequelize.HasManyRemoveAssociationMixin<UserComments, UserCommentsId>;
+  removeUserComments!: Sequelize.HasManyRemoveAssociationsMixin<UserComments, UserCommentsId>;
+  hasUserComment!: Sequelize.HasManyHasAssociationMixin<UserComments, UserCommentsId>;
+  hasUserComments!: Sequelize.HasManyHasAssociationsMixin<UserComments, UserCommentsId>;
+  countUserComments!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformUserPlaylist hasMany UserLikes via playlistId
+  userLikes!: UserLikes[];
+  getUserLikes!: Sequelize.HasManyGetAssociationsMixin<UserLikes>;
+  setUserLikes!: Sequelize.HasManySetAssociationsMixin<UserLikes, UserLikesId>;
+  addUserLike!: Sequelize.HasManyAddAssociationMixin<UserLikes, UserLikesId>;
+  addUserLikes!: Sequelize.HasManyAddAssociationsMixin<UserLikes, UserLikesId>;
+  createUserLike!: Sequelize.HasManyCreateAssociationMixin<UserLikes>;
+  removeUserLike!: Sequelize.HasManyRemoveAssociationMixin<UserLikes, UserLikesId>;
+  removeUserLikes!: Sequelize.HasManyRemoveAssociationsMixin<UserLikes, UserLikesId>;
+  hasUserLike!: Sequelize.HasManyHasAssociationMixin<UserLikes, UserLikesId>;
+  hasUserLikes!: Sequelize.HasManyHasAssociationsMixin<UserLikes, UserLikesId>;
+  countUserLikes!: Sequelize.HasManyCountAssociationsMixin;
+  // PlatformUserPlaylist belongsTo State via stateId
+  state!: State;
+  getState!: Sequelize.BelongsToGetAssociationMixin<State>;
+  setState!: Sequelize.BelongsToSetAssociationMixin<State, StateId>;
+  createState!: Sequelize.BelongsToCreateAssociationMixin<State>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof PlatformUserPlaylist {
+    return PlatformUserPlaylist.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      unique: "uk_app_user_platform_playlist",
+      field: 'app_user_id'
+    },
+    platformId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'platform',
+        key: 'id'
+      },
+      unique: "uk_app_user_platform_playlist",
+      field: 'platform_id'
+    },
+    externalPlaylistId: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "uk_app_user_platform_playlist",
+      field: 'external_playlist_id'
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: true
+    },
+    public: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      defaultValue: false
+    },
+    snapshotId: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'snapshot_id'
+    },
+    collaborative: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: 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'
+    },
+    stateId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      references: {
+        model: 'state',
+        key: 'id'
+      },
+      field: 'state_id'
+    },
+    earbugAccessControlPreference: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      defaultValue: "PRIVATE",
+      field: 'earbug_access_control_preference'
+    }
+  }, {
+    sequelize,
+    tableName: 'platform_user_playlist',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "playlist_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "uk_app_user_platform_playlist",
+        unique: true,
+        fields: [
+          { name: "app_user_id" },
+          { name: "platform_id" },
+          { name: "external_playlist_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/PlatformUserPlaylistArtistAffinity.ts

@@ -0,0 +1,136 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AffinityTier, AffinityTierId } from './AffinityTier';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+
+export interface PlatformUserPlaylistArtistAffinityAttributes {
+  id: string;
+  platformUserPlaylistId: string;
+  canonArtistId: string;
+  affinityTierId: number;
+  rank: number;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type PlatformUserPlaylistArtistAffinityPk = "id";
+export type PlatformUserPlaylistArtistAffinityId = PlatformUserPlaylistArtistAffinity[PlatformUserPlaylistArtistAffinityPk];
+export type PlatformUserPlaylistArtistAffinityOptionalAttributes = "id" | "createdAt" | "updatedAt";
+export type PlatformUserPlaylistArtistAffinityCreationAttributes = Optional<PlatformUserPlaylistArtistAffinityAttributes, PlatformUserPlaylistArtistAffinityOptionalAttributes>;
+
+export class PlatformUserPlaylistArtistAffinity extends Model<PlatformUserPlaylistArtistAffinityAttributes, PlatformUserPlaylistArtistAffinityCreationAttributes> implements PlatformUserPlaylistArtistAffinityAttributes {
+  id!: string;
+  platformUserPlaylistId!: string;
+  canonArtistId!: string;
+  affinityTierId!: number;
+  rank!: number;
+  createdAt!: Date;
+  updatedAt!: Date;
+
+  // PlatformUserPlaylistArtistAffinity belongsTo AffinityTier via affinityTierId
+  affinityTier!: AffinityTier;
+  getAffinityTier!: Sequelize.BelongsToGetAssociationMixin<AffinityTier>;
+  setAffinityTier!: Sequelize.BelongsToSetAssociationMixin<AffinityTier, AffinityTierId>;
+  createAffinityTier!: Sequelize.BelongsToCreateAssociationMixin<AffinityTier>;
+  // PlatformUserPlaylistArtistAffinity belongsTo CanonArtist via canonArtistId
+  canonArtist!: CanonArtist;
+  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+  // PlatformUserPlaylistArtistAffinity belongsTo PlatformUserPlaylist via platformUserPlaylistId
+  platformUserPlaylist!: PlatformUserPlaylist;
+  getPlatformUserPlaylist!: Sequelize.BelongsToGetAssociationMixin<PlatformUserPlaylist>;
+  setPlatformUserPlaylist!: Sequelize.BelongsToSetAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  createPlatformUserPlaylist!: Sequelize.BelongsToCreateAssociationMixin<PlatformUserPlaylist>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof PlatformUserPlaylistArtistAffinity {
+    return PlatformUserPlaylistArtistAffinity.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    platformUserPlaylistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'platform_user_playlist',
+        key: 'id'
+      },
+      unique: "unique_pupaa_canon_artist",
+      field: 'platform_user_playlist_id'
+    },
+    canonArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'canon_artist',
+        key: 'id'
+      },
+      unique: "unique_pupaa_canon_artist",
+      field: 'canon_artist_id'
+    },
+    affinityTierId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'affinity_tier',
+        key: 'id'
+      },
+      field: 'affinity_tier_id'
+    },
+    rank: {
+      type: DataTypes.INTEGER,
+      allowNull: false
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    },
+    updatedAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'updated_at'
+    }
+  }, {
+    sequelize,
+    tableName: 'platform_user_playlist_artist_affinity',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_platform_user_playlist_artist_affinity",
+        fields: [
+          { name: "platform_user_playlist_id" },
+        ]
+      },
+      {
+        name: "idx_platform_user_playlist_artist_affinity_artist",
+        fields: [
+          { name: "canon_artist_id" },
+        ]
+      },
+      {
+        name: "platform_user_playlist_artist_affinity_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "unique_pupaa_canon_artist",
+        unique: true,
+        fields: [
+          { name: "platform_user_playlist_id" },
+          { name: "canon_artist_id" },
+        ]
+      },
+    ]
+  });
+  }
+}