Struct InteractionRequirement 

pub struct InteractionRequirement {
    pub key: String,
    pub kind: InteractionKind,
    pub blocking: bool,
    pub revision_independent: bool,
    pub text_resolution: TextResolutionPolicy,
    pub confirms_risk: RiskClass,
    pub expires_in: Option<Duration>,
    pub payload: Option<InteractionPayload>,
}

What a user-owned phase requires from the user (I6).

The requirement is data; the workflow turns it into a full InteractionSpec through WorkflowDefinition::build_interaction, where it can consult state. When the projection can already describe the whole card, it may set payload and rely on the default implementation.

Fields

key: String

Stable key per phase (e.g. "send_confirmation").

kind: InteractionKind

Shape of the interaction.

blocking: bool

Whether it owns unqualified answers for the case (I5).

revision_independent: bool

Whether a revision change leaves it valid.

text_resolution: TextResolutionPolicy

Whether typed text may resolve it.

confirms_risk: RiskClass

Highest risk class an answer to this card authorizes. Conservative by default, so a requirement that forgets it cannot be resolved from text.

expires_in: Option<Duration>

Time to live.

payload: Option<InteractionPayload>

Full payload when the projection can describe it.

Implementations

impl InteractionRequirement

pub fn blocking(key: impl Into<String>, kind: InteractionKind) -> Self

A blocking, revision-bound requirement with Never text resolution.

pub fn non_blocking(key: impl Into<String>, kind: InteractionKind) -> Self

A non-blocking requirement: a card the case offers without owning the answers to everything else.

The flag existed and could not be set, which made every declared card blocking whether or not the question wanted one. A blocking card owns unqualified answers for the whole case (I5), so putting one beside a question whose ordinary answer is a value leaves the user reading buttons that cannot say what they came to say.

The other half of that problem is answered by the claim the act declares, which lets the refusal be spoken instead of pressed. This is the smaller lever, kept because a field nobody can write is not a field.

pub fn with_confirms_risk(self, risk: RiskClass) -> Self

Declares the highest risk class an answer authorizes. Lowering it is what makes a card resolvable from typed text (spec §15.7).

pub fn with_payload(self, payload: InteractionPayload) -> Self

Attaches a full payload.

pub fn with_text_resolution(self, policy: TextResolutionPolicy) -> Self

Sets the text resolution policy.

pub fn to_spec(&self, case_ref: CaseRef) -> InteractionSpec

Builds a spec for case_ref, using payload or a title-only payload named after the key.

A title-only payload is answerable for no kind, so a requirement without a payload must be completed by WorkflowDefinition::build_interaction; the spec is validated there.

Trait Implementations

impl Clone for InteractionRequirement

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InteractionRequirement

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InteractionRequirement

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for InteractionRequirement

impl PartialEq for InteractionRequirement

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for InteractionRequirement

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for InteractionRequirement