@aws-sdk/client-bedrock-runtime 3.859.0 → 3.862.0

package/dist-types/models/models_0.d.ts

@@ -601,6 +601,400 @@ export declare const GuardrailAction: {
  * @public
  */
 export type GuardrailAction = (typeof GuardrailAction)[keyof typeof GuardrailAction];
+/**
+ * <p>References a specific automated reasoning policy rule that was applied during evaluation.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningRule {
+    /**
+     * <p>The unique identifier of the automated reasoning rule.</p>
+     * @public
+     */
+    identifier?: string | undefined;
+    /**
+     * <p>The ARN of the automated reasoning policy version that contains this rule.</p>
+     * @public
+     */
+    policyVersionArn?: string | undefined;
+}
+/**
+ * <p>A logical statement that includes both formal logic representation and natural language explanation.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningStatement {
+    /**
+     * <p>The formal logical representation of the statement.</p>
+     * @public
+     */
+    logic?: string | undefined;
+    /**
+     * <p>The natural language explanation of the logical statement.</p>
+     * @public
+     */
+    naturalLanguage?: string | undefined;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const GuardrailAutomatedReasoningLogicWarningType: {
+    readonly ALWAYS_FALSE: "ALWAYS_FALSE";
+    readonly ALWAYS_TRUE: "ALWAYS_TRUE";
+};
+/**
+ * @public
+ */
+export type GuardrailAutomatedReasoningLogicWarningType = (typeof GuardrailAutomatedReasoningLogicWarningType)[keyof typeof GuardrailAutomatedReasoningLogicWarningType];
+/**
+ * <p>Identifies logical issues in the translated statements that exist independent of any policy rules, such as statements that are always true or always false.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningLogicWarning {
+    /**
+     * <p>The category of the detected logical issue, such as statements that are always true or always false.</p>
+     * @public
+     */
+    type?: GuardrailAutomatedReasoningLogicWarningType | undefined;
+    /**
+     * <p>The logical statements that serve as premises under which the claims are validated.</p>
+     * @public
+     */
+    premises?: GuardrailAutomatedReasoningStatement[] | undefined;
+    /**
+     * <p>The logical statements that are validated while assuming the policy and premises.</p>
+     * @public
+     */
+    claims?: GuardrailAutomatedReasoningStatement[] | undefined;
+}
+/**
+ * <p>References a portion of the original input text that corresponds to logical elements.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningInputTextReference {
+    /**
+     * <p>The specific text from the original input that this reference points to.</p>
+     * @public
+     */
+    text?: string | undefined;
+}
+/**
+ * <p>Contains the logical translation of natural language input into formal logical statements, including premises, claims, and confidence scores.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningTranslation {
+    /**
+     * <p>The logical statements that serve as the foundation or assumptions for the claims.</p>
+     * @public
+     */
+    premises?: GuardrailAutomatedReasoningStatement[] | undefined;
+    /**
+     * <p>The logical statements that are being validated against the premises and policy rules.</p>
+     * @public
+     */
+    claims?: GuardrailAutomatedReasoningStatement[] | undefined;
+    /**
+     * <p>References to portions of the original input text that correspond to the premises but could not be fully translated.</p>
+     * @public
+     */
+    untranslatedPremises?: GuardrailAutomatedReasoningInputTextReference[] | undefined;
+    /**
+     * <p>References to portions of the original input text that correspond to the claims but could not be fully translated.</p>
+     * @public
+     */
+    untranslatedClaims?: GuardrailAutomatedReasoningInputTextReference[] | undefined;
+    /**
+     * <p>A confidence score between 0 and 1 indicating how certain the system is about the logical translation.</p>
+     * @public
+     */
+    confidence?: number | undefined;
+}
+/**
+ * <p>Indicates that no valid claims can be made due to logical contradictions in the premises or rules.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningImpossibleFinding {
+    /**
+     * <p>The logical translation of the input that this finding evaluates.</p>
+     * @public
+     */
+    translation?: GuardrailAutomatedReasoningTranslation | undefined;
+    /**
+     * <p>The automated reasoning policy rules that contradict the claims and/or premises in the input.</p>
+     * @public
+     */
+    contradictingRules?: GuardrailAutomatedReasoningRule[] | undefined;
+    /**
+     * <p>Indication of a logic issue with the translation without needing to consider the automated reasoning policy rules.</p>
+     * @public
+     */
+    logicWarning?: GuardrailAutomatedReasoningLogicWarning | undefined;
+}
+/**
+ * <p>Indicates that the claims are logically false and contradictory to the established rules or premises.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningInvalidFinding {
+    /**
+     * <p>The logical translation of the input that this finding invalidates.</p>
+     * @public
+     */
+    translation?: GuardrailAutomatedReasoningTranslation | undefined;
+    /**
+     * <p>The automated reasoning policy rules that contradict the claims in the input.</p>
+     * @public
+     */
+    contradictingRules?: GuardrailAutomatedReasoningRule[] | undefined;
+    /**
+     * <p>Indication of a logic issue with the translation without needing to consider the automated reasoning policy rules.</p>
+     * @public
+     */
+    logicWarning?: GuardrailAutomatedReasoningLogicWarning | undefined;
+}
+/**
+ * <p>Indicates that no relevant logical information could be extracted from the input for validation.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningNoTranslationsFinding {
+}
+/**
+ * <p>Represents a logical scenario where claims can be evaluated as true or false, containing specific logical assignments.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningScenario {
+    /**
+     * <p>List of logical assignments and statements that define this scenario.</p>
+     * @public
+     */
+    statements?: GuardrailAutomatedReasoningStatement[] | undefined;
+}
+/**
+ * <p>Indicates that the claims could be either true or false depending on additional assumptions not provided in the input.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningSatisfiableFinding {
+    /**
+     * <p>The logical translation of the input that this finding evaluates.</p>
+     * @public
+     */
+    translation?: GuardrailAutomatedReasoningTranslation | undefined;
+    /**
+     * <p>An example scenario demonstrating how the claims could be logically true.</p>
+     * @public
+     */
+    claimsTrueScenario?: GuardrailAutomatedReasoningScenario | undefined;
+    /**
+     * <p>An example scenario demonstrating how the claims could be logically false.</p>
+     * @public
+     */
+    claimsFalseScenario?: GuardrailAutomatedReasoningScenario | undefined;
+    /**
+     * <p>Indication of a logic issue with the translation without needing to consider the automated reasoning policy rules.</p>
+     * @public
+     */
+    logicWarning?: GuardrailAutomatedReasoningLogicWarning | undefined;
+}
+/**
+ * <p>Indicates that the input exceeds the processing capacity due to the volume or complexity of the logical information.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningTooComplexFinding {
+}
+/**
+ * <p>Represents one possible logical interpretation of ambiguous input content.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningTranslationOption {
+    /**
+     * <p>Example translations that provide this possible interpretation of the input.</p>
+     * @public
+     */
+    translations?: GuardrailAutomatedReasoningTranslation[] | undefined;
+}
+/**
+ * <p>Indicates that the input has multiple valid logical interpretations, requiring additional context or clarification.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningTranslationAmbiguousFinding {
+    /**
+     * <p>Different logical interpretations that were detected during translation of the input.</p>
+     * @public
+     */
+    options?: GuardrailAutomatedReasoningTranslationOption[] | undefined;
+    /**
+     * <p>Scenarios showing how the different translation options differ in meaning.</p>
+     * @public
+     */
+    differenceScenarios?: GuardrailAutomatedReasoningScenario[] | undefined;
+}
+/**
+ * <p>Indicates that the claims are definitively true and logically implied by the premises, with no possible alternative interpretations.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningValidFinding {
+    /**
+     * <p>The logical translation of the input that this finding validates.</p>
+     * @public
+     */
+    translation?: GuardrailAutomatedReasoningTranslation | undefined;
+    /**
+     * <p>An example scenario demonstrating how the claims are logically true.</p>
+     * @public
+     */
+    claimsTrueScenario?: GuardrailAutomatedReasoningScenario | undefined;
+    /**
+     * <p>The automated reasoning policy rules that support why this result is considered valid.</p>
+     * @public
+     */
+    supportingRules?: GuardrailAutomatedReasoningRule[] | undefined;
+    /**
+     * <p>Indication of a logic issue with the translation without needing to consider the automated reasoning policy rules.</p>
+     * @public
+     */
+    logicWarning?: GuardrailAutomatedReasoningLogicWarning | undefined;
+}
+/**
+ * <p>Represents a logical validation result from automated reasoning policy evaluation. The finding indicates whether claims in the input are logically valid, invalid, satisfiable, impossible, or have other logical issues.</p>
+ * @public
+ */
+export type GuardrailAutomatedReasoningFinding = GuardrailAutomatedReasoningFinding.ImpossibleMember | GuardrailAutomatedReasoningFinding.InvalidMember | GuardrailAutomatedReasoningFinding.NoTranslationsMember | GuardrailAutomatedReasoningFinding.SatisfiableMember | GuardrailAutomatedReasoningFinding.TooComplexMember | GuardrailAutomatedReasoningFinding.TranslationAmbiguousMember | GuardrailAutomatedReasoningFinding.ValidMember | GuardrailAutomatedReasoningFinding.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace GuardrailAutomatedReasoningFinding {
+    /**
+     * <p>Indicates that the claims are definitively true and logically implied by the premises, with no possible alternative interpretations.</p>
+     * @public
+     */
+    interface ValidMember {
+        valid: GuardrailAutomatedReasoningValidFinding;
+        invalid?: never;
+        satisfiable?: never;
+        impossible?: never;
+        translationAmbiguous?: never;
+        tooComplex?: never;
+        noTranslations?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>Indicates that the claims are logically false and contradictory to the established rules or premises.</p>
+     * @public
+     */
+    interface InvalidMember {
+        valid?: never;
+        invalid: GuardrailAutomatedReasoningInvalidFinding;
+        satisfiable?: never;
+        impossible?: never;
+        translationAmbiguous?: never;
+        tooComplex?: never;
+        noTranslations?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>Indicates that the claims could be either true or false depending on additional assumptions not provided in the input.</p>
+     * @public
+     */
+    interface SatisfiableMember {
+        valid?: never;
+        invalid?: never;
+        satisfiable: GuardrailAutomatedReasoningSatisfiableFinding;
+        impossible?: never;
+        translationAmbiguous?: never;
+        tooComplex?: never;
+        noTranslations?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>Indicates that no valid claims can be made due to logical contradictions in the premises or rules.</p>
+     * @public
+     */
+    interface ImpossibleMember {
+        valid?: never;
+        invalid?: never;
+        satisfiable?: never;
+        impossible: GuardrailAutomatedReasoningImpossibleFinding;
+        translationAmbiguous?: never;
+        tooComplex?: never;
+        noTranslations?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>Indicates that the input has multiple valid logical interpretations, requiring additional context or clarification.</p>
+     * @public
+     */
+    interface TranslationAmbiguousMember {
+        valid?: never;
+        invalid?: never;
+        satisfiable?: never;
+        impossible?: never;
+        translationAmbiguous: GuardrailAutomatedReasoningTranslationAmbiguousFinding;
+        tooComplex?: never;
+        noTranslations?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>Indicates that the input exceeds the processing capacity due to the volume or complexity of the logical information.</p>
+     * @public
+     */
+    interface TooComplexMember {
+        valid?: never;
+        invalid?: never;
+        satisfiable?: never;
+        impossible?: never;
+        translationAmbiguous?: never;
+        tooComplex: GuardrailAutomatedReasoningTooComplexFinding;
+        noTranslations?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>Indicates that no relevant logical information could be extracted from the input for validation.</p>
+     * @public
+     */
+    interface NoTranslationsMember {
+        valid?: never;
+        invalid?: never;
+        satisfiable?: never;
+        impossible?: never;
+        translationAmbiguous?: never;
+        tooComplex?: never;
+        noTranslations: GuardrailAutomatedReasoningNoTranslationsFinding;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        valid?: never;
+        invalid?: never;
+        satisfiable?: never;
+        impossible?: never;
+        translationAmbiguous?: never;
+        tooComplex?: never;
+        noTranslations?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        valid: (value: GuardrailAutomatedReasoningValidFinding) => T;
+        invalid: (value: GuardrailAutomatedReasoningInvalidFinding) => T;
+        satisfiable: (value: GuardrailAutomatedReasoningSatisfiableFinding) => T;
+        impossible: (value: GuardrailAutomatedReasoningImpossibleFinding) => T;
+        translationAmbiguous: (value: GuardrailAutomatedReasoningTranslationAmbiguousFinding) => T;
+        tooComplex: (value: GuardrailAutomatedReasoningTooComplexFinding) => T;
+        noTranslations: (value: GuardrailAutomatedReasoningNoTranslationsFinding) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: GuardrailAutomatedReasoningFinding, visitor: Visitor<T>) => T;
+}
+/**
+ * <p>Contains the results of automated reasoning policy evaluation, including logical findings about the validity of claims made in the input content.</p>
+ * @public
+ */
+export interface GuardrailAutomatedReasoningPolicyAssessment {
+    /**
+     * <p>List of logical validation results produced by evaluating the input content against automated reasoning policies.</p>
+     * @public
+     */
+    findings?: GuardrailAutomatedReasoningFinding[] | undefined;
+}
 /**
  * @public
  * @enum
@@ -853,6 +1247,16 @@ export interface GuardrailUsage {
      * @public
      */
     contentPolicyImageUnits?: number | undefined;
+    /**
+     * <p>The number of text units processed by the automated reasoning policy.</p>
+     * @public
+     */
+    automatedReasoningPolicyUnits?: number | undefined;
+    /**
+     * <p>The number of automated reasoning policies that were processed during the guardrail evaluation.</p>
+     * @public
+     */
+    automatedReasoningPolicies?: number | undefined;
 }
 /**
  * <p>The invocation metrics for the guardrail.</p>
@@ -1178,6 +1582,11 @@ export interface GuardrailAssessment {
      * @public
      */
     contextualGroundingPolicy?: GuardrailContextualGroundingPolicyAssessment | undefined;
+    /**
+     * <p>The automated reasoning policy assessment results, including logical validation findings for the input content.</p>
+     * @public
+     */
+    automatedReasoningPolicy?: GuardrailAutomatedReasoningPolicyAssessment | undefined;
     /**
      * <p>The invocation metrics for the guardrail assessment.</p>
      * @public
@@ -4247,6 +4656,66 @@ export declare const GuardrailContentBlockFilterSensitiveLog: (obj: GuardrailCon
  * @internal
  */
 export declare const ApplyGuardrailRequestFilterSensitiveLog: (obj: ApplyGuardrailRequest) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAutomatedReasoningStatementFilterSensitiveLog: (obj: GuardrailAutomatedReasoningStatement) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAutomatedReasoningLogicWarningFilterSensitiveLog: (obj: GuardrailAutomatedReasoningLogicWarning) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAutomatedReasoningInputTextReferenceFilterSensitiveLog: (obj: GuardrailAutomatedReasoningInputTextReference) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAutomatedReasoningTranslationFilterSensitiveLog: (obj: GuardrailAutomatedReasoningTranslation) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAutomatedReasoningImpossibleFindingFilterSensitiveLog: (obj: GuardrailAutomatedReasoningImpossibleFinding) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAutomatedReasoningInvalidFindingFilterSensitiveLog: (obj: GuardrailAutomatedReasoningInvalidFinding) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAutomatedReasoningScenarioFilterSensitiveLog: (obj: GuardrailAutomatedReasoningScenario) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAutomatedReasoningSatisfiableFindingFilterSensitiveLog: (obj: GuardrailAutomatedReasoningSatisfiableFinding) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAutomatedReasoningTranslationOptionFilterSensitiveLog: (obj: GuardrailAutomatedReasoningTranslationOption) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAutomatedReasoningTranslationAmbiguousFindingFilterSensitiveLog: (obj: GuardrailAutomatedReasoningTranslationAmbiguousFinding) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAutomatedReasoningValidFindingFilterSensitiveLog: (obj: GuardrailAutomatedReasoningValidFinding) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAutomatedReasoningFindingFilterSensitiveLog: (obj: GuardrailAutomatedReasoningFinding) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAutomatedReasoningPolicyAssessmentFilterSensitiveLog: (obj: GuardrailAutomatedReasoningPolicyAssessment) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailAssessmentFilterSensitiveLog: (obj: GuardrailAssessment) => any;
+/**
+ * @internal
+ */
+export declare const ApplyGuardrailResponseFilterSensitiveLog: (obj: ApplyGuardrailResponse) => any;
 /**
  * @internal
  */
@@ -4287,6 +4756,14 @@ export declare const ConverseRequestFilterSensitiveLog: (obj: ConverseRequest) =
  * @internal
  */
 export declare const ConverseOutputFilterSensitiveLog: (obj: ConverseOutput) => any;
+/**
+ * @internal
+ */
+export declare const GuardrailTraceAssessmentFilterSensitiveLog: (obj: GuardrailTraceAssessment) => any;
+/**
+ * @internal
+ */
+export declare const ConverseTraceFilterSensitiveLog: (obj: ConverseTrace) => any;
 /**
  * @internal
  */
@@ -4307,6 +4784,14 @@ export declare const ContentBlockDeltaFilterSensitiveLog: (obj: ContentBlockDelt
  * @internal
  */
 export declare const ContentBlockDeltaEventFilterSensitiveLog: (obj: ContentBlockDeltaEvent) => any;
+/**
+ * @internal
+ */
+export declare const ConverseStreamTraceFilterSensitiveLog: (obj: ConverseStreamTrace) => any;
+/**
+ * @internal
+ */
+export declare const ConverseStreamMetadataEventFilterSensitiveLog: (obj: ConverseStreamMetadataEvent) => any;
 /**
  * @internal
  */