@google/adk 0.3.0 → 0.4.0

package/dist/cjs/sessions/database_session_service.js

@@ -0,0 +1,364 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var database_session_service_exports = {};
+__export(database_session_service_exports, {
+  DatabaseSessionService: () => DatabaseSessionService,
+  isDatabaseConnectionString: () => isDatabaseConnectionString
+});
+module.exports = __toCommonJS(database_session_service_exports);
+var import_core = require("@mikro-orm/core");
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
+var import_base_session_service = require("./base_session_service.js");
+var import_operations = require("./db/operations.js");
+var import_schema = require("./db/schema.js");
+var import_session = require("./session.js");
+var import_state = require("./state.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function isDatabaseConnectionString(uri) {
+  if (!uri) {
+    return false;
+  }
+  return uri.startsWith("postgres://") || uri.startsWith("postgresql://") || uri.startsWith("mysql://") || uri.startsWith("mariadb://") || uri.startsWith("mssql://") || uri.startsWith("sqlite://");
+}
+class DatabaseSessionService extends import_base_session_service.BaseSessionService {
+  constructor(connectionStringOrOptions) {
+    super();
+    this.initialized = false;
+    if (typeof connectionStringOrOptions === "string") {
+      this.options = (0, import_operations.getConnectionOptionsFromUri)(connectionStringOrOptions);
+    } else {
+      if (!connectionStringOrOptions.driver) {
+        throw new Error("Driver is required when passing options object.");
+      }
+      this.options = {
+        ...connectionStringOrOptions,
+        entities: import_schema.ENTITIES
+      };
+    }
+  }
+  async init() {
+    if (this.initialized) {
+      return;
+    }
+    this.orm = await import_core.MikroORM.init(this.options);
+    await (0, import_operations.ensureDatabaseCreated)(this.orm);
+    await (0, import_operations.validateDatabaseSchemaVersion)(this.orm);
+    this.initialized = true;
+  }
+  async createSession({
+    appName,
+    userId,
+    state,
+    sessionId
+  }) {
+    await this.init();
+    const em = this.orm.em.fork();
+    const id = sessionId || (0, import_env_aware_utils.randomUUID)();
+    const now = /* @__PURE__ */ new Date();
+    const existing = await em.findOne(import_schema.StorageSession, {
+      id,
+      appName,
+      userId
+    });
+    if (existing) {
+      throw new Error(`Session with id ${id} already exists.`);
+    }
+    let appStateModel = await em.findOne(import_schema.StorageAppState, { appName });
+    if (!appStateModel) {
+      appStateModel = em.create(import_schema.StorageAppState, {
+        appName,
+        state: {},
+        updateTime: now
+      });
+      em.persist(appStateModel);
+    }
+    let userStateModel = await em.findOne(import_schema.StorageUserState, { appName, userId });
+    if (!userStateModel) {
+      userStateModel = em.create(import_schema.StorageUserState, {
+        appName,
+        userId,
+        state: {}
+      });
+      em.persist(userStateModel);
+    }
+    const appStateDelta = {};
+    const userStateDelta = {};
+    const sessionState = {};
+    if (state) {
+      for (const [key, value] of Object.entries(state)) {
+        if (key.startsWith(import_state.State.APP_PREFIX)) {
+          appStateDelta[key.replace(import_state.State.APP_PREFIX, "")] = value;
+        } else if (key.startsWith(import_state.State.USER_PREFIX)) {
+          userStateDelta[key.replace(import_state.State.USER_PREFIX, "")] = value;
+        } else {
+          sessionState[key] = value;
+        }
+      }
+    }
+    if (Object.keys(appStateDelta).length > 0) {
+      appStateModel.state = { ...appStateModel.state, ...appStateDelta };
+    }
+    if (Object.keys(userStateDelta).length > 0) {
+      userStateModel.state = { ...userStateModel.state, ...userStateDelta };
+    }
+    const storageSession = em.create(import_schema.StorageSession, {
+      id,
+      appName,
+      userId,
+      state: sessionState,
+      createTime: now,
+      updateTime: now
+    });
+    em.persist(storageSession);
+    await em.flush();
+    const mergedState = (0, import_base_session_service.mergeStates)(
+      appStateModel.state,
+      userStateModel.state,
+      sessionState
+    );
+    return (0, import_session.createSession)({
+      id,
+      appName,
+      userId,
+      state: mergedState,
+      events: [],
+      lastUpdateTime: storageSession.createTime.getTime()
+    });
+  }
+  async getSession({
+    appName,
+    userId,
+    sessionId,
+    config
+  }) {
+    await this.init();
+    const em = this.orm.em.fork();
+    const storageSession = await em.findOne(import_schema.StorageSession, {
+      appName,
+      userId,
+      id: sessionId
+    });
+    if (!storageSession) {
+      return void 0;
+    }
+    const eventWhere = {
+      appName,
+      userId,
+      sessionId
+    };
+    if (config == null ? void 0 : config.afterTimestamp) {
+      eventWhere.timestamp = { $gt: new Date(config.afterTimestamp) };
+    }
+    const storageEvents = await em.find(import_schema.StorageEvent, eventWhere, {
+      orderBy: { timestamp: "DESC" },
+      limit: config == null ? void 0 : config.numRecentEvents
+    });
+    storageEvents.reverse();
+    const appStateModel = await em.findOne(import_schema.StorageAppState, { appName });
+    const userStateModel = await em.findOne(import_schema.StorageUserState, {
+      appName,
+      userId
+    });
+    const mergedState = (0, import_base_session_service.mergeStates)(
+      (appStateModel == null ? void 0 : appStateModel.state) || {},
+      (userStateModel == null ? void 0 : userStateModel.state) || {},
+      storageSession.state
+    );
+    return (0, import_session.createSession)({
+      id: sessionId,
+      appName,
+      userId,
+      state: mergedState,
+      events: storageEvents.map((se) => se.eventData),
+      lastUpdateTime: storageSession.updateTime.getTime()
+    });
+  }
+  async listSessions({
+    appName,
+    userId
+  }) {
+    await this.init();
+    const em = this.orm.em.fork();
+    const where = { appName };
+    if (userId) {
+      where.userId = userId;
+    }
+    const storageSessions = await em.find(import_schema.StorageSession, where);
+    const appStateModel = await em.findOne(import_schema.StorageAppState, { appName });
+    const appState = (appStateModel == null ? void 0 : appStateModel.state) || {};
+    const userStateMap = {};
+    if (userId) {
+      const u = await em.findOne(import_schema.StorageUserState, { appName, userId });
+      if (u) userStateMap[userId] = u.state;
+    } else {
+      const allUserStates = await em.find(import_schema.StorageUserState, { appName });
+      for (const u of allUserStates) {
+        userStateMap[u.userId] = u.state;
+      }
+    }
+    const sessions = storageSessions.map((ss) => {
+      const uState = userStateMap[ss.userId] || {};
+      const merged = (0, import_base_session_service.mergeStates)(appState, uState, ss.state);
+      return (0, import_session.createSession)({
+        id: ss.id,
+        appName: ss.appName,
+        userId: ss.userId,
+        state: merged,
+        events: [],
+        lastUpdateTime: ss.updateTime.getTime()
+      });
+    });
+    return { sessions };
+  }
+  async deleteSession({
+    appName,
+    userId,
+    sessionId
+  }) {
+    await this.init();
+    const em = this.orm.em.fork();
+    await em.nativeDelete(import_schema.StorageSession, { appName, userId, id: sessionId });
+    await em.nativeDelete(import_schema.StorageEvent, { appName, userId, sessionId });
+  }
+  async appendEvent({
+    session,
+    event
+  }) {
+    await this.init();
+    const em = this.orm.em.fork();
+    if (event.partial) {
+      return event;
+    }
+    const trimmedEvent = (0, import_base_session_service.trimTempDeltaState)(event);
+    await em.transactional(async (txEm) => {
+      const storageSession = await txEm.findOne(
+        import_schema.StorageSession,
+        {
+          appName: session.appName,
+          userId: session.userId,
+          id: session.id
+        },
+        { lockMode: import_core.LockMode.PESSIMISTIC_WRITE }
+      );
+      if (!storageSession) {
+        throw new Error(`Session ${session.id} not found for appendEvent`);
+      }
+      let appStateModel = await txEm.findOne(import_schema.StorageAppState, {
+        appName: session.appName
+      });
+      if (!appStateModel) {
+        appStateModel = txEm.create(import_schema.StorageAppState, {
+          appName: session.appName,
+          state: {},
+          updateTime: /* @__PURE__ */ new Date()
+        });
+        txEm.persist(appStateModel);
+      }
+      let userStateModel = await txEm.findOne(import_schema.StorageUserState, {
+        appName: session.appName,
+        userId: session.userId
+      });
+      if (!userStateModel) {
+        userStateModel = txEm.create(import_schema.StorageUserState, {
+          appName: session.appName,
+          userId: session.userId,
+          state: {}
+        });
+        txEm.persist(userStateModel);
+      }
+      if (storageSession.updateTime.getTime() > session.lastUpdateTime) {
+        const events = await txEm.find(
+          import_schema.StorageEvent,
+          {
+            appName: session.appName,
+            userId: session.userId,
+            sessionId: session.id
+          },
+          { orderBy: { timestamp: "ASC" } }
+        );
+        const mergedState = (0, import_base_session_service.mergeStates)(
+          appStateModel.state,
+          userStateModel.state,
+          storageSession.state
+        );
+        session.state = mergedState;
+        session.events = events.map((e) => e.eventData);
+      }
+      if (event.actions && event.actions.stateDelta) {
+        const appDelta = {};
+        const userDelta = {};
+        const sessionDelta = {};
+        for (const [key, value] of Object.entries(event.actions.stateDelta)) {
+          if (key.startsWith(import_state.State.APP_PREFIX)) {
+            appDelta[key.replace(import_state.State.APP_PREFIX, "")] = value;
+          } else if (key.startsWith(import_state.State.USER_PREFIX)) {
+            userDelta[key.replace(import_state.State.USER_PREFIX, "")] = value;
+          } else {
+            sessionDelta[key] = value;
+          }
+        }
+        if (Object.keys(appDelta).length > 0) {
+          appStateModel.state = { ...appStateModel.state, ...appDelta };
+        }
+        if (Object.keys(userDelta).length > 0) {
+          userStateModel.state = { ...userStateModel.state, ...userDelta };
+        }
+        if (Object.keys(sessionDelta).length > 0) {
+          storageSession.state = { ...storageSession.state, ...sessionDelta };
+        }
+      }
+      const newStorageEvent = txEm.create(import_schema.StorageEvent, {
+        id: trimmedEvent.id,
+        appName: session.appName,
+        userId: session.userId,
+        sessionId: session.id,
+        invocationId: trimmedEvent.invocationId,
+        timestamp: new Date(trimmedEvent.timestamp),
+        eventData: trimmedEvent
+      });
+      txEm.persist(newStorageEvent);
+      await txEm.commit();
+      storageSession.updateTime = new Date(event.timestamp);
+      const newMergedState = (0, import_base_session_service.mergeStates)(
+        appStateModel.state,
+        userStateModel.state,
+        storageSession.state
+      );
+      session.state = newMergedState;
+      session.events.push(event);
+      session.lastUpdateTime = storageSession.updateTime.getTime();
+    });
+    return event;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatabaseSessionService,
+  isDatabaseConnectionString
+});

package/dist/cjs/sessions/db/operations.js

@@ -0,0 +1,114 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var operations_exports = {};
+__export(operations_exports, {
+  ensureDatabaseCreated: () => ensureDatabaseCreated,
+  getConnectionOptionsFromUri: () => getConnectionOptionsFromUri,
+  validateDatabaseSchemaVersion: () => validateDatabaseSchemaVersion
+});
+module.exports = __toCommonJS(operations_exports);
+var import_core = require("@mikro-orm/core");
+var import_mariadb = require("@mikro-orm/mariadb");
+var import_mssql = require("@mikro-orm/mssql");
+var import_mysql = require("@mikro-orm/mysql");
+var import_postgresql = require("@mikro-orm/postgresql");
+var import_sqlite = require("@mikro-orm/sqlite");
+var import_schema = require("./schema.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function getConnectionOptionsFromUri(uri) {
+  let driver;
+  if (uri.startsWith("postgres://") || uri.startsWith("postgresql://")) {
+    driver = import_postgresql.PostgreSqlDriver;
+  } else if (uri.startsWith("mysql://")) {
+    driver = import_mysql.MySqlDriver;
+  } else if (uri.startsWith("mariadb://")) {
+    driver = import_mariadb.MariaDbDriver;
+  } else if (uri.startsWith("sqlite://")) {
+    driver = import_sqlite.SqliteDriver;
+  } else if (uri.startsWith("mssql://")) {
+    driver = import_mssql.MsSqlDriver;
+  } else {
+    throw new Error(`Unsupported database URI: ${uri}`);
+  }
+  if (uri === "sqlite://:memory:") {
+    return {
+      entities: import_schema.ENTITIES,
+      dbName: ":memory:",
+      driver
+    };
+  }
+  const { host, port, username, password, pathname } = new URL(uri);
+  const hostName = host.split(":")[0];
+  return {
+    entities: import_schema.ENTITIES,
+    dbName: pathname.slice(1),
+    host: hostName,
+    port: port ? parseInt(port) : void 0,
+    user: username,
+    password,
+    driver
+  };
+}
+async function ensureDatabaseCreated(ormOrUrlOrOptions) {
+  let orm;
+  if (ormOrUrlOrOptions instanceof import_core.MikroORM) {
+    orm = ormOrUrlOrOptions;
+  } else if (typeof ormOrUrlOrOptions === "string") {
+    orm = await import_core.MikroORM.init(getConnectionOptionsFromUri(ormOrUrlOrOptions));
+  } else {
+    orm = await import_core.MikroORM.init(ormOrUrlOrOptions);
+  }
+  await orm.schema.ensureDatabase();
+  await orm.schema.updateSchema();
+}
+async function validateDatabaseSchemaVersion(orm) {
+  const em = orm.em.fork();
+  const existing = await em.findOne(import_schema.StorageMetadata, {
+    key: import_schema.SCHEMA_VERSION_KEY
+  });
+  if (existing) {
+    if (existing.value !== import_schema.SCHEMA_VERSION_1_JSON) {
+      throw new Error(
+        `ADK Database schema version ${existing.value} is not compatible.`
+      );
+    }
+    return;
+  }
+  const newVersion = em.create(import_schema.StorageMetadata, {
+    key: import_schema.SCHEMA_VERSION_KEY,
+    value: import_schema.SCHEMA_VERSION_1_JSON
+  });
+  await em.persist(newVersion).flush();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureDatabaseCreated,
+  getConnectionOptionsFromUri,
+  validateDatabaseSchemaVersion
+});

package/dist/cjs/sessions/db/schema.js

@@ -0,0 +1,204 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var schema_exports = {};
+__export(schema_exports, {
+  ENTITIES: () => ENTITIES,
+  SCHEMA_VERSION_1_JSON: () => SCHEMA_VERSION_1_JSON,
+  SCHEMA_VERSION_KEY: () => SCHEMA_VERSION_KEY,
+  StorageAppState: () => StorageAppState,
+  StorageEvent: () => StorageEvent,
+  StorageMetadata: () => StorageMetadata,
+  StorageSession: () => StorageSession,
+  StorageUserState: () => StorageUserState
+});
+module.exports = __toCommonJS(schema_exports);
+var import_core = require("@mikro-orm/core");
+var import_event = require("../../events/event.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const SCHEMA_VERSION_KEY = "schema_version";
+const SCHEMA_VERSION_1_JSON = "1";
+class CamelCaseToSnakeCaseJsonType extends import_core.JsonType {
+  convertToDatabaseValue(value) {
+    return JSON.stringify((0, import_event.transformToSnakeCaseEvent)(value));
+  }
+  convertToJSValue(value) {
+    if (typeof value === "string") {
+      return (0, import_event.transformToCamelCaseEvent)(JSON.parse(value));
+    }
+    return (0, import_event.transformToCamelCaseEvent)(value);
+  }
+}
+let StorageMetadata = class {
+};
+__decorateClass([
+  (0, import_core.PrimaryKey)({ type: "string" })
+], StorageMetadata.prototype, "key", 2);
+__decorateClass([
+  (0, import_core.Property)({ type: "string" })
+], StorageMetadata.prototype, "value", 2);
+StorageMetadata = __decorateClass([
+  (0, import_core.Entity)({ tableName: "adk_internal_metadata" })
+], StorageMetadata);
+let StorageAppState = class {
+  constructor() {
+    this.updateTime = /* @__PURE__ */ new Date();
+  }
+};
+__decorateClass([
+  (0, import_core.PrimaryKey)({ type: "string", fieldName: "app_name" })
+], StorageAppState.prototype, "appName", 2);
+__decorateClass([
+  (0, import_core.Property)({ type: "json" })
+], StorageAppState.prototype, "state", 2);
+__decorateClass([
+  (0, import_core.Property)({
+    type: "datetime",
+    fieldName: "update_time",
+    onCreate: () => /* @__PURE__ */ new Date(),
+    onUpdate: () => /* @__PURE__ */ new Date()
+  })
+], StorageAppState.prototype, "updateTime", 2);
+StorageAppState = __decorateClass([
+  (0, import_core.Entity)({ tableName: "app_states" })
+], StorageAppState);
+import_core.PrimaryKey.name;
+let StorageUserState = class {
+  constructor() {
+    this.updateTime = /* @__PURE__ */ new Date();
+  }
+};
+__decorateClass([
+  (0, import_core.PrimaryKey)({ type: "string", fieldName: "app_name" })
+], StorageUserState.prototype, "appName", 2);
+__decorateClass([
+  (0, import_core.PrimaryKey)({ type: "string", fieldName: "user_id" })
+], StorageUserState.prototype, "userId", 2);
+__decorateClass([
+  (0, import_core.Property)({ type: "json" })
+], StorageUserState.prototype, "state", 2);
+__decorateClass([
+  (0, import_core.Property)({
+    type: "datetime",
+    fieldName: "update_time",
+    onCreate: () => /* @__PURE__ */ new Date(),
+    onUpdate: () => /* @__PURE__ */ new Date()
+  })
+], StorageUserState.prototype, "updateTime", 2);
+StorageUserState = __decorateClass([
+  (0, import_core.Entity)({ tableName: "user_states" })
+], StorageUserState);
+import_core.PrimaryKey.name;
+let StorageSession = class {
+  constructor() {
+    this.createTime = /* @__PURE__ */ new Date();
+    this.updateTime = /* @__PURE__ */ new Date();
+  }
+};
+__decorateClass([
+  (0, import_core.PrimaryKey)({ type: "string" })
+], StorageSession.prototype, "id", 2);
+__decorateClass([
+  (0, import_core.PrimaryKey)({ type: "string", fieldName: "app_name" })
+], StorageSession.prototype, "appName", 2);
+__decorateClass([
+  (0, import_core.PrimaryKey)({ type: "string", fieldName: "user_id" })
+], StorageSession.prototype, "userId", 2);
+__decorateClass([
+  (0, import_core.Property)({ type: "json" })
+], StorageSession.prototype, "state", 2);
+__decorateClass([
+  (0, import_core.Property)({
+    type: "datetime",
+    fieldName: "create_time",
+    onCreate: () => /* @__PURE__ */ new Date()
+  })
+], StorageSession.prototype, "createTime", 2);
+__decorateClass([
+  (0, import_core.Property)({
+    type: "datetime",
+    fieldName: "update_time",
+    onCreate: () => /* @__PURE__ */ new Date()
+  })
+], StorageSession.prototype, "updateTime", 2);
+StorageSession = __decorateClass([
+  (0, import_core.Entity)({ tableName: "sessions" })
+], StorageSession);
+import_core.PrimaryKey.name;
+let StorageEvent = class {
+};
+__decorateClass([
+  (0, import_core.PrimaryKey)({ type: "string" })
+], StorageEvent.prototype, "id", 2);
+__decorateClass([
+  (0, import_core.PrimaryKey)({ type: "string", fieldName: "app_name" })
+], StorageEvent.prototype, "appName", 2);
+__decorateClass([
+  (0, import_core.PrimaryKey)({ type: "string", fieldName: "user_id" })
+], StorageEvent.prototype, "userId", 2);
+__decorateClass([
+  (0, import_core.PrimaryKey)({ type: "string", fieldName: "session_id" })
+], StorageEvent.prototype, "sessionId", 2);
+__decorateClass([
+  (0, import_core.Property)({ type: "string", fieldName: "invocation_id" })
+], StorageEvent.prototype, "invocationId", 2);
+__decorateClass([
+  (0, import_core.Property)({ type: "datetime" })
+], StorageEvent.prototype, "timestamp", 2);
+__decorateClass([
+  (0, import_core.Property)({ type: CamelCaseToSnakeCaseJsonType, fieldName: "event_data" })
+], StorageEvent.prototype, "eventData", 2);
+StorageEvent = __decorateClass([
+  (0, import_core.Entity)({ tableName: "events" })
+], StorageEvent);
+const ENTITIES = [
+  StorageMetadata,
+  StorageAppState,
+  StorageUserState,
+  StorageSession,
+  StorageEvent
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENTITIES,
+  SCHEMA_VERSION_1_JSON,
+  SCHEMA_VERSION_KEY,
+  StorageAppState,
+  StorageEvent,
+  StorageMetadata,
+  StorageSession,
+  StorageUserState
+});