@okf/ootils 1.26.1 → 1.26.3

package/dist/node.mjs

@@ -223,6 +223,34 @@ var init_GLOBAL_BULLMQ_CONFIG = __esm({
           }
         }
       },
+      SENTIMENT_AND_NER_QUEUE: {
+        id: "sentiment-and-ner-queue",
+        queueConfig: {
+          defaultJobOptions: {
+            attempts: 3,
+            backoff: {
+              type: "exponential",
+              delay: 2e3
+            },
+            removeOnComplete: 30,
+            removeOnFail: 100
+          },
+          streams: {
+            events: {
+              maxLen: 10
+            }
+          }
+        },
+        workerConfig: {
+          concurrency: 1,
+          lockDuration: 9e4,
+          maxStalledCount: 3,
+          limiter: {
+            max: 100,
+            duration: 6e4
+          }
+        }
+      },
       AI_AUTO_ANNOTATE_QUEUE: {
         id: "ai-auto-annotate-queue",
         queueConfig: {
@@ -879,31 +907,54 @@ var require_ElasticSearchConnector = __commonJS({
     "use strict";
     var { Client } = __require("@elastic/elasticsearch");
     var ElasticSearchConnector2 = class _ElasticSearchConnector {
+      /**
+       * @param {Object} options
+       *
+       * Multi-env mode (preferred):
+       *   { env: 'dev', configs: { dev: { cloudId, apiKey }, staging: { cloudId, apiKey }, prod: { cloudId, apiKey } } }
+       *
+       * Legacy single-env mode (backwards compat):
+       *   { cloudId: '...', apiKey: '...' }
+       */
       constructor(options = {}) {
+        this.env = options.env || null;
+        this.clients = {};
         this.client = null;
-        this.cloudId = options.cloudId;
-        this.apiKey = options.apiKey;
-        _ElasticSearchConnector.instance = this;
-        if (!this.cloudId) {
-          throw new Error("Cloud ID must be provided in constructor options or ELASTIC_CLOUD_ID environment variable");
-        }
-        if (!this.apiKey) {
-          throw new Error("API Key must be provided in constructor options or ELASTIC_API_KEY environment variable");
+        if (options.configs) {
+          this._configs = options.configs;
+        } else if (options.cloudId && options.apiKey) {
+          this._legacyConfig = { cloudId: options.cloudId, apiKey: options.apiKey };
+        } else {
+          throw new Error("ElasticSearchConnector: provide either { configs } for multi-env or { cloudId, apiKey } for single-env");
         }
+        _ElasticSearchConnector.instance = this;
       }
       /**
-       * Initialize Elasticsearch client
+       * Initialize Elasticsearch client(s).
+       * Multi-env: connects to all configured envs.
+       * Legacy: connects a single client.
        */
       connect() {
-        this.client = new Client({
-          cloud: {
-            id: this.cloudId
-          },
-          auth: {
-            apiKey: this.apiKey
+        if (this._configs) {
+          for (const [env, conf] of Object.entries(this._configs)) {
+            if (!conf.cloudId || !conf.apiKey) {
+              console.log(`[ES] Skipping env "${env}" \u2014 missing cloudId or apiKey`);
+              continue;
+            }
+            this.clients[env] = new Client({
+              cloud: { id: conf.cloudId },
+              auth: { apiKey: conf.apiKey }
+            });
           }
-        });
-        console.log("\u2705 Elasticsearch client initialized");
+          this.client = this.clients[this.env] || null;
+          console.log(`\u2705 Elasticsearch clients initialized for envs: ${Object.keys(this.clients).join(", ")}`);
+        } else {
+          this.client = new Client({
+            cloud: { id: this._legacyConfig.cloudId },
+            auth: { apiKey: this._legacyConfig.apiKey }
+          });
+          console.log("\u2705 Elasticsearch client initialized");
+        }
         return this.client;
       }
       // Static method to get the instance
@@ -913,22 +964,43 @@ var require_ElasticSearchConnector = __commonJS({
         }
         return _ElasticSearchConnector.instance;
       }
-      // Static method to get the client
-      static getClient() {
-        if (!_ElasticSearchConnector.instance || !_ElasticSearchConnector.instance.client) {
-          throw new Error("ElasticSearchConnector not initialized or client not connected");
+      /**
+       * Get an Elasticsearch client.
+       * @param {string} [env] - Optional env to get a specific env's client.
+       *                         If omitted, returns the current env's client (backwards compat).
+       */
+      static getClient(env) {
+        const inst = _ElasticSearchConnector.instance;
+        if (!inst) {
+          throw new Error("ElasticSearchConnector not initialized");
+        }
+        if (env && inst.clients[env]) {
+          return inst.clients[env];
         }
-        return _ElasticSearchConnector.instance.client;
+        if (inst.client) {
+          return inst.client;
+        }
+        throw new Error("ElasticSearchConnector not initialized or client not connected");
+      }
+      static getEnv() {
+        return _ElasticSearchConnector.instance?.env;
       }
       /**
-       * Close the Elasticsearch client
+       * Close all Elasticsearch clients.
        */
       async close() {
-        if (this.client) {
+        for (const [env, client] of Object.entries(this.clients)) {
+          try {
+            await client.close();
+          } catch (_) {
+          }
+        }
+        if (this.client && !Object.values(this.clients).includes(this.client)) {
           await this.client.close();
-          console.log("\u2705 Elasticsearch client closed");
-          this.client = null;
         }
+        this.clients = {};
+        this.client = null;
+        console.log("\u2705 Elasticsearch client(s) closed");
       }
     };
     ElasticSearchConnector2.instance = null;
@@ -1071,11 +1143,55 @@ var init_GeneratedTopics = __esm({
   }
 });
 
+// src/models/GeneratedEntities.ts
+import { Schema as Schema3 } from "mongoose";
+var GeneratedEntitiesSchema, GeneratedEntities_default;
+var init_GeneratedEntities = __esm({
+  "src/models/GeneratedEntities.ts"() {
+    "use strict";
+    GeneratedEntitiesSchema = new Schema3(
+      {
+        canonicalName: {
+          type: String,
+          trim: true,
+          required: true
+        },
+        type: {
+          type: String,
+          required: true,
+          trim: true
+        },
+        embeddings: {
+          type: [Number],
+          required: true
+        },
+        aliases: {
+          type: [String],
+          default: []
+        }
+      },
+      { timestamps: true, collection: "SYSTEM_generatedEntities" }
+    );
+    GeneratedEntitiesSchema.index(
+      {
+        canonicalName: 1,
+        type: 1
+      },
+      {
+        unique: true,
+        name: "unique_entity_per_type"
+      }
+    );
+    GeneratedEntities_default = GeneratedEntitiesSchema;
+  }
+});
+
 // src/models/index.ts
 var models_exports = {};
 __export(models_exports, {
   AIChatSchema: () => AIChat_default,
   AnnotationSchema: () => Annotations_default,
+  GeneratedEntitiesSchema: () => GeneratedEntities_default,
   GeneratedTopicsSchema: () => GeneratedTopics_default,
   PlatformConfigsSchema: () => PlatformConfigs_default,
   TplSchema: () => Tpl_default
@@ -1088,6 +1204,7 @@ var init_models = __esm({
     init_PlatformConfigs();
     init_Tpl();
     init_GeneratedTopics();
+    init_GeneratedEntities();
   }
 });
 
@@ -1128,7 +1245,7 @@ var require_getModelByTenant = __commonJS({
   "src/db/getModelByTenant.js"(exports, module) {
     "use strict";
     var { getDbByTenant: getDbByTenant2 } = (init_getDbByTenant(), __toCommonJS(getDbByTenant_exports));
-    var { AIChatSchema: AIChatSchema2, AnnotationSchema: AnnotationSchema2, PlatformConfigsSchema: PlatformConfigsSchema2, TplSchema: TplSchema2, GeneratedTopicsSchema: GeneratedTopicsSchema2 } = (init_models(), __toCommonJS(models_exports));
+    var { AIChatSchema: AIChatSchema2, AnnotationSchema: AnnotationSchema2, PlatformConfigsSchema: PlatformConfigsSchema2, TplSchema: TplSchema2, GeneratedTopicsSchema: GeneratedTopicsSchema2, GeneratedEntitiesSchema: GeneratedEntitiesSchema2 } = (init_models(), __toCommonJS(models_exports));
     var getModelByTenant3 = ({ tenant, modelName, schema, env }) => {
       if (!tenant) {
         throw new Error("tenant id has not been provided");
@@ -1169,13 +1286,20 @@ var require_getModelByTenant = __commonJS({
       schema: GeneratedTopicsSchema2,
       env
     });
+    var getGeneratedEntitiesModelByTenant2 = ({ tenant, env }) => getModelByTenant3({
+      tenant,
+      modelName: "generatedEntities",
+      schema: GeneratedEntitiesSchema2,
+      env
+    });
     module.exports = {
       getModelByTenant: getModelByTenant3,
       getAIChatModelByTenant: getAIChatModelByTenant2,
       getAnnotationsModelByTenant: getAnnotationsModelByTenant2,
       getPlatformConfigsModelByTenant: getPlatformConfigsModelByTenant2,
       getTplModelByTenant: getTplModelByTenant2,
-      getGeneratedTopicsModelByTenant: getGeneratedTopicsModelByTenant2
+      getGeneratedTopicsModelByTenant: getGeneratedTopicsModelByTenant2,
+      getGeneratedEntitiesModelByTenant: getGeneratedEntitiesModelByTenant2
     };
   }
 });
@@ -1240,6 +1364,36 @@ var init_SecretManagerConnector = __esm({
         const configs = _SecretManagerConnector.getSecret("envSpecificConfigs");
         return env ? configs[env] : configs;
       }
+      /**
+       * Get Redis configs for all envs, structured for RedisCacheConnector multi-env mode.
+       * @returns {{ dev: { host, port, password }, staging: { host, port, password }, prod: { host, port, password } }}
+       */
+      static getRedisConfigsForAllEnvs() {
+        const all = _SecretManagerConnector.getEnvSpecificConfigs();
+        const result = {};
+        for (const env of Object.keys(all)) {
+          const c = all[env];
+          if (c?.REDIS_HOST) {
+            result[env] = { host: c.REDIS_HOST, port: c.REDIS_PORT, password: c.REDIS_PASSWORD };
+          }
+        }
+        return result;
+      }
+      /**
+       * Get Elasticsearch configs for all envs, structured for ElasticSearchConnector multi-env mode.
+       * @returns {{ dev: { cloudId, apiKey }, staging: { cloudId, apiKey }, prod: { cloudId, apiKey } }}
+       */
+      static getElasticConfigsForAllEnvs() {
+        const all = _SecretManagerConnector.getEnvSpecificConfigs();
+        const result = {};
+        for (const env of Object.keys(all)) {
+          const c = all[env];
+          if (c?.ELASTIC_CLOUD_ID) {
+            result[env] = { cloudId: c.ELASTIC_CLOUD_ID, apiKey: c.ELASTIC_API_KEY };
+          }
+        }
+        return result;
+      }
       static async addSecretVersion(secretName, data) {
         const instance = _SecretManagerConnector.instance;
         const payload = Buffer.from(JSON.stringify(data, null, 2));
@@ -3271,24 +3425,56 @@ var BASE_SETTINGS_FOR_CONFIGS_CACHE = [
   }
 ];
 var RedisCacheConnector = class _RedisCacheConnector {
+  /**
+   * @param {Object} options
+   *
+   * Multi-env mode (preferred):
+   *   { env: 'dev', configs: { dev: { host, port, password }, staging: { host, port, password }, prod: { host, port, password } } }
+   *
+   * Legacy single-env mode (backwards compat):
+   *   { host: '...', port: 6379, password: '...', env: 'dev' }
+   */
   constructor(options = {}) {
     /**
-     * Initialize Redis client
+     * Initialize Redis client(s).
+     * Multi-env: connects to all configured envs.
+     * Legacy: connects a single client.
      */
     __publicField(this, "connect", async () => {
       try {
-        this.client = new Redis({
-          host: this.host,
-          port: this.port,
-          password: this.password
-        });
-        this.client.on("connect", () => {
-          console.log("\u2705 Connected to our redis cache instance!");
-        });
-        await new Promise((resolve, reject) => {
-          this.client.on("ready", resolve);
-          this.client.on("error", reject);
-        });
+        if (this._configs) {
+          for (const [env, conf] of Object.entries(this._configs)) {
+            if (!conf.host || !conf.port || !conf.password) {
+              console.log(`[Redis] Skipping env "${env}" \u2014 missing config`);
+              continue;
+            }
+            const redisClient = new Redis({
+              host: conf.host,
+              port: conf.port,
+              password: conf.password
+            });
+            await new Promise((resolve, reject) => {
+              redisClient.on("ready", resolve);
+              redisClient.on("error", reject);
+            });
+            this.clients[env] = redisClient;
+          }
+          this.client = this.clients[this.env] || null;
+          console.log(`\u2705 Redis clients initialized for envs: ${Object.keys(this.clients).join(", ")}`);
+        } else {
+          this.client = new Redis({
+            host: this._legacyConfig.host,
+            port: this._legacyConfig.port,
+            password: this._legacyConfig.password
+          });
+          this.client.on("connect", () => {
+            console.log("\u2705 Connected to our redis cache instance!");
+          });
+          await new Promise((resolve, reject) => {
+            this.client.on("ready", resolve);
+            this.client.on("error", reject);
+          });
+        }
         return this.client;
       } catch (err) {
         console.error(err.message);
@@ -3300,24 +3486,20 @@ var RedisCacheConnector = class _RedisCacheConnector {
         "RedisCacheConnector instance already exists. Use RedisCacheConnector.getInstance() instead."
       );
     }
-    this.client = null;
-    this.host = options.host;
     this.env = options.env;
-    this.port = options.port;
-    this.password = options.password;
-    _RedisCacheConnector.instance = this;
-    if (!this.host) {
-      throw new Error("Host must be provided in constructor options");
-    }
-    if (!this.port) {
-      throw new Error("Port must be provided in constructor options");
-    }
-    if (!this.password) {
-      throw new Error("Password must be provided in constructor options");
+    this.clients = {};
+    this.client = null;
+    if (options.configs) {
+      this._configs = options.configs;
+    } else if (options.host && options.port && options.password) {
+      this._legacyConfig = { host: options.host, port: options.port, password: options.password };
+    } else {
+      throw new Error("RedisCacheConnector: provide either { configs } for multi-env or { host, port, password } for single-env");
     }
     if (!this.env) {
       throw new Error("Env must be provided in constructor options");
     }
+    _RedisCacheConnector.instance = this;
   }
   static getEnv() {
     if (!_RedisCacheConnector.instance) {
@@ -3332,14 +3514,23 @@ var RedisCacheConnector = class _RedisCacheConnector {
     }
     return _RedisCacheConnector.instance;
   }
-  // Static method to get the client
-  static getClient() {
-    if (!_RedisCacheConnector.instance || !_RedisCacheConnector.instance.client) {
-      throw new Error(
-        "RedisCacheConnector not initialized or client not connected"
-      );
+  /**
+   * Get a Redis client.
+   * @param {string} [env] - Optional env to get a specific env's client.
+   *                         If omitted, returns the current env's client (backwards compat).
+   */
+  static getClient(env) {
+    const inst = _RedisCacheConnector.instance;
+    if (!inst) {
+      throw new Error("RedisCacheConnector not initialized or client not connected");
+    }
+    if (env && inst.clients[env]) {
+      return inst.clients[env];
     }
-    return _RedisCacheConnector.instance.client;
+    if (inst.client) {
+      return inst.client;
+    }
+    throw new Error("RedisCacheConnector not initialized or client not connected");
   }
   /**
    * Find documents in Redis cache
@@ -3353,8 +3544,8 @@ var RedisCacheConnector = class _RedisCacheConnector {
    */
   static async findConfigsInCache({ tenant, modelName, type, env }) {
     try {
-      const client = this.getClient();
       const environment = env || this.getEnv();
+      const client = this.getClient(environment);
       const keyPrefix = `${environment}:${tenant}:${modelName}:`;
       const keys = await client.keys(`${keyPrefix}${type || "*"}`);
       if (keys.length === 0) {
@@ -3419,12 +3610,6 @@ var RedisCacheConnector = class _RedisCacheConnector {
   /**
    * Generate Redis key for config caching
    * @private
-   * @param {Object} params - Parameters for key generation
-   * @param {string} params.tenant - The tenant identifier
-   * @param {'platformConfigs'|'tpl'} params.modelName - The model/collection name
-   * @param {string} params.type - The document type
-   * @param {string} [params.env] - Environment (defaults to current env)
-   * @returns {string} The Redis key
    */
   static _getRedisKeyForConfig({ tenant, modelName, type, env }) {
     const environment = env || this.getEnv();
@@ -3442,12 +3627,13 @@ var RedisCacheConnector = class _RedisCacheConnector {
    * @see {platformConfigTypes} for valid platformConfigs type values
    */
   static async setOneConfigInCache({ tenant, modelName, type, val, env }) {
-    const client = this.getClient();
+    const environment = env || this.getEnv();
+    const client = this.getClient(environment);
     const cacheKey = this._getRedisKeyForConfig({
       tenant,
       modelName,
       type,
-      env
+      env: environment
     });
     await client.set(cacheKey, JSON.stringify(val));
   }
@@ -3473,12 +3659,13 @@ var RedisCacheConnector = class _RedisCacheConnector {
     newVal,
     env
   }) {
-    const client = this.getClient();
+    const environment = env || this.getEnv();
+    const client = this.getClient(environment);
     const cacheKey = this._getRedisKeyForConfig({
       tenant,
       modelName,
       type,
-      env
+      env: environment
     });
     const delResult = await client.del(cacheKey);
     let setResult;
@@ -3503,8 +3690,8 @@ var RedisCacheConnector = class _RedisCacheConnector {
    */
   static async loadTplsAndPlatformConfigsToCache({ tenant }) {
     try {
-      const client = this.getClient();
       const environment = this.getEnv();
+      const client = this.getClient(environment);
       if (!tenant) throw new Error("No tenant/s defined to recache");
       console.log(`Loading configs and templates into cache...`);
       const tenantToClusterMapping = import_MongoConnector2.MongoConnector.getTenantToClusterMapping();
@@ -3554,14 +3741,21 @@ var RedisCacheConnector = class _RedisCacheConnector {
     }
   }
   /**
-   * Close the Redis client
+   * Close all Redis clients.
    */
   async close() {
-    if (this.client) {
+    for (const [env, client] of Object.entries(this.clients)) {
+      try {
+        await client.quit();
+      } catch (_) {
+      }
+    }
+    if (this.client && !Object.values(this.clients).includes(this.client)) {
       await this.client.quit();
-      console.log("\u2705 Redis client closed");
-      this.client = null;
     }
+    this.clients = {};
+    this.client = null;
+    console.log("\u2705 Redis client closed");
   }
 };
 RedisCacheConnector.instance = null;
@@ -3589,6 +3783,7 @@ var export_ProducerManager = import_ProducerManager.ProducerManager;
 var export_WorkerManager = import_WorkerManager.WorkerManager;
 var export_getAIChatModelByTenant = import_getModelByTenant2.getAIChatModelByTenant;
 var export_getAnnotationsModelByTenant = import_getModelByTenant2.getAnnotationsModelByTenant;
+var export_getGeneratedEntitiesModelByTenant = import_getModelByTenant2.getGeneratedEntitiesModelByTenant;
 var export_getGeneratedTopicsModelByTenant = import_getModelByTenant2.getGeneratedTopicsModelByTenant;
 var export_getModelByTenant = import_getModelByTenant2.getModelByTenant;
 var export_getPlatformConfigsModelByTenant = import_getModelByTenant2.getPlatformConfigsModelByTenant;
@@ -3604,6 +3799,7 @@ export {
   export_ElasticSearchConnector as ElasticSearchConnector,
   FILTER_IDS,
   export_GET_GLOBAL_BULLMQ_CONFIG as GET_GLOBAL_BULLMQ_CONFIG,
+  GeneratedEntities_default as GeneratedEntitiesSchema,
   GeneratedTopics_default as GeneratedTopicsSchema,
   export_MongoConnector as MongoConnector,
   PlatformConfigs_default as PlatformConfigsSchema,
@@ -3629,6 +3825,7 @@ export {
   export_getAnnotationsModelByTenant as getAnnotationsModelByTenant,
   getDbByTenant,
   getFilterKeyForBlock,
+  export_getGeneratedEntitiesModelByTenant as getGeneratedEntitiesModelByTenant,
   export_getGeneratedTopicsModelByTenant as getGeneratedTopicsModelByTenant,
   export_getModelByTenant as getModelByTenant,
   export_getPlatformConfigsModelByTenant as getPlatformConfigsModelByTenant,

package/dist/universal.d.mts

@@ -502,7 +502,7 @@ declare namespace BASE_BULLMQ_CONFIG {
         }
         export { workerConfig_5 as workerConfig };
     }
-    namespace AI_AUTO_ANNOTATE_QUEUE {
+    namespace SENTIMENT_AND_NER_QUEUE {
         let id_6: string;
         export { id_6 as id };
         export namespace queueConfig_6 {
@@ -539,10 +539,17 @@ declare namespace BASE_BULLMQ_CONFIG {
             export { lockDuration_6 as lockDuration };
             let maxStalledCount_6: number;
             export { maxStalledCount_6 as maxStalledCount };
+            export namespace limiter_3 {
+                let max_3: number;
+                export { max_3 as max };
+                let duration_3: number;
+                export { duration_3 as duration };
+            }
+            export { limiter_3 as limiter };
         }
         export { workerConfig_6 as workerConfig };
     }
-    namespace ANNOS_ELASTIC_SYNC_QUEUE {
+    namespace AI_AUTO_ANNOTATE_QUEUE {
         let id_7: string;
         export { id_7 as id };
         export namespace queueConfig_7 {
@@ -582,7 +589,7 @@ declare namespace BASE_BULLMQ_CONFIG {
         }
         export { workerConfig_7 as workerConfig };
     }
-    namespace CHUNKS_ELASTIC_SYNC_QUEUE {
+    namespace ANNOS_ELASTIC_SYNC_QUEUE {
         let id_8: string;
         export { id_8 as id };
         export namespace queueConfig_8 {
@@ -622,7 +629,7 @@ declare namespace BASE_BULLMQ_CONFIG {
         }
         export { workerConfig_8 as workerConfig };
     }
-    namespace CONTENT_ELASTIC_SYNC_QUEUE {
+    namespace CHUNKS_ELASTIC_SYNC_QUEUE {
         let id_9: string;
         export { id_9 as id };
         export namespace queueConfig_9 {
@@ -662,7 +669,7 @@ declare namespace BASE_BULLMQ_CONFIG {
         }
         export { workerConfig_9 as workerConfig };
     }
-    namespace REINDEX_QUEUE {
+    namespace CONTENT_ELASTIC_SYNC_QUEUE {
         let id_10: string;
         export { id_10 as id };
         export namespace queueConfig_10 {
@@ -676,8 +683,6 @@ declare namespace BASE_BULLMQ_CONFIG {
                     export { delay_10 as delay };
                 }
                 export { backoff_10 as backoff };
-                let delay_11: number;
-                export { delay_11 as delay };
                 let removeOnComplete_10: number;
                 export { removeOnComplete_10 as removeOnComplete };
                 let removeOnFail_10: number;
@@ -704,6 +709,48 @@ declare namespace BASE_BULLMQ_CONFIG {
         }
         export { workerConfig_10 as workerConfig };
     }
+    namespace REINDEX_QUEUE {
+        let id_11: string;
+        export { id_11 as id };
+        export namespace queueConfig_11 {
+            export namespace defaultJobOptions_11 {
+                let attempts_11: number;
+                export { attempts_11 as attempts };
+                export namespace backoff_11 {
+                    let type_11: string;
+                    export { type_11 as type };
+                    let delay_11: number;
+                    export { delay_11 as delay };
+                }
+                export { backoff_11 as backoff };
+                let delay_12: number;
+                export { delay_12 as delay };
+                let removeOnComplete_11: number;
+                export { removeOnComplete_11 as removeOnComplete };
+                let removeOnFail_11: number;
+                export { removeOnFail_11 as removeOnFail };
+            }
+            export { defaultJobOptions_11 as defaultJobOptions };
+            export namespace streams_11 {
+                export namespace events_11 {
+                    let maxLen_11: number;
+                    export { maxLen_11 as maxLen };
+                }
+                export { events_11 as events };
+            }
+            export { streams_11 as streams };
+        }
+        export { queueConfig_11 as queueConfig };
+        export namespace workerConfig_11 {
+            let concurrency_11: number;
+            export { concurrency_11 as concurrency };
+            let lockDuration_11: number;
+            export { lockDuration_11 as lockDuration };
+            let maxStalledCount_11: number;
+            export { maxStalledCount_11 as maxStalledCount };
+        }
+        export { workerConfig_11 as workerConfig };
+    }
 }
 
 interface PlatformContextContentItem {