Enum AutomatedReasoningCheckFinding 

#[non_exhaustive]
pub enum AutomatedReasoningCheckFinding {
    Impossible(AutomatedReasoningCheckImpossibleFinding),
    Invalid(AutomatedReasoningCheckInvalidFinding),
    NoTranslations(AutomatedReasoningCheckNoTranslationsFinding),
    Satisfiable(AutomatedReasoningCheckSatisfiableFinding),
    TooComplex(AutomatedReasoningCheckTooComplexFinding),
    TranslationAmbiguous(AutomatedReasoningCheckTranslationAmbiguousFinding),
    Valid(AutomatedReasoningCheckValidFinding),
    #[non_exhaustive]
    Unknown,
}

Represents the result of an Automated Reasoning validation check, indicating whether the content is logically valid, invalid, or falls into other categories based on the policy rules.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Impossible(AutomatedReasoningCheckImpossibleFinding)

Indicates that Automated Reasoning cannot make a statement about the claims. This can happen if the premises are logically incorrect, or if there is a conflict within the Automated Reasoning policy itself.

Invalid(AutomatedReasoningCheckInvalidFinding)

Indicates that the claims are false. The claims are not implied by the premises and Automated Reasoning policy. Furthermore, there exist different claims that are consistent with the premises and Automated Reasoning policy.

NoTranslations(AutomatedReasoningCheckNoTranslationsFinding)

Identifies that some or all of the input prompt wasn't translated into logic. This can happen if the input isn't relevant to the Automated Reasoning policy, or if the policy doesn't have variables to model relevant input.

Satisfiable(AutomatedReasoningCheckSatisfiableFinding)

Indicates that the claims can be true or false. It depends on what assumptions are made for the claim to be implied from the premises and Automated Reasoning policy rules. In this situation, different assumptions can make input claims false and alternative claims true.

TooComplex(AutomatedReasoningCheckTooComplexFinding)

Indicates that the input contains too much information for Automated Reasoning to process within its latency limits.

TranslationAmbiguous(AutomatedReasoningCheckTranslationAmbiguousFinding)

Indicates that an ambiguity was detected in the translation, making it unsound to continue with validity checking. Additional context or follow-up questions might be needed to get translation to succeed.

Valid(AutomatedReasoningCheckValidFinding)

Indicates that the claims are true. The claims are implied by the premises and the Automated Reasoning policy. Given the Automated Reasoning policy and premises, it is not possible for these claims to be false.

#[non_exhaustive]

Unknown

The Unknown variant represents cases where new union variant was received. Consider upgrading the SDK to the latest available version. An unknown enum variant

Note: If you encounter this error, consider upgrading your SDK to the latest version. The Unknown variant represents cases where the server sent a value that wasn’t recognized by the client. This can happen when the server adds new functionality, but the client has not been updated. To investigate this, consider turning on debug logging to print the raw HTTP response.

Implementations

impl AutomatedReasoningCheckFinding

pub fn as_impossible( &self, ) -> Result<&AutomatedReasoningCheckImpossibleFinding, &Self>

Tries to convert the enum instance into Impossible, extracting the inner AutomatedReasoningCheckImpossibleFinding. Returns Err(&Self) if it can’t be converted.

pub fn is_impossible(&self) -> bool

Returns true if this is a Impossible.

pub fn as_invalid( &self, ) -> Result<&AutomatedReasoningCheckInvalidFinding, &Self>

Tries to convert the enum instance into Invalid, extracting the inner AutomatedReasoningCheckInvalidFinding. Returns Err(&Self) if it can’t be converted.

pub fn is_invalid(&self) -> bool

Returns true if this is a Invalid.

pub fn as_no_translations( &self, ) -> Result<&AutomatedReasoningCheckNoTranslationsFinding, &Self>

Tries to convert the enum instance into NoTranslations, extracting the inner AutomatedReasoningCheckNoTranslationsFinding. Returns Err(&Self) if it can’t be converted.

pub fn is_no_translations(&self) -> bool

Returns true if this is a NoTranslations.

pub fn as_satisfiable( &self, ) -> Result<&AutomatedReasoningCheckSatisfiableFinding, &Self>

Tries to convert the enum instance into Satisfiable, extracting the inner AutomatedReasoningCheckSatisfiableFinding. Returns Err(&Self) if it can’t be converted.

pub fn is_satisfiable(&self) -> bool

Returns true if this is a Satisfiable.

pub fn as_too_complex( &self, ) -> Result<&AutomatedReasoningCheckTooComplexFinding, &Self>

Tries to convert the enum instance into TooComplex, extracting the inner AutomatedReasoningCheckTooComplexFinding. Returns Err(&Self) if it can’t be converted.

pub fn is_too_complex(&self) -> bool

Returns true if this is a TooComplex.

pub fn as_translation_ambiguous( &self, ) -> Result<&AutomatedReasoningCheckTranslationAmbiguousFinding, &Self>

Tries to convert the enum instance into TranslationAmbiguous, extracting the inner AutomatedReasoningCheckTranslationAmbiguousFinding. Returns Err(&Self) if it can’t be converted.

pub fn is_translation_ambiguous(&self) -> bool

Returns true if this is a TranslationAmbiguous.

pub fn as_valid(&self) -> Result<&AutomatedReasoningCheckValidFinding, &Self>

Tries to convert the enum instance into Valid, extracting the inner AutomatedReasoningCheckValidFinding. Returns Err(&Self) if it can’t be converted.

pub fn is_valid(&self) -> bool

Returns true if this is a Valid.

pub fn is_unknown(&self) -> bool

Returns true if the enum instance is the Unknown variant.

Trait Implementations

impl Clone for AutomatedReasoningCheckFinding

fn clone(&self) -> AutomatedReasoningCheckFinding

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AutomatedReasoningCheckFinding

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

Formats the value using the given formatter.

impl PartialEq for AutomatedReasoningCheckFinding

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for AutomatedReasoningCheckFinding