/** * True when `guardCondition` is guaranteed to hold whenever `consumerCondition` does, so a step * gated by `guardCondition` cannot be skipped on any execution path that reaches a step gated by * `consumerCondition`. Each of the guard's top-level `&&` clauses must either be one of the * consumer's own clauses, or — when the guard clause is itself a `(a || b)` group — the consumer * must require one of that group's alternatives. That second case is what a shared trailing gate * ANDed onto an OR of per-consumer clauses produces: `(A || B) && G` guarding two steps gated * `A && G` and `B && G` respectively — the shape a shared secret takes when it backs two * differently-gated consumer steps in the same job. * * Clauses alone aren't enough: a guard with the implicit `success()`/default status restriction is * skipped on any path where an earlier step already failed, so it cannot protect a consumer gated * `always()` or `failure()` that still runs on that same path. `other` (e.g. `failure()`, * `cancelled()`) is rejected outright as a guard status — this check can't reason about whether the * guard and consumer agree on which failure path they run on, and a false "safe" verdict is the real * risk (see file header). An `always()` guard has no restriction, so it entails any consumer status. * Either side being `ambiguous` (an unparenthesized `&&`/`||` mix — see `hasTopLevelMixedOperators`) * rejects entailment outright, since its clauses can't be trusted to reflect real precedence. */ export declare function conditionEntails(guardCondition: string, consumerCondition: string): boolean;