@hotmeshio/hotmesh 0.21.1 → 0.22.1

package/build/services/store/providers/postgres/kvtables.js

@@ -166,65 +166,6 @@ const KVTables = (context) => ({
         ON ${jobsTable} (key) WHERE is_live;
       `);
         }
-        // v0.21.0: signal queue table for first-class HITL escalation primitives
-        const sigTable = `${schemaName}.hotmesh_signals`;
-        const { rows: sigRows } = await client.query(`SELECT to_regclass('${sigTable}') AS tbl`);
-        if (!sigRows[0].tbl) {
-            await client.query(`
-        CREATE TABLE IF NOT EXISTS ${sigTable} (
-          id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-          namespace       TEXT NOT NULL,
-          app_id          TEXT NOT NULL,
-          signal_key      TEXT NOT NULL,
-          workflow_id     TEXT NOT NULL,
-          job_id          TEXT,
-          topic           TEXT,
-          status          TEXT NOT NULL DEFAULT 'pending',
-          role            TEXT,
-          type            TEXT,
-          subtype         TEXT,
-          priority        INT  NOT NULL DEFAULT 5,
-          description     TEXT,
-          task_queue      TEXT,
-          workflow_type   TEXT,
-          assigned_to     TEXT,
-          claimed_at      TIMESTAMPTZ,
-          claim_expires_at TIMESTAMPTZ,
-          resolved_at     TIMESTAMPTZ,
-          resolver_payload JSONB,
-          envelope        JSONB,
-          metadata        JSONB,
-          expires_at      TIMESTAMPTZ,
-          created_at      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-          updated_at      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-          UNIQUE(namespace, app_id, signal_key)
-        );
-      `);
-            await client.query(`
-        CREATE INDEX IF NOT EXISTS idx_hmsig_namespace_status
-          ON ${sigTable}(namespace, app_id, status);
-      `);
-            await client.query(`
-        CREATE INDEX IF NOT EXISTS idx_hmsig_signal_key
-          ON ${sigTable}(namespace, app_id, signal_key);
-      `);
-            await client.query(`
-        CREATE INDEX IF NOT EXISTS idx_hmsig_role_status
-          ON ${sigTable}(namespace, app_id, role, status);
-      `);
-            await client.query(`
-        CREATE INDEX IF NOT EXISTS idx_hmsig_task_queue
-          ON ${sigTable}(namespace, app_id, task_queue, status);
-      `);
-            await client.query(`
-        CREATE INDEX IF NOT EXISTS idx_hmsig_metadata_gin
-          ON ${sigTable} USING GIN(metadata);
-      `);
-            await client.query(`
-        CREATE INDEX IF NOT EXISTS idx_hmsig_claim_expiry
-          ON ${sigTable}(claim_expires_at) WHERE status = 'claimed';
-      `);
-        }
     },
     async createTables(client, appName) {
         try {
@@ -259,6 +200,87 @@ const KVTables = (context) => ({
                 deployed_at TIMESTAMPTZ DEFAULT NOW(),
                 PRIMARY KEY (app_id, version)
               );
+            `);
+                        await client.query(`
+              CREATE TABLE IF NOT EXISTS public.hmsh_escalations (
+                id               UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+                namespace        TEXT NOT NULL,
+                app_id           TEXT NOT NULL,
+                signal_key       TEXT,
+                topic            TEXT,
+                workflow_id      TEXT,
+                task_queue       TEXT,
+                workflow_type    TEXT,
+                type             TEXT,
+                subtype          TEXT,
+                entity           TEXT,
+                description      TEXT,
+                role             TEXT,
+                status           TEXT NOT NULL DEFAULT 'pending',
+                priority         INT  NOT NULL DEFAULT 5,
+                assigned_to      TEXT,
+                assigned_until   TIMESTAMPTZ,
+                claimed_at       TIMESTAMPTZ,
+                claim_expires_at TIMESTAMPTZ,
+                resolved_at      TIMESTAMPTZ,
+                escalation_payload JSONB,
+                resolver_payload   JSONB,
+                envelope           JSONB,
+                metadata           JSONB,
+                origin_id          TEXT,
+                parent_id          TEXT,
+                initiated_by       TEXT,
+                created_by         TEXT,
+                milestones         JSONB NOT NULL DEFAULT '[]',
+                trace_id           TEXT,
+                span_id            TEXT,
+                expires_at         TIMESTAMPTZ,
+                created_at         TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+                updated_at         TIMESTAMPTZ NOT NULL DEFAULT NOW()
+              );
+            `);
+                        await client.query(`
+              CREATE UNIQUE INDEX IF NOT EXISTS idx_hmsh_esc_signal_key
+                ON public.hmsh_escalations(namespace, app_id, signal_key)
+                WHERE signal_key IS NOT NULL;
+            `);
+                        await client.query(`
+              CREATE INDEX IF NOT EXISTS idx_hmsh_esc_available
+                ON public.hmsh_escalations(namespace, app_id, role, priority ASC, created_at ASC)
+                WHERE status = 'pending';
+            `);
+                        await client.query(`
+              CREATE INDEX IF NOT EXISTS idx_hmsh_esc_available_expiry
+                ON public.hmsh_escalations(namespace, app_id, role, assigned_until, created_at DESC);
+            `);
+                        await client.query(`
+              CREATE INDEX IF NOT EXISTS idx_hmsh_esc_assigned
+                ON public.hmsh_escalations(assigned_to, assigned_until, created_at DESC)
+                WHERE status = 'claimed' AND assigned_to IS NOT NULL;
+            `);
+                        await client.query(`
+              CREATE INDEX IF NOT EXISTS idx_hmsh_esc_claim_expiry
+                ON public.hmsh_escalations(claim_expires_at)
+                WHERE status = 'claimed';
+            `);
+                        await client.query(`
+              CREATE INDEX IF NOT EXISTS idx_hmsh_esc_entity
+                ON public.hmsh_escalations(namespace, app_id, entity, created_at DESC)
+                WHERE entity IS NOT NULL;
+            `);
+                        await client.query(`
+              CREATE INDEX IF NOT EXISTS idx_hmsh_esc_workflow
+                ON public.hmsh_escalations(workflow_id)
+                WHERE workflow_id IS NOT NULL;
+            `);
+                        await client.query(`
+              CREATE INDEX IF NOT EXISTS idx_hmsh_esc_origin
+                ON public.hmsh_escalations(origin_id)
+                WHERE origin_id IS NOT NULL;
+            `);
+                        await client.query(`
+              CREATE INDEX IF NOT EXISTS idx_hmsh_esc_metadata
+                ON public.hmsh_escalations USING GIN(metadata jsonb_path_ops);
             `);
                         break;
                     case 'relational_connection':
@@ -320,6 +342,8 @@ const KVTables = (context) => ({
                 id UUID DEFAULT gen_random_uuid(),
                 key TEXT NOT NULL,
                 entity TEXT,
+                origin_id TEXT,
+                parent_id TEXT,
                 status INTEGER NOT NULL,
                 context JSONB DEFAULT '{}',
                 created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
@@ -535,64 +559,6 @@ const KVTables = (context) => ({
               ON ${fullTableName} (key, score, member);
             `);
                         break;
-                    case 'signal_queue': {
-                        const tbl = fullTableName;
-                        await client.query(`
-              CREATE TABLE IF NOT EXISTS ${tbl} (
-                id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-                namespace       TEXT NOT NULL,
-                app_id          TEXT NOT NULL,
-                signal_key      TEXT NOT NULL,
-                workflow_id     TEXT NOT NULL,
-                job_id          TEXT,
-                topic           TEXT,
-                status          TEXT NOT NULL DEFAULT 'pending',
-                role            TEXT,
-                type            TEXT,
-                subtype         TEXT,
-                priority        INT  NOT NULL DEFAULT 5,
-                description     TEXT,
-                task_queue      TEXT,
-                workflow_type   TEXT,
-                assigned_to     TEXT,
-                claimed_at      TIMESTAMPTZ,
-                claim_expires_at TIMESTAMPTZ,
-                resolved_at     TIMESTAMPTZ,
-                resolver_payload JSONB,
-                envelope        JSONB,
-                metadata        JSONB,
-                expires_at      TIMESTAMPTZ,
-                created_at      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-                updated_at      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-                UNIQUE(namespace, app_id, signal_key)
-              );
-            `);
-                        await client.query(`
-              CREATE INDEX IF NOT EXISTS idx_hmsig_namespace_status
-                ON ${tbl}(namespace, app_id, status);
-            `);
-                        await client.query(`
-              CREATE INDEX IF NOT EXISTS idx_hmsig_signal_key
-                ON ${tbl}(namespace, app_id, signal_key);
-            `);
-                        await client.query(`
-              CREATE INDEX IF NOT EXISTS idx_hmsig_role_status
-                ON ${tbl}(namespace, app_id, role, status);
-            `);
-                        await client.query(`
-              CREATE INDEX IF NOT EXISTS idx_hmsig_task_queue
-                ON ${tbl}(namespace, app_id, task_queue, status);
-            `);
-                        await client.query(`
-              CREATE INDEX IF NOT EXISTS idx_hmsig_metadata_gin
-                ON ${tbl} USING GIN(metadata);
-            `);
-                        await client.query(`
-              CREATE INDEX IF NOT EXISTS idx_hmsig_claim_expiry
-                ON ${tbl}(claim_expires_at) WHERE status = 'claimed';
-            `);
-                        break;
-                    }
                     default:
                         context.logger.warn(`Unknown table type for ${tableDef.name}`);
                         break;
@@ -710,11 +676,6 @@ const KVTables = (context) => ({
                 name: 'signal_registry',
                 type: 'string',
             },
-            {
-                schema: schemaName,
-                name: 'hotmesh_signals',
-                type: 'signal_queue',
-            },
         ];
         return tableDefinitions;
     },

package/build/services/store/providers/postgres/kvtypes/hash/basic.d.ts

@@ -1,6 +1,6 @@
 import { HashContext, SqlResult, HSetOptions, ProviderTransaction } from './types';
 export declare function createBasicOperations(context: HashContext['context']): {
-    hsetnx(key: string, field: string, value: string, multi?: ProviderTransaction, entity?: string): Promise<number>;
+    hsetnx(key: string, field: string, value: string, multi?: ProviderTransaction, entity?: string, originId?: string, parentId?: string): Promise<number>;
     hset(key: string, fields: Record<string, string>, options?: HSetOptions, multi?: ProviderTransaction): Promise<number | any>;
     hget(key: string, field: string, multi?: ProviderTransaction): Promise<string | null>;
     hdel(key: string, fields: string[], multi?: unknown): Promise<number>;

package/build/services/store/providers/postgres/kvtypes/hash/basic.js

@@ -4,8 +4,8 @@ exports._setStatusAndCollateGuid = exports._collateLeg2Entry = exports._hincrbyf
 const utils_1 = require("./utils");
 function createBasicOperations(context) {
     return {
-        async hsetnx(key, field, value, multi, entity) {
-            const { sql, params } = _hset(context, key, { [field]: value }, { nx: true, entity });
+        async hsetnx(key, field, value, multi, entity, originId, parentId) {
+            const { sql, params } = _hset(context, key, { [field]: value }, { nx: true, entity, originId, parentId });
             if (multi) {
                 multi.addCommand(sql, params, 'number');
                 return Promise.resolve(0);
@@ -281,25 +281,25 @@ function _hset(context, key, fields, options) {
         if (options?.nx) {
             // Use WHERE NOT EXISTS to enforce nx
             sql = `
-        INSERT INTO ${targetTable} (id, key, status, entity)
-        SELECT gen_random_uuid(), $1, $2, $3
+        INSERT INTO ${targetTable} (id, key, status, entity, origin_id, parent_id)
+        SELECT gen_random_uuid(), $1, $2, $3, $4, $5
         WHERE NOT EXISTS (
           SELECT 1 FROM ${targetTable}
           WHERE key = $1 AND is_live
         )
         RETURNING 1 as count
       `;
-            params.push(key, fields[':'], options?.entity ?? null);
+            params.push(key, fields[':'], options?.entity ?? null, options?.originId ?? null, options?.parentId ?? null);
         }
         else {
             // Update existing job or insert new one
             sql = `
-        INSERT INTO ${targetTable} (id, key, status, entity)
-        VALUES (gen_random_uuid(), $1, $2, $3)
+        INSERT INTO ${targetTable} (id, key, status, entity, origin_id, parent_id)
+        VALUES (gen_random_uuid(), $1, $2, $3, $4, $5)
         ON CONFLICT (key) WHERE is_live DO UPDATE SET status = EXCLUDED.status
         RETURNING 1 as count
       `;
-            params.push(key, fields[':'], options?.entity ?? null);
+            params.push(key, fields[':'], options?.entity ?? null, options?.originId ?? null, options?.parentId ?? null);
         }
     }
     else if (isJobsTableResult) {

package/build/services/store/providers/postgres/kvtypes/hash/index.d.ts

@@ -20,7 +20,7 @@ export declare const hashModule: (context: KVSQL) => {
         cursor: number;
         keys: string[];
     }>;
-    hsetnx(key: string, field: string, value: string, multi?: import("./types").ProviderTransaction, entity?: string): Promise<number>;
+    hsetnx(key: string, field: string, value: string, multi?: import("./types").ProviderTransaction, entity?: string, originId?: string, parentId?: string): Promise<number>;
     hget(key: string, field: string, multi?: import("./types").ProviderTransaction): Promise<string>;
     hdel(key: string, fields: string[], multi?: unknown): Promise<number>;
     hmget(key: string, fields: string[], multi?: import("./types").ProviderTransaction): Promise<string[]>;

package/build/services/store/providers/postgres/postgres.d.ts

@@ -11,7 +11,6 @@ import { Transitions } from '../../../../types/transition';
 import { JobInterruptOptions } from '../../../../types/job';
 import { WorkListTaskType } from '../../../../types/task';
 import { ThrottleOptions } from '../../../../types/quorum';
-import { SignalQueueEntry } from '../../../../types/signal';
 import { StoreService } from '../..';
 import { PostgresClientType } from '../../../../types';
 import { KVSQL } from './kvsql';
@@ -105,7 +104,7 @@ declare class PostgresStoreService extends StoreService<ProviderClient, Provider
      * `purposeful re-entry`.
      */
     collateSynthetic(jobId: string, guid: string, amount: number, transaction?: ProviderTransaction): Promise<number>;
-    setStateNX(jobId: string, appId: string, status?: number, entity?: string, transaction?: ProviderTransaction): Promise<boolean>;
+    setStateNX(jobId: string, appId: string, status?: number, entity?: string, transaction?: ProviderTransaction, originId?: string, parentId?: string): Promise<boolean>;
     getSchema(activityId: string, appVersion: AppVID): Promise<ActivityType>;
     getSchemas(appVersion: AppVID): Promise<Record<string, ActivityType>>;
     setSchemas(schemas: Record<string, ActivityType>, appVersion: AppVID): Promise<any>;
@@ -223,198 +222,62 @@ declare class PostgresStoreService extends StoreService<ProviderClient, Provider
         activity?: string;
         types?: string[];
     }): Promise<import('../../../../types/exporter').StreamHistoryEntry[]>;
-    private signalQueueTable;
-    private rowToSignalEntry;
-    enqueueSignal(params: {
-        namespace: string;
-        appId: string;
-        signalKey: string;
-        workflowId: string;
-        jobId?: string;
+    /**
+     * Parse a HotMesh-encoded value string.
+     * Values may be prefixed with `/s` (JSON), `/d` (number), `/t` or `/f` (boolean), `/n` (null).
+     */
+    private parseHmshValue;
+    private _escalationInsertSql;
+    private _escalationInsertParams;
+    createEscalation(params: import('../../../../types/hmsh_escalations').CreateEscalationParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry>;
+    /**
+     * Enqueues the escalation INSERT into an existing Leg1 transaction so the row
+     * is written atomically with the job state checkpoint. On conflict
+     * (ON CONFLICT DO NOTHING) the command is a no-op, making it safe for
+     * idempotent re-runs after a crash.
+     */
+    addEscalationToTransaction(params: import('../../../../types/hmsh_escalations').CreateEscalationParams, transaction: import('../../../../types/provider').ProviderTransaction): void;
+    /**
+     * Full-fidelity INSERT for data migration. Preserves the original `id` (UUID),
+     * lifecycle state, and timestamps from the source table. Uses
+     * `ON CONFLICT (id) DO NOTHING` so re-running a migration batch is safe —
+     * rows that already exist are skipped and `null` is returned for them.
+     */
+    createEscalationForMigration(params: import('../../../../types/hmsh_escalations').MigrateEscalationParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
+    getEscalation(id: string, namespace?: string): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
+    getEscalationBySignalKey(signalKey: string, namespace?: string): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
+    listEscalations(params?: import('../../../../types/hmsh_escalations').ListEscalationsParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry[]>;
+    claimEscalation(params: import('../../../../types/hmsh_escalations').ClaimEscalationParams): Promise<import('../../../../types/hmsh_escalations').ClaimEscalationResult>;
+    claimEscalationByMetadata(params: import('../../../../types/hmsh_escalations').ClaimByMetadataParams): Promise<import('../../../../types/hmsh_escalations').ClaimByMetadataResult>;
+    releaseEscalation(params: import('../../../../types/hmsh_escalations').ReleaseEscalationParams): Promise<import('../../../../types/hmsh_escalations').ReleaseEscalationResult>;
+    resolveEscalation(params: import('../../../../types/hmsh_escalations').ResolveEscalationParams): Promise<import('../../../../types/hmsh_escalations').ResolveEscalationResult & {
+        signalKey?: string;
         topic?: string;
-        role?: string;
-        type?: string;
-        subtype?: string;
-        priority?: number;
-        description?: string;
-        taskQueue?: string;
-        workflowType?: string;
-        assignedTo?: string;
-        metadata?: Record<string, unknown>;
-        envelope?: Record<string, unknown>;
-        expiresAt?: Date;
-    }): Promise<{
-        id: string;
-    } | null>;
-    claimSignal(params: {
-        namespace: string;
-        appId: string;
-        id: string;
-        assignee?: string;
-        durationMinutes?: number;
-    }): Promise<{
-        ok: true;
-        entry: SignalQueueEntry;
-    } | {
-        ok: false;
-        reason: 'not-found' | 'conflict';
     }>;
-    claimSignalByMetadata(params: {
-        namespace: string;
-        appId: string;
-        key: string;
-        value: unknown;
-        assignee?: string;
-        durationMinutes?: number;
-    }): Promise<{
-        ok: true;
-        entry: SignalQueueEntry;
-    } | {
-        ok: false;
-        reason: 'not-found' | 'conflict';
-    }>;
-    releaseSignal(params: {
-        namespace: string;
-        appId: string;
-        id: string;
-    }): Promise<{
-        ok: true;
-    } | {
-        ok: false;
-        reason: 'not-found' | 'wrong-status';
+    resolveEscalationByMetadata(params: import('../../../../types/hmsh_escalations').ResolveByMetadataParams): Promise<import('../../../../types/hmsh_escalations').ResolveEscalationResult & {
+        signalKey?: string;
+        topic?: string;
     }>;
-    resolveSignal(params: {
-        namespace: string;
-        appId: string;
+    /**
+     * Queues the escalation UPDATE into an existing transaction without executing it.
+     * Used by client.ts resolve() to commit the status change atomically with signal delivery.
+     */
+    queueResolveEscalation(params: {
         id: string;
+        namespace?: string;
         resolverPayload?: Record<string, unknown>;
-    }): Promise<{
-        ok: true;
-        signalKey: string;
-        topic: string;
-    } | {
-        ok: false;
-        reason: 'not-found' | 'already-resolved';
-    }>;
-    resolveSignalByMetadata(params: {
-        namespace: string;
-        appId: string;
-        key: string;
-        value: unknown;
-        resolverPayload?: Record<string, unknown>;
-    }): Promise<{
-        ok: true;
-        signalKey: string;
-        topic: string;
-    } | {
-        ok: false;
-        reason: 'not-found';
-    }>;
-    releaseExpiredSignals(params: {
-        namespace: string;
-        appId: string;
-    }): Promise<number>;
-    listSignals(params: {
-        namespace: string;
-        appId: string;
-        status?: string;
-        role?: string;
-        taskQueue?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<{
-        id: string;
-        namespace: string;
-        appId: string;
-        signalKey: string;
-        workflowId: string;
-        jobId: string;
-        topic: string;
-        status: "pending" | "claimed" | "resolved" | "expired" | "released";
-        role: string;
-        type: string;
-        subtype: string;
-        priority: number;
-        description: string;
-        taskQueue: string;
-        workflowType: string;
-        assignedTo: string;
-        claimedAt: Date;
-        claimExpiresAt: Date;
-        resolvedAt: Date;
-        resolverPayload: Record<string, unknown>;
-        envelope: Record<string, unknown>;
-        metadata: Record<string, unknown>;
-        expiresAt: Date;
-        createdAt: Date;
-        updatedAt: Date;
-    }[]>;
-    getSignal(params: {
-        namespace: string;
-        appId: string;
-        id: string;
-    }): Promise<{
-        id: string;
-        namespace: string;
-        appId: string;
-        signalKey: string;
-        workflowId: string;
-        jobId: string;
-        topic: string;
-        status: "pending" | "claimed" | "resolved" | "expired" | "released";
-        role: string;
-        type: string;
-        subtype: string;
-        priority: number;
-        description: string;
-        taskQueue: string;
-        workflowType: string;
-        assignedTo: string;
-        claimedAt: Date;
-        claimExpiresAt: Date;
-        resolvedAt: Date;
-        resolverPayload: Record<string, unknown>;
-        envelope: Record<string, unknown>;
-        metadata: Record<string, unknown>;
-        expiresAt: Date;
-        createdAt: Date;
-        updatedAt: Date;
-    }>;
-    getSignalBySignalKey(params: {
-        namespace: string;
-        appId: string;
-        signalKey: string;
-    }): Promise<{
-        id: string;
-        namespace: string;
-        appId: string;
-        signalKey: string;
-        workflowId: string;
-        jobId: string;
-        topic: string;
-        status: "pending" | "claimed" | "resolved" | "expired" | "released";
-        role: string;
-        type: string;
-        subtype: string;
-        priority: number;
-        description: string;
-        taskQueue: string;
-        workflowType: string;
-        assignedTo: string;
-        claimedAt: Date;
-        claimExpiresAt: Date;
-        resolvedAt: Date;
-        resolverPayload: Record<string, unknown>;
-        envelope: Record<string, unknown>;
-        metadata: Record<string, unknown>;
-        expiresAt: Date;
-        createdAt: Date;
-        updatedAt: Date;
-    }>;
+    }, transaction: {
+        addCommand: (sql: string, params: any[], returnType: string) => any;
+    }): void;
     /**
-     * Parse a HotMesh-encoded value string.
-     * Values may be prefixed with `/s` (JSON), `/d` (number), `/t` or `/f` (boolean), `/n` (null).
+     * Finds the highest-priority pending or claimed escalation matching the given metadata filter.
+     * Used by client.ts resolveByMetadata() to get routing info before building the atomic transaction.
      */
-    private parseHmshValue;
+    findEscalationByMetadata(key: string, value: string, roles: string[] | null, namespace?: string): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
+    cancelEscalation(id: string, namespace?: string): Promise<import('../../../../types/hmsh_escalations').CancelEscalationResult>;
+    escalateEscalationToRole(params: import('../../../../types/hmsh_escalations').EscalateToRoleParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
+    updateEscalation(params: import('../../../../types/hmsh_escalations').UpdateEscalationParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
+    appendEscalationMilestones(params: import('../../../../types/hmsh_escalations').AppendMilestonesParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
+    releaseExpiredEscalations(namespace?: string): Promise<number>;
 }
 export { PostgresStoreService };