mcp-event-intelligence 0.4.0 → 0.6.0

package/dist/src/intelligenceProtocol/triggerSchemas.js

@@ -1,18 +1,37 @@
 import { z } from 'zod';
 import { RuntimeTargetSchema } from './schemas.js';
-export const COMPOSITE_TRIGGER_PROTOCOL_VERSION = '0.1.0';
-export const COMPOSITE_TRIGGER_SCHEMA_VERSION = 'trigger.v0.1';
+import { PatternAstV2DefinitionSchema, PatternMeasureSchema, collectPatternDurationsMs, collectGuaranteedPatternBindings, collectPatternMeasureRefs, collectPatternRefs, } from './patternV2Schemas.js';
+export const COMPOSITE_TRIGGER_PROTOCOL_VERSION = '0.2.0';
+export const COMPOSITE_TRIGGER_SCHEMA_VERSION = 'trigger.v0.2';
 const Id = z.string().min(1).max(200);
 const Timestamp = z.string().datetime({ offset: true });
 const Scalar = z.union([z.string(), z.number(), z.boolean()]);
-const ClockTime = z.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/);
-const CalendarDate = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
 export const StructuredPredicateSchema = z.discriminatedUnion('op', [
     z.object({ path: z.string().min(1), op: z.literal('eq'), value: Scalar }),
     z.object({ path: z.string().min(1), op: z.literal('neq'), value: Scalar }),
     z.object({ path: z.string().min(1), op: z.literal('contains'), value: Scalar }),
+    z.object({ path: z.string().min(1), op: z.literal('startsWith'), value: z.string() }),
+    z.object({ path: z.string().min(1), op: z.literal('endsWith'), value: z.string() }),
+    z.object({
+        path: z.string().min(1),
+        op: z.literal('regex'),
+        value: z.string(),
+        flags: z.string().max(10).optional(),
+    }),
     z.object({ path: z.string().min(1), op: z.literal('in'), value: z.array(Scalar).min(1) }),
+    z.object({ path: z.string().min(1), op: z.literal('notIn'), value: z.array(Scalar).min(1) }),
+    z.object({
+        path: z.string().min(1),
+        op: z.literal('between'),
+        value: z.tuple([Scalar, Scalar]),
+    }),
     z.object({ path: z.string().min(1), op: z.literal('exists'), value: z.boolean().default(true) }),
+    z.object({ path: z.string().min(1), op: z.literal('isNull'), value: z.boolean().default(true) }),
+    z.object({
+        path: z.string().min(1),
+        op: z.literal('type'),
+        value: z.enum(['string', 'number', 'boolean', 'null', 'object', 'array']),
+    }),
     z.object({ path: z.string().min(1), op: z.literal('gt'), value: z.number() }),
     z.object({ path: z.string().min(1), op: z.literal('gte'), value: z.number() }),
     z.object({ path: z.string().min(1), op: z.literal('lt'), value: z.number() }),
@@ -26,83 +45,6 @@ export const TriggerClauseSchema = z.object({
     arguments: z.record(z.string(), z.unknown()).default({}),
     where: z.array(StructuredPredicateSchema).default([]),
 });
-const TriggerExpressionSchema = z.discriminatedUnion('kind', [
-    z.object({ kind: z.literal('allOf'), refs: z.array(Id).min(2) }),
-    z.object({ kind: z.literal('anyOf'), refs: z.array(Id).min(1) }),
-    z.object({ kind: z.literal('sequence'), refs: z.array(Id).min(2) }),
-    z.object({ kind: z.literal('count'), ref: Id, atLeast: z.number().int().min(1) }),
-]);
-export const CalendarTemporalConditionSchema = z.object({
-    id: Id,
-    kind: z.literal('calendar'),
-    ref: Id,
-    timezone: z.string().min(1),
-    before: ClockTime.optional(),
-    after: ClockTime.optional(),
-    weekdays: z.array(z.number().int().min(1).max(7)).min(1).optional(),
-    dates: z.array(CalendarDate).min(1).optional(),
-    dateRange: z.object({
-        start: CalendarDate,
-        end: CalendarDate,
-    }).optional(),
-    dayOfMonth: z.array(z.number().int().min(1).max(31)).min(1).optional(),
-}).strict();
-export const AbsenceTemporalConditionSchema = z.object({
-    id: Id,
-    kind: z.literal('absence'),
-    ref: Id,
-    afterRef: Id,
-    forMs: z.number().int().positive().optional(),
-    untilLocalTime: ClockTime.optional(),
-    timezone: z.string().min(1).optional(),
-}).superRefine((value, ctx) => {
-    if (!value.forMs && !value.untilLocalTime) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'absence requires forMs or untilLocalTime',
-        });
-    }
-    if (value.untilLocalTime && !value.timezone) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'absence untilLocalTime requires timezone',
-        });
-    }
-});
-export const TemporalConditionSchema = z.discriminatedUnion('kind', [
-    CalendarTemporalConditionSchema,
-    AbsenceTemporalConditionSchema,
-    z.object({ id: Id, kind: z.literal('not'), ref: Id }),
-    z.object({ id: Id, kind: z.literal('unless'), ref: Id }),
-    z.object({ id: Id, kind: z.literal('after'), ref: Id, afterRef: Id }),
-    z.object({ id: Id, kind: z.literal('until'), ref: Id, beforeRef: Id }),
-    z.object({
-        id: Id,
-        kind: z.literal('debounce'),
-        ref: Id,
-        forMs: z.number().int().positive(),
-    }),
-    z.object({
-        id: Id,
-        kind: z.literal('threshold'),
-        ref: Id,
-        atLeast: z.number().int().min(1),
-    }),
-    z.object({
-        id: Id,
-        kind: z.literal('rate'),
-        ref: Id,
-        atLeast: z.number().int().min(1),
-        perMs: z.number().int().positive(),
-    }),
-    z.object({
-        id: Id,
-        kind: z.literal('distinct'),
-        ref: Id,
-        path: z.string().min(1),
-        atLeast: z.number().int().min(1),
-    }),
-]);
 export const DerivedEventProjectionSchema = z.object({
     key: z.string().regex(/^[A-Za-z_][A-Za-z0-9_-]{0,63}$/),
     ref: Id,
@@ -113,6 +55,7 @@ export const DerivedEventDefinitionSchema = z.object({
     contractVersion: z.string().min(1).max(50),
     projections: z.array(DerivedEventProjectionSchema).max(32).default([]),
     constants: z.record(z.string(), Scalar).default({}),
+    measures: z.array(PatternMeasureSchema).max(32).default([]),
 }).strict();
 export const DerivedEventEvidenceRefSchema = z.object({
     serverId: Id.nullable(),
@@ -120,10 +63,15 @@ export const DerivedEventEvidenceRefSchema = z.object({
     sourceEventId: Id,
     traceId: Id,
     occurredAt: Timestamp,
+    receivedAt: Timestamp.optional(),
     payloadHash: z.string().regex(/^[a-f0-9]{64}$/).nullable(),
     contractVersion: z.string().min(1).nullable().optional(),
     schemaFingerprint: z.string().regex(/^[a-f0-9]{64}$/).nullable().optional(),
 }).strict();
+export const EventTimePolicySchema = z.object({
+    allowedLatenessMs: z.number().int().nonnegative()
+        .max(1000 * 60 * 60 * 24 * 30),
+}).strict();
 export const TriggerLifecyclePolicySchema = z.object({
     oneShot: z.boolean().default(false),
     maxFirings: z.number().int().min(1).optional(),
@@ -160,20 +108,6 @@ export const ContinuationContractSchema = z.object({
         includeData: true,
     }),
 }).strict();
-export const DeterministicCorrelationSchema = z.object({
-    kind: z.literal('same_value'),
-    fields: z.array(z.object({
-        ref: Id,
-        path: z.string().min(1),
-    })).min(2),
-});
-export const SemanticCorrelationSchema = z.object({
-    instruction: z.string().min(1),
-    input: z.array(z.string().min(1)).min(1),
-    matchThreshold: z.number().min(0).max(1),
-    rejectThreshold: z.number().min(0).max(1),
-    uncertain: z.enum(['escalate', 'reject', 'match']).default('escalate'),
-});
 export const CompositeTriggerDefinitionSchema = z.object({
     protocolVersion: z.literal(COMPOSITE_TRIGGER_PROTOCOL_VERSION)
         .default(COMPOSITE_TRIGGER_PROTOCOL_VERSION),
@@ -182,27 +116,41 @@ export const CompositeTriggerDefinitionSchema = z.object({
     triggerId: Id,
     version: z.string().min(1),
     description: z.string().max(500).optional(),
+    conditionOnly: z.boolean().default(false),
     continuation: ContinuationContractSchema.optional(),
     clauses: z.array(TriggerClauseSchema).min(1),
-    expression: TriggerExpressionSchema,
-    temporal: z.array(TemporalConditionSchema).default([]),
+    pattern: PatternAstV2DefinitionSchema,
+    eventTime: EventTimePolicySchema.optional(),
     lifecycle: TriggerLifecyclePolicySchema.default({
         oneShot: false,
         cooldownMs: 0,
         completeOnGoal: false,
     }),
     withinMs: z.number().int().positive().max(1000 * 60 * 60 * 24 * 30),
-    correlation: z.object({
-        deterministic: DeterministicCorrelationSchema.optional(),
-        semantic: SemanticCorrelationSchema.optional(),
-    }).optional(),
     target: RuntimeTargetSchema.optional(),
     derivedEvent: DerivedEventDefinitionSchema.optional(),
 }).superRefine((value, ctx) => {
-    if (!value.target && !value.derivedEvent) {
+    if (!value.target && !value.derivedEvent && !value.conditionOnly) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Trigger requires target, derivedEvent, or conditionOnly=true',
+        });
+    }
+    if (value.conditionOnly &&
+        (value.target || value.derivedEvent || value.continuation)) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'conditionOnly triggers cannot declare target, derivedEvent, or continuation',
+        });
+    }
+    if (value.conditionOnly &&
+        (value.lifecycle.oneShot ||
+            value.lifecycle.maxFirings !== undefined ||
+            value.lifecycle.cooldownMs > 0 ||
+            value.lifecycle.completeOnGoal)) {
         ctx.addIssue({
             code: 'custom',
-            message: 'Trigger requires target, derivedEvent, or both',
+            message: 'conditionOnly triggers cannot use effect-based lifecycle fields',
         });
     }
     if (value.continuation && !value.target) {
@@ -215,27 +163,38 @@ export const CompositeTriggerDefinitionSchema = z.object({
     if (ids.size !== value.clauses.length) {
         ctx.addIssue({ code: 'custom', message: 'Trigger clause ids must be unique' });
     }
-    const refs = value.expression.kind === 'count'
-        ? [value.expression.ref]
-        : value.expression.refs;
-    for (const ref of refs) {
-        if (!ids.has(ref)) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `Expression references unknown clause: ${ref}`,
-            });
-        }
-    }
-    for (const field of value.correlation?.deterministic?.fields ?? []) {
-        if (!ids.has(field.ref)) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `Correlation references unknown clause: ${field.ref}`,
-            });
-        }
-    }
     if (value.derivedEvent) {
         const projectionKeys = new Set();
+        const measureKeys = new Set();
+        for (const measure of value.derivedEvent.measures ?? []) {
+            if (measure.key === '_derived') {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: 'Derived event measure key _derived is reserved',
+                });
+            }
+            if (measureKeys.has(measure.key)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Derived event measure key must be unique: ${measure.key}`,
+                });
+            }
+            if (Object.prototype.hasOwnProperty.call(value.derivedEvent.constants, measure.key)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Derived event key cannot be both constant and measure: ${measure.key}`,
+                });
+            }
+            for (const ref of collectPatternMeasureRefs(measure)) {
+                if (!ids.has(ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Derived event measure ${measure.key} references unknown clause: ${ref}`,
+                    });
+                }
+            }
+            measureKeys.add(measure.key);
+        }
         for (const projection of value.derivedEvent.projections) {
             if (!ids.has(projection.ref)) {
                 ctx.addIssue({
@@ -243,6 +202,12 @@ export const CompositeTriggerDefinitionSchema = z.object({
                     message: `Derived event projection references unknown clause: ${projection.ref}`,
                 });
             }
+            if (measureKeys.has(projection.key)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `Derived event key cannot be both measure and projection: ${projection.key}`,
+                });
+            }
             if (projectionKeys.has(projection.key)) {
                 ctx.addIssue({
                     code: 'custom',
@@ -270,61 +235,68 @@ export const CompositeTriggerDefinitionSchema = z.object({
             });
         }
     }
-    const conditionIds = new Set();
-    for (const condition of value.temporal) {
-        if (conditionIds.has(condition.id)) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `Temporal condition id must be unique: ${condition.id}`,
-            });
-        }
-        conditionIds.add(condition.id);
-        const conditionRefs = [];
-        if ('ref' in condition)
-            conditionRefs.push(condition.ref);
-        if ('afterRef' in condition)
-            conditionRefs.push(condition.afterRef);
-        if ('beforeRef' in condition)
-            conditionRefs.push(condition.beforeRef);
-        for (const ref of conditionRefs) {
+    {
+        const patternRefs = collectPatternRefs(value.pattern.root);
+        for (const ref of patternRefs) {
             if (!ids.has(ref)) {
                 ctx.addIssue({
                     code: 'custom',
-                    message: `Temporal condition ${condition.id} references unknown clause: ${ref}`,
+                    message: `Pattern AST references unknown clause: ${ref}`,
                 });
             }
         }
-        if (condition.kind === 'calendar') {
-            try {
-                new Intl.DateTimeFormat('en-US', { timeZone: condition.timezone });
-            }
-            catch {
-                ctx.addIssue({
-                    code: 'custom',
-                    message: `Invalid IANA timezone: ${condition.timezone}`,
-                });
+        for (const dimension of value.pattern.partitionBy) {
+            const dimensionRefs = new Set();
+            for (const field of dimension.fields) {
+                if (!ids.has(field.ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Pattern partition ${dimension.key} references unknown clause: ${field.ref}`,
+                    });
+                }
+                if (dimensionRefs.has(field.ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Pattern partition ${dimension.key} has duplicate field mapping for ${field.ref}`,
+                    });
+                }
+                dimensionRefs.add(field.ref);
             }
-            if (condition.before &&
-                condition.after &&
-                condition.before === condition.after) {
-                ctx.addIssue({
-                    code: 'custom',
-                    message: 'calendar before and after cannot be identical',
-                });
+            for (const ref of patternRefs) {
+                if (!dimensionRefs.has(ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Pattern partition ${dimension.key} does not map pattern ref: ${ref}`,
+                    });
+                }
             }
         }
-        if (condition.kind === 'absence' &&
-            condition.timezone) {
-            try {
-                new Intl.DateTimeFormat('en-US', { timeZone: condition.timezone });
-            }
-            catch {
-                ctx.addIssue({
-                    code: 'custom',
-                    message: `Invalid IANA timezone: ${condition.timezone}`,
-                });
+        const guaranteedPatternRefs = collectGuaranteedPatternBindings(value.pattern.root);
+        if (typeof value.pattern.selection.afterMatch === 'object' &&
+            !guaranteedPatternRefs.includes(value.pattern.selection.afterMatch.ref)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Pattern afterMatch ref is not guaranteed by every match: ${value.pattern.selection.afterMatch.ref}`,
+            });
+        }
+        for (const measure of value.derivedEvent?.measures ?? []) {
+            for (const ref of collectPatternMeasureRefs(measure)) {
+                if (!guaranteedPatternRefs.includes(ref)) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: `Derived measure ${measure.key} references non-guaranteed pattern ref: ${ref}`,
+                    });
+                }
             }
         }
+        const oversized = collectPatternDurationsMs(value.pattern.root)
+            .filter((duration) => duration > value.withinMs);
+        if (oversized.length) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Pattern AST duration exceeds trigger withinMs: ${Math.max(...oversized)} > ${value.withinMs}`,
+            });
+        }
     }
 });
 export const CorrelatableEventSchema = z.object({
@@ -332,6 +304,7 @@ export const CorrelatableEventSchema = z.object({
     sourceEventId: Id,
     name: z.string().min(1),
     occurredAt: Timestamp,
+    receivedAt: Timestamp.optional(),
     provider: z.string().min(1).optional(),
     serverId: Id.optional(),
     subscriptionArguments: z.record(z.string(), z.unknown()).default({}),
@@ -353,13 +326,14 @@ export const TriggerSourceEventSchema = z.object({
     sourceEventId: Id,
     eventName: z.string().min(1),
     occurredAt: Timestamp,
+    receivedAt: Timestamp.optional(),
     provider: z.string().min(1).optional(),
     serverId: Id.optional(),
     subscriptionArguments: z.record(z.string(), z.unknown()).default({}),
     payloadHash: z.string().regex(/^[a-f0-9]{64}$/).optional(),
     data: z.record(z.string(), z.unknown()),
 });
-export const CompositeCorrelationDecisionSchema = z.object({
+export const PatternSemanticDecisionSchema = z.object({
     evaluator: z.string().min(1),
     outcome: z.enum(['match', 'reject', 'uncertain']),
     probability: z.number().min(0).max(1),
@@ -376,6 +350,17 @@ export const TriggerMatchStatusSchema = z.enum([
     'fired',
     'expired',
 ]);
+export const PatternMatchStateSchema = z.object({
+    version: z.literal('2'),
+    role: z.enum(['buffer', 'match']),
+    signature: z.string().min(1).optional(),
+    maxObservedOccurredAt: Timestamp.optional(),
+    completedAt: Timestamp.optional(),
+    semanticDecisions: z.array(z.object({
+        nodeId: Id,
+        decision: PatternSemanticDecisionSchema,
+    }).strict()).default([]),
+}).strict();
 export const TriggerMatchRecordSchema = z.object({
     protocolVersion: z.literal(COMPOSITE_TRIGGER_PROTOCOL_VERSION),
     schemaVersion: z.literal(COMPOSITE_TRIGGER_SCHEMA_VERSION),
@@ -383,12 +368,13 @@ export const TriggerMatchRecordSchema = z.object({
     triggerId: Id,
     triggerVersion: z.string().min(1),
     status: TriggerMatchStatusSchema,
-    correlationKey: z.string().nullable(),
+    partitionKey: z.string().nullable(),
     openedAt: Timestamp,
     expiresAt: Timestamp,
     updatedAt: Timestamp,
     sourceEvents: z.array(TriggerSourceEventSchema),
-    correlationDecision: CompositeCorrelationDecisionSchema.nullable(),
+    semanticDecision: PatternSemanticDecisionSchema.nullable(),
+    patternState: PatternMatchStateSchema.optional(),
     firedWakeId: Id.nullable(),
     derivedEventIds: z.array(Id).default([]),
 });

package/dist/src/intelligenceProtocol/version.d.ts

@@ -1,6 +1,6 @@
 export declare const EVENT_INTELLIGENCE_PROTOCOL: "mcp-event-intelligence";
-export declare const EVENT_INTELLIGENCE_PROTOCOL_VERSION: "0.1.0";
-export declare const EVENT_INTELLIGENCE_SCHEMA_VERSION: "ei.v0.1";
+export declare const EVENT_INTELLIGENCE_PROTOCOL_VERSION: "0.2.0";
+export declare const EVENT_INTELLIGENCE_SCHEMA_VERSION: "ei.v0.2";
 export declare const EVENT_INTELLIGENCE_COMPATIBILITY: {
     readonly mcpEvents: "experimental-ext-triggers-events/design-sketch";
     readonly mcpCore: "2026-07-28";

package/dist/src/intelligenceProtocol/version.js

@@ -1,6 +1,6 @@
 export const EVENT_INTELLIGENCE_PROTOCOL = 'mcp-event-intelligence';
-export const EVENT_INTELLIGENCE_PROTOCOL_VERSION = '0.1.0';
-export const EVENT_INTELLIGENCE_SCHEMA_VERSION = 'ei.v0.1';
+export const EVENT_INTELLIGENCE_PROTOCOL_VERSION = '0.2.0';
+export const EVENT_INTELLIGENCE_SCHEMA_VERSION = 'ei.v0.2';
 export const EVENT_INTELLIGENCE_COMPATIBILITY = {
     mcpEvents: 'experimental-ext-triggers-events/design-sketch',
     mcpCore: '2026-07-28',

package/dist/src/mcpEvents/consumer.d.ts

@@ -5,4 +5,5 @@ export declare function mcpOccurrenceToCorrelatableEvent(event: EventOccurrence,
     provider?: string;
     serverId?: string;
     subscriptionArguments?: Record<string, unknown>;
+    receivedAt?: string;
 }): Promise<CorrelatableEvent>;

package/dist/src/mcpEvents/consumer.js

@@ -6,6 +6,7 @@ export async function mcpOccurrenceToCorrelatableEvent(event, input) {
         sourceEventId: event.eventId,
         name: event.name,
         occurredAt: event.timestamp,
+        ...(input.receivedAt ? { receivedAt: input.receivedAt } : {}),
         ...(input.provider ? { provider: input.provider } : {}),
         ...(input.serverId ? { serverId: input.serverId } : {}),
         subscriptionArguments: input.subscriptionArguments ?? {},

package/dist/src/patternV2/evaluator.d.ts

@@ -0,0 +1,51 @@
+import type { SemanticDecision, SemanticEvaluator } from '../semantic/types.js';
+import type { TriggerSourceEvent } from '../intelligenceProtocol/triggerSchemas.js';
+import type { PatternAstV2Definition, PatternMeasure } from '../intelligenceProtocol/patternV2Schemas.js';
+export interface PatternV2SemanticDecision {
+    nodeId: string;
+    decision: SemanticDecision;
+}
+export interface PatternV2Candidate {
+    bindings: Record<string, TriggerSourceEvent[]>;
+    events: TriggerSourceEvent[];
+    startIndex: number;
+    endIndex: number;
+    pendingUntil?: string;
+    semanticDecisions: PatternV2SemanticDecision[];
+}
+export interface PatternV2SemanticTrace {
+    nodeId: string;
+    candidateSignature: string;
+    decision: SemanticDecision;
+}
+export interface PatternV2SemanticCache {
+    get(key: string): Promise<SemanticDecision | null> | SemanticDecision | null;
+    set(key: string, decision: SemanticDecision): Promise<void> | void;
+}
+export interface PatternV2Evaluation {
+    matches: PatternV2Candidate[];
+    pending: PatternV2Candidate[];
+    semanticEvaluations: number;
+    semanticCacheHits: number;
+    semanticCacheMisses: number;
+    semanticTrace: PatternV2SemanticTrace[];
+    truncated: boolean;
+}
+export declare function evaluatePatternAggregate(candidate: PatternV2Candidate, input: {
+    function: 'sum' | 'avg' | 'min' | 'max' | 'count' | 'countDistinct' | 'first' | 'last' | 'nth' | 'stddev' | 'percentile';
+    ref: string;
+    path?: string;
+    nth?: number;
+    percentile?: number;
+}): unknown;
+export declare function evaluatePatternMeasure(candidate: PatternV2Candidate, measure: PatternMeasure): unknown;
+export declare function evaluatePatternV2({ definition, events, evaluator, now, allowedLatenessMs, semanticCache, semanticCacheNamespace, }: {
+    definition: PatternAstV2Definition;
+    events: TriggerSourceEvent[];
+    evaluator?: SemanticEvaluator | null;
+    now?: Date;
+    allowedLatenessMs?: number;
+    semanticCache?: PatternV2SemanticCache | null;
+    semanticCacheNamespace?: string;
+}): Promise<PatternV2Evaluation>;
+export declare function patternV2CandidateSignature(candidate: PatternV2Candidate): string;