@aws-sdk/client-sagemaker-runtime 3.398.0 → 3.404.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,6 +1,6 @@
 import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
 import { collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
-import { InternalDependencyException, InternalFailure, ModelError, ModelNotReadyException, ServiceUnavailable, ValidationError, } from "../models/models_0";
+import { InternalDependencyException, InternalFailure, InternalStreamFailure, ModelError, ModelNotReadyException, ModelStreamError, ServiceUnavailable, ValidationError, } from "../models/models_0";
 import { SageMakerRuntimeServiceException as __BaseException } from "../models/SageMakerRuntimeServiceException";
 export const se_InvokeEndpointCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
@@ -61,6 +61,33 @@ export const se_InvokeEndpointAsyncCommand = async (input, context) => {
         body,
     });
 };
+export const se_InvokeEndpointWithResponseStreamCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": input.ContentType || "application/octet-stream",
+        "x-amzn-sagemaker-accept": input.Accept,
+        "x-amzn-sagemaker-custom-attributes": input.CustomAttributes,
+        "x-amzn-sagemaker-target-variant": input.TargetVariant,
+        "x-amzn-sagemaker-target-container-hostname": input.TargetContainerHostname,
+        "x-amzn-sagemaker-inference-id": input.InferenceId,
+    });
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/endpoints/{EndpointName}/invocations-response-stream";
+    resolvedPath = __resolvedPath(resolvedPath, input, "EndpointName", () => input.EndpointName, "{EndpointName}", false);
+    let body;
+    if (input.Body !== undefined) {
+        body = input.Body;
+    }
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const de_InvokeEndpointCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_InvokeEndpointCommandError(output, context);
@@ -150,6 +177,54 @@ const de_InvokeEndpointAsyncCommandError = async (output, context) => {
             });
     }
 };
+export const de_InvokeEndpointWithResponseStreamCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_InvokeEndpointWithResponseStreamCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+        ContentType: [, output.headers["x-amzn-sagemaker-content-type"]],
+        InvokedProductionVariant: [, output.headers["x-amzn-invoked-production-variant"]],
+        CustomAttributes: [, output.headers["x-amzn-sagemaker-custom-attributes"]],
+    });
+    const data = output.body;
+    contents.Body = de_ResponseStream(data, context);
+    return contents;
+};
+const de_InvokeEndpointWithResponseStreamCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalFailure":
+        case "com.amazonaws.sagemakerruntime#InternalFailure":
+            throw await de_InternalFailureRes(parsedOutput, context);
+        case "InternalStreamFailure":
+        case "com.amazonaws.sagemakerruntime#InternalStreamFailure":
+            throw await de_InternalStreamFailureRes(parsedOutput, context);
+        case "ModelError":
+        case "com.amazonaws.sagemakerruntime#ModelError":
+            throw await de_ModelErrorRes(parsedOutput, context);
+        case "ModelStreamError":
+        case "com.amazonaws.sagemakerruntime#ModelStreamError":
+            throw await de_ModelStreamErrorRes(parsedOutput, context);
+        case "ServiceUnavailable":
+        case "com.amazonaws.sagemakerruntime#ServiceUnavailable":
+            throw await de_ServiceUnavailableRes(parsedOutput, context);
+        case "ValidationError":
+        case "com.amazonaws.sagemakerruntime#ValidationError":
+            throw await de_ValidationErrorRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 const throwDefaultError = withBaseException(__BaseException);
 const de_InternalDependencyExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
@@ -177,6 +252,19 @@ const de_InternalFailureRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_InternalStreamFailureRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        Message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InternalStreamFailure({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_ModelErrorRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -206,6 +294,20 @@ const de_ModelNotReadyExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_ModelStreamErrorRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        ErrorCode: __expectString,
+        Message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ModelStreamError({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_ServiceUnavailableRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -232,6 +334,45 @@ const de_ValidationErrorRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_ResponseStream = (output, context) => {
+    return context.eventStreamMarshaller.deserialize(output, async (event) => {
+        if (event["PayloadPart"] != null) {
+            return {
+                PayloadPart: await de_PayloadPart_event(event["PayloadPart"], context),
+            };
+        }
+        if (event["ModelStreamError"] != null) {
+            return {
+                ModelStreamError: await de_ModelStreamError_event(event["ModelStreamError"], context),
+            };
+        }
+        if (event["InternalStreamFailure"] != null) {
+            return {
+                InternalStreamFailure: await de_InternalStreamFailure_event(event["InternalStreamFailure"], context),
+            };
+        }
+        return { $unknown: output };
+    });
+};
+const de_InternalStreamFailure_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return de_InternalStreamFailureRes(parsedOutput, context);
+};
+const de_ModelStreamError_event = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseBody(output.body, context),
+    };
+    return de_ModelStreamErrorRes(parsedOutput, context);
+};
+const de_PayloadPart_event = async (output, context) => {
+    const contents = {};
+    contents.Bytes = output.body;
+    return contents;
+};
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
     requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],

package/dist-es/runtimeConfig.browser.js

@@ -2,6 +2,7 @@ import packageInfo from "../package.json";
 import { Sha256 } from "@aws-crypto/sha256-browser";
 import { defaultUserAgent } from "@aws-sdk/util-user-agent-browser";
 import { DEFAULT_USE_DUALSTACK_ENDPOINT, DEFAULT_USE_FIPS_ENDPOINT } from "@smithy/config-resolver";
+import { eventStreamSerdeProvider } from "@smithy/eventstream-serde-browser";
 import { FetchHttpHandler as RequestHandler, streamCollector } from "@smithy/fetch-http-handler";
 import { invalidProvider } from "@smithy/invalid-dependency";
 import { calculateBodyLength } from "@smithy/util-body-length-browser";
@@ -22,6 +23,7 @@ export const getRuntimeConfig = (config) => {
         credentialDefaultProvider: config?.credentialDefaultProvider ?? ((_) => () => Promise.reject(new Error("Credential is missing"))),
         defaultUserAgentProvider: config?.defaultUserAgentProvider ??
             defaultUserAgent({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        eventStreamSerdeProvider: config?.eventStreamSerdeProvider ?? eventStreamSerdeProvider,
         maxAttempts: config?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
         region: config?.region ?? invalidProvider("Region is missing"),
         requestHandler: config?.requestHandler ?? new RequestHandler(defaultConfigProvider),

package/dist-es/runtimeConfig.js

@@ -3,6 +3,7 @@ import { decorateDefaultCredentialProvider } from "@aws-sdk/client-sts";
 import { defaultProvider as credentialDefaultProvider } from "@aws-sdk/credential-provider-node";
 import { defaultUserAgent } from "@aws-sdk/util-user-agent-node";
 import { NODE_REGION_CONFIG_FILE_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, } from "@smithy/config-resolver";
+import { eventStreamSerdeProvider } from "@smithy/eventstream-serde-node";
 import { Hash } from "@smithy/hash-node";
 import { NODE_MAX_ATTEMPT_CONFIG_OPTIONS, NODE_RETRY_MODE_CONFIG_OPTIONS } from "@smithy/middleware-retry";
 import { loadConfig as loadNodeConfig } from "@smithy/node-config-provider";
@@ -27,6 +28,7 @@ export const getRuntimeConfig = (config) => {
         credentialDefaultProvider: config?.credentialDefaultProvider ?? decorateDefaultCredentialProvider(credentialDefaultProvider),
         defaultUserAgentProvider: config?.defaultUserAgentProvider ??
             defaultUserAgent({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        eventStreamSerdeProvider: config?.eventStreamSerdeProvider ?? eventStreamSerdeProvider,
         maxAttempts: config?.maxAttempts ?? loadNodeConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS),
         region: config?.region ?? loadNodeConfig(NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS),
         requestHandler: config?.requestHandler ?? new RequestHandler(defaultConfigProvider),

package/dist-types/SageMakerRuntime.d.ts

@@ -1,6 +1,7 @@
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
 import { InvokeEndpointAsyncCommandInput, InvokeEndpointAsyncCommandOutput } from "./commands/InvokeEndpointAsyncCommand";
 import { InvokeEndpointCommandInput, InvokeEndpointCommandOutput } from "./commands/InvokeEndpointCommand";
+import { InvokeEndpointWithResponseStreamCommandInput, InvokeEndpointWithResponseStreamCommandOutput } from "./commands/InvokeEndpointWithResponseStreamCommand";
 import { SageMakerRuntimeClient } from "./SageMakerRuntimeClient";
 export interface SageMakerRuntime {
     /**
@@ -15,6 +16,12 @@ export interface SageMakerRuntime {
     invokeEndpointAsync(args: InvokeEndpointAsyncCommandInput, options?: __HttpHandlerOptions): Promise<InvokeEndpointAsyncCommandOutput>;
     invokeEndpointAsync(args: InvokeEndpointAsyncCommandInput, cb: (err: any, data?: InvokeEndpointAsyncCommandOutput) => void): void;
     invokeEndpointAsync(args: InvokeEndpointAsyncCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: InvokeEndpointAsyncCommandOutput) => void): void;
+    /**
+     * @see {@link InvokeEndpointWithResponseStreamCommand}
+     */
+    invokeEndpointWithResponseStream(args: InvokeEndpointWithResponseStreamCommandInput, options?: __HttpHandlerOptions): Promise<InvokeEndpointWithResponseStreamCommandOutput>;
+    invokeEndpointWithResponseStream(args: InvokeEndpointWithResponseStreamCommandInput, cb: (err: any, data?: InvokeEndpointWithResponseStreamCommandOutput) => void): void;
+    invokeEndpointWithResponseStream(args: InvokeEndpointWithResponseStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: InvokeEndpointWithResponseStreamCommandOutput) => void): void;
 }
 /**
  * @public

package/dist-types/SageMakerRuntimeClient.d.ts

@@ -3,24 +3,26 @@ import { AwsAuthInputConfig, AwsAuthResolvedConfig } from "@aws-sdk/middleware-s
 import { UserAgentInputConfig, UserAgentResolvedConfig } from "@aws-sdk/middleware-user-agent";
 import { Credentials as __Credentials } from "@aws-sdk/types";
 import { RegionInputConfig, RegionResolvedConfig } from "@smithy/config-resolver";
+import { EventStreamSerdeInputConfig, EventStreamSerdeResolvedConfig } from "@smithy/eventstream-serde-config-resolver";
 import { EndpointInputConfig, EndpointResolvedConfig } from "@smithy/middleware-endpoint";
 import { RetryInputConfig, RetryResolvedConfig } from "@smithy/middleware-retry";
 import { HttpHandler as __HttpHandler } from "@smithy/protocol-http";
 import { Client as __Client, DefaultsMode as __DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@smithy/smithy-client";
-import { BodyLengthCalculator as __BodyLengthCalculator, CheckOptionalClientConfig as __CheckOptionalClientConfig, ChecksumConstructor as __ChecksumConstructor, Decoder as __Decoder, Encoder as __Encoder, 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 { 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 { InvokeEndpointAsyncCommandInput, InvokeEndpointAsyncCommandOutput } from "./commands/InvokeEndpointAsyncCommand";
 import { InvokeEndpointCommandInput, InvokeEndpointCommandOutput } from "./commands/InvokeEndpointCommand";
+import { InvokeEndpointWithResponseStreamCommandInput, InvokeEndpointWithResponseStreamCommandOutput } from "./commands/InvokeEndpointWithResponseStreamCommand";
 import { ClientInputEndpointParameters, ClientResolvedEndpointParameters, EndpointParameters } from "./endpoint/EndpointParameters";
 import { RuntimeExtension, RuntimeExtensionsConfig } from "./runtimeExtensions";
 export { __Client };
 /**
  * @public
  */
-export type ServiceInputTypes = InvokeEndpointAsyncCommandInput | InvokeEndpointCommandInput;
+export type ServiceInputTypes = InvokeEndpointAsyncCommandInput | InvokeEndpointCommandInput | InvokeEndpointWithResponseStreamCommandInput;
 /**
  * @public
  */
-export type ServiceOutputTypes = InvokeEndpointAsyncCommandOutput | InvokeEndpointCommandOutput;
+export type ServiceOutputTypes = InvokeEndpointAsyncCommandOutput | InvokeEndpointCommandOutput | InvokeEndpointWithResponseStreamCommandOutput;
 /**
  * @public
  */
@@ -123,6 +125,10 @@ export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__
      * Optional extensions
      */
     extensions?: RuntimeExtension[];
+    /**
+     * The function that provides necessary utilities for generating and parsing event stream
+     */
+    eventStreamSerdeProvider?: __EventStreamSerdeProvider;
     /**
      * The {@link @smithy/smithy-client#DefaultsMode} that will be used to determine how certain default configuration options are resolved in the SDK.
      */
@@ -131,7 +137,7 @@ export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__
 /**
  * @public
  */
-export type SageMakerRuntimeClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointInputConfig<EndpointParameters> & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig & ClientInputEndpointParameters;
+export type SageMakerRuntimeClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointInputConfig<EndpointParameters> & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig & EventStreamSerdeInputConfig & ClientInputEndpointParameters;
 /**
  * @public
  *
@@ -142,7 +148,7 @@ export interface SageMakerRuntimeClientConfig extends SageMakerRuntimeClientConf
 /**
  * @public
  */
-export type SageMakerRuntimeClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RuntimeExtensionsConfig & RegionResolvedConfig & EndpointResolvedConfig<EndpointParameters> & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig & ClientResolvedEndpointParameters;
+export type SageMakerRuntimeClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RuntimeExtensionsConfig & RegionResolvedConfig & EndpointResolvedConfig<EndpointParameters> & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig & EventStreamSerdeResolvedConfig & ClientResolvedEndpointParameters;
 /**
  * @public
  *

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

@@ -23,18 +23,18 @@ export interface InvokeEndpointAsyncCommandOutput extends InvokeEndpointAsyncOut
 }
 /**
  * @public
- * <p>After you deploy a model into production using Amazon SageMaker hosting services, your client
- *             applications use this API to get inferences from the model hosted at the specified
- *             endpoint in an asynchronous manner.</p>
+ * <p>After you deploy a model into production using Amazon SageMaker hosting services,
+ *             your client applications use this API to get inferences from the model hosted at the
+ *             specified endpoint in an asynchronous manner.</p>
  *          <p>Inference requests sent to this API are enqueued for asynchronous processing. The
  *             processing of the inference request may or may not complete before you receive a
  *             response from this API. The response from this API will not contain the result of the
  *             inference request but contain information about where you can locate it.</p>
- *          <p>Amazon SageMaker strips all <code>POST</code> headers except those supported by the API. Amazon SageMaker
- *             might add additional headers. You should not rely on the behavior of headers outside
- *             those enumerated in the request syntax.</p>
- *          <p>Calls to <code>InvokeEndpointAsync</code> are authenticated by using Amazon Web Services Signature Version 4. For information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html">Authenticating Requests (Amazon Web Services Signature Version 4)</a> in the
- *                 <i>Amazon S3 API Reference</i>.</p>
+ *          <p>Amazon SageMaker strips all POST headers except those supported by the API. Amazon SageMaker might add
+ *     additional headers. You should not rely on the behavior of headers outside those
+ *     enumerated in the request syntax. </p>
+ *          <p>Calls to <code>InvokeEndpointAsync</code> are authenticated by using Amazon Web Services Signature Version 4. For information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html">Authenticating
+ *                 Requests (Amazon Web Services Signature Version 4)</a> in the <i>Amazon S3 API Reference</i>.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -36,25 +36,24 @@ export interface InvokeEndpointCommandOutput extends InvokeEndpointCommandOutput
 }
 /**
  * @public
- * <p>After you deploy a model into production using Amazon SageMaker hosting services, your
- *             client applications use this API to get inferences from the model hosted at the
+ * <p>After you deploy a model into production using Amazon SageMaker hosting services,
+ *             your client applications use this API to get inferences from the model hosted at the
  *             specified endpoint. </p>
  *          <p>For an overview of Amazon SageMaker, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works.html">How It Works</a>. </p>
  *          <p>Amazon SageMaker strips all POST headers except those supported by the API. Amazon SageMaker might add
- *             additional headers. You should not rely on the behavior of headers outside those
- *             enumerated in the request syntax. </p>
+ *     additional headers. You should not rely on the behavior of headers outside those
+ *     enumerated in the request syntax. </p>
  *          <p>Calls to <code>InvokeEndpoint</code> are authenticated by using Amazon Web Services
  *             Signature Version 4. For information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html">Authenticating
- *                 Requests (Amazon Web Services Signature Version 4)</a> in the <i>Amazon S3 API
- *                 Reference</i>.</p>
+ *                 Requests (Amazon Web Services Signature Version 4)</a> in the <i>Amazon S3 API Reference</i>.</p>
  *          <p>A customer's model containers must respond to requests within 60 seconds. The model
  *             itself can have a maximum processing time of 60 seconds before responding to
  *             invocations. If your model is going to take 50-60 seconds of processing time, the SDK
  *             socket timeout should be set to be 70 seconds.</p>
  *          <note>
  *             <p>Endpoints are scoped to an individual account, and are not public. The URL does
- *                 not contain the account ID, but Amazon SageMaker determines the account ID from the
- *                 authentication token that is supplied by the caller.</p>
+ *                 not contain the account ID, but Amazon SageMaker determines the account ID from
+ *                 the authentication token that is supplied by the caller.</p>
  *          </note>
  * @example
  * Use a bare-bones client and the command you need to make an API call.

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

@@ -0,0 +1,151 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as $Command } from "@smithy/smithy-client";
+import { BlobPayloadInputTypes, Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { InvokeEndpointWithResponseStreamInput, InvokeEndpointWithResponseStreamOutput } from "../models/models_0";
+import { SageMakerRuntimeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SageMakerRuntimeClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ */
+export type InvokeEndpointWithResponseStreamCommandInputType = Omit<InvokeEndpointWithResponseStreamInput, "Body"> & {
+    Body: BlobPayloadInputTypes;
+};
+/**
+ * @public
+ *
+ * The input for {@link InvokeEndpointWithResponseStreamCommand}.
+ */
+export interface InvokeEndpointWithResponseStreamCommandInput extends InvokeEndpointWithResponseStreamCommandInputType {
+}
+/**
+ * @public
+ *
+ * The output of {@link InvokeEndpointWithResponseStreamCommand}.
+ */
+export interface InvokeEndpointWithResponseStreamCommandOutput extends InvokeEndpointWithResponseStreamOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Invokes a model at the specified endpoint to return the inference response as a
+ *             stream. The inference stream provides the response payload incrementally as a series of
+ *             parts. Before you can get an inference stream, you must have access to a model that's
+ *             deployed using Amazon SageMaker hosting services, and the container for that model
+ *             must support inference streaming.</p>
+ *          <p>For more information that can help you use this API, see the following sections in the
+ *                     <i>Amazon SageMaker Developer Guide</i>:</p>
+ *          <ul>
+ *             <li>
+ *                <p>For information about how to add streaming support to a model, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-inference-code.html#your-algorithms-inference-code-how-containe-serves-requests">How Containers Serve Requests</a>.</p>
+ *             </li>
+ *             <li>
+ *                <p>For information about how to process the streaming response, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-test-endpoints.html">Invoke real-time endpoints</a>.</p>
+ *             </li>
+ *          </ul>
+ *          <p>Amazon SageMaker strips all POST headers except those supported by the API. Amazon SageMaker might add
+ *     additional headers. You should not rely on the behavior of headers outside those
+ *     enumerated in the request syntax. </p>
+ *          <p>Calls to <code>InvokeEndpointWithResponseStream</code> are authenticated by using
+ *                 Amazon Web Services Signature Version 4. For information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html">Authenticating Requests (Amazon Web Services Signature Version 4)</a> in the
+ *                     <i>Amazon S3 API Reference</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SageMakerRuntimeClient, InvokeEndpointWithResponseStreamCommand } from "@aws-sdk/client-sagemaker-runtime"; // ES Modules import
+ * // const { SageMakerRuntimeClient, InvokeEndpointWithResponseStreamCommand } = require("@aws-sdk/client-sagemaker-runtime"); // CommonJS import
+ * const client = new SageMakerRuntimeClient(config);
+ * const input = { // InvokeEndpointWithResponseStreamInput
+ *   EndpointName: "STRING_VALUE", // required
+ *   Body: "BLOB_VALUE", // required
+ *   ContentType: "STRING_VALUE",
+ *   Accept: "STRING_VALUE",
+ *   CustomAttributes: "STRING_VALUE",
+ *   TargetVariant: "STRING_VALUE",
+ *   TargetContainerHostname: "STRING_VALUE",
+ *   InferenceId: "STRING_VALUE",
+ * };
+ * const command = new InvokeEndpointWithResponseStreamCommand(input);
+ * const response = await client.send(command);
+ * // { // InvokeEndpointWithResponseStreamOutput
+ * //   Body: { // ResponseStream Union: only one key present
+ * //     PayloadPart: { // PayloadPart
+ * //       Bytes: "BLOB_VALUE",
+ * //     },
+ * //     ModelStreamError: { // ModelStreamError
+ * //       Message: "STRING_VALUE",
+ * //       ErrorCode: "STRING_VALUE",
+ * //     },
+ * //     InternalStreamFailure: { // InternalStreamFailure
+ * //       Message: "STRING_VALUE",
+ * //     },
+ * //   },
+ * //   ContentType: "STRING_VALUE",
+ * //   InvokedProductionVariant: "STRING_VALUE",
+ * //   CustomAttributes: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param InvokeEndpointWithResponseStreamCommandInput - {@link InvokeEndpointWithResponseStreamCommandInput}
+ * @returns {@link InvokeEndpointWithResponseStreamCommandOutput}
+ * @see {@link InvokeEndpointWithResponseStreamCommandInput} for command's `input` shape.
+ * @see {@link InvokeEndpointWithResponseStreamCommandOutput} for command's `response` shape.
+ * @see {@link SageMakerRuntimeClientResolvedConfig | config} for SageMakerRuntimeClient's `config` shape.
+ *
+ * @throws {@link InternalFailure} (server fault)
+ *  <p> An internal failure occurred. </p>
+ *
+ * @throws {@link InternalStreamFailure} (server fault)
+ *  <p>The stream processing failed because of an unknown error, exception or failure. Try your request again.</p>
+ *
+ * @throws {@link ModelError} (client fault)
+ *  <p> Model (owned by the customer in the container) returned 4xx or 5xx error code.
+ *         </p>
+ *
+ * @throws {@link ModelStreamError} (client fault)
+ *  <p> An error occurred while streaming the response body. This error can have the
+ *     following error codes:</p>
+ *          <dl>
+ *             <dt>ModelInvocationTimeExceeded</dt>
+ *             <dd>
+ *                <p>The model failed to finish sending the response within the timeout period allowed by Amazon SageMaker.</p>
+ *             </dd>
+ *             <dt>StreamBroken</dt>
+ *             <dd>
+ *                <p>The Transmission Control Protocol (TCP) connection between the client and
+ *                     the model was reset or closed.</p>
+ *             </dd>
+ *          </dl>
+ *
+ * @throws {@link ServiceUnavailable} (server fault)
+ *  <p> The service is unavailable. Try your call again. </p>
+ *
+ * @throws {@link ValidationError} (client fault)
+ *  <p> Inspect your request and try again. </p>
+ *
+ * @throws {@link SageMakerRuntimeServiceException}
+ * <p>Base exception class for all service exceptions from SageMakerRuntime service.</p>
+ *
+ */
+export declare class InvokeEndpointWithResponseStreamCommand extends $Command<InvokeEndpointWithResponseStreamCommandInput, InvokeEndpointWithResponseStreamCommandOutput, SageMakerRuntimeClientResolvedConfig> {
+    readonly input: InvokeEndpointWithResponseStreamCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: InvokeEndpointWithResponseStreamCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerRuntimeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<InvokeEndpointWithResponseStreamCommandInput, InvokeEndpointWithResponseStreamCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -1,2 +1,3 @@
 export * from "./InvokeEndpointAsyncCommand";
 export * from "./InvokeEndpointCommand";
+export * from "./InvokeEndpointWithResponseStreamCommand";