@aws-sdk/client-bedrock-agent-runtime - npm Package Compare versions

Comparing version 3.542.0 to 3.543.0

dist-es/models/models_0.js

@@ -226,2 +226,30 @@ import { SENSITIVE_STRING } from "@smithy/smithy-client";
 };
+export var RetrievalFilter;
+(function (RetrievalFilter) {
+    RetrievalFilter.visit = (value, visitor) => {
+        if (value.equals !== undefined)
+            return visitor.equals(value.equals);
+        if (value.notEquals !== undefined)
+            return visitor.notEquals(value.notEquals);
+        if (value.greaterThan !== undefined)
+            return visitor.greaterThan(value.greaterThan);
+        if (value.greaterThanOrEquals !== undefined)
+            return visitor.greaterThanOrEquals(value.greaterThanOrEquals);
+        if (value.lessThan !== undefined)
+            return visitor.lessThan(value.lessThan);
+        if (value.lessThanOrEquals !== undefined)
+            return visitor.lessThanOrEquals(value.lessThanOrEquals);
+        if (value.in !== undefined)
+            return visitor.in(value.in);
+        if (value.notIn !== undefined)
+            return visitor.notIn(value.notIn);
+        if (value.startsWith !== undefined)
+            return visitor.startsWith(value.startsWith);
+        if (value.andAll !== undefined)
+            return visitor.andAll(value.andAll);
+        if (value.orAll !== undefined)
+            return visitor.orAll(value.orAll);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(RetrievalFilter || (RetrievalFilter = {}));
 export const ActionGroupInvocationInputFilterSensitiveLog = (obj) => ({
@@ -258,2 +286,3 @@ ...obj,
     ...(obj.location && { location: SENSITIVE_STRING }),
+    ...(obj.metadata && { metadata: SENSITIVE_STRING }),
 });
@@ -430,21 +459,2 @@ export const CitationFilterSensitiveLog = (obj) => ({
 });
-export const KnowledgeBaseRetrieveAndGenerateConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.generationConfiguration && {
-        generationConfiguration: GenerationConfigurationFilterSensitiveLog(obj.generationConfiguration),
-    }),
-});
-export const RetrieveAndGenerateConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.knowledgeBaseConfiguration && {
-        knowledgeBaseConfiguration: KnowledgeBaseRetrieveAndGenerateConfigurationFilterSensitiveLog(obj.knowledgeBaseConfiguration),
-    }),
-});
-export const RetrieveAndGenerateRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.input && { input: SENSITIVE_STRING }),
-    ...(obj.retrieveAndGenerateConfiguration && {
-        retrieveAndGenerateConfiguration: RetrieveAndGenerateConfigurationFilterSensitiveLog(obj.retrieveAndGenerateConfiguration),
-    }),
-});
 export const RetrieveAndGenerateOutputFilterSensitiveLog = (obj) => ({
@@ -461,6 +471,2 @@ ...obj,
 });
-export const RetrieveRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.retrievalQuery && { retrievalQuery: SENSITIVE_STRING }),
-});
 export const KnowledgeBaseRetrievalResultFilterSensitiveLog = (obj) => ({
@@ -470,2 +476,3 @@ ...obj,
     ...(obj.location && { location: SENSITIVE_STRING }),
+    ...(obj.metadata && { metadata: SENSITIVE_STRING }),
 });
@@ -476,1 +483,66 @@ export const RetrieveResponseFilterSensitiveLog = (obj) => ({
 });
+export const RetrievalFilterFilterSensitiveLog = (obj) => {
+    if (obj.equals !== undefined)
+        return { equals: obj.equals };
+    if (obj.notEquals !== undefined)
+        return { notEquals: obj.notEquals };
+    if (obj.greaterThan !== undefined)
+        return { greaterThan: obj.greaterThan };
+    if (obj.greaterThanOrEquals !== undefined)
+        return { greaterThanOrEquals: obj.greaterThanOrEquals };
+    if (obj.lessThan !== undefined)
+        return { lessThan: obj.lessThan };
+    if (obj.lessThanOrEquals !== undefined)
+        return { lessThanOrEquals: obj.lessThanOrEquals };
+    if (obj.in !== undefined)
+        return { in: obj.in };
+    if (obj.notIn !== undefined)
+        return { notIn: obj.notIn };
+    if (obj.startsWith !== undefined)
+        return { startsWith: obj.startsWith };
+    if (obj.andAll !== undefined)
+        return { andAll: SENSITIVE_STRING };
+    if (obj.orAll !== undefined)
+        return { orAll: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const KnowledgeBaseVectorSearchConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.filter && { filter: SENSITIVE_STRING }),
+});
+export const KnowledgeBaseRetrievalConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.vectorSearchConfiguration && {
+        vectorSearchConfiguration: KnowledgeBaseVectorSearchConfigurationFilterSensitiveLog(obj.vectorSearchConfiguration),
+    }),
+});
+export const KnowledgeBaseRetrieveAndGenerateConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.retrievalConfiguration && {
+        retrievalConfiguration: KnowledgeBaseRetrievalConfigurationFilterSensitiveLog(obj.retrievalConfiguration),
+    }),
+    ...(obj.generationConfiguration && {
+        generationConfiguration: GenerationConfigurationFilterSensitiveLog(obj.generationConfiguration),
+    }),
+});
+export const RetrieveRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.retrievalQuery && { retrievalQuery: SENSITIVE_STRING }),
+    ...(obj.retrievalConfiguration && {
+        retrievalConfiguration: KnowledgeBaseRetrievalConfigurationFilterSensitiveLog(obj.retrievalConfiguration),
+    }),
+});
+export const RetrieveAndGenerateConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.knowledgeBaseConfiguration && {
+        knowledgeBaseConfiguration: KnowledgeBaseRetrieveAndGenerateConfigurationFilterSensitiveLog(obj.knowledgeBaseConfiguration),
+    }),
+});
+export const RetrieveAndGenerateRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.input && { input: SENSITIVE_STRING }),
+    ...(obj.retrieveAndGenerateConfiguration && {
+        retrieveAndGenerateConfiguration: RetrieveAndGenerateConfigurationFilterSensitiveLog(obj.retrieveAndGenerateConfiguration),
+    }),
+});

dist-es/protocols/Aws_restJson1.js

@@ -5,3 +5,3 @@ import { awsExpectUnion as __expectUnion, loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
 import { BedrockAgentRuntimeServiceException as __BaseException } from "../models/BedrockAgentRuntimeServiceException";
-import { AccessDeniedException, BadGatewayException, ConflictException, DependencyFailedException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { AccessDeniedException, BadGatewayException, ConflictException, DependencyFailedException, InternalServerException, ResourceNotFoundException, RetrievalFilter, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
 export const se_InvokeAgentCommand = async (input, context) => {
@@ -36,3 +36,3 @@ const b = rb(input, context);
         nextToken: [],
-        retrievalConfiguration: (_) => _json(_),
+        retrievalConfiguration: (_) => se_KnowledgeBaseRetrievalConfiguration(_, context),
         retrievalQuery: (_) => _json(_),
@@ -52,3 +52,3 @@ }));
         input: (_) => _json(_),
-        retrieveAndGenerateConfiguration: (_) => _json(_),
+        retrieveAndGenerateConfiguration: (_) => se_RetrieveAndGenerateConfiguration(_, context),
         sessionConfiguration: (_) => _json(_),
@@ -97,3 +97,3 @@ sessionId: [],
     const doc = take(data, {
-        citations: _json,
+        citations: (_) => de_Citations(_, context),
         output: _json,
@@ -403,2 +403,79 @@ sessionId: __expectString,
 };
+const se_FilterAttribute = (input, context) => {
+    return take(input, {
+        key: [],
+        value: (_) => se_FilterValue(_, context),
+    });
+};
+const se_FilterValue = (input, context) => {
+    return input;
+};
+const se_KnowledgeBaseRetrievalConfiguration = (input, context) => {
+    return take(input, {
+        vectorSearchConfiguration: (_) => se_KnowledgeBaseVectorSearchConfiguration(_, context),
+    });
+};
+const se_KnowledgeBaseRetrieveAndGenerateConfiguration = (input, context) => {
+    return take(input, {
+        generationConfiguration: _json,
+        knowledgeBaseId: [],
+        modelArn: [],
+        retrievalConfiguration: (_) => se_KnowledgeBaseRetrievalConfiguration(_, context),
+    });
+};
+const se_KnowledgeBaseVectorSearchConfiguration = (input, context) => {
+    return take(input, {
+        filter: (_) => se_RetrievalFilter(_, context),
+        numberOfResults: [],
+        overrideSearchType: [],
+    });
+};
+const se_RetrievalFilter = (input, context) => {
+    return RetrievalFilter.visit(input, {
+        andAll: (value) => ({ andAll: se_RetrievalFilterList(value, context) }),
+        equals: (value) => ({ equals: se_FilterAttribute(value, context) }),
+        greaterThan: (value) => ({ greaterThan: se_FilterAttribute(value, context) }),
+        greaterThanOrEquals: (value) => ({ greaterThanOrEquals: se_FilterAttribute(value, context) }),
+        in: (value) => ({ in: se_FilterAttribute(value, context) }),
+        lessThan: (value) => ({ lessThan: se_FilterAttribute(value, context) }),
+        lessThanOrEquals: (value) => ({ lessThanOrEquals: se_FilterAttribute(value, context) }),
+        notEquals: (value) => ({ notEquals: se_FilterAttribute(value, context) }),
+        notIn: (value) => ({ notIn: se_FilterAttribute(value, context) }),
+        orAll: (value) => ({ orAll: se_RetrievalFilterList(value, context) }),
+        startsWith: (value) => ({ startsWith: se_FilterAttribute(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const se_RetrievalFilterList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_RetrievalFilter(entry, context);
+    });
+};
+const se_RetrieveAndGenerateConfiguration = (input, context) => {
+    return take(input, {
+        knowledgeBaseConfiguration: (_) => se_KnowledgeBaseRetrieveAndGenerateConfiguration(_, context),
+        type: [],
+    });
+};
+const de_Attribution = (output, context) => {
+    return take(output, {
+        citations: (_) => de_Citations(_, context),
+    });
+};
+const de_Citation = (output, context) => {
+    return take(output, {
+        generatedResponsePart: _json,
+        retrievedReferences: (_) => de_RetrievedReferences(_, context),
+    });
+};
+const de_Citations = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Citation(entry, context);
+    });
+    return retVal;
+};
 const de_InferenceConfiguration = (output, context) => {
@@ -413,2 +490,7 @@ return take(output, {
 };
+const de_KnowledgeBaseLookupOutput = (output, context) => {
+    return take(output, {
+        retrievedReferences: (_) => de_RetrievedReferences(_, context),
+    });
+};
 const de_KnowledgeBaseRetrievalResult = (output, context) => {
@@ -418,2 +500,3 @@ return take(output, {
         location: _json,
+        metadata: (_) => de_RetrievalResultMetadata(_, context),
         score: __limitedParseDouble,
@@ -441,2 +524,12 @@ });
 };
+const de_Observation = (output, context) => {
+    return take(output, {
+        actionGroupInvocationOutput: _json,
+        finalResponse: _json,
+        knowledgeBaseLookupOutput: (_) => de_KnowledgeBaseLookupOutput(_, context),
+        repromptResponse: _json,
+        traceId: __expectString,
+        type: __expectString,
+    });
+};
 const de_OrchestrationTrace = (output, context) => {
@@ -455,3 +548,3 @@ if (output.invocationInput != null) {
         return {
-            observation: _json(output.observation),
+            observation: de_Observation(output.observation, context),
         };
@@ -468,3 +561,3 @@ }
     return take(output, {
-        attribution: _json,
+        attribution: (_) => de_Attribution(_, context),
         bytes: context.base64Decoder,
@@ -499,2 +592,29 @@ });
 };
+const de_RetrievalResultMetadata = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = de_RetrievalResultMetadataValue(value, context);
+        return acc;
+    }, {});
+};
+const de_RetrievalResultMetadataValue = (output, context) => {
+    return output;
+};
+const de_RetrievedReference = (output, context) => {
+    return take(output, {
+        content: _json,
+        location: _json,
+        metadata: (_) => de_RetrievalResultMetadata(_, context),
+    });
+};
+const de_RetrievedReferences = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_RetrievedReference(entry, context);
+    });
+    return retVal;
+};
 const de_Trace = (output, context) => {
@@ -501,0 +621,0 @@ if (output.failureTrace != null) {

dist-types/commands/InvokeAgentCommand.d.ts

@@ -110,2 +110,5 @@ import { Command as $Command } from "@smithy/smithy-client";
  * //                 },
+ * //                 metadata: { // RetrievalResultMetadata
+ * //                   "<keys>": "DOCUMENT_VALUE",
+ * //                 },
  * //               },
@@ -202,2 +205,5 @@ * //             ],
  * //                   },
+ * //                   metadata: {
+ * //                     "<keys>": "DOCUMENT_VALUE",
+ * //                   },
  * //                 },
@@ -204,0 +210,0 @@ * //               ],

dist-types/commands/RetrieveAndGenerateCommand.d.ts

@@ -29,3 +29,3 @@ import { Command as $Command } from "@smithy/smithy-client";
 /**
- * <p>Queries a knowledge base and generates responses based on the retrieved results. The response cites up to five sources but only selects the ones that are relevant to the query.</p>
+ * <p>Queries a knowledge base and generates responses based on the retrieved results. The response only cites sources that are relevant to the query.</p>
  * @example
@@ -51,2 +51,50 @@ * Use a bare-bones client and the command you need to make an API call.
  *           overrideSearchType: "HYBRID" || "SEMANTIC",
+ *           filter: { // RetrievalFilter Union: only one key present
+ *             equals: { // FilterAttribute
+ *               key: "STRING_VALUE", // required
+ *               value: "DOCUMENT_VALUE", // required
+ *             },
+ *             notEquals: {
+ *               key: "STRING_VALUE", // required
+ *               value: "DOCUMENT_VALUE", // required
+ *             },
+ *             greaterThan: {
+ *               key: "STRING_VALUE", // required
+ *               value: "DOCUMENT_VALUE", // required
+ *             },
+ *             greaterThanOrEquals: {
+ *               key: "STRING_VALUE", // required
+ *               value: "DOCUMENT_VALUE", // required
+ *             },
+ *             lessThan: {
+ *               key: "STRING_VALUE", // required
+ *               value: "DOCUMENT_VALUE", // required
+ *             },
+ *             lessThanOrEquals: "<FilterAttribute>",
+ *             in: "<FilterAttribute>",
+ *             notIn: "<FilterAttribute>",
+ *             startsWith: "<FilterAttribute>",
+ *             andAll: [ // RetrievalFilterList
+ *               {//  Union: only one key present
+ *                 equals: "<FilterAttribute>",
+ *                 notEquals: "<FilterAttribute>",
+ *                 greaterThan: "<FilterAttribute>",
+ *                 greaterThanOrEquals: "<FilterAttribute>",
+ *                 lessThan: "<FilterAttribute>",
+ *                 lessThanOrEquals: "<FilterAttribute>",
+ *                 in: "<FilterAttribute>",
+ *                 notIn: "<FilterAttribute>",
+ *                 startsWith: "<FilterAttribute>",
+ *                 andAll: [
+ *                   "<RetrievalFilter>",
+ *                 ],
+ *                 orAll: [
+ *                   "<RetrievalFilter>",
+ *                 ],
+ *               },
+ *             ],
+ *             orAll: [
+ *               "<RetrievalFilter>",
+ *             ],
+ *           },
  *         },
@@ -94,2 +142,5 @@ *       },
  * //           },
+ * //           metadata: { // RetrievalResultMetadata
+ * //             "<keys>": "DOCUMENT_VALUE",
+ * //           },
  * //         },
@@ -96,0 +147,0 @@ * //       ],

dist-types/commands/RetrieveCommand.d.ts

@@ -45,2 +45,50 @@ import { Command as $Command } from "@smithy/smithy-client";
  *       overrideSearchType: "HYBRID" || "SEMANTIC",
+ *       filter: { // RetrievalFilter Union: only one key present
+ *         equals: { // FilterAttribute
+ *           key: "STRING_VALUE", // required
+ *           value: "DOCUMENT_VALUE", // required
+ *         },
+ *         notEquals: {
+ *           key: "STRING_VALUE", // required
+ *           value: "DOCUMENT_VALUE", // required
+ *         },
+ *         greaterThan: {
+ *           key: "STRING_VALUE", // required
+ *           value: "DOCUMENT_VALUE", // required
+ *         },
+ *         greaterThanOrEquals: {
+ *           key: "STRING_VALUE", // required
+ *           value: "DOCUMENT_VALUE", // required
+ *         },
+ *         lessThan: {
+ *           key: "STRING_VALUE", // required
+ *           value: "DOCUMENT_VALUE", // required
+ *         },
+ *         lessThanOrEquals: "<FilterAttribute>",
+ *         in: "<FilterAttribute>",
+ *         notIn: "<FilterAttribute>",
+ *         startsWith: "<FilterAttribute>",
+ *         andAll: [ // RetrievalFilterList
+ *           {//  Union: only one key present
+ *             equals: "<FilterAttribute>",
+ *             notEquals: "<FilterAttribute>",
+ *             greaterThan: "<FilterAttribute>",
+ *             greaterThanOrEquals: "<FilterAttribute>",
+ *             lessThan: "<FilterAttribute>",
+ *             lessThanOrEquals: "<FilterAttribute>",
+ *             in: "<FilterAttribute>",
+ *             notIn: "<FilterAttribute>",
+ *             startsWith: "<FilterAttribute>",
+ *             andAll: [
+ *               "<RetrievalFilter>",
+ *             ],
+ *             orAll: [
+ *               "<RetrievalFilter>",
+ *             ],
+ *           },
+ *         ],
+ *         orAll: [
+ *           "<RetrievalFilter>",
+ *         ],
+ *       },
  *     },
@@ -65,2 +113,5 @@ *   },
  * //       score: Number("double"),
+ * //       metadata: { // RetrievalResultMetadata
+ * //         "<keys>": "DOCUMENT_VALUE",
+ * //       },
  * //     },
@@ -67,0 +118,0 @@ * //   ],

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

 import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { DocumentType as __DocumentType } from "@smithy/types";
 import { BedrockAgentRuntimeServiceException as __BaseException } from "./BedrockAgentRuntimeServiceException";
@@ -98,2 +99,3 @@ export declare class AccessDeniedException extends __BaseException {
   location?: RetrievalResultLocation;
+  metadata?: Record<string, __DocumentType>;
 }
@@ -613,2 +615,6 @@ export interface Citation {
 }
+export interface FilterAttribute {
+  key: string | undefined;
+  value: __DocumentType | undefined;
+}
 export declare const SearchType: {
@@ -619,15 +625,2 @@ readonly HYBRID: "HYBRID";
 export type SearchType = (typeof SearchType)[keyof typeof SearchType];
-export interface KnowledgeBaseVectorSearchConfiguration {
-  numberOfResults?: number;
-  overrideSearchType?: SearchType;
-}
-export interface KnowledgeBaseRetrievalConfiguration {
-  vectorSearchConfiguration: KnowledgeBaseVectorSearchConfiguration | undefined;
-}
-export interface KnowledgeBaseRetrieveAndGenerateConfiguration {
-  knowledgeBaseId: string | undefined;
-  modelArn: string | undefined;
-  retrievalConfiguration?: KnowledgeBaseRetrievalConfiguration;
-  generationConfiguration?: GenerationConfiguration;
-}
 export declare const RetrieveAndGenerateType: {
@@ -638,15 +631,5 @@ readonly KNOWLEDGE_BASE: "KNOWLEDGE_BASE";
   (typeof RetrieveAndGenerateType)[keyof typeof RetrieveAndGenerateType];
-export interface RetrieveAndGenerateConfiguration {
-  type: RetrieveAndGenerateType | undefined;
-  knowledgeBaseConfiguration?: KnowledgeBaseRetrieveAndGenerateConfiguration;
-}
 export interface RetrieveAndGenerateSessionConfiguration {
   kmsKeyArn: string | undefined;
 }
-export interface RetrieveAndGenerateRequest {
-  sessionId?: string;
-  input: RetrieveAndGenerateInput | undefined;
-  retrieveAndGenerateConfiguration?: RetrieveAndGenerateConfiguration;
-  sessionConfiguration?: RetrieveAndGenerateSessionConfiguration;
-}
 export interface RetrieveAndGenerateOutput {
@@ -663,8 +646,2 @@ text: string | undefined;
 }
-export interface RetrieveRequest {
-  knowledgeBaseId: string | undefined;
-  retrievalQuery: KnowledgeBaseQuery | undefined;
-  retrievalConfiguration?: KnowledgeBaseRetrievalConfiguration;
-  nextToken?: string;
-}
 export interface KnowledgeBaseRetrievalResult {
@@ -674,2 +651,3 @@ content: RetrievalResultContent | undefined;
   score?: number;
+  metadata?: Record<string, __DocumentType>;
 }
@@ -680,2 +658,230 @@ export interface RetrieveResponse {
 }
+export type RetrievalFilter =
+  | RetrievalFilter.AndAllMember
+  | RetrievalFilter.EqualsMember
+  | RetrievalFilter.GreaterThanMember
+  | RetrievalFilter.GreaterThanOrEqualsMember
+  | RetrievalFilter.InMember
+  | RetrievalFilter.LessThanMember
+  | RetrievalFilter.LessThanOrEqualsMember
+  | RetrievalFilter.NotEqualsMember
+  | RetrievalFilter.NotInMember
+  | RetrievalFilter.OrAllMember
+  | RetrievalFilter.StartsWithMember
+  | RetrievalFilter.$UnknownMember;
+export declare namespace RetrievalFilter {
+  interface EqualsMember {
+    equals: FilterAttribute;
+    notEquals?: never;
+    greaterThan?: never;
+    greaterThanOrEquals?: never;
+    lessThan?: never;
+    lessThanOrEquals?: never;
+    in?: never;
+    notIn?: never;
+    startsWith?: never;
+    andAll?: never;
+    orAll?: never;
+    $unknown?: never;
+  }
+  interface NotEqualsMember {
+    equals?: never;
+    notEquals: FilterAttribute;
+    greaterThan?: never;
+    greaterThanOrEquals?: never;
+    lessThan?: never;
+    lessThanOrEquals?: never;
+    in?: never;
+    notIn?: never;
+    startsWith?: never;
+    andAll?: never;
+    orAll?: never;
+    $unknown?: never;
+  }
+  interface GreaterThanMember {
+    equals?: never;
+    notEquals?: never;
+    greaterThan: FilterAttribute;
+    greaterThanOrEquals?: never;
+    lessThan?: never;
+    lessThanOrEquals?: never;
+    in?: never;
+    notIn?: never;
+    startsWith?: never;
+    andAll?: never;
+    orAll?: never;
+    $unknown?: never;
+  }
+  interface GreaterThanOrEqualsMember {
+    equals?: never;
+    notEquals?: never;
+    greaterThan?: never;
+    greaterThanOrEquals: FilterAttribute;
+    lessThan?: never;
+    lessThanOrEquals?: never;
+    in?: never;
+    notIn?: never;
+    startsWith?: never;
+    andAll?: never;
+    orAll?: never;
+    $unknown?: never;
+  }
+  interface LessThanMember {
+    equals?: never;
+    notEquals?: never;
+    greaterThan?: never;
+    greaterThanOrEquals?: never;
+    lessThan: FilterAttribute;
+    lessThanOrEquals?: never;
+    in?: never;
+    notIn?: never;
+    startsWith?: never;
+    andAll?: never;
+    orAll?: never;
+    $unknown?: never;
+  }
+  interface LessThanOrEqualsMember {
+    equals?: never;
+    notEquals?: never;
+    greaterThan?: never;
+    greaterThanOrEquals?: never;
+    lessThan?: never;
+    lessThanOrEquals: FilterAttribute;
+    in?: never;
+    notIn?: never;
+    startsWith?: never;
+    andAll?: never;
+    orAll?: never;
+    $unknown?: never;
+  }
+  interface InMember {
+    equals?: never;
+    notEquals?: never;
+    greaterThan?: never;
+    greaterThanOrEquals?: never;
+    lessThan?: never;
+    lessThanOrEquals?: never;
+    in: FilterAttribute;
+    notIn?: never;
+    startsWith?: never;
+    andAll?: never;
+    orAll?: never;
+    $unknown?: never;
+  }
+  interface NotInMember {
+    equals?: never;
+    notEquals?: never;
+    greaterThan?: never;
+    greaterThanOrEquals?: never;
+    lessThan?: never;
+    lessThanOrEquals?: never;
+    in?: never;
+    notIn: FilterAttribute;
+    startsWith?: never;
+    andAll?: never;
+    orAll?: never;
+    $unknown?: never;
+  }
+  interface StartsWithMember {
+    equals?: never;
+    notEquals?: never;
+    greaterThan?: never;
+    greaterThanOrEquals?: never;
+    lessThan?: never;
+    lessThanOrEquals?: never;
+    in?: never;
+    notIn?: never;
+    startsWith: FilterAttribute;
+    andAll?: never;
+    orAll?: never;
+    $unknown?: never;
+  }
+  interface AndAllMember {
+    equals?: never;
+    notEquals?: never;
+    greaterThan?: never;
+    greaterThanOrEquals?: never;
+    lessThan?: never;
+    lessThanOrEquals?: never;
+    in?: never;
+    notIn?: never;
+    startsWith?: never;
+    andAll: RetrievalFilter[];
+    orAll?: never;
+    $unknown?: never;
+  }
+  interface OrAllMember {
+    equals?: never;
+    notEquals?: never;
+    greaterThan?: never;
+    greaterThanOrEquals?: never;
+    lessThan?: never;
+    lessThanOrEquals?: never;
+    in?: never;
+    notIn?: never;
+    startsWith?: never;
+    andAll?: never;
+    orAll: RetrievalFilter[];
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    equals?: never;
+    notEquals?: never;
+    greaterThan?: never;
+    greaterThanOrEquals?: never;
+    lessThan?: never;
+    lessThanOrEquals?: never;
+    in?: never;
+    notIn?: never;
+    startsWith?: never;
+    andAll?: never;
+    orAll?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    equals: (value: FilterAttribute) => T;
+    notEquals: (value: FilterAttribute) => T;
+    greaterThan: (value: FilterAttribute) => T;
+    greaterThanOrEquals: (value: FilterAttribute) => T;
+    lessThan: (value: FilterAttribute) => T;
+    lessThanOrEquals: (value: FilterAttribute) => T;
+    in: (value: FilterAttribute) => T;
+    notIn: (value: FilterAttribute) => T;
+    startsWith: (value: FilterAttribute) => T;
+    andAll: (value: RetrievalFilter[]) => T;
+    orAll: (value: RetrievalFilter[]) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: RetrievalFilter, visitor: Visitor<T>) => T;
+}
+export interface KnowledgeBaseVectorSearchConfiguration {
+  numberOfResults?: number;
+  overrideSearchType?: SearchType;
+  filter?: RetrievalFilter;
+}
+export interface KnowledgeBaseRetrievalConfiguration {
+  vectorSearchConfiguration: KnowledgeBaseVectorSearchConfiguration | undefined;
+}
+export interface KnowledgeBaseRetrieveAndGenerateConfiguration {
+  knowledgeBaseId: string | undefined;
+  modelArn: string | undefined;
+  retrievalConfiguration?: KnowledgeBaseRetrievalConfiguration;
+  generationConfiguration?: GenerationConfiguration;
+}
+export interface RetrieveRequest {
+  knowledgeBaseId: string | undefined;
+  retrievalQuery: KnowledgeBaseQuery | undefined;
+  retrievalConfiguration?: KnowledgeBaseRetrievalConfiguration;
+  nextToken?: string;
+}
+export interface RetrieveAndGenerateConfiguration {
+  type: RetrieveAndGenerateType | undefined;
+  knowledgeBaseConfiguration?: KnowledgeBaseRetrieveAndGenerateConfiguration;
+}
+export interface RetrieveAndGenerateRequest {
+  sessionId?: string;
+  input: RetrieveAndGenerateInput | undefined;
+  retrieveAndGenerateConfiguration?: RetrieveAndGenerateConfiguration;
+  sessionConfiguration?: RetrieveAndGenerateSessionConfiguration;
+}
 export declare const ActionGroupInvocationInputFilterSensitiveLog: (
@@ -767,11 +973,2 @@ obj: ActionGroupInvocationInput
 ) => any;
-export declare const KnowledgeBaseRetrieveAndGenerateConfigurationFilterSensitiveLog: (
-  obj: KnowledgeBaseRetrieveAndGenerateConfiguration
-) => any;
-export declare const RetrieveAndGenerateConfigurationFilterSensitiveLog: (
-  obj: RetrieveAndGenerateConfiguration
-) => any;
-export declare const RetrieveAndGenerateRequestFilterSensitiveLog: (
-  obj: RetrieveAndGenerateRequest
-) => any;
 export declare const RetrieveAndGenerateOutputFilterSensitiveLog: (
@@ -786,5 +983,2 @@ obj: RetrieveAndGenerateOutput
 ) => any;
-export declare const RetrieveRequestFilterSensitiveLog: (
-  obj: RetrieveRequest
-) => any;
 export declare const KnowledgeBaseRetrievalResultFilterSensitiveLog: (
@@ -796,1 +990,22 @@ obj: KnowledgeBaseRetrievalResult
 ) => any;
+export declare const RetrievalFilterFilterSensitiveLog: (
+  obj: RetrievalFilter
+) => any;
+export declare const KnowledgeBaseVectorSearchConfigurationFilterSensitiveLog: (
+  obj: KnowledgeBaseVectorSearchConfiguration
+) => any;
+export declare const KnowledgeBaseRetrievalConfigurationFilterSensitiveLog: (
+  obj: KnowledgeBaseRetrievalConfiguration
+) => any;
+export declare const KnowledgeBaseRetrieveAndGenerateConfigurationFilterSensitiveLog: (
+  obj: KnowledgeBaseRetrieveAndGenerateConfiguration
+) => any;
+export declare const RetrieveRequestFilterSensitiveLog: (
+  obj: RetrieveRequest
+) => any;
+export declare const RetrieveAndGenerateConfigurationFilterSensitiveLog: (
+  obj: RetrieveAndGenerateConfiguration
+) => any;
+export declare const RetrieveAndGenerateRequestFilterSensitiveLog: (
+  obj: RetrieveAndGenerateRequest
+) => any;

package.json

 {
   "name": "@aws-sdk/client-bedrock-agent-runtime",
   "description": "AWS SDK for JavaScript Bedrock Agent Runtime Client for Node.js, Browser and React Native",
-  "version": "3.542.0",
+  "version": "3.543.0",
   "scripts": {
@@ -6,0 +6,0 @@ "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",

No alert changes

Improved metrics

Total package byte prevSize

390226

increased by10.85%

Lines of code

8922

increased by12.79%

No dependency changes