@earbug/db-models 0.0.21 → 0.0.23

package/dist/AffinityRelationshipType.d.ts

@@ -0,0 +1,35 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { UserAffinity, UserAffinityId } from './UserAffinity';
+export interface AffinityRelationshipTypeAttributes {
+    name: string;
+    category: string;
+    tier: string;
+    id: 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 declare class AffinityRelationshipType extends Model<AffinityRelationshipTypeAttributes, AffinityRelationshipTypeCreationAttributes> implements AffinityRelationshipTypeAttributes {
+    name: string;
+    category: string;
+    tier: string;
+    id: string;
+    createDate?: Date;
+    updateDate?: Date;
+    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;
+}

package/dist/AffinityRelationshipType.js

@@ -0,0 +1,87 @@
+"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.AffinityRelationshipType = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class AffinityRelationshipType extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return AffinityRelationshipType.init({
+            name: {
+                type: sequelize_1.DataTypes.STRING(50),
+                allowNull: false,
+                unique: "affinity_relationship_type_name_unique"
+            },
+            category: {
+                type: sequelize_1.DataTypes.STRING(20),
+                allowNull: false
+            },
+            tier: {
+                type: sequelize_1.DataTypes.STRING(20),
+                allowNull: false
+            },
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.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" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.AffinityRelationshipType = AffinityRelationshipType;

package/dist/AppUser.d.ts

@@ -11,8 +11,10 @@ import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum
 import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
 import type { RadioShow, RadioShowId } from './RadioShow';
 import type { State, StateId } from './State';
+import type { UserAffinity, UserAffinityId } from './UserAffinity';
 import type { UserComments, UserCommentsId } from './UserComments';
 import type { UserContacts, UserContactsId } from './UserContacts';
+import type { UserEngagementFactor, UserEngagementFactorId } from './UserEngagementFactor';
 import type { UserLikes, UserLikesId } from './UserLikes';
 export interface AppUserAttributes {
     email: string;
@@ -181,6 +183,17 @@ export declare class AppUser extends Model<AppUserAttributes, AppUserCreationAtt
     hasRadioShow: Sequelize.HasManyHasAssociationMixin<RadioShow, RadioShowId>;
     hasRadioShows: Sequelize.HasManyHasAssociationsMixin<RadioShow, RadioShowId>;
     countRadioShows: Sequelize.HasManyCountAssociationsMixin;
+    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;
     userComments: UserComments[];
     getUserComments: Sequelize.HasManyGetAssociationsMixin<UserComments>;
     setUserComments: Sequelize.HasManySetAssociationsMixin<UserComments, UserCommentsId>;
@@ -203,6 +216,17 @@ export declare class AppUser extends Model<AppUserAttributes, AppUserCreationAtt
     hasUserContact: Sequelize.HasManyHasAssociationMixin<UserContacts, UserContactsId>;
     hasUserContacts: Sequelize.HasManyHasAssociationsMixin<UserContacts, UserContactsId>;
     countUserContacts: Sequelize.HasManyCountAssociationsMixin;
+    userEngagementFactors: UserEngagementFactor[];
+    getUserEngagementFactors: Sequelize.HasManyGetAssociationsMixin<UserEngagementFactor>;
+    setUserEngagementFactors: Sequelize.HasManySetAssociationsMixin<UserEngagementFactor, UserEngagementFactorId>;
+    addUserEngagementFactor: Sequelize.HasManyAddAssociationMixin<UserEngagementFactor, UserEngagementFactorId>;
+    addUserEngagementFactors: Sequelize.HasManyAddAssociationsMixin<UserEngagementFactor, UserEngagementFactorId>;
+    createUserEngagementFactor: Sequelize.HasManyCreateAssociationMixin<UserEngagementFactor>;
+    removeUserEngagementFactor: Sequelize.HasManyRemoveAssociationMixin<UserEngagementFactor, UserEngagementFactorId>;
+    removeUserEngagementFactors: Sequelize.HasManyRemoveAssociationsMixin<UserEngagementFactor, UserEngagementFactorId>;
+    hasUserEngagementFactor: Sequelize.HasManyHasAssociationMixin<UserEngagementFactor, UserEngagementFactorId>;
+    hasUserEngagementFactors: Sequelize.HasManyHasAssociationsMixin<UserEngagementFactor, UserEngagementFactorId>;
+    countUserEngagementFactors: Sequelize.HasManyCountAssociationsMixin;
     userLikes: UserLikes[];
     getUserLikes: Sequelize.HasManyGetAssociationsMixin<UserLikes>;
     setUserLikes: Sequelize.HasManySetAssociationsMixin<UserLikes, UserLikesId>;

package/dist/FeedConfig.d.ts

@@ -0,0 +1,19 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+export interface FeedConfigAttributes {
+    id: string;
+    resultsCount: number;
+    createDate?: Date;
+    updateDate?: Date;
+}
+export type FeedConfigPk = "id";
+export type FeedConfigId = FeedConfig[FeedConfigPk];
+export type FeedConfigOptionalAttributes = "id" | "resultsCount" | "createDate" | "updateDate";
+export type FeedConfigCreationAttributes = Optional<FeedConfigAttributes, FeedConfigOptionalAttributes>;
+export declare class FeedConfig extends Model<FeedConfigAttributes, FeedConfigCreationAttributes> implements FeedConfigAttributes {
+    id: string;
+    resultsCount: number;
+    createDate?: Date;
+    updateDate?: Date;
+    static initModel(sequelize: Sequelize.Sequelize): typeof FeedConfig;
+}

package/dist/FeedConfig.js

@@ -0,0 +1,73 @@
+"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.FeedConfig = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class FeedConfig extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return FeedConfig.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            resultsCount: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 100,
+                field: 'results_count'
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            }
+        }, {
+            sequelize,
+            tableName: 'feed_config',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "feed_config_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.FeedConfig = FeedConfig;

package/dist/FeedContentType.d.ts

@@ -0,0 +1,43 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { UserEngagementFactor, UserEngagementFactorId } from './UserEngagementFactor';
+export interface FeedContentTypeAttributes {
+    name: string;
+    id: string;
+    mixPercentage: number;
+    affinityMixHigh: number;
+    affinityMixMedium: number;
+    affinityMixLow: number;
+    apiEndpoint?: string;
+    isActive: boolean;
+    createDate?: Date;
+    updateDate?: Date;
+}
+export type FeedContentTypePk = "id";
+export type FeedContentTypeId = FeedContentType[FeedContentTypePk];
+export type FeedContentTypeOptionalAttributes = "id" | "mixPercentage" | "affinityMixHigh" | "affinityMixMedium" | "affinityMixLow" | "apiEndpoint" | "isActive" | "createDate" | "updateDate";
+export type FeedContentTypeCreationAttributes = Optional<FeedContentTypeAttributes, FeedContentTypeOptionalAttributes>;
+export declare class FeedContentType extends Model<FeedContentTypeAttributes, FeedContentTypeCreationAttributes> implements FeedContentTypeAttributes {
+    name: string;
+    id: string;
+    mixPercentage: number;
+    affinityMixHigh: number;
+    affinityMixMedium: number;
+    affinityMixLow: number;
+    apiEndpoint?: string;
+    isActive: boolean;
+    createDate?: Date;
+    updateDate?: Date;
+    userEngagementFactors: UserEngagementFactor[];
+    getUserEngagementFactors: Sequelize.HasManyGetAssociationsMixin<UserEngagementFactor>;
+    setUserEngagementFactors: Sequelize.HasManySetAssociationsMixin<UserEngagementFactor, UserEngagementFactorId>;
+    addUserEngagementFactor: Sequelize.HasManyAddAssociationMixin<UserEngagementFactor, UserEngagementFactorId>;
+    addUserEngagementFactors: Sequelize.HasManyAddAssociationsMixin<UserEngagementFactor, UserEngagementFactorId>;
+    createUserEngagementFactor: Sequelize.HasManyCreateAssociationMixin<UserEngagementFactor>;
+    removeUserEngagementFactor: Sequelize.HasManyRemoveAssociationMixin<UserEngagementFactor, UserEngagementFactorId>;
+    removeUserEngagementFactors: Sequelize.HasManyRemoveAssociationsMixin<UserEngagementFactor, UserEngagementFactorId>;
+    hasUserEngagementFactor: Sequelize.HasManyHasAssociationMixin<UserEngagementFactor, UserEngagementFactorId>;
+    hasUserEngagementFactors: Sequelize.HasManyHasAssociationsMixin<UserEngagementFactor, UserEngagementFactorId>;
+    countUserEngagementFactors: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof FeedContentType;
+}

package/dist/FeedContentType.js

@@ -0,0 +1,107 @@
+"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.FeedContentType = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class FeedContentType extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return FeedContentType.init({
+            name: {
+                type: sequelize_1.DataTypes.STRING(50),
+                allowNull: false
+            },
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            mixPercentage: {
+                type: sequelize_1.DataTypes.DECIMAL,
+                allowNull: false,
+                defaultValue: 20,
+                field: 'mix_percentage'
+            },
+            affinityMixHigh: {
+                type: sequelize_1.DataTypes.DECIMAL,
+                allowNull: false,
+                defaultValue: 30,
+                field: 'affinity_mix_high'
+            },
+            affinityMixMedium: {
+                type: sequelize_1.DataTypes.DECIMAL,
+                allowNull: false,
+                defaultValue: 50,
+                field: 'affinity_mix_medium'
+            },
+            affinityMixLow: {
+                type: sequelize_1.DataTypes.DECIMAL,
+                allowNull: false,
+                defaultValue: 20,
+                field: 'affinity_mix_low'
+            },
+            apiEndpoint: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: true,
+                defaultValue: "",
+                field: 'api_endpoint'
+            },
+            isActive: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: true,
+                field: 'is_active'
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            }
+        }, {
+            sequelize,
+            tableName: 'feed_content_type',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "feed_content_type_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.FeedContentType = FeedContentType;

package/dist/UserAffinity.d.ts

@@ -0,0 +1,33 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AffinityRelationshipType, AffinityRelationshipTypeId } from './AffinityRelationshipType';
+import type { AppUser, AppUserId } from './AppUser';
+export interface UserAffinityAttributes {
+    userId: string;
+    affinityRelationshipTypeId: string;
+    relatedId: string;
+    id: string;
+    createDate?: Date;
+    updateDate?: Date;
+}
+export type UserAffinityPk = "id";
+export type UserAffinityId = UserAffinity[UserAffinityPk];
+export type UserAffinityOptionalAttributes = "id" | "createDate" | "updateDate";
+export type UserAffinityCreationAttributes = Optional<UserAffinityAttributes, UserAffinityOptionalAttributes>;
+export declare class UserAffinity extends Model<UserAffinityAttributes, UserAffinityCreationAttributes> implements UserAffinityAttributes {
+    userId: string;
+    affinityRelationshipTypeId: string;
+    relatedId: string;
+    id: string;
+    createDate?: Date;
+    updateDate?: Date;
+    affinityRelationshipType: AffinityRelationshipType;
+    getAffinityRelationshipType: Sequelize.BelongsToGetAssociationMixin<AffinityRelationshipType>;
+    setAffinityRelationshipType: Sequelize.BelongsToSetAssociationMixin<AffinityRelationshipType, AffinityRelationshipTypeId>;
+    createAffinityRelationshipType: Sequelize.BelongsToCreateAssociationMixin<AffinityRelationshipType>;
+    user: AppUser;
+    getUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UserAffinity;
+}

package/dist/UserAffinity.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.UserAffinity = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class UserAffinity extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return UserAffinity.init({
+            userId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                unique: "user_affinity_user_id_affinity_relationship_type_id_related_id_",
+                field: 'user_id'
+            },
+            affinityRelationshipTypeId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'affinity_relationship_type',
+                    key: 'id'
+                },
+                unique: "user_affinity_user_id_affinity_relationship_type_id_related_id_",
+                field: 'affinity_relationship_type_id'
+            },
+            relatedId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                unique: "user_affinity_user_id_affinity_relationship_type_id_related_id_",
+                field: 'related_id'
+            },
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            }
+        }, {
+            sequelize,
+            tableName: 'user_affinity',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "user_affinity_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "user_affinity_user_id_affinity_relationship_type_id_index",
+                    fields: [
+                        { name: "user_id" },
+                        { name: "affinity_relationship_type_id" },
+                    ]
+                },
+                {
+                    name: "user_affinity_user_id_affinity_relationship_type_id_related_id_",
+                    unique: true,
+                    fields: [
+                        { name: "user_id" },
+                        { name: "affinity_relationship_type_id" },
+                        { name: "related_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.UserAffinity = UserAffinity;

package/dist/UserEngagementFactor.d.ts

@@ -0,0 +1,33 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { FeedContentType, FeedContentTypeId } from './FeedContentType';
+export interface UserEngagementFactorAttributes {
+    userId: string;
+    contentTypeId: string;
+    id: string;
+    engagementFactor: number;
+    createDate?: Date;
+    updateDate?: Date;
+}
+export type UserEngagementFactorPk = "id";
+export type UserEngagementFactorId = UserEngagementFactor[UserEngagementFactorPk];
+export type UserEngagementFactorOptionalAttributes = "id" | "engagementFactor" | "createDate" | "updateDate";
+export type UserEngagementFactorCreationAttributes = Optional<UserEngagementFactorAttributes, UserEngagementFactorOptionalAttributes>;
+export declare class UserEngagementFactor extends Model<UserEngagementFactorAttributes, UserEngagementFactorCreationAttributes> implements UserEngagementFactorAttributes {
+    userId: string;
+    contentTypeId: string;
+    id: string;
+    engagementFactor: number;
+    createDate?: Date;
+    updateDate?: Date;
+    user: AppUser;
+    getUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    contentType: FeedContentType;
+    getContentType: Sequelize.BelongsToGetAssociationMixin<FeedContentType>;
+    setContentType: Sequelize.BelongsToSetAssociationMixin<FeedContentType, FeedContentTypeId>;
+    createContentType: Sequelize.BelongsToCreateAssociationMixin<FeedContentType>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof UserEngagementFactor;
+}