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

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

@@ -241,6 +241,185 @@ export declare const GuardrailAction: {
 };
 export type GuardrailAction =
   (typeof GuardrailAction)[keyof typeof GuardrailAction];
+export interface GuardrailAutomatedReasoningRule {
+  identifier?: string | undefined;
+  policyVersionArn?: string | undefined;
+}
+export interface GuardrailAutomatedReasoningStatement {
+  logic?: string | undefined;
+  naturalLanguage?: string | undefined;
+}
+export declare const GuardrailAutomatedReasoningLogicWarningType: {
+  readonly ALWAYS_FALSE: "ALWAYS_FALSE";
+  readonly ALWAYS_TRUE: "ALWAYS_TRUE";
+};
+export type GuardrailAutomatedReasoningLogicWarningType =
+  (typeof GuardrailAutomatedReasoningLogicWarningType)[keyof typeof GuardrailAutomatedReasoningLogicWarningType];
+export interface GuardrailAutomatedReasoningLogicWarning {
+  type?: GuardrailAutomatedReasoningLogicWarningType | undefined;
+  premises?: GuardrailAutomatedReasoningStatement[] | undefined;
+  claims?: GuardrailAutomatedReasoningStatement[] | undefined;
+}
+export interface GuardrailAutomatedReasoningInputTextReference {
+  text?: string | undefined;
+}
+export interface GuardrailAutomatedReasoningTranslation {
+  premises?: GuardrailAutomatedReasoningStatement[] | undefined;
+  claims?: GuardrailAutomatedReasoningStatement[] | undefined;
+  untranslatedPremises?:
+    | GuardrailAutomatedReasoningInputTextReference[]
+    | undefined;
+  untranslatedClaims?:
+    | GuardrailAutomatedReasoningInputTextReference[]
+    | undefined;
+  confidence?: number | undefined;
+}
+export interface GuardrailAutomatedReasoningImpossibleFinding {
+  translation?: GuardrailAutomatedReasoningTranslation | undefined;
+  contradictingRules?: GuardrailAutomatedReasoningRule[] | undefined;
+  logicWarning?: GuardrailAutomatedReasoningLogicWarning | undefined;
+}
+export interface GuardrailAutomatedReasoningInvalidFinding {
+  translation?: GuardrailAutomatedReasoningTranslation | undefined;
+  contradictingRules?: GuardrailAutomatedReasoningRule[] | undefined;
+  logicWarning?: GuardrailAutomatedReasoningLogicWarning | undefined;
+}
+export interface GuardrailAutomatedReasoningNoTranslationsFinding {}
+export interface GuardrailAutomatedReasoningScenario {
+  statements?: GuardrailAutomatedReasoningStatement[] | undefined;
+}
+export interface GuardrailAutomatedReasoningSatisfiableFinding {
+  translation?: GuardrailAutomatedReasoningTranslation | undefined;
+  claimsTrueScenario?: GuardrailAutomatedReasoningScenario | undefined;
+  claimsFalseScenario?: GuardrailAutomatedReasoningScenario | undefined;
+  logicWarning?: GuardrailAutomatedReasoningLogicWarning | undefined;
+}
+export interface GuardrailAutomatedReasoningTooComplexFinding {}
+export interface GuardrailAutomatedReasoningTranslationOption {
+  translations?: GuardrailAutomatedReasoningTranslation[] | undefined;
+}
+export interface GuardrailAutomatedReasoningTranslationAmbiguousFinding {
+  options?: GuardrailAutomatedReasoningTranslationOption[] | undefined;
+  differenceScenarios?: GuardrailAutomatedReasoningScenario[] | undefined;
+}
+export interface GuardrailAutomatedReasoningValidFinding {
+  translation?: GuardrailAutomatedReasoningTranslation | undefined;
+  claimsTrueScenario?: GuardrailAutomatedReasoningScenario | undefined;
+  supportingRules?: GuardrailAutomatedReasoningRule[] | undefined;
+  logicWarning?: GuardrailAutomatedReasoningLogicWarning | undefined;
+}
+export type GuardrailAutomatedReasoningFinding =
+  | GuardrailAutomatedReasoningFinding.ImpossibleMember
+  | GuardrailAutomatedReasoningFinding.InvalidMember
+  | GuardrailAutomatedReasoningFinding.NoTranslationsMember
+  | GuardrailAutomatedReasoningFinding.SatisfiableMember
+  | GuardrailAutomatedReasoningFinding.TooComplexMember
+  | GuardrailAutomatedReasoningFinding.TranslationAmbiguousMember
+  | GuardrailAutomatedReasoningFinding.ValidMember
+  | GuardrailAutomatedReasoningFinding.$UnknownMember;
+export declare namespace GuardrailAutomatedReasoningFinding {
+  interface ValidMember {
+    valid: GuardrailAutomatedReasoningValidFinding;
+    invalid?: never;
+    satisfiable?: never;
+    impossible?: never;
+    translationAmbiguous?: never;
+    tooComplex?: never;
+    noTranslations?: never;
+    $unknown?: never;
+  }
+  interface InvalidMember {
+    valid?: never;
+    invalid: GuardrailAutomatedReasoningInvalidFinding;
+    satisfiable?: never;
+    impossible?: never;
+    translationAmbiguous?: never;
+    tooComplex?: never;
+    noTranslations?: never;
+    $unknown?: never;
+  }
+  interface SatisfiableMember {
+    valid?: never;
+    invalid?: never;
+    satisfiable: GuardrailAutomatedReasoningSatisfiableFinding;
+    impossible?: never;
+    translationAmbiguous?: never;
+    tooComplex?: never;
+    noTranslations?: never;
+    $unknown?: never;
+  }
+  interface ImpossibleMember {
+    valid?: never;
+    invalid?: never;
+    satisfiable?: never;
+    impossible: GuardrailAutomatedReasoningImpossibleFinding;
+    translationAmbiguous?: never;
+    tooComplex?: never;
+    noTranslations?: never;
+    $unknown?: never;
+  }
+  interface TranslationAmbiguousMember {
+    valid?: never;
+    invalid?: never;
+    satisfiable?: never;
+    impossible?: never;
+    translationAmbiguous: GuardrailAutomatedReasoningTranslationAmbiguousFinding;
+    tooComplex?: never;
+    noTranslations?: never;
+    $unknown?: never;
+  }
+  interface TooComplexMember {
+    valid?: never;
+    invalid?: never;
+    satisfiable?: never;
+    impossible?: never;
+    translationAmbiguous?: never;
+    tooComplex: GuardrailAutomatedReasoningTooComplexFinding;
+    noTranslations?: never;
+    $unknown?: never;
+  }
+  interface NoTranslationsMember {
+    valid?: never;
+    invalid?: never;
+    satisfiable?: never;
+    impossible?: never;
+    translationAmbiguous?: never;
+    tooComplex?: never;
+    noTranslations: GuardrailAutomatedReasoningNoTranslationsFinding;
+    $unknown?: never;
+  }
+  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;
+}
+export interface GuardrailAutomatedReasoningPolicyAssessment {
+  findings?: GuardrailAutomatedReasoningFinding[] | undefined;
+}
 export declare const GuardrailContentPolicyAction: {
   readonly BLOCKED: "BLOCKED";
   readonly NONE: "NONE";
@@ -325,6 +504,8 @@ export interface GuardrailUsage {
   sensitiveInformationPolicyFreeUnits: number | undefined;
   contextualGroundingPolicyUnits: number | undefined;
   contentPolicyImageUnits?: number | undefined;
+  automatedReasoningPolicyUnits?: number | undefined;
+  automatedReasoningPolicies?: number | undefined;
 }
 export interface GuardrailInvocationMetrics {
   guardrailProcessingLatency?: number | undefined;
@@ -446,6 +627,9 @@ export interface GuardrailAssessment {
   contextualGroundingPolicy?:
     | GuardrailContextualGroundingPolicyAssessment
     | undefined;
+  automatedReasoningPolicy?:
+    | GuardrailAutomatedReasoningPolicyAssessment
+    | undefined;
   invocationMetrics?: GuardrailInvocationMetrics | undefined;
 }
 export interface GuardrailOutputContent {
@@ -2076,6 +2260,51 @@ export declare const GuardrailContentBlockFilterSensitiveLog: (
 export declare const ApplyGuardrailRequestFilterSensitiveLog: (
   obj: ApplyGuardrailRequest
 ) => any;
+export declare const GuardrailAutomatedReasoningStatementFilterSensitiveLog: (
+  obj: GuardrailAutomatedReasoningStatement
+) => any;
+export declare const GuardrailAutomatedReasoningLogicWarningFilterSensitiveLog: (
+  obj: GuardrailAutomatedReasoningLogicWarning
+) => any;
+export declare const GuardrailAutomatedReasoningInputTextReferenceFilterSensitiveLog: (
+  obj: GuardrailAutomatedReasoningInputTextReference
+) => any;
+export declare const GuardrailAutomatedReasoningTranslationFilterSensitiveLog: (
+  obj: GuardrailAutomatedReasoningTranslation
+) => any;
+export declare const GuardrailAutomatedReasoningImpossibleFindingFilterSensitiveLog: (
+  obj: GuardrailAutomatedReasoningImpossibleFinding
+) => any;
+export declare const GuardrailAutomatedReasoningInvalidFindingFilterSensitiveLog: (
+  obj: GuardrailAutomatedReasoningInvalidFinding
+) => any;
+export declare const GuardrailAutomatedReasoningScenarioFilterSensitiveLog: (
+  obj: GuardrailAutomatedReasoningScenario
+) => any;
+export declare const GuardrailAutomatedReasoningSatisfiableFindingFilterSensitiveLog: (
+  obj: GuardrailAutomatedReasoningSatisfiableFinding
+) => any;
+export declare const GuardrailAutomatedReasoningTranslationOptionFilterSensitiveLog: (
+  obj: GuardrailAutomatedReasoningTranslationOption
+) => any;
+export declare const GuardrailAutomatedReasoningTranslationAmbiguousFindingFilterSensitiveLog: (
+  obj: GuardrailAutomatedReasoningTranslationAmbiguousFinding
+) => any;
+export declare const GuardrailAutomatedReasoningValidFindingFilterSensitiveLog: (
+  obj: GuardrailAutomatedReasoningValidFinding
+) => any;
+export declare const GuardrailAutomatedReasoningFindingFilterSensitiveLog: (
+  obj: GuardrailAutomatedReasoningFinding
+) => any;
+export declare const GuardrailAutomatedReasoningPolicyAssessmentFilterSensitiveLog: (
+  obj: GuardrailAutomatedReasoningPolicyAssessment
+) => any;
+export declare const GuardrailAssessmentFilterSensitiveLog: (
+  obj: GuardrailAssessment
+) => any;
+export declare const ApplyGuardrailResponseFilterSensitiveLog: (
+  obj: ApplyGuardrailResponse
+) => any;
 export declare const GuardrailConverseImageSourceFilterSensitiveLog: (
   obj: GuardrailConverseImageSource
 ) => any;
@@ -2102,6 +2331,12 @@ export declare const ConverseRequestFilterSensitiveLog: (
 export declare const ConverseOutputFilterSensitiveLog: (
   obj: ConverseOutput
 ) => any;
+export declare const GuardrailTraceAssessmentFilterSensitiveLog: (
+  obj: GuardrailTraceAssessment
+) => any;
+export declare const ConverseTraceFilterSensitiveLog: (
+  obj: ConverseTrace
+) => any;
 export declare const ConverseResponseFilterSensitiveLog: (
   obj: ConverseResponse
 ) => any;
@@ -2117,6 +2352,12 @@ export declare const ContentBlockDeltaFilterSensitiveLog: (
 export declare const ContentBlockDeltaEventFilterSensitiveLog: (
   obj: ContentBlockDeltaEvent
 ) => any;
+export declare const ConverseStreamTraceFilterSensitiveLog: (
+  obj: ConverseStreamTrace
+) => any;
+export declare const ConverseStreamMetadataEventFilterSensitiveLog: (
+  obj: ConverseStreamMetadataEvent
+) => any;
 export declare const ConverseStreamOutputFilterSensitiveLog: (
   obj: ConverseStreamOutput
 ) => any;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-bedrock-runtime",
   "description": "AWS SDK for JavaScript Bedrock Runtime Client for Node.js, Browser and React Native",
-  "version": "3.859.0",
+  "version": "3.861.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "node ../../scripts/compilation/inline client-bedrock-runtime",