@aws-sdk/client-bedrock-agent-runtime 3.609.0 → 3.614.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,8 +1,37 @@
 import { awsExpectUnion as __expectUnion, loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
 import { requestBuilder as rb } from "@smithy/core";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, limitedParseFloat32 as __limitedParseFloat32, map, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, limitedParseFloat32 as __limitedParseFloat32, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
 import { BedrockAgentRuntimeServiceException as __BaseException } from "../models/BedrockAgentRuntimeServiceException";
-import { AccessDeniedException, BadGatewayException, ConflictException, DependencyFailedException, InternalServerException, ResourceNotFoundException, RetrievalFilter, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { AccessDeniedException, BadGatewayException, ConflictException, DependencyFailedException, FlowInputContent, InternalServerException, ResourceNotFoundException, RetrievalFilter, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+export const se_DeleteAgentMemoryCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/agents/{agentId}/agentAliases/{agentAliasId}/memories");
+    b.p("agentId", () => input.agentId, "{agentId}", false);
+    b.p("agentAliasId", () => input.agentAliasId, "{agentAliasId}", false);
+    const query = map({
+        [_mI]: [, input[_mI]],
+    });
+    let body;
+    b.m("DELETE").h(headers).q(query).b(body);
+    return b.build();
+};
+export const se_GetAgentMemoryCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/agents/{agentId}/agentAliases/{agentAliasId}/memories");
+    b.p("agentId", () => input.agentId, "{agentId}", false);
+    b.p("agentAliasId", () => input.agentAliasId, "{agentAliasId}", false);
+    const query = map({
+        [_nT]: [, input[_nT]],
+        [_mIa]: [() => input.maxItems !== void 0, () => input[_mIa].toString()],
+        [_mT]: [, __expectNonNull(input[_mT], `memoryType`)],
+        [_mI]: [, __expectNonNull(input[_mI], `memoryId`)],
+    });
+    let body;
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
+};
 export const se_InvokeAgentCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -17,7 +46,23 @@ export const se_InvokeAgentCommand = async (input, context) => {
         enableTrace: [],
         endSession: [],
         inputText: [],
-        sessionState: (_) => _json(_),
+        memoryId: [],
+        sessionState: (_) => se_SessionState(_, context),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
+export const se_InvokeFlowCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/flows/{flowIdentifier}/aliases/{flowAliasIdentifier}");
+    b.p("flowIdentifier", () => input.flowIdentifier, "{flowIdentifier}", false);
+    b.p("flowAliasIdentifier", () => input.flowAliasIdentifier, "{flowAliasIdentifier}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        inputs: (_) => se_FlowInputs(_, context),
     }));
     b.m("POST").h(headers).b(body);
     return b.build();
@@ -54,6 +99,31 @@ export const se_RetrieveAndGenerateCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const de_DeleteAgentMemoryCommand = async (output, context) => {
+    if (output.statusCode !== 202 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+export const de_GetAgentMemoryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        memoryContents: (_) => de_Memories(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_InvokeAgentCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -62,11 +132,23 @@ export const de_InvokeAgentCommand = async (output, context) => {
         $metadata: deserializeMetadata(output),
         [_cT]: [, output.headers[_xabact]],
         [_sI]: [, output.headers[_xabasi]],
+        [_mI]: [, output.headers[_xabami]],
     });
     const data = output.body;
     contents.completion = de_ResponseStream(data, context);
     return contents;
 };
+export const de_InvokeFlowCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = output.body;
+    contents.responseStream = de_FlowResponseStream(data, context);
+    return contents;
+};
 export const de_RetrieveCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -262,6 +344,66 @@ const de_ValidationExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_FlowResponseStream = (output, context) => {
+    return context.eventStreamMarshaller.deserialize(output, async (event) => {
+        if (event["flowOutputEvent"] != null) {
+            return {
+                flowOutputEvent: await de_FlowOutputEvent_event(event["flowOutputEvent"], context),
+            };
+        }
+        if (event["flowCompletionEvent"] != null) {
+            return {
+                flowCompletionEvent: await de_FlowCompletionEvent_event(event["flowCompletionEvent"], context),
+            };
+        }
+        if (event["internalServerException"] != null) {
+            return {
+                internalServerException: await de_InternalServerException_event(event["internalServerException"], context),
+            };
+        }
+        if (event["validationException"] != null) {
+            return {
+                validationException: await de_ValidationException_event(event["validationException"], context),
+            };
+        }
+        if (event["resourceNotFoundException"] != null) {
+            return {
+                resourceNotFoundException: await de_ResourceNotFoundException_event(event["resourceNotFoundException"], context),
+            };
+        }
+        if (event["serviceQuotaExceededException"] != null) {
+            return {
+                serviceQuotaExceededException: await de_ServiceQuotaExceededException_event(event["serviceQuotaExceededException"], context),
+            };
+        }
+        if (event["throttlingException"] != null) {
+            return {
+                throttlingException: await de_ThrottlingException_event(event["throttlingException"], context),
+            };
+        }
+        if (event["accessDeniedException"] != null) {
+            return {
+                accessDeniedException: await de_AccessDeniedException_event(event["accessDeniedException"], context),
+            };
+        }
+        if (event["conflictException"] != null) {
+            return {
+                conflictException: await de_ConflictException_event(event["conflictException"], context),
+            };
+        }
+        if (event["dependencyFailedException"] != null) {
+            return {
+                dependencyFailedException: await de_DependencyFailedException_event(event["dependencyFailedException"], context),
+            };
+        }
+        if (event["badGatewayException"] != null) {
+            return {
+                badGatewayException: await de_BadGatewayException_event(event["badGatewayException"], context),
+            };
+        }
+        return { $unknown: output };
+    });
+};
 const de_ResponseStream = (output, context) => {
     return context.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["chunk"] != null) {
@@ -324,6 +466,11 @@ const de_ResponseStream = (output, context) => {
                 badGatewayException: await de_BadGatewayException_event(event["badGatewayException"], context),
             };
         }
+        if (event["files"] != null) {
+            return {
+                files: await de_FilePart_event(event["files"], context),
+            };
+        }
         return { $unknown: output };
     });
 };
@@ -355,6 +502,24 @@ const de_DependencyFailedException_event = async (output, context) => {
     };
     return de_DependencyFailedExceptionRes(parsedOutput, context);
 };
+const de_FilePart_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, de_FilePart(data, context));
+    return contents;
+};
+const de_FlowCompletionEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, _json(data));
+    return contents;
+};
+const de_FlowOutputEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, de_FlowOutputEvent(data, context));
+    return contents;
+};
 const de_InternalServerException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
@@ -427,6 +592,12 @@ const se_ByteContentDoc = (input, context) => {
         identifier: [],
     });
 };
+const se_ByteContentFile = (input, context) => {
+    return take(input, {
+        data: context.base64Encoder,
+        mediaType: [],
+    });
+};
 const se_ExternalSource = (input, context) => {
     return take(input, {
         byteContent: (_) => se_ByteContentDoc(_, context),
@@ -456,6 +627,13 @@ const se_ExternalSourcesRetrieveAndGenerateConfiguration = (input, context) => {
         sources: (_) => se_ExternalSources(_, context),
     });
 };
+const se_FileSource = (input, context) => {
+    return take(input, {
+        byteContent: (_) => se_ByteContentFile(_, context),
+        s3Location: _json,
+        sourceType: [],
+    });
+};
 const se_FilterAttribute = (input, context) => {
     return take(input, {
         key: [],
@@ -465,6 +643,26 @@ const se_FilterAttribute = (input, context) => {
 const se_FilterValue = (input, context) => {
     return input;
 };
+const se_FlowInput = (input, context) => {
+    return take(input, {
+        content: (_) => se_FlowInputContent(_, context),
+        nodeName: [],
+        nodeOutputName: [],
+    });
+};
+const se_FlowInputContent = (input, context) => {
+    return FlowInputContent.visit(input, {
+        document: (value) => ({ document: se_Document(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const se_FlowInputs = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_FlowInput(entry, context);
+    });
+};
 const se_GenerationConfiguration = (input, context) => {
     return take(input, {
         additionalModelRequestFields: (_) => se_AdditionalModelRequestFields(_, context),
@@ -478,6 +676,33 @@ const se_InferenceConfig = (input, context) => {
         textInferenceConfig: (_) => se_TextInferenceConfig(_, context),
     });
 };
+const se_InputFile = (input, context) => {
+    return take(input, {
+        name: [],
+        source: (_) => se_FileSource(_, context),
+        useCase: [],
+    });
+};
+const se_InputFiles = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_InputFile(entry, context);
+    });
+};
+const se_KnowledgeBaseConfiguration = (input, context) => {
+    return take(input, {
+        knowledgeBaseId: [],
+        retrievalConfiguration: (_) => se_KnowledgeBaseRetrievalConfiguration(_, context),
+    });
+};
+const se_KnowledgeBaseConfigurations = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_KnowledgeBaseConfiguration(entry, context);
+    });
+};
 const se_KnowledgeBaseRetrievalConfiguration = (input, context) => {
     return take(input, {
         vectorSearchConfiguration: (_) => se_KnowledgeBaseVectorSearchConfiguration(_, context),
@@ -488,6 +713,7 @@ const se_KnowledgeBaseRetrieveAndGenerateConfiguration = (input, context) => {
         generationConfiguration: (_) => se_GenerationConfiguration(_, context),
         knowledgeBaseId: [],
         modelArn: [],
+        orchestrationConfiguration: _json,
         retrievalConfiguration: (_) => se_KnowledgeBaseRetrievalConfiguration(_, context),
     });
 };
@@ -530,6 +756,16 @@ const se_RetrieveAndGenerateConfiguration = (input, context) => {
         type: [],
     });
 };
+const se_SessionState = (input, context) => {
+    return take(input, {
+        files: (_) => se_InputFiles(_, context),
+        invocationId: [],
+        knowledgeBaseConfigurations: (_) => se_KnowledgeBaseConfigurations(_, context),
+        promptSessionAttributes: _json,
+        returnControlInvocationResults: _json,
+        sessionAttributes: _json,
+    });
+};
 const se_TextInferenceConfig = (input, context) => {
     return take(input, {
         maxTokens: [],
@@ -538,6 +774,9 @@ const se_TextInferenceConfig = (input, context) => {
         topP: __serializeFloat,
     });
 };
+const se_Document = (input, context) => {
+    return input;
+};
 const de_Attribution = (output, context) => {
     return take(output, {
         citations: (_) => de_Citations(_, context),
@@ -557,6 +796,26 @@ const de_Citations = (output, context) => {
     });
     return retVal;
 };
+const de_FilePart = (output, context) => {
+    return take(output, {
+        files: (_) => de_OutputFiles(_, context),
+    });
+};
+const de_FlowOutputContent = (output, context) => {
+    if (output.document != null) {
+        return {
+            document: de_Document(output.document, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_FlowOutputEvent = (output, context) => {
+    return take(output, {
+        content: (_) => de_FlowOutputContent(__expectUnion(_), context),
+        nodeName: __expectString,
+        nodeType: __expectString,
+    });
+};
 const de_InferenceConfiguration = (output, context) => {
     return take(output, {
         maximumLength: __expectInt32,
@@ -587,6 +846,31 @@ const de_KnowledgeBaseRetrievalResults = (output, context) => {
     });
     return retVal;
 };
+const de_Memories = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Memory(__expectUnion(entry), context);
+    });
+    return retVal;
+};
+const de_Memory = (output, context) => {
+    if (output.sessionSummary != null) {
+        return {
+            sessionSummary: de_MemorySessionSummary(output.sessionSummary, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_MemorySessionSummary = (output, context) => {
+    return take(output, {
+        memoryId: __expectString,
+        sessionExpiryTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        sessionId: __expectString,
+        sessionStartTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        summaryText: __expectString,
+    });
+};
 const de_ModelInvocationInput = (output, context) => {
     return take(output, {
         inferenceConfiguration: (_) => de_InferenceConfiguration(_, context),
@@ -601,6 +885,7 @@ const de_ModelInvocationInput = (output, context) => {
 const de_Observation = (output, context) => {
     return take(output, {
         actionGroupInvocationOutput: _json,
+        codeInterpreterInvocationOutput: _json,
         finalResponse: _json,
         knowledgeBaseLookupOutput: (_) => de_KnowledgeBaseLookupOutput(_, context),
         repromptResponse: _json,
@@ -631,6 +916,21 @@ const de_OrchestrationTrace = (output, context) => {
     }
     return { $unknown: Object.entries(output)[0] };
 };
+const de_OutputFile = (output, context) => {
+    return take(output, {
+        bytes: context.base64Decoder,
+        name: __expectString,
+        type: __expectString,
+    });
+};
+const de_OutputFiles = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_OutputFile(entry, context);
+    });
+    return retVal;
+};
 const de_PayloadPart = (output, context) => {
     return take(output, {
         attribution: (_) => de_Attribution(_, context),
@@ -727,6 +1027,9 @@ const de_TracePart = (output, context) => {
         trace: (_) => de_Trace(__expectUnion(_), context),
     });
 };
+const de_Document = (output, context) => {
+    return output;
+};
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
     requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
@@ -740,6 +1043,11 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
     (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
     (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
 const _cT = "contentType";
+const _mI = "memoryId";
+const _mIa = "maxItems";
+const _mT = "memoryType";
+const _nT = "nextToken";
 const _sI = "sessionId";
 const _xabact = "x-amzn-bedrock-agent-content-type";
+const _xabami = "x-amz-bedrock-agent-memory-id";
 const _xabasi = "x-amz-bedrock-agent-session-id";

package/dist-types/BedrockAgentRuntime.d.ts

@@ -1,15 +1,36 @@
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
 import { BedrockAgentRuntimeClient } from "./BedrockAgentRuntimeClient";
+import { DeleteAgentMemoryCommandInput, DeleteAgentMemoryCommandOutput } from "./commands/DeleteAgentMemoryCommand";
+import { GetAgentMemoryCommandInput, GetAgentMemoryCommandOutput } from "./commands/GetAgentMemoryCommand";
 import { InvokeAgentCommandInput, InvokeAgentCommandOutput } from "./commands/InvokeAgentCommand";
+import { InvokeFlowCommandInput, InvokeFlowCommandOutput } from "./commands/InvokeFlowCommand";
 import { RetrieveAndGenerateCommandInput, RetrieveAndGenerateCommandOutput } from "./commands/RetrieveAndGenerateCommand";
 import { RetrieveCommandInput, RetrieveCommandOutput } from "./commands/RetrieveCommand";
 export interface BedrockAgentRuntime {
+    /**
+     * @see {@link DeleteAgentMemoryCommand}
+     */
+    deleteAgentMemory(args: DeleteAgentMemoryCommandInput, options?: __HttpHandlerOptions): Promise<DeleteAgentMemoryCommandOutput>;
+    deleteAgentMemory(args: DeleteAgentMemoryCommandInput, cb: (err: any, data?: DeleteAgentMemoryCommandOutput) => void): void;
+    deleteAgentMemory(args: DeleteAgentMemoryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteAgentMemoryCommandOutput) => void): void;
+    /**
+     * @see {@link GetAgentMemoryCommand}
+     */
+    getAgentMemory(args: GetAgentMemoryCommandInput, options?: __HttpHandlerOptions): Promise<GetAgentMemoryCommandOutput>;
+    getAgentMemory(args: GetAgentMemoryCommandInput, cb: (err: any, data?: GetAgentMemoryCommandOutput) => void): void;
+    getAgentMemory(args: GetAgentMemoryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetAgentMemoryCommandOutput) => void): void;
     /**
      * @see {@link InvokeAgentCommand}
      */
     invokeAgent(args: InvokeAgentCommandInput, options?: __HttpHandlerOptions): Promise<InvokeAgentCommandOutput>;
     invokeAgent(args: InvokeAgentCommandInput, cb: (err: any, data?: InvokeAgentCommandOutput) => void): void;
     invokeAgent(args: InvokeAgentCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: InvokeAgentCommandOutput) => void): void;
+    /**
+     * @see {@link InvokeFlowCommand}
+     */
+    invokeFlow(args: InvokeFlowCommandInput, options?: __HttpHandlerOptions): Promise<InvokeFlowCommandOutput>;
+    invokeFlow(args: InvokeFlowCommandInput, cb: (err: any, data?: InvokeFlowCommandOutput) => void): void;
+    invokeFlow(args: InvokeFlowCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: InvokeFlowCommandOutput) => void): void;
     /**
      * @see {@link RetrieveCommand}
      */

package/dist-types/BedrockAgentRuntimeClient.d.ts

@@ -8,7 +8,10 @@ import { HttpHandlerUserInput as __HttpHandlerUserInput } from "@smithy/protocol
 import { Client as __Client, DefaultsMode as __DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@smithy/smithy-client";
 import { AwsCredentialIdentityProvider, BodyLengthCalculator as __BodyLengthCalculator, CheckOptionalClientConfig as __CheckOptionalClientConfig, ChecksumConstructor as __ChecksumConstructor, Decoder as __Decoder, Encoder as __Encoder, EventStreamSerdeProvider as __EventStreamSerdeProvider, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@smithy/types";
 import { HttpAuthSchemeInputConfig, HttpAuthSchemeResolvedConfig } from "./auth/httpAuthSchemeProvider";
+import { DeleteAgentMemoryCommandInput, DeleteAgentMemoryCommandOutput } from "./commands/DeleteAgentMemoryCommand";
+import { GetAgentMemoryCommandInput, GetAgentMemoryCommandOutput } from "./commands/GetAgentMemoryCommand";
 import { InvokeAgentCommandInput, InvokeAgentCommandOutput } from "./commands/InvokeAgentCommand";
+import { InvokeFlowCommandInput, InvokeFlowCommandOutput } from "./commands/InvokeFlowCommand";
 import { RetrieveAndGenerateCommandInput, RetrieveAndGenerateCommandOutput } from "./commands/RetrieveAndGenerateCommand";
 import { RetrieveCommandInput, RetrieveCommandOutput } from "./commands/RetrieveCommand";
 import { ClientInputEndpointParameters, ClientResolvedEndpointParameters, EndpointParameters } from "./endpoint/EndpointParameters";
@@ -17,11 +20,11 @@ export { __Client };
 /**
  * @public
  */
-export type ServiceInputTypes = InvokeAgentCommandInput | RetrieveAndGenerateCommandInput | RetrieveCommandInput;
+export type ServiceInputTypes = DeleteAgentMemoryCommandInput | GetAgentMemoryCommandInput | InvokeAgentCommandInput | InvokeFlowCommandInput | RetrieveAndGenerateCommandInput | RetrieveCommandInput;
 /**
  * @public
  */
-export type ServiceOutputTypes = InvokeAgentCommandOutput | RetrieveAndGenerateCommandOutput | RetrieveCommandOutput;
+export type ServiceOutputTypes = DeleteAgentMemoryCommandOutput | GetAgentMemoryCommandOutput | InvokeAgentCommandOutput | InvokeFlowCommandOutput | RetrieveAndGenerateCommandOutput | RetrieveCommandOutput;
 /**
  * @public
  */

package/dist-types/commands/DeleteAgentMemoryCommand.d.ts

@@ -0,0 +1,87 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { BedrockAgentRuntimeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BedrockAgentRuntimeClient";
+import { DeleteAgentMemoryRequest, DeleteAgentMemoryResponse } from "../models/models_0";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link DeleteAgentMemoryCommand}.
+ */
+export interface DeleteAgentMemoryCommandInput extends DeleteAgentMemoryRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link DeleteAgentMemoryCommand}.
+ */
+export interface DeleteAgentMemoryCommandOutput extends DeleteAgentMemoryResponse, __MetadataBearer {
+}
+declare const DeleteAgentMemoryCommand_base: {
+    new (input: DeleteAgentMemoryCommandInput): import("@smithy/smithy-client").CommandImpl<DeleteAgentMemoryCommandInput, DeleteAgentMemoryCommandOutput, BedrockAgentRuntimeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (__0_0: DeleteAgentMemoryCommandInput): import("@smithy/smithy-client").CommandImpl<DeleteAgentMemoryCommandInput, DeleteAgentMemoryCommandOutput, BedrockAgentRuntimeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Deletes memory from the specified memory identifier.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BedrockAgentRuntimeClient, DeleteAgentMemoryCommand } from "@aws-sdk/client-bedrock-agent-runtime"; // ES Modules import
+ * // const { BedrockAgentRuntimeClient, DeleteAgentMemoryCommand } = require("@aws-sdk/client-bedrock-agent-runtime"); // CommonJS import
+ * const client = new BedrockAgentRuntimeClient(config);
+ * const input = { // DeleteAgentMemoryRequest
+ *   agentId: "STRING_VALUE", // required
+ *   agentAliasId: "STRING_VALUE", // required
+ *   memoryId: "STRING_VALUE",
+ * };
+ * const command = new DeleteAgentMemoryCommand(input);
+ * const response = await client.send(command);
+ * // {};
+ *
+ * ```
+ *
+ * @param DeleteAgentMemoryCommandInput - {@link DeleteAgentMemoryCommandInput}
+ * @returns {@link DeleteAgentMemoryCommandOutput}
+ * @see {@link DeleteAgentMemoryCommandInput} for command's `input` shape.
+ * @see {@link DeleteAgentMemoryCommandOutput} for command's `response` shape.
+ * @see {@link BedrockAgentRuntimeClientResolvedConfig | config} for BedrockAgentRuntimeClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>The request is denied because of missing access permissions. Check your permissions and retry your request.</p>
+ *
+ * @throws {@link BadGatewayException} (server fault)
+ *  <p>There was an issue with a dependency due to a server issue. Retry your request.</p>
+ *
+ * @throws {@link ConflictException} (client fault)
+ *  <p>There was a conflict performing an operation. Resolve the conflict and retry your request.</p>
+ *
+ * @throws {@link DependencyFailedException} (client fault)
+ *  <p>There was an issue with a dependency. Check the resource configurations and retry the request.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>An internal server error occurred. Retry your request.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>The specified resource Amazon Resource Name (ARN) was not found. Check the Amazon Resource Name (ARN) and try your request again.</p>
+ *
+ * @throws {@link ServiceQuotaExceededException} (client fault)
+ *  <p>The number of requests exceeds the service quota. Resubmit your request later.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The number of requests exceeds the limit. Resubmit your request later.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>Input validation failed. Check your request parameters and retry the request.</p>
+ *
+ * @throws {@link BedrockAgentRuntimeServiceException}
+ * <p>Base exception class for all service exceptions from BedrockAgentRuntime service.</p>
+ *
+ * @public
+ */
+export declare class DeleteAgentMemoryCommand extends DeleteAgentMemoryCommand_base {
+}