@earbug/db-models 0.0.62 → 0.0.64

package/models/AccessControlPreference.ts

@@ -0,0 +1,53 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+
+export interface AccessControlPreferenceAttributes {
+  id: number;
+  name: string;
+}
+
+export type AccessControlPreferencePk = "id";
+export type AccessControlPreferenceId = AccessControlPreference[AccessControlPreferencePk];
+export type AccessControlPreferenceCreationAttributes = AccessControlPreferenceAttributes;
+
+export class AccessControlPreference extends Model<AccessControlPreferenceAttributes, AccessControlPreferenceCreationAttributes> implements AccessControlPreferenceAttributes {
+  id!: number;
+  name!: string;
+
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof AccessControlPreference {
+    return AccessControlPreference.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "access_control_preference_name_unique"
+    }
+  }, {
+    sequelize,
+    tableName: 'access_control_preference',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "access_control_preference_name_unique",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "access_control_preference_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/AffinityRelationshipType.ts

@@ -0,0 +1,96 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { UserAffinity, UserAffinityId } from './UserAffinity';
+
+export interface AffinityRelationshipTypeAttributes {
+  id: string;
+  name: string;
+  category: string;
+  tier: string;
+  createDate?: Date;
+  updateDate?: Date;
+}
+
+export type AffinityRelationshipTypePk = "id";
+export type AffinityRelationshipTypeId = AffinityRelationshipType[AffinityRelationshipTypePk];
+export type AffinityRelationshipTypeOptionalAttributes = "id" | "createDate" | "updateDate";
+export type AffinityRelationshipTypeCreationAttributes = Optional<AffinityRelationshipTypeAttributes, AffinityRelationshipTypeOptionalAttributes>;
+
+export class AffinityRelationshipType extends Model<AffinityRelationshipTypeAttributes, AffinityRelationshipTypeCreationAttributes> implements AffinityRelationshipTypeAttributes {
+  id!: string;
+  name!: string;
+  category!: string;
+  tier!: string;
+  createDate?: Date;
+  updateDate?: Date;
+
+  // AffinityRelationshipType hasMany UserAffinity via affinityRelationshipTypeId
+  userAffinities!: UserAffinity[];
+  getUserAffinities!: Sequelize.HasManyGetAssociationsMixin<UserAffinity>;
+  setUserAffinities!: Sequelize.HasManySetAssociationsMixin<UserAffinity, UserAffinityId>;
+  addUserAffinity!: Sequelize.HasManyAddAssociationMixin<UserAffinity, UserAffinityId>;
+  addUserAffinities!: Sequelize.HasManyAddAssociationsMixin<UserAffinity, UserAffinityId>;
+  createUserAffinity!: Sequelize.HasManyCreateAssociationMixin<UserAffinity>;
+  removeUserAffinity!: Sequelize.HasManyRemoveAssociationMixin<UserAffinity, UserAffinityId>;
+  removeUserAffinities!: Sequelize.HasManyRemoveAssociationsMixin<UserAffinity, UserAffinityId>;
+  hasUserAffinity!: Sequelize.HasManyHasAssociationMixin<UserAffinity, UserAffinityId>;
+  hasUserAffinities!: Sequelize.HasManyHasAssociationsMixin<UserAffinity, UserAffinityId>;
+  countUserAffinities!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof AffinityRelationshipType {
+    return AffinityRelationshipType.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.STRING(50),
+      allowNull: false,
+      unique: "affinity_relationship_type_name_unique"
+    },
+    category: {
+      type: DataTypes.STRING(20),
+      allowNull: false
+    },
+    tier: {
+      type: DataTypes.STRING(20),
+      allowNull: false
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'affinity_relationship_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "affinity_relationship_type_name_unique",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "affinity_relationship_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/AffinityTier.ts

@@ -0,0 +1,131 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId } from './JukeboxSessionArtistAffinity';
+import type { JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId } from './JukeboxSessionGenreAffinity';
+import type { PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId } from './PlatformUserPlaylistArtistAffinity';
+import type { PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId } from './PlatformUserPlaylistGenreAffinity';
+import type { UserArtistAffinity, UserArtistAffinityId } from './UserArtistAffinity';
+import type { UserGenreAffinity, UserGenreAffinityId } from './UserGenreAffinity';
+
+export interface AffinityTierAttributes {
+  id: number;
+  name: string;
+}
+
+export type AffinityTierPk = "id";
+export type AffinityTierId = AffinityTier[AffinityTierPk];
+export type AffinityTierCreationAttributes = AffinityTierAttributes;
+
+export class AffinityTier extends Model<AffinityTierAttributes, AffinityTierCreationAttributes> implements AffinityTierAttributes {
+  id!: number;
+  name!: string;
+
+  // AffinityTier hasMany JukeboxSessionArtistAffinity via affinityTierId
+  jukeboxSessionArtistAffinities!: JukeboxSessionArtistAffinity[];
+  getJukeboxSessionArtistAffinities!: Sequelize.HasManyGetAssociationsMixin<JukeboxSessionArtistAffinity>;
+  setJukeboxSessionArtistAffinities!: Sequelize.HasManySetAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  addJukeboxSessionArtistAffinity!: Sequelize.HasManyAddAssociationMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  addJukeboxSessionArtistAffinities!: Sequelize.HasManyAddAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  createJukeboxSessionArtistAffinity!: Sequelize.HasManyCreateAssociationMixin<JukeboxSessionArtistAffinity>;
+  removeJukeboxSessionArtistAffinity!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  removeJukeboxSessionArtistAffinities!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  hasJukeboxSessionArtistAffinity!: Sequelize.HasManyHasAssociationMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  hasJukeboxSessionArtistAffinities!: Sequelize.HasManyHasAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  countJukeboxSessionArtistAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // AffinityTier hasMany JukeboxSessionGenreAffinity via affinityTierId
+  jukeboxSessionGenreAffinities!: JukeboxSessionGenreAffinity[];
+  getJukeboxSessionGenreAffinities!: Sequelize.HasManyGetAssociationsMixin<JukeboxSessionGenreAffinity>;
+  setJukeboxSessionGenreAffinities!: Sequelize.HasManySetAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  addJukeboxSessionGenreAffinity!: Sequelize.HasManyAddAssociationMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  addJukeboxSessionGenreAffinities!: Sequelize.HasManyAddAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  createJukeboxSessionGenreAffinity!: Sequelize.HasManyCreateAssociationMixin<JukeboxSessionGenreAffinity>;
+  removeJukeboxSessionGenreAffinity!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  removeJukeboxSessionGenreAffinities!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  hasJukeboxSessionGenreAffinity!: Sequelize.HasManyHasAssociationMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  hasJukeboxSessionGenreAffinities!: Sequelize.HasManyHasAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  countJukeboxSessionGenreAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // AffinityTier hasMany PlatformUserPlaylistArtistAffinity via affinityTierId
+  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;
+  // AffinityTier hasMany PlatformUserPlaylistGenreAffinity via affinityTierId
+  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;
+  // AffinityTier hasMany UserArtistAffinity via affinityTierId
+  userArtistAffinities!: UserArtistAffinity[];
+  getUserArtistAffinities!: Sequelize.HasManyGetAssociationsMixin<UserArtistAffinity>;
+  setUserArtistAffinities!: Sequelize.HasManySetAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  addUserArtistAffinity!: Sequelize.HasManyAddAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
+  addUserArtistAffinities!: Sequelize.HasManyAddAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  createUserArtistAffinity!: Sequelize.HasManyCreateAssociationMixin<UserArtistAffinity>;
+  removeUserArtistAffinity!: Sequelize.HasManyRemoveAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
+  removeUserArtistAffinities!: Sequelize.HasManyRemoveAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  hasUserArtistAffinity!: Sequelize.HasManyHasAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
+  hasUserArtistAffinities!: Sequelize.HasManyHasAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  countUserArtistAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // AffinityTier hasMany UserGenreAffinity via affinityTierId
+  userGenreAffinities!: UserGenreAffinity[];
+  getUserGenreAffinities!: Sequelize.HasManyGetAssociationsMixin<UserGenreAffinity>;
+  setUserGenreAffinities!: Sequelize.HasManySetAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  addUserGenreAffinity!: Sequelize.HasManyAddAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
+  addUserGenreAffinities!: Sequelize.HasManyAddAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  createUserGenreAffinity!: Sequelize.HasManyCreateAssociationMixin<UserGenreAffinity>;
+  removeUserGenreAffinity!: Sequelize.HasManyRemoveAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
+  removeUserGenreAffinities!: Sequelize.HasManyRemoveAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  hasUserGenreAffinity!: Sequelize.HasManyHasAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
+  hasUserGenreAffinities!: Sequelize.HasManyHasAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  countUserGenreAffinities!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof AffinityTier {
+    return AffinityTier.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.STRING(32),
+      allowNull: false,
+      unique: "affinity_tier_name_unique"
+    }
+  }, {
+    sequelize,
+    tableName: 'affinity_tier',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "affinity_tier_name_unique",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "affinity_tier_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}