@hotmeshio/hotmesh 0.5.1 → 0.5.3

package/README.md

@@ -16,11 +16,11 @@ Use HotMesh to:
 
 ## Table of Contents
 
-1. [Quick Start](#-quick-start)
-2. [Permanent Memory Architecture](#-permanent-memory-architecture)
-3. [Durable AI Agents](#-durable-ai-agents)
-4. [Building Pipelines with State](#-building-pipelines-with-state)
-5. [Documentation & Links](#-documentation--links)
+1. [Quick Start](#quick-start)
+2. [Permanent Memory Architecture](#permanent-memory-architecture)
+3. [Durable AI Agents](#durable-ai-agents)
+4. [Building Pipelines with State](#building-pipelines-with-state)
+5. [Documentation & Links](#documentation--links)
 
 ---
 
@@ -106,9 +106,9 @@ This index improves performance for filtered queries while reducing index size.
 
 ## Durable AI Agents
 
-Agents often require memory—context that persists between invocations, spans multiple perspectives, or outlives a single process. HotMesh supports that natively.
+Agents often require memory—context that persists between invocations, spans multiple perspectives, or outlives a single process.
 
-The following example builds a "research agent" that runs sub-flows and self-reflects on the results.
+The following example builds a "research agent" that executes hooks with different perspectives and then synthesizes. The data-first approach sets up initial state and then uses temporary hook functions to augment over the lifecycle of the entity record.
 
 ### Research Agent Example
 
@@ -116,54 +116,57 @@ The following example builds a "research agent" that runs sub-flows and self-ref
 
 ```ts
 export async function researchAgent(query: string): Promise<any> {
-  const entity = await MemFlow.workflow.entity();
+  const agent = await MemFlow.workflow.entity();
 
   // Set up shared memory for this agent session
-  await entity.set({
+  const initialState = {
     query,
     findings: [],
     perspectives: {},
     confidence: 0,
-    status: 'researching'
-  });
+    verification: {},
+    status: 'researching',
+    startTime: new Date().toISOString(),
+  }
+  await agent.set<typeof initialState>(initialState);
 
-  // Launch perspective hooks in parallel (no need to await here)
-  const optimistic = MemFlow.workflow.execHook({
+  // Launch perspective hooks in parallel
+  await MemFlow.workflow.execHook({
     taskQueue: 'agents',
     workflowName: 'optimisticPerspective',
-    args: [query]
+    args: [query],
+    signalId: 'optimistic-complete'
   });
 
-  const skeptical = MemFlow.workflow.execHook({
+  await MemFlow.workflow.execHook({
     taskQueue: 'agents',
     workflowName: 'skepticalPerspective',
-    args: [query]
+    args: [query],
+    signalId: 'skeptical-complete'
   });
 
-  // Launch a child workflow with its own isolated entity/state
-  const factChecker = await MemFlow.workflow.execChild({
-    entity: 'fact-checker',
-    workflowName: 'factCheckAgent',
-    workflowId: `fact-check-${Date.now()}`,
+  await MemFlow.workflow.execHook({
+    taskQueue: 'agents',
+    workflowName: 'verificationHook',
     args: [query],
-    taskQueue: 'agents'
+    signalId: 'verification-complete'
   });
 
-  // Wait for all views to complete before analyzing
-  await Promise.all([optimistic, skeptical, factChecker]);
-
-  // Final synthesis: aggregate and compare all perspectives
   await MemFlow.workflow.execHook({
     taskQueue: 'perspectives',
     workflowName: 'synthesizePerspectives',
-    args: []
+    args: [],
+    signalId: 'synthesis-complete',
   });
 
-  return await entity.get();
+  // return analysis, verification, and synthesis
+  return await agent.get();
 }
 ```
 
-#### Hooks: Perspectives
+> 💡 A complete implementation of this Research Agent example with tests, OpenAI integration, and multi-perspective analysis can be found in the [agent test suite](https://github.com/hotmeshio/sdk-typescript/tree/main/tests/memflow/agent).
+
+#### Perspective Hooks
 
 ```ts
 // Optimistic hook looks for affirming evidence
@@ -182,27 +185,11 @@ export async function skepticalPerspective(query: string, config: {signal: strin
   await entity.merge({ perspectives: { skeptical: { counterEvidence, confidence: 0.6 }}});
   await MemFlow.workflow.signal(config.signal, {});
 }
-```
-
-#### Child Agent: Fact Checker
-
-```ts
-// A dedicated child agent with its own entity type and context
-export async function factCheckAgent(query: string): Promise<any> {
-  const entity = await MemFlow.workflow.entity();
-  await entity.set({ query, sources: [], verifications: [] });
 
-  await MemFlow.workflow.execHook({
-    taskQueue: 'agents',
-    workflowName: 'verifySourceCredibility',
-    args: [query]
-  });
-
-  return await entity.get();
-}
+// Other hooks...
 ```
 
-#### Synthesis
+#### Synthesis Hook
 
 ```ts
 // Synthesis hook aggregates different viewpoints
@@ -229,7 +216,7 @@ export async function synthesizePerspectives(config: {signal: string}): Promise<
 
 ## Building Pipelines with State
 
-HotMesh treats pipelines as long-lived records, not ephemeral jobs. Every pipeline run is stateful, resumable, and traceable.
+HotMesh treats pipelines as long-lived records. Every pipeline run is stateful, resumable, and traceable.
 
 ### Setup a Data Pipeline
 
@@ -355,6 +342,8 @@ export async function triggerRefresh() {
 }
 ```
 
+> 💡 A complete implementation of this Pipeline example with OpenAI Vision integration, processing hooks, and document workflow automation can be found in the [pipeline test suite](https://github.com/hotmeshio/sdk-typescript/tree/main/tests/memflow/pipeline).
+
 ---
 
 ## Documentation & Links

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.5.1",
+    "version": "0.5.3",
     "description": "Permanent-Memory Workflows & AI Agents",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -27,26 +27,27 @@
         "test:connect:postgres": "NODE_ENV=test jest ./tests/unit/services/connector/providers/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:connect:redis": "NODE_ENV=test jest ./tests/unit/services/connector/providers/redis.test.ts --detectOpenHandles --forceExit --verbose",
         "test:connect:nats": "NODE_ENV=test jest ./tests/unit/services/connector/providers/nats.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:cycle": "NODE_ENV=test jest ./tests/functional/cycle/*.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:memflow": "NODE_ENV=test jest ./tests/memflow/*/*.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow": "NODE_ENV=test jest ./tests/memflow/*/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:basic": "HMSH_LOGLEVEL=info NODE_ENV=test jest ./tests/memflow/basic/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:collision": "NODE_ENV=test jest ./tests/memflow/collision/*.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:fatal": "NODE_ENV=test jest ./tests/memflow/fatal/*.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:goodbye": "NODE_ENV=test jest ./tests/memflow/goodbye/*.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:entity": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/memflow/entity/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:agent": "NODE_ENV=test HMSH_LOGLEVEL=debug jest ./tests/memflow/agent/postgres.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:memflow:hello": "HMSH_TELEMETRY=debug HMSH_LOGLEVEL=debug HMSH_IS_CLUSTER=true NODE_ENV=test jest ./tests/memflow/helloworld/*.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:memflow:hook": "NODE_ENV=test jest ./tests/memflow/hook/*.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:memflow:interrupt": "NODE_ENV=test jest ./tests/memflow/interrupt/*.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:memflow:loopactivity": "NODE_ENV=test jest ./tests/memflow/loopactivity/*.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:memflow:nested": "NODE_ENV=test jest ./tests/memflow/nested/*.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:memflow:retry": "NODE_ENV=test jest ./tests/memflow/retry/*.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:memflow:sleep": "NODE_ENV=test jest ./tests/memflow/sleep/*.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:memflow:signal": "NODE_ENV=test jest ./tests/memflow/signal/*.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:memflow:unknown": "NODE_ENV=test jest ./tests/memflow/unknown/*.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow:hello": "HMSH_TELEMETRY=debug HMSH_LOGLEVEL=debug HMSH_IS_CLUSTER=true NODE_ENV=test jest ./tests/memflow/helloworld/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow:hook": "NODE_ENV=test jest ./tests/memflow/hook/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow:interrupt": "NODE_ENV=test jest ./tests/memflow/interrupt/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow:loopactivity": "NODE_ENV=test jest ./tests/memflow/loopactivity/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow:nested": "NODE_ENV=test jest ./tests/memflow/nested/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow:pipeline": "NODE_ENV=test jest ./tests/memflow/pipeline/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow:retry": "NODE_ENV=test jest ./tests/memflow/retry/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow:sleep": "NODE_ENV=test jest ./tests/memflow/sleep/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow:signal": "NODE_ENV=test jest ./tests/memflow/signal/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow:unknown": "NODE_ENV=test jest ./tests/memflow/unknown/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:cycle": "NODE_ENV=test jest ./tests/functional/cycle/*.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:functional": "NODE_ENV=test jest ./tests/functional/* --detectOpenHandles --forceExit --verbose",
         "test:emit": "NODE_ENV=test jest ./tests/functional/emit/*.test.ts --detectOpenHandles --forceExit --verbose",
         "test:pending": "NODE_ENV=test jest ./tests/functional/pending/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:functional": "NODE_ENV=test jest ./tests/functional/* --detectOpenHandles --forceExit --verbose",
         "test:hmsh": "NODE_ENV=test jest ./tests/functional/*.test.ts --detectOpenHandles --verbose --forceExit",
         "test:hook": "NODE_ENV=test jest ./tests/functional/hook/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:interrupt": "NODE_ENV=test jest ./tests/functional/interrupt/*.test.ts --detectOpenHandles --forceExit --verbose",
@@ -74,7 +75,6 @@
         "test:sub:postgres": "NODE_ENV=test jest ./tests/functional/sub/providers/postgres/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:sub:nats": "NODE_ENV=test jest ./tests/functional/sub/providers/nats/nats.test.ts --detectOpenHandles --forceExit --verbose",
         "test:trigger": "NODE_ENV=test jest ./tests/unit/services/activities/trigger.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:meshdata": "NODE_ENV=test jest ./tests/meshdata/postgres.test.ts --forceExit --verbose --detectOpenHandles",
         "test:meshos": "HMSH_LOGLEVEL=info NODE_ENV=test HMSH_IS_CLUSTER=true jest ./tests/meshos/*.test.ts --forceExit --verbose --detectOpenHandles",
         "test:meshcall": "NODE_ENV=test jest ./tests/meshcall/*.test.ts --forceExit --verbose --detectOpenHandles",
         "test:unit": "NODE_ENV=test jest ./tests/unit/*/*/index.test.ts --detectOpenHandles --forceExit --verbose"
@@ -109,6 +109,7 @@
         "@types/pg": "^8.10.0",
         "@typescript-eslint/eslint-plugin": "^5.62.0",
         "@typescript-eslint/parser": "^5.62.0",
+        "dotenv": "^16.3.1",
         "eslint": "^8.57.0",
         "eslint-config-prettier": "^9.1.0",
         "eslint-plugin-import": "^2.29.1",
@@ -117,6 +118,7 @@
         "javascript-obfuscator": "^4.1.1",
         "jest": "^29.5.0",
         "nats": "^2.28.0",
+        "openai": "^5.9.0",
         "pg": "^8.10.0",
         "redis": "^4.6.13",
         "rimraf": "^4.4.1",

package/build/services/hotmesh/index.d.ts

@@ -11,7 +11,7 @@ import { JobStatsInput, GetStatsOptions, IdsResponse, StatsResponse } from '../.
 import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../types/stream';
 /**
  * HotMesh is a distributed, reentrant process orchestration engine that transforms
- * Redis, Postgres, or NATS into a resilient service mesh capable of running
+ * Postgres into a resilient service mesh capable of running
  * fault-tolerant workflows across multiple services and systems.
  *
  * ## Core Concepts
@@ -25,14 +25,10 @@ import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../
  * provides built-in retry logic, idempotency, and failure recovery. Your business
  * logic doesn't need to handle timeouts or retries - the engine manages all of that.
  *
- * **Multi-Provider Support**: Supports Redis/ValKey, Postgres, and NATS as backend
- * providers, allowing you to leverage existing infrastructure investments.
- *
  * ## Key Features
  *
  * - **Fault Tolerance**: Automatic retry, timeout, and failure recovery
  * - **Distributed Execution**: No single point of failure
- * - **Multi-Provider**: Redis, Postgres, NATS backend support
  * - **YAML-Driven**: Model-driven development with declarative workflow definitions
  * - **OpenTelemetry**: Built-in observability and tracing
  * - **Durable State**: Workflow state persists across system restarts
@@ -59,15 +55,17 @@ import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../
  * @example
  * ```typescript
  * import { HotMesh } from '@hotmeshio/hotmesh';
- * import Redis from 'ioredis';
+ * import { Client as Postgres } from 'pg';
  *
- * // Initialize with Redis backend
+ * // Initialize with Postgres backend
  * const hotMesh = await HotMesh.init({
  *   appId: 'my-app',
  *   engine: {
  *     connection: {
- *       class: Redis,
- *       options: { host: 'localhost', port: 6379 }
+ *       class: Postgres,
+ *       options: {
+ *         connectionString: 'postgresql://user:pass@localhost:5432/db'
+ *       }
  *     }
  *   }
  * });
@@ -192,9 +190,9 @@ import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../
  * await HotMesh.stop();
  * ```
  *
- * @see {@link https://hotmesh.io/docs} - Complete documentation
+ * @see {@link https://docs.hotmesh.io/} - Complete documentation
  * @see {@link https://github.com/hotmeshio/samples-typescript} - Examples and tutorials
- * @see {@link https://zenodo.org/records/12168558} - Academic paper on the architecture
+ * @see {@link https://zenodo.org/records/12168558} - White paper on the architecture
  */
 declare class HotMesh {
     namespace: string;

package/build/services/hotmesh/index.js

@@ -12,7 +12,7 @@ const worker_1 = require("../worker");
 const enums_1 = require("../../modules/enums");
 /**
  * HotMesh is a distributed, reentrant process orchestration engine that transforms
- * Redis, Postgres, or NATS into a resilient service mesh capable of running
+ * Postgres into a resilient service mesh capable of running
  * fault-tolerant workflows across multiple services and systems.
  *
  * ## Core Concepts
@@ -26,14 +26,10 @@ const enums_1 = require("../../modules/enums");
  * provides built-in retry logic, idempotency, and failure recovery. Your business
  * logic doesn't need to handle timeouts or retries - the engine manages all of that.
  *
- * **Multi-Provider Support**: Supports Redis/ValKey, Postgres, and NATS as backend
- * providers, allowing you to leverage existing infrastructure investments.
- *
  * ## Key Features
  *
  * - **Fault Tolerance**: Automatic retry, timeout, and failure recovery
  * - **Distributed Execution**: No single point of failure
- * - **Multi-Provider**: Redis, Postgres, NATS backend support
  * - **YAML-Driven**: Model-driven development with declarative workflow definitions
  * - **OpenTelemetry**: Built-in observability and tracing
  * - **Durable State**: Workflow state persists across system restarts
@@ -60,15 +56,17 @@ const enums_1 = require("../../modules/enums");
  * @example
  * ```typescript
  * import { HotMesh } from '@hotmeshio/hotmesh';
- * import Redis from 'ioredis';
+ * import { Client as Postgres } from 'pg';
  *
- * // Initialize with Redis backend
+ * // Initialize with Postgres backend
  * const hotMesh = await HotMesh.init({
  *   appId: 'my-app',
  *   engine: {
  *     connection: {
- *       class: Redis,
- *       options: { host: 'localhost', port: 6379 }
+ *       class: Postgres,
+ *       options: {
+ *         connectionString: 'postgresql://user:pass@localhost:5432/db'
+ *       }
  *     }
  *   }
  * });
@@ -193,9 +191,9 @@ const enums_1 = require("../../modules/enums");
  * await HotMesh.stop();
  * ```
  *
- * @see {@link https://hotmesh.io/docs} - Complete documentation
+ * @see {@link https://docs.hotmesh.io/} - Complete documentation
  * @see {@link https://github.com/hotmeshio/samples-typescript} - Examples and tutorials
- * @see {@link https://zenodo.org/records/12168558} - Academic paper on the architecture
+ * @see {@link https://zenodo.org/records/12168558} - White paper on the architecture
  */
 class HotMesh {
     /**

package/build/services/memflow/entity.d.ts

@@ -62,7 +62,7 @@ export declare class Entity {
      * const entity = await workflow.entity();
      * await entity.set({ user: { id: 123, name: "John" } });
      */
-    set(value: any): Promise<any>;
+    set<T>(value: T): Promise<T>;
     /**
      * Deep merges the provided object with the existing entity
      *
@@ -79,7 +79,7 @@ export declare class Entity {
      * const user = await entity.get("user");
      * const email = await entity.get("user.email");
      */
-    get(path?: string): Promise<any>;
+    get<T>(path?: string): Promise<T>;
     /**
      * Deletes a value from the entity by path
      *
@@ -137,7 +137,171 @@ export declare class Entity {
      */
     setIfNotExists(path: string, value: any): Promise<any>;
     /**
-     * @private
+     * Finds entity records matching complex conditions using JSONB/SQL queries.
+     * This is a readonly operation that queries across all entities of a given type.
+     *
+     * @example
+     * ```typescript
+     * // Basic find with simple conditions
+     * const activeUsers = await Entity.find(
+     *   'user',
+     *   { status: 'active', country: 'US' },
+     *   hotMeshClient
+     * );
+     *
+     * // Complex query with comparison operators
+     * const seniorUsers = await Entity.find(
+     *   'user',
+     *   {
+     *     age: { $gte: 65 },
+     *     status: 'active',
+     *     'preferences.notifications': true
+     *   },
+     *   hotMeshClient,
+     *   { limit: 10, offset: 0 }
+     * );
+     *
+     * // Query with multiple conditions and nested objects
+     * const premiumUsers = await Entity.find(
+     *   'user',
+     *   {
+     *     'subscription.type': 'premium',
+     *     'subscription.status': 'active',
+     *     'billing.amount': { $gt: 100 },
+     *     'profile.verified': true
+     *   },
+     *   hotMeshClient,
+     *   { limit: 20 }
+     * );
+     *
+     * // Array conditions
+     * const taggedPosts = await Entity.find(
+     *   'post',
+     *   {
+     *     'tags': { $in: ['typescript', 'javascript'] },
+     *     'status': 'published',
+     *     'views': { $gte: 1000 }
+     *   },
+     *   hotMeshClient
+     * );
+     * ```
+     */
+    static find(entity: string, conditions: Record<string, any>, hotMeshClient: HotMesh, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<any[]>;
+    /**
+     * Finds a specific entity record by its ID using direct JSONB/SQL queries.
+     * This is the most efficient method for retrieving a single entity record.
+     *
+     * @example
+     * ```typescript
+     * // Basic findById usage
+     * const user = await Entity.findById('user', 'user123', hotMeshClient);
+     *
+     * // Example with type checking
+     * interface User {
+     *   id: string;
+     *   name: string;
+     *   email: string;
+     *   preferences: {
+     *     theme: 'light' | 'dark';
+     *     notifications: boolean;
+     *   };
+     * }
+     *
+     * const typedUser = await Entity.findById<User>('user', 'user456', hotMeshClient);
+     * console.log(typedUser.preferences.theme); // 'light' | 'dark'
+     *
+     * // Error handling example
+     * try {
+     *   const order = await Entity.findById('order', 'order789', hotMeshClient);
+     *   if (!order) {
+     *     console.log('Order not found');
+     *     return;
+     *   }
+     *   console.log('Order details:', order);
+     * } catch (error) {
+     *   console.error('Error fetching order:', error);
+     * }
+     * ```
+     */
+    static findById(entity: string, id: string, hotMeshClient: HotMesh): Promise<any>;
+    /**
+     * Finds entity records matching a specific field condition using JSONB/SQL queries.
+     * Supports various operators for flexible querying across all entities of a type.
+     *
+     * @example
+     * ```typescript
+     * // Basic equality search
+     * const activeUsers = await Entity.findByCondition(
+     *   'user',
+     *   'status',
+     *   'active',
+     *   '=',
+     *   hotMeshClient,
+     *   { limit: 20 }
+     * );
+     *
+     * // Numeric comparison
+     * const highValueOrders = await Entity.findByCondition(
+     *   'order',
+     *   'total_amount',
+     *   1000,
+     *   '>=',
+     *   hotMeshClient
+     * );
+     *
+     * // Pattern matching with LIKE
+     * const gmailUsers = await Entity.findByCondition(
+     *   'user',
+     *   'email',
+     *   '%@gmail.com',
+     *   'LIKE',
+     *   hotMeshClient
+     * );
+     *
+     * // IN operator for multiple values
+     * const specificProducts = await Entity.findByCondition(
+     *   'product',
+     *   'category',
+     *   ['electronics', 'accessories'],
+     *   'IN',
+     *   hotMeshClient
+     * );
+     *
+     * // Not equals operator
+     * const nonPremiumUsers = await Entity.findByCondition(
+     *   'user',
+     *   'subscription_type',
+     *   'premium',
+     *   '!=',
+     *   hotMeshClient
+     * );
+     *
+     * // Date comparison
+     * const recentOrders = await Entity.findByCondition(
+     *   'order',
+     *   'created_at',
+     *   new Date('2024-01-01'),
+     *   '>',
+     *   hotMeshClient,
+     *   { limit: 50 }
+     * );
+     * ```
+     */
+    static findByCondition(entity: string, field: string, value: any, operator: '=' | '!=' | '>' | '<' | '>=' | '<=' | 'LIKE' | 'IN', hotMeshClient: HotMesh, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<any[]>;
+    /**
+     * Creates an efficient GIN index for a specific entity field to optimize queries.
+     *
+     * @example
+     * ```typescript
+     * await Entity.createIndex('user', 'email', hotMeshClient);
+     * await Entity.createIndex('user', 'status', hotMeshClient);
+     * ```
      */
-    private deepMerge;
+    static createIndex(entity: string, field: string, hotMeshClient: HotMesh, indexType?: 'gin'): Promise<void>;
 }