@earbug/db-models 0.0.1

package/.nvmrc

@@ -0,0 +1 @@
+20

package/dist/AppUser.d.ts

@@ -0,0 +1,161 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUserDevice, AppUserDeviceId } from './AppUserDevice';
+import type { AppUserFollowRelation, AppUserFollowRelationId } from './AppUserFollowRelation';
+import type { AppUserPlatformRelation, AppUserPlatformRelationId } from './AppUserPlatformRelation';
+import type { JukeboxInvite, JukeboxInviteId } from './JukeboxInvite';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum';
+import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+import type { State, StateId } from './State';
+import type { UserContacts, UserContactsId } from './UserContacts';
+export interface AppUserAttributes {
+    id: string;
+    email: string;
+    firstName: string;
+    createDate: Date;
+    updateDate: Date;
+    stateId: number;
+    syncContacts?: boolean;
+    lastName?: string;
+    autoApproveFollowers: boolean;
+    lastHarvested?: Date;
+    lastHarvestedError?: string;
+}
+export type AppUserPk = "id";
+export type AppUserId = AppUser[AppUserPk];
+export type AppUserOptionalAttributes = "id" | "createDate" | "updateDate" | "stateId" | "syncContacts" | "lastName" | "autoApproveFollowers" | "lastHarvested" | "lastHarvestedError";
+export type AppUserCreationAttributes = Optional<AppUserAttributes, AppUserOptionalAttributes>;
+export declare class AppUser extends Model<AppUserAttributes, AppUserCreationAttributes> implements AppUserAttributes {
+    id: string;
+    email: string;
+    firstName: string;
+    createDate: Date;
+    updateDate: Date;
+    stateId: number;
+    syncContacts?: boolean;
+    lastName?: string;
+    autoApproveFollowers: boolean;
+    lastHarvested?: Date;
+    lastHarvestedError?: string;
+    appUserDevices: AppUserDevice[];
+    getAppUserDevices: Sequelize.HasManyGetAssociationsMixin<AppUserDevice>;
+    setAppUserDevices: Sequelize.HasManySetAssociationsMixin<AppUserDevice, AppUserDeviceId>;
+    addAppUserDevice: Sequelize.HasManyAddAssociationMixin<AppUserDevice, AppUserDeviceId>;
+    addAppUserDevices: Sequelize.HasManyAddAssociationsMixin<AppUserDevice, AppUserDeviceId>;
+    createAppUserDevice: Sequelize.HasManyCreateAssociationMixin<AppUserDevice>;
+    removeAppUserDevice: Sequelize.HasManyRemoveAssociationMixin<AppUserDevice, AppUserDeviceId>;
+    removeAppUserDevices: Sequelize.HasManyRemoveAssociationsMixin<AppUserDevice, AppUserDeviceId>;
+    hasAppUserDevice: Sequelize.HasManyHasAssociationMixin<AppUserDevice, AppUserDeviceId>;
+    hasAppUserDevices: Sequelize.HasManyHasAssociationsMixin<AppUserDevice, AppUserDeviceId>;
+    countAppUserDevices: Sequelize.HasManyCountAssociationsMixin;
+    appUserFollowRelations: AppUserFollowRelation[];
+    getAppUserFollowRelations: Sequelize.HasManyGetAssociationsMixin<AppUserFollowRelation>;
+    setAppUserFollowRelations: Sequelize.HasManySetAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    addAppUserFollowRelation: Sequelize.HasManyAddAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    addAppUserFollowRelations: Sequelize.HasManyAddAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    createAppUserFollowRelation: Sequelize.HasManyCreateAssociationMixin<AppUserFollowRelation>;
+    removeAppUserFollowRelation: Sequelize.HasManyRemoveAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    removeAppUserFollowRelations: Sequelize.HasManyRemoveAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    hasAppUserFollowRelation: Sequelize.HasManyHasAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    hasAppUserFollowRelations: Sequelize.HasManyHasAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    countAppUserFollowRelations: Sequelize.HasManyCountAssociationsMixin;
+    followingAppUserAppUserFollowRelations: AppUserFollowRelation[];
+    getFollowingAppUserAppUserFollowRelations: Sequelize.HasManyGetAssociationsMixin<AppUserFollowRelation>;
+    setFollowingAppUserAppUserFollowRelations: Sequelize.HasManySetAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    addFollowingAppUserAppUserFollowRelation: Sequelize.HasManyAddAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    addFollowingAppUserAppUserFollowRelations: Sequelize.HasManyAddAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    createFollowingAppUserAppUserFollowRelation: Sequelize.HasManyCreateAssociationMixin<AppUserFollowRelation>;
+    removeFollowingAppUserAppUserFollowRelation: Sequelize.HasManyRemoveAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    removeFollowingAppUserAppUserFollowRelations: Sequelize.HasManyRemoveAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    hasFollowingAppUserAppUserFollowRelation: Sequelize.HasManyHasAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    hasFollowingAppUserAppUserFollowRelations: Sequelize.HasManyHasAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+    countFollowingAppUserAppUserFollowRelations: Sequelize.HasManyCountAssociationsMixin;
+    appUserPlatformRelation: AppUserPlatformRelation;
+    getAppUserPlatformRelation: Sequelize.HasOneGetAssociationMixin<AppUserPlatformRelation>;
+    setAppUserPlatformRelation: Sequelize.HasOneSetAssociationMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+    createAppUserPlatformRelation: Sequelize.HasOneCreateAssociationMixin<AppUserPlatformRelation>;
+    jukeboxInvites: JukeboxInvite[];
+    getJukeboxInvites: Sequelize.HasManyGetAssociationsMixin<JukeboxInvite>;
+    setJukeboxInvites: Sequelize.HasManySetAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+    addJukeboxInvite: Sequelize.HasManyAddAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+    addJukeboxInvites: Sequelize.HasManyAddAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+    createJukeboxInvite: Sequelize.HasManyCreateAssociationMixin<JukeboxInvite>;
+    removeJukeboxInvite: Sequelize.HasManyRemoveAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+    removeJukeboxInvites: Sequelize.HasManyRemoveAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+    hasJukeboxInvite: Sequelize.HasManyHasAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+    hasJukeboxInvites: Sequelize.HasManyHasAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+    countJukeboxInvites: Sequelize.HasManyCountAssociationsMixin;
+    inviterUserJukeboxInvites: JukeboxInvite[];
+    getInviterUserJukeboxInvites: Sequelize.HasManyGetAssociationsMixin<JukeboxInvite>;
+    setInviterUserJukeboxInvites: Sequelize.HasManySetAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+    addInviterUserJukeboxInvite: Sequelize.HasManyAddAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+    addInviterUserJukeboxInvites: Sequelize.HasManyAddAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+    createInviterUserJukeboxInvite: Sequelize.HasManyCreateAssociationMixin<JukeboxInvite>;
+    removeInviterUserJukeboxInvite: Sequelize.HasManyRemoveAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+    removeInviterUserJukeboxInvites: Sequelize.HasManyRemoveAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+    hasInviterUserJukeboxInvite: Sequelize.HasManyHasAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+    hasInviterUserJukeboxInvites: Sequelize.HasManyHasAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+    countInviterUserJukeboxInvites: Sequelize.HasManyCountAssociationsMixin;
+    jukeboxQueueEntries: JukeboxQueueEntry[];
+    getJukeboxQueueEntries: Sequelize.HasManyGetAssociationsMixin<JukeboxQueueEntry>;
+    setJukeboxQueueEntries: Sequelize.HasManySetAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    addJukeboxQueueEntry: Sequelize.HasManyAddAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    addJukeboxQueueEntries: Sequelize.HasManyAddAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    createJukeboxQueueEntry: Sequelize.HasManyCreateAssociationMixin<JukeboxQueueEntry>;
+    removeJukeboxQueueEntry: Sequelize.HasManyRemoveAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    removeJukeboxQueueEntries: Sequelize.HasManyRemoveAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    hasJukeboxQueueEntry: Sequelize.HasManyHasAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    hasJukeboxQueueEntries: Sequelize.HasManyHasAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    countJukeboxQueueEntries: Sequelize.HasManyCountAssociationsMixin;
+    jukeboxUsers: JukeboxUser[];
+    getJukeboxUsers: Sequelize.HasManyGetAssociationsMixin<JukeboxUser>;
+    setJukeboxUsers: Sequelize.HasManySetAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    addJukeboxUser: Sequelize.HasManyAddAssociationMixin<JukeboxUser, JukeboxUserId>;
+    addJukeboxUsers: Sequelize.HasManyAddAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    createJukeboxUser: Sequelize.HasManyCreateAssociationMixin<JukeboxUser>;
+    removeJukeboxUser: Sequelize.HasManyRemoveAssociationMixin<JukeboxUser, JukeboxUserId>;
+    removeJukeboxUsers: Sequelize.HasManyRemoveAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    hasJukeboxUser: Sequelize.HasManyHasAssociationMixin<JukeboxUser, JukeboxUserId>;
+    hasJukeboxUsers: Sequelize.HasManyHasAssociationsMixin<JukeboxUser, JukeboxUserId>;
+    countJukeboxUsers: Sequelize.HasManyCountAssociationsMixin;
+    platformUserAlbums: PlatformUserAlbum[];
+    getPlatformUserAlbums: Sequelize.HasManyGetAssociationsMixin<PlatformUserAlbum>;
+    setPlatformUserAlbums: Sequelize.HasManySetAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    addPlatformUserAlbum: Sequelize.HasManyAddAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    addPlatformUserAlbums: Sequelize.HasManyAddAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    createPlatformUserAlbum: Sequelize.HasManyCreateAssociationMixin<PlatformUserAlbum>;
+    removePlatformUserAlbum: Sequelize.HasManyRemoveAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    removePlatformUserAlbums: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    hasPlatformUserAlbum: Sequelize.HasManyHasAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    hasPlatformUserAlbums: Sequelize.HasManyHasAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+    countPlatformUserAlbums: Sequelize.HasManyCountAssociationsMixin;
+    platformUserPlaylists: PlatformUserPlaylist[];
+    getPlatformUserPlaylists: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylist>;
+    setPlatformUserPlaylists: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    addPlatformUserPlaylist: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    addPlatformUserPlaylists: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    createPlatformUserPlaylist: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylist>;
+    removePlatformUserPlaylist: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    removePlatformUserPlaylists: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    hasPlatformUserPlaylist: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    hasPlatformUserPlaylists: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+    countPlatformUserPlaylists: Sequelize.HasManyCountAssociationsMixin;
+    userContacts: UserContacts[];
+    getUserContacts: Sequelize.HasManyGetAssociationsMixin<UserContacts>;
+    setUserContacts: Sequelize.HasManySetAssociationsMixin<UserContacts, UserContactsId>;
+    addUserContact: Sequelize.HasManyAddAssociationMixin<UserContacts, UserContactsId>;
+    addUserContacts: Sequelize.HasManyAddAssociationsMixin<UserContacts, UserContactsId>;
+    createUserContact: Sequelize.HasManyCreateAssociationMixin<UserContacts>;
+    removeUserContact: Sequelize.HasManyRemoveAssociationMixin<UserContacts, UserContactsId>;
+    removeUserContacts: Sequelize.HasManyRemoveAssociationsMixin<UserContacts, UserContactsId>;
+    hasUserContact: Sequelize.HasManyHasAssociationMixin<UserContacts, UserContactsId>;
+    hasUserContacts: Sequelize.HasManyHasAssociationsMixin<UserContacts, UserContactsId>;
+    countUserContacts: Sequelize.HasManyCountAssociationsMixin;
+    state: State;
+    getState: Sequelize.BelongsToGetAssociationMixin<State>;
+    setState: Sequelize.BelongsToSetAssociationMixin<State, StateId>;
+    createState: Sequelize.BelongsToCreateAssociationMixin<State>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof AppUser;
+}

package/dist/AppUser.js

@@ -0,0 +1,121 @@
+"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.AppUser = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class AppUser extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return AppUser.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+                primaryKey: true
+            },
+            email: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                unique: "uk_app_user_email"
+            },
+            firstName: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'first_name'
+            },
+            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'
+            },
+            stateId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0,
+                references: {
+                    model: 'state',
+                    key: 'id'
+                },
+                field: 'state_id'
+            },
+            syncContacts: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: true,
+                defaultValue: false,
+                field: 'sync_contacts'
+            },
+            lastName: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 'last_name'
+            },
+            autoApproveFollowers: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: true,
+                field: 'auto_approve_followers'
+            },
+            lastHarvested: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                field: 'last_harvested'
+            },
+            lastHarvestedError: {
+                type: sequelize_1.DataTypes.STRING(512),
+                allowNull: true,
+                field: 'last_harvested_error'
+            }
+        }, {
+            sequelize,
+            tableName: 'app_user',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "app_user_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "uk_app_user_email",
+                    unique: true,
+                    fields: [
+                        { name: "email" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.AppUser = AppUser;

package/dist/AppUserDevice.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+export interface AppUserDeviceAttributes {
+    id: string;
+    appUserId: string;
+    devicePlatformId: number;
+    endpointArn: string;
+    createdAt: Date;
+}
+export type AppUserDevicePk = "id";
+export type AppUserDeviceId = AppUserDevice[AppUserDevicePk];
+export type AppUserDeviceOptionalAttributes = "id" | "createdAt";
+export type AppUserDeviceCreationAttributes = Optional<AppUserDeviceAttributes, AppUserDeviceOptionalAttributes>;
+export declare class AppUserDevice extends Model<AppUserDeviceAttributes, AppUserDeviceCreationAttributes> implements AppUserDeviceAttributes {
+    id: string;
+    appUserId: string;
+    devicePlatformId: number;
+    endpointArn: string;
+    createdAt: Date;
+    appUser: AppUser;
+    getAppUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setAppUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createAppUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof AppUserDevice;
+}

package/dist/AppUserDevice.js

@@ -0,0 +1,88 @@
+"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.AppUserDevice = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class AppUserDevice extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return AppUserDevice.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            appUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                field: 'app_user_id'
+            },
+            devicePlatformId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                field: 'device_platform_id'
+            },
+            endpointArn: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                unique: "unique_app_user_device_endpoint_arn",
+                field: 'endpoint_arn'
+            },
+            createdAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'created_at'
+            }
+        }, {
+            sequelize,
+            tableName: 'app_user_device',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "app_user_device_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "unique_app_user_device_endpoint_arn",
+                    unique: true,
+                    fields: [
+                        { name: "endpoint_arn" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.AppUserDevice = AppUserDevice;

package/dist/AppUserFollowRelation.d.ts

@@ -0,0 +1,34 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+export interface AppUserFollowRelationAttributes {
+    id: string;
+    appUserId: string;
+    followingAppUserId: string;
+    stateId: number;
+    isBlocked: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type AppUserFollowRelationPk = "id";
+export type AppUserFollowRelationId = AppUserFollowRelation[AppUserFollowRelationPk];
+export type AppUserFollowRelationOptionalAttributes = "id" | "stateId" | "createdAt" | "updatedAt";
+export type AppUserFollowRelationCreationAttributes = Optional<AppUserFollowRelationAttributes, AppUserFollowRelationOptionalAttributes>;
+export declare class AppUserFollowRelation extends Model<AppUserFollowRelationAttributes, AppUserFollowRelationCreationAttributes> implements AppUserFollowRelationAttributes {
+    id: string;
+    appUserId: string;
+    followingAppUserId: string;
+    stateId: number;
+    isBlocked: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    appUser: AppUser;
+    getAppUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setAppUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createAppUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    followingAppUser: AppUser;
+    getFollowingAppUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setFollowingAppUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createFollowingAppUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof AppUserFollowRelation;
+}

package/dist/AppUserFollowRelation.js

@@ -0,0 +1,113 @@
+"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.AppUserFollowRelation = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class AppUserFollowRelation extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return AppUserFollowRelation.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            appUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                unique: "unique_app_user_followers",
+                field: 'app_user_id'
+            },
+            followingAppUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                unique: "unique_app_user_followers",
+                field: 'following_app_user_id'
+            },
+            stateId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0,
+                field: 'state_id'
+            },
+            isBlocked: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false,
+                field: 'is_blocked'
+            },
+            createdAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'created_at'
+            },
+            updatedAt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'updated_at'
+            }
+        }, {
+            sequelize,
+            tableName: 'app_user_follow_relation',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "app_user_follow_relation_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "app_user_id",
+                    fields: [
+                        { name: "app_user_id" },
+                    ]
+                },
+                {
+                    name: "unique_app_user_followers",
+                    unique: true,
+                    fields: [
+                        { name: "app_user_id" },
+                        { name: "following_app_user_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.AppUserFollowRelation = AppUserFollowRelation;

package/dist/AppUserPlatformRelation.d.ts

@@ -0,0 +1,43 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { Platform, PlatformId } from './Platform';
+export interface AppUserPlatformRelationAttributes {
+    id: string;
+    appUserId: string;
+    platformId: number;
+    externalUserId: string;
+    createDate: Date;
+    updateDate: Date;
+    accessToken: string;
+    refreshToken?: string;
+    expirationDate: Date;
+    countryCode: string;
+    stateId: number;
+}
+export type AppUserPlatformRelationPk = "id";
+export type AppUserPlatformRelationId = AppUserPlatformRelation[AppUserPlatformRelationPk];
+export type AppUserPlatformRelationOptionalAttributes = "id" | "createDate" | "updateDate" | "refreshToken" | "stateId";
+export type AppUserPlatformRelationCreationAttributes = Optional<AppUserPlatformRelationAttributes, AppUserPlatformRelationOptionalAttributes>;
+export declare class AppUserPlatformRelation extends Model<AppUserPlatformRelationAttributes, AppUserPlatformRelationCreationAttributes> implements AppUserPlatformRelationAttributes {
+    id: string;
+    appUserId: string;
+    platformId: number;
+    externalUserId: string;
+    createDate: Date;
+    updateDate: Date;
+    accessToken: string;
+    refreshToken?: string;
+    expirationDate: Date;
+    countryCode: string;
+    stateId: number;
+    appUser: AppUser;
+    getAppUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setAppUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createAppUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    platform: Platform;
+    getPlatform: Sequelize.BelongsToGetAssociationMixin<Platform>;
+    setPlatform: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+    createPlatform: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof AppUserPlatformRelation;
+}