/**
 * Pattern-swap compatibility — the deterministic shape gate for a contextual
 * pattern swap. A swap keeps the circuit closed when the replacement shares the
 * current pattern's entity-inlet cardinality and can emit the events the
 * consumer's trait listens for. Semantic ranking (which compatible pattern best
 * matches the user's instruction) is the embedding step, layered on top of this
 * gate — never the other way around.
 */
/** The data-inlet cardinality of a pattern (`record`/`collection`), or `null`
 *  when the pattern has no entity inlet (layout / leaf patterns). */
export declare function getEntityCardinality(patternType: string): 'record' | 'collection' | null;
/** Events a pattern emits, from its declared event-outlet contract. */
export declare function getEmittedEvents(patternType: string): string[];
export interface PatternSwapGate {
    /** Events the replacement MUST be able to emit (the trait's listened set), so
     *  handlers still fire after the swap. Omit to skip the outlet gate. */
    requiredEmits?: readonly string[];
}
/**
 * Pattern types a `currentType` node can be swapped to while keeping the circuit
 * closed: same entity-inlet cardinality, and — when `requiredEmits` is given —
 * able to emit every required event. Deterministic and unranked; the caller
 * ranks the result semantically (embeddings).
 */
export declare function findCompatiblePatterns(currentType: string, gate?: PatternSwapGate): string[];
