@earbug/db-models 0.0.1

package/dist/JukeboxStatus.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JukeboxStatus = void 0;
+const sequelize_1 = require("sequelize");
+class JukeboxStatus extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return JukeboxStatus.init({
+            id: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            description: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'jukebox_status',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "jukebox_status_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.JukeboxStatus = JukeboxStatus;

package/dist/JukeboxTerminationCondition.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+export interface JukeboxTerminationConditionAttributes {
+    id: number;
+    description: string;
+}
+export type JukeboxTerminationConditionPk = "id";
+export type JukeboxTerminationConditionId = JukeboxTerminationCondition[JukeboxTerminationConditionPk];
+export type JukeboxTerminationConditionCreationAttributes = JukeboxTerminationConditionAttributes;
+export declare class JukeboxTerminationCondition extends Model<JukeboxTerminationConditionAttributes, JukeboxTerminationConditionCreationAttributes> implements JukeboxTerminationConditionAttributes {
+    id: number;
+    description: string;
+    jukeboxSessions: JukeboxSession[];
+    getJukeboxSessions: Sequelize.HasManyGetAssociationsMixin<JukeboxSession>;
+    setJukeboxSessions: Sequelize.HasManySetAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    addJukeboxSession: Sequelize.HasManyAddAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    addJukeboxSessions: Sequelize.HasManyAddAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    createJukeboxSession: Sequelize.HasManyCreateAssociationMixin<JukeboxSession>;
+    removeJukeboxSession: Sequelize.HasManyRemoveAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    removeJukeboxSessions: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    hasJukeboxSession: Sequelize.HasManyHasAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    hasJukeboxSessions: Sequelize.HasManyHasAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    countJukeboxSessions: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxTerminationCondition;
+}

package/dist/JukeboxTerminationCondition.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JukeboxTerminationCondition = void 0;
+const sequelize_1 = require("sequelize");
+class JukeboxTerminationCondition extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return JukeboxTerminationCondition.init({
+            id: {
+                autoIncrement: true,
+                autoIncrementIdentity: true,
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            description: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'jukebox_termination_condition',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "jukebox_termination_condition_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.JukeboxTerminationCondition = JukeboxTerminationCondition;

package/dist/JukeboxType.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+export interface JukeboxTypeAttributes {
+    id: number;
+    description: string;
+}
+export type JukeboxTypePk = "id";
+export type JukeboxTypeId = JukeboxType[JukeboxTypePk];
+export type JukeboxTypeCreationAttributes = JukeboxTypeAttributes;
+export declare class JukeboxType extends Model<JukeboxTypeAttributes, JukeboxTypeCreationAttributes> implements JukeboxTypeAttributes {
+    id: number;
+    description: string;
+    jukeboxSessions: JukeboxSession[];
+    getJukeboxSessions: Sequelize.HasManyGetAssociationsMixin<JukeboxSession>;
+    setJukeboxSessions: Sequelize.HasManySetAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    addJukeboxSession: Sequelize.HasManyAddAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    addJukeboxSessions: Sequelize.HasManyAddAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    createJukeboxSession: Sequelize.HasManyCreateAssociationMixin<JukeboxSession>;
+    removeJukeboxSession: Sequelize.HasManyRemoveAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    removeJukeboxSessions: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    hasJukeboxSession: Sequelize.HasManyHasAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    hasJukeboxSessions: Sequelize.HasManyHasAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+    countJukeboxSessions: Sequelize.HasManyCountAssociationsMixin;
+    static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxType;
+}

package/dist/JukeboxType.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JukeboxType = void 0;
+const sequelize_1 = require("sequelize");
+class JukeboxType extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return JukeboxType.init({
+            id: {
+                autoIncrement: true,
+                autoIncrementIdentity: true,
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            description: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'jukebox_type',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "jukebox_type_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.JukeboxType = JukeboxType;

package/dist/JukeboxUser.d.ts

@@ -0,0 +1,56 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+import type { JukeboxUserType, JukeboxUserTypeId } from './JukeboxUserType';
+import type { PauseStatusType, PauseStatusTypeId } from './PauseStatusType';
+export interface JukeboxUserAttributes {
+    id: string;
+    jukeboxSessionId: string;
+    appUserId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    enterDate: Date;
+    exitDate?: Date;
+    jukeboxUserTypeId: number;
+    pauseStatusTypeId: number;
+    pausedQueueEntryId?: string;
+}
+export type JukeboxUserPk = "id";
+export type JukeboxUserId = JukeboxUser[JukeboxUserPk];
+export type JukeboxUserOptionalAttributes = "id" | "createdAt" | "updatedAt" | "enterDate" | "exitDate" | "jukeboxUserTypeId" | "pauseStatusTypeId" | "pausedQueueEntryId";
+export type JukeboxUserCreationAttributes = Optional<JukeboxUserAttributes, JukeboxUserOptionalAttributes>;
+export declare class JukeboxUser extends Model<JukeboxUserAttributes, JukeboxUserCreationAttributes> implements JukeboxUserAttributes {
+    id: string;
+    jukeboxSessionId: string;
+    appUserId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    enterDate: Date;
+    exitDate?: Date;
+    jukeboxUserTypeId: number;
+    pauseStatusTypeId: number;
+    pausedQueueEntryId?: string;
+    appUser: AppUser;
+    getAppUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+    setAppUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+    createAppUser: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+    pausedQueueEntry: JukeboxQueueEntry;
+    getPausedQueueEntry: Sequelize.BelongsToGetAssociationMixin<JukeboxQueueEntry>;
+    setPausedQueueEntry: Sequelize.BelongsToSetAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    createPausedQueueEntry: Sequelize.BelongsToCreateAssociationMixin<JukeboxQueueEntry>;
+    jukeboxSession: JukeboxSession;
+    getJukeboxSession: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+    setJukeboxSession: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    createJukeboxSession: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+    jukeboxUserType: JukeboxUserType;
+    getJukeboxUserType: Sequelize.BelongsToGetAssociationMixin<JukeboxUserType>;
+    setJukeboxUserType: Sequelize.BelongsToSetAssociationMixin<JukeboxUserType, JukeboxUserTypeId>;
+    createJukeboxUserType: Sequelize.BelongsToCreateAssociationMixin<JukeboxUserType>;
+    pauseStatusType: PauseStatusType;
+    getPauseStatusType: Sequelize.BelongsToGetAssociationMixin<PauseStatusType>;
+    setPauseStatusType: Sequelize.BelongsToSetAssociationMixin<PauseStatusType, PauseStatusTypeId>;
+    createPauseStatusType: Sequelize.BelongsToCreateAssociationMixin<PauseStatusType>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxUser;
+}

package/dist/JukeboxUser.js

@@ -0,0 +1,135 @@
+"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.JukeboxUser = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class JukeboxUser extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return JukeboxUser.init({
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            jukeboxSessionId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'jukebox_session',
+                    key: 'id'
+                },
+                unique: "unique_jukebox_user_id",
+                field: 'jukebox_session_id'
+            },
+            appUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                unique: "unique_jukebox_user_id",
+                field: 'app_user_id'
+            },
+            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'
+            },
+            enterDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'enter_date'
+            },
+            exitDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                field: 'exit_date'
+            },
+            jukeboxUserTypeId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0,
+                references: {
+                    model: 'jukebox_user_type',
+                    key: 'id'
+                },
+                field: 'jukebox_user_type_id'
+            },
+            pauseStatusTypeId: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 0,
+                references: {
+                    model: 'pause_status_type',
+                    key: 'id'
+                },
+                field: 'pause_status_type_id'
+            },
+            pausedQueueEntryId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'jukebox_queue_entry',
+                    key: 'id'
+                },
+                field: 'paused_queue_entry_id'
+            }
+        }, {
+            sequelize,
+            tableName: 'jukebox_user',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "jukebox_user_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+                {
+                    name: "unique_jukebox_user_id",
+                    unique: true,
+                    fields: [
+                        { name: "jukebox_session_id" },
+                        { name: "app_user_id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.JukeboxUser = JukeboxUser;

package/dist/JukeboxUserType.d.ts

@@ -0,0 +1,26 @@
+import * as Sequelize from 'sequelize';
+import { Model } from 'sequelize';
+import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+export interface JukeboxUserTypeAttributes {
+    id: number;
+    description: string;
+}
+export type JukeboxUserTypePk = "id";
+export type JukeboxUserTypeId = JukeboxUserType[JukeboxUserTypePk];
+export type JukeboxUserTypeCreationAttributes = JukeboxUserTypeAttributes;
+export declare class JukeboxUserType extends Model<JukeboxUserTypeAttributes, JukeboxUserTypeCreationAttributes> implements JukeboxUserTypeAttributes {
+    id: number;
+    description: string;
+    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;
+    static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxUserType;
+}

package/dist/JukeboxUserType.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JukeboxUserType = void 0;
+const sequelize_1 = require("sequelize");
+class JukeboxUserType extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return JukeboxUserType.init({
+            id: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                primaryKey: true
+            },
+            description: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: false
+            }
+        }, {
+            sequelize,
+            tableName: 'jukebox_user_type',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "jukebox_user_type_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.JukeboxUserType = JukeboxUserType;

package/dist/KnexMigrations.d.ts

@@ -0,0 +1,19 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+export interface KnexMigrationsAttributes {
+    id: number;
+    name?: string;
+    batch?: number;
+    migrationTime?: Date;
+}
+export type KnexMigrationsPk = "id";
+export type KnexMigrationsId = KnexMigrations[KnexMigrationsPk];
+export type KnexMigrationsOptionalAttributes = "id" | "name" | "batch" | "migrationTime";
+export type KnexMigrationsCreationAttributes = Optional<KnexMigrationsAttributes, KnexMigrationsOptionalAttributes>;
+export declare class KnexMigrations extends Model<KnexMigrationsAttributes, KnexMigrationsCreationAttributes> implements KnexMigrationsAttributes {
+    id: number;
+    name?: string;
+    batch?: number;
+    migrationTime?: Date;
+    static initModel(sequelize: Sequelize.Sequelize): typeof KnexMigrations;
+}

package/dist/KnexMigrations.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnexMigrations = void 0;
+const sequelize_1 = require("sequelize");
+class KnexMigrations extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return KnexMigrations.init({
+            id: {
+                autoIncrement: true,
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                primaryKey: true
+            },
+            name: {
+                type: sequelize_1.DataTypes.STRING(255),
+                allowNull: true
+            },
+            batch: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: true
+            },
+            migrationTime: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                field: 'migration_time'
+            }
+        }, {
+            sequelize,
+            tableName: 'knex_migrations',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "knex_migrations_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.KnexMigrations = KnexMigrations;

package/dist/KnexMigrationsLock.d.ts

@@ -0,0 +1,15 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+export interface KnexMigrationsLockAttributes {
+    index: number;
+    isLocked?: number;
+}
+export type KnexMigrationsLockPk = "index";
+export type KnexMigrationsLockId = KnexMigrationsLock[KnexMigrationsLockPk];
+export type KnexMigrationsLockOptionalAttributes = "index" | "isLocked";
+export type KnexMigrationsLockCreationAttributes = Optional<KnexMigrationsLockAttributes, KnexMigrationsLockOptionalAttributes>;
+export declare class KnexMigrationsLock extends Model<KnexMigrationsLockAttributes, KnexMigrationsLockCreationAttributes> implements KnexMigrationsLockAttributes {
+    index: number;
+    isLocked?: number;
+    static initModel(sequelize: Sequelize.Sequelize): typeof KnexMigrationsLock;
+}

package/dist/KnexMigrationsLock.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnexMigrationsLock = void 0;
+const sequelize_1 = require("sequelize");
+class KnexMigrationsLock extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return KnexMigrationsLock.init({
+            index: {
+                autoIncrement: true,
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                primaryKey: true
+            },
+            isLocked: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: true,
+                field: 'is_locked'
+            }
+        }, {
+            sequelize,
+            tableName: 'knex_migrations_lock',
+            schema: 'public',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "knex_migrations_lock_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "index" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.KnexMigrationsLock = KnexMigrationsLock;

package/dist/MetricsDaily.d.ts

@@ -0,0 +1,19 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+export interface MetricsDailyAttributes {
+    day?: string;
+    eventType: string;
+    createdAt: Date;
+    updatedAt: Date;
+    metrics?: object;
+}
+export type MetricsDailyOptionalAttributes = "day" | "createdAt" | "updatedAt" | "metrics";
+export type MetricsDailyCreationAttributes = Optional<MetricsDailyAttributes, MetricsDailyOptionalAttributes>;
+export declare class MetricsDaily extends Model<MetricsDailyAttributes, MetricsDailyCreationAttributes> implements MetricsDailyAttributes {
+    day?: string;
+    eventType: string;
+    createdAt: Date;
+    updatedAt: Date;
+    metrics?: object;
+    static initModel(sequelize: Sequelize.Sequelize): typeof MetricsDaily;
+}

package/dist/MetricsDaily.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.MetricsDaily = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class MetricsDaily extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return MetricsDaily.init({
+            day: {
+                type: sequelize_1.DataTypes.DATEONLY,
+                allowNull: true
+            },
+            eventType: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'event_type'
+            },
+            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'
+            },
+            metrics: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true
+            }
+        }, {
+            sequelize,
+            tableName: 'metrics_daily',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "metrics_daily_day_event_type_unique",
+                    unique: true,
+                    fields: [
+                        { name: "day" },
+                        { name: "event_type" },
+                    ]
+                },
+                {
+                    name: "metrics_daily_event_type_index",
+                    fields: [
+                        { name: "event_type" },
+                    ]
+                },
+                {
+                    name: "metricsdaily_day_idx",
+                    fields: [
+                        { name: "day" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.MetricsDaily = MetricsDaily;

package/dist/MetricsEvent.d.ts

@@ -0,0 +1,23 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+export interface MetricsEventAttributes {
+    eventType: string;
+    appUserId: string;
+    sessionId: string;
+    devicePlatformId: number;
+    createdAt: Date;
+    meta?: object;
+    objectId?: string;
+}
+export type MetricsEventOptionalAttributes = "createdAt" | "meta" | "objectId";
+export type MetricsEventCreationAttributes = Optional<MetricsEventAttributes, MetricsEventOptionalAttributes>;
+export declare class MetricsEvent extends Model<MetricsEventAttributes, MetricsEventCreationAttributes> implements MetricsEventAttributes {
+    eventType: string;
+    appUserId: string;
+    sessionId: string;
+    devicePlatformId: number;
+    createdAt: Date;
+    meta?: object;
+    objectId?: string;
+    static initModel(sequelize: Sequelize.Sequelize): typeof MetricsEvent;
+}