@aws-sdk/client-sagemaker-runtime 3.928.0 → 3.929.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var eventstreamSerdeConfigResolver = require('@smithy/eventstream-serde-config-resolver');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
@@ -15,8 +16,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -93,6 +92,7 @@ class SageMakerRuntimeClient extends smithyClient.Client {
         const _config_8 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_7);
         const _config_9 = resolveRuntimeExtensions(_config_8, configuration?.extensions || []);
         this.config = _config_9;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -112,14 +112,14 @@ class SageMakerRuntimeClient extends smithyClient.Client {
     }
 }
 
-class SageMakerRuntimeServiceException extends smithyClient.ServiceException {
+let SageMakerRuntimeServiceException$1 = class SageMakerRuntimeServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, SageMakerRuntimeServiceException.prototype);
     }
-}
+};
 
-class InternalDependencyException extends SageMakerRuntimeServiceException {
+let InternalDependencyException$1 = class InternalDependencyException extends SageMakerRuntimeServiceException$1 {
     name = "InternalDependencyException";
     $fault = "server";
     Message;
@@ -132,8 +132,8 @@ class InternalDependencyException extends SageMakerRuntimeServiceException {
         Object.setPrototypeOf(this, InternalDependencyException.prototype);
         this.Message = opts.Message;
     }
-}
-class InternalFailure extends SageMakerRuntimeServiceException {
+};
+let InternalFailure$1 = class InternalFailure extends SageMakerRuntimeServiceException$1 {
     name = "InternalFailure";
     $fault = "server";
     Message;
@@ -146,8 +146,8 @@ class InternalFailure extends SageMakerRuntimeServiceException {
         Object.setPrototypeOf(this, InternalFailure.prototype);
         this.Message = opts.Message;
     }
-}
-class ModelError extends SageMakerRuntimeServiceException {
+};
+let ModelError$1 = class ModelError extends SageMakerRuntimeServiceException$1 {
     name = "ModelError";
     $fault = "client";
     Message;
@@ -166,8 +166,8 @@ class ModelError extends SageMakerRuntimeServiceException {
         this.OriginalMessage = opts.OriginalMessage;
         this.LogStreamArn = opts.LogStreamArn;
     }
-}
-class ModelNotReadyException extends SageMakerRuntimeServiceException {
+};
+let ModelNotReadyException$1 = class ModelNotReadyException extends SageMakerRuntimeServiceException$1 {
     name = "ModelNotReadyException";
     $fault = "client";
     Message;
@@ -180,8 +180,8 @@ class ModelNotReadyException extends SageMakerRuntimeServiceException {
         Object.setPrototypeOf(this, ModelNotReadyException.prototype);
         this.Message = opts.Message;
     }
-}
-class ServiceUnavailable extends SageMakerRuntimeServiceException {
+};
+let ServiceUnavailable$1 = class ServiceUnavailable extends SageMakerRuntimeServiceException$1 {
     name = "ServiceUnavailable";
     $fault = "server";
     Message;
@@ -194,8 +194,8 @@ class ServiceUnavailable extends SageMakerRuntimeServiceException {
         Object.setPrototypeOf(this, ServiceUnavailable.prototype);
         this.Message = opts.Message;
     }
-}
-class ValidationError extends SageMakerRuntimeServiceException {
+};
+let ValidationError$1 = class ValidationError extends SageMakerRuntimeServiceException$1 {
     name = "ValidationError";
     $fault = "client";
     Message;
@@ -208,8 +208,8 @@ class ValidationError extends SageMakerRuntimeServiceException {
         Object.setPrototypeOf(this, ValidationError.prototype);
         this.Message = opts.Message;
     }
-}
-class InternalStreamFailure extends SageMakerRuntimeServiceException {
+};
+let InternalStreamFailure$1 = class InternalStreamFailure extends SageMakerRuntimeServiceException$1 {
     name = "InternalStreamFailure";
     $fault = "server";
     Message;
@@ -222,8 +222,8 @@ class InternalStreamFailure extends SageMakerRuntimeServiceException {
         Object.setPrototypeOf(this, InternalStreamFailure.prototype);
         this.Message = opts.Message;
     }
-}
-class ModelStreamError extends SageMakerRuntimeServiceException {
+};
+let ModelStreamError$1 = class ModelStreamError extends SageMakerRuntimeServiceException$1 {
     name = "ModelStreamError";
     $fault = "client";
     Message;
@@ -238,7 +238,7 @@ class ModelStreamError extends SageMakerRuntimeServiceException {
         this.Message = opts.Message;
         this.ErrorCode = opts.ErrorCode;
     }
-}
+};
 exports.ResponseStream = void 0;
 (function (ResponseStream) {
     ResponseStream.visit = (value, visitor) => {
@@ -251,399 +251,533 @@ exports.ResponseStream = void 0;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(exports.ResponseStream || (exports.ResponseStream = {}));
-const InvokeEndpointInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Body && { Body: smithyClient.SENSITIVE_STRING }),
-    ...(obj.CustomAttributes && { CustomAttributes: smithyClient.SENSITIVE_STRING }),
-});
-const InvokeEndpointOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Body && { Body: smithyClient.SENSITIVE_STRING }),
-    ...(obj.CustomAttributes && { CustomAttributes: smithyClient.SENSITIVE_STRING }),
-});
-const InvokeEndpointAsyncInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.CustomAttributes && { CustomAttributes: smithyClient.SENSITIVE_STRING }),
-});
-const InvokeEndpointWithResponseStreamInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Body && { Body: smithyClient.SENSITIVE_STRING }),
-    ...(obj.CustomAttributes && { CustomAttributes: smithyClient.SENSITIVE_STRING }),
-});
-const PayloadPartFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Bytes && { Bytes: smithyClient.SENSITIVE_STRING }),
-});
-const ResponseStreamFilterSensitiveLog = (obj) => {
-    if (obj.PayloadPart !== undefined)
-        return { PayloadPart: PayloadPartFilterSensitiveLog(obj.PayloadPart) };
-    if (obj.ModelStreamError !== undefined)
-        return { ModelStreamError: obj.ModelStreamError };
-    if (obj.InternalStreamFailure !== undefined)
-        return { InternalStreamFailure: obj.InternalStreamFailure };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const InvokeEndpointWithResponseStreamOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Body && { Body: "STREAMING_CONTENT" }),
-    ...(obj.CustomAttributes && { CustomAttributes: smithyClient.SENSITIVE_STRING }),
-});
 
-const se_InvokeEndpointCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        [_ct]: input[_CT] || "application/octet-stream",
-        [_a]: input[_A],
-        [_xasca]: input[_CA],
-        [_xastm]: input[_TM],
-        [_xastv]: input[_TV],
-        [_xastch]: input[_TCH],
-        [_xasii]: input[_II],
-        [_xasee]: input[_EE],
-        [_xasic]: input[_ICN],
-        [_xassi]: input[_SI],
-    });
-    b.bp("/endpoints/{EndpointName}/invocations");
-    b.p("EndpointName", () => input.EndpointName, "{EndpointName}", false);
-    let body;
-    if (input.Body !== undefined) {
-        body = input.Body;
-    }
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_InvokeEndpointAsyncCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        [_xasct]: input[_CT],
-        [_xasa]: input[_A],
-        [_xasca]: input[_CA],
-        [_xasii]: input[_II],
-        [_xasi]: input[_IL],
-        [_xasr]: [() => smithyClient.isSerializableHeaderValue(input[_RTTLS]), () => input[_RTTLS].toString()],
-        [_xasi_]: [() => smithyClient.isSerializableHeaderValue(input[_ITS]), () => input[_ITS].toString()],
-    });
-    b.bp("/endpoints/{EndpointName}/async-invocations");
-    b.p("EndpointName", () => input.EndpointName, "{EndpointName}", false);
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_InvokeEndpointWithResponseStreamCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        [_ct]: input[_CT] || "application/octet-stream",
-        [_xasa]: input[_A],
-        [_xasca]: input[_CA],
-        [_xastv]: input[_TV],
-        [_xastch]: input[_TCH],
-        [_xasii]: input[_II],
-        [_xasic]: input[_ICN],
-        [_xassi]: input[_SI],
-    });
-    b.bp("/endpoints/{EndpointName}/invocations-response-stream");
-    b.p("EndpointName", () => input.EndpointName, "{EndpointName}", false);
-    let body;
-    if (input.Body !== undefined) {
-        body = input.Body;
-    }
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_InvokeEndpointCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_CT]: [, output.headers[_ct]],
-        [_IPV]: [, output.headers[_xaipv]],
-        [_CA]: [, output.headers[_xasca]],
-        [_NSI]: [, output.headers[_xasnsi]],
-        [_CSI]: [, output.headers[_xascsi]],
-    });
-    const data = await smithyClient.collectBody(output.body, context);
-    contents.Body = data;
-    return contents;
-};
-const de_InvokeEndpointAsyncCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_OL]: [, output.headers[_xaso]],
-        [_FL]: [, output.headers[_xasf]],
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        InferenceId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_InvokeEndpointWithResponseStreamCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_CT]: [, output.headers[_xasct]],
-        [_IPV]: [, output.headers[_xaipv]],
-        [_CA]: [, output.headers[_xasca]],
-    });
-    const data = output.body;
-    contents.Body = de_ResponseStream(data, context);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalDependencyException":
-        case "com.amazonaws.sagemakerruntime#InternalDependencyException":
-            throw await de_InternalDependencyExceptionRes(parsedOutput);
-        case "InternalFailure":
-        case "com.amazonaws.sagemakerruntime#InternalFailure":
-            throw await de_InternalFailureRes(parsedOutput);
-        case "ModelError":
-        case "com.amazonaws.sagemakerruntime#ModelError":
-            throw await de_ModelErrorRes(parsedOutput);
-        case "ModelNotReadyException":
-        case "com.amazonaws.sagemakerruntime#ModelNotReadyException":
-            throw await de_ModelNotReadyExceptionRes(parsedOutput);
-        case "ServiceUnavailable":
-        case "com.amazonaws.sagemakerruntime#ServiceUnavailable":
-            throw await de_ServiceUnavailableRes(parsedOutput);
-        case "ValidationError":
-        case "com.amazonaws.sagemakerruntime#ValidationError":
-            throw await de_ValidationErrorRes(parsedOutput);
-        case "InternalStreamFailure":
-        case "com.amazonaws.sagemakerruntime#InternalStreamFailure":
-            throw await de_InternalStreamFailureRes(parsedOutput);
-        case "ModelStreamError":
-        case "com.amazonaws.sagemakerruntime#ModelStreamError":
-            throw await de_ModelStreamErrorRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(SageMakerRuntimeServiceException);
-const de_InternalDependencyExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalDependencyException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalFailureRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalFailure({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalStreamFailureRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalStreamFailure({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ModelErrorRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        LogStreamArn: smithyClient.expectString,
-        Message: smithyClient.expectString,
-        OriginalMessage: smithyClient.expectString,
-        OriginalStatusCode: smithyClient.expectInt32,
-    });
-    Object.assign(contents, doc);
-    const exception = new ModelError({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ModelNotReadyExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ModelNotReadyException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ModelStreamErrorRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        ErrorCode: smithyClient.expectString,
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ModelStreamError({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceUnavailableRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceUnavailable({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationErrorRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationError({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.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"]),
-            };
-        }
-        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: event };
-    });
-};
-const de_InternalStreamFailure_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_InternalStreamFailureRes(parsedOutput);
-};
-const de_ModelStreamError_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_ModelStreamErrorRes(parsedOutput);
-};
-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"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
 const _A = "Accept";
+const _B = "Body";
+const _BB = "BodyBlob";
+const _By = "Bytes";
 const _CA = "CustomAttributes";
+const _CAH = "CustomAttributesHeader";
 const _CSI = "ClosedSessionId";
 const _CT = "ContentType";
+const _CT_ = "Content-Type";
+const _EC = "ErrorCode";
 const _EE = "EnableExplanations";
+const _EN = "EndpointName";
 const _FL = "FailureLocation";
 const _ICN = "InferenceComponentName";
+const _IDE = "InternalDependencyException";
+const _IE = "InvokeEndpoint";
+const _IEA = "InvokeEndpointAsync";
+const _IEAI = "InvokeEndpointAsyncInput";
+const _IEAO = "InvokeEndpointAsyncOutput";
+const _IEI = "InvokeEndpointInput";
+const _IEO = "InvokeEndpointOutput";
+const _IEWRS = "InvokeEndpointWithResponseStream";
+const _IEWRSI = "InvokeEndpointWithResponseStreamInput";
+const _IEWRSO = "InvokeEndpointWithResponseStreamOutput";
+const _IF = "InternalFailure";
 const _II = "InferenceId";
 const _IL = "InputLocation";
 const _IPV = "InvokedProductionVariant";
+const _ISF = "InternalStreamFailure";
 const _ITS = "InvocationTimeoutSeconds";
+const _LSA = "LogStreamArn";
+const _M = "Message";
+const _ME = "ModelError";
+const _MNRE = "ModelNotReadyException";
+const _MSE = "ModelStreamError";
 const _NSI = "NewSessionId";
 const _OL = "OutputLocation";
+const _OM = "OriginalMessage";
+const _OSC = "OriginalStatusCode";
+const _PB = "PartBlob";
+const _PP = "PayloadPart";
+const _RS = "ResponseStream";
 const _RTTLS = "RequestTTLSeconds";
 const _SI = "SessionId";
+const _SU = "ServiceUnavailable";
 const _TCH = "TargetContainerHostname";
 const _TM = "TargetModel";
 const _TV = "TargetVariant";
-const _a = "accept";
-const _ct = "content-type";
-const _xaipv = "x-amzn-invoked-production-variant";
-const _xasa = "x-amzn-sagemaker-accept";
-const _xasca = "x-amzn-sagemaker-custom-attributes";
-const _xascsi = "x-amzn-sagemaker-closed-session-id";
-const _xasct = "x-amzn-sagemaker-content-type";
-const _xasee = "x-amzn-sagemaker-enable-explanations";
-const _xasf = "x-amzn-sagemaker-failurelocation";
-const _xasi = "x-amzn-sagemaker-inputlocation";
-const _xasi_ = "x-amzn-sagemaker-invocationtimeoutseconds";
-const _xasic = "x-amzn-sagemaker-inference-component";
-const _xasii = "x-amzn-sagemaker-inference-id";
-const _xasnsi = "x-amzn-sagemaker-new-session-id";
-const _xaso = "x-amzn-sagemaker-outputlocation";
-const _xasr = "x-amzn-sagemaker-requestttlseconds";
-const _xassi = "x-amzn-sagemaker-session-id";
-const _xastch = "x-amzn-sagemaker-target-container-hostname";
-const _xastm = "x-amzn-sagemaker-target-model";
-const _xastv = "x-amzn-sagemaker-target-variant";
+const _VE = "ValidationError";
+const _XASA = "X-Amzn-SageMaker-Accept";
+const _XASCA = "X-Amzn-SageMaker-Custom-Attributes";
+const _XASCSI = "X-Amzn-SageMaker-Closed-Session-Id";
+const _XASCT = "X-Amzn-SageMaker-Content-Type";
+const _XASEE = "X-Amzn-SageMaker-Enable-Explanations";
+const _XASF = "X-Amzn-SageMaker-FailureLocation";
+const _XASI = "X-Amzn-SageMaker-InputLocation";
+const _XASIC = "X-Amzn-SageMaker-Inference-Component";
+const _XASII = "X-Amzn-SageMaker-Inference-Id";
+const _XASI_ = "X-Amzn-SageMaker-InvocationTimeoutSeconds";
+const _XASNSI = "X-Amzn-SageMaker-New-Session-Id";
+const _XASO = "X-Amzn-SageMaker-OutputLocation";
+const _XASR = "X-Amzn-SageMaker-RequestTTLSeconds";
+const _XASSI = "X-Amzn-SageMaker-Session-Id";
+const _XASTCH = "X-Amzn-SageMaker-Target-Container-Hostname";
+const _XASTM = "X-Amzn-SageMaker-Target-Model";
+const _XASTV = "X-Amzn-SageMaker-Target-Variant";
+const _aQE = "awsQueryError";
+const _c = "client";
+const _e = "error";
+const _eP = "eventPayload";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.sagemakerruntime";
+const _st = "streaming";
+const _xAIPV = "x-Amzn-Invoked-Production-Variant";
+const n0 = "com.amazonaws.sagemakerruntime";
+var BodyBlob = [0, n0, _BB, 8, 21];
+var CustomAttributesHeader = [0, n0, _CAH, 8, 0];
+var PartBlob = [0, n0, _PB, 8, 21];
+var InternalDependencyException = [
+    -3,
+    n0,
+    _IDE,
+    {
+        [_e]: _s,
+        [_hE]: 530,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalDependencyException, InternalDependencyException$1);
+var InternalFailure = [
+    -3,
+    n0,
+    _IF,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalFailure, InternalFailure$1);
+var InternalStreamFailure = [
+    -3,
+    n0,
+    _ISF,
+    {
+        [_e]: _s,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalStreamFailure, InternalStreamFailure$1);
+var InvokeEndpointAsyncInput = [
+    3,
+    n0,
+    _IEAI,
+    0,
+    [_EN, _CT, _A, _CA, _II, _IL, _RTTLS, _ITS],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hH]: _XASCT,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASA,
+            },
+        ],
+        [
+            () => CustomAttributesHeader,
+            {
+                [_hH]: _XASCA,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASII,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASI,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _XASR,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _XASI_,
+            },
+        ],
+    ],
+];
+var InvokeEndpointAsyncOutput = [
+    3,
+    n0,
+    _IEAO,
+    0,
+    [_II, _OL, _FL],
+    [
+        0,
+        [
+            0,
+            {
+                [_hH]: _XASO,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASF,
+            },
+        ],
+    ],
+];
+var InvokeEndpointInput = [
+    3,
+    n0,
+    _IEI,
+    0,
+    [_EN, _B, _CT, _A, _CA, _TM, _TV, _TCH, _II, _EE, _ICN, _SI],
+    [
+        [0, 1],
+        [() => BodyBlob, 16],
+        [
+            0,
+            {
+                [_hH]: _CT_,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _A,
+            },
+        ],
+        [
+            () => CustomAttributesHeader,
+            {
+                [_hH]: _XASCA,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASTM,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASTV,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASTCH,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASII,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASEE,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASIC,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASSI,
+            },
+        ],
+    ],
+];
+var InvokeEndpointOutput = [
+    3,
+    n0,
+    _IEO,
+    0,
+    [_B, _CT, _IPV, _CA, _NSI, _CSI],
+    [
+        [() => BodyBlob, 16],
+        [
+            0,
+            {
+                [_hH]: _CT_,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xAIPV,
+            },
+        ],
+        [
+            () => CustomAttributesHeader,
+            {
+                [_hH]: _XASCA,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASNSI,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASCSI,
+            },
+        ],
+    ],
+];
+var InvokeEndpointWithResponseStreamInput = [
+    3,
+    n0,
+    _IEWRSI,
+    0,
+    [_EN, _B, _CT, _A, _CA, _TV, _TCH, _II, _ICN, _SI],
+    [
+        [0, 1],
+        [() => BodyBlob, 16],
+        [
+            0,
+            {
+                [_hH]: _CT_,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASA,
+            },
+        ],
+        [
+            () => CustomAttributesHeader,
+            {
+                [_hH]: _XASCA,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASTV,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASTCH,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASII,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASIC,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _XASSI,
+            },
+        ],
+    ],
+];
+var InvokeEndpointWithResponseStreamOutput = [
+    3,
+    n0,
+    _IEWRSO,
+    0,
+    [_B, _CT, _IPV, _CA],
+    [
+        [() => ResponseStream, 16],
+        [
+            0,
+            {
+                [_hH]: _XASCT,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xAIPV,
+            },
+        ],
+        [
+            () => CustomAttributesHeader,
+            {
+                [_hH]: _XASCA,
+            },
+        ],
+    ],
+];
+var ModelError = [
+    -3,
+    n0,
+    _ME,
+    {
+        [_e]: _c,
+        [_hE]: 424,
+    },
+    [_M, _OSC, _OM, _LSA],
+    [0, 1, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ModelError, ModelError$1);
+var ModelNotReadyException = [
+    -3,
+    n0,
+    _MNRE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+        [_aQE]: [`ModelNotReadyException`, 429],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ModelNotReadyException, ModelNotReadyException$1);
+var ModelStreamError = [
+    -3,
+    n0,
+    _MSE,
+    {
+        [_e]: _c,
+    },
+    [_M, _EC],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ModelStreamError, ModelStreamError$1);
+var PayloadPart = [
+    3,
+    n0,
+    _PP,
+    0,
+    [_By],
+    [
+        [
+            () => PartBlob,
+            {
+                [_eP]: 1,
+            },
+        ],
+    ],
+];
+var ServiceUnavailable = [
+    -3,
+    n0,
+    _SU,
+    {
+        [_e]: _s,
+        [_hE]: 503,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceUnavailable, ServiceUnavailable$1);
+var ValidationError = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationError, ValidationError$1);
+var SageMakerRuntimeServiceException = [
+    -3,
+    _sm,
+    "SageMakerRuntimeServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_sm).registerError(SageMakerRuntimeServiceException, SageMakerRuntimeServiceException$1);
+var ResponseStream = [
+    3,
+    n0,
+    _RS,
+    {
+        [_st]: 1,
+    },
+    [_PP, _MSE, _ISF],
+    [
+        [() => PayloadPart, 0],
+        [() => ModelStreamError, 0],
+        [() => InternalStreamFailure, 0],
+    ],
+];
+var InvokeEndpoint = [
+    9,
+    n0,
+    _IE,
+    {
+        [_h]: ["POST", "/endpoints/{EndpointName}/invocations", 200],
+    },
+    () => InvokeEndpointInput,
+    () => InvokeEndpointOutput,
+];
+var InvokeEndpointAsync = [
+    9,
+    n0,
+    _IEA,
+    {
+        [_h]: ["POST", "/endpoints/{EndpointName}/async-invocations", 202],
+    },
+    () => InvokeEndpointAsyncInput,
+    () => InvokeEndpointAsyncOutput,
+];
+var InvokeEndpointWithResponseStream = [
+    9,
+    n0,
+    _IEWRS,
+    {
+        [_h]: ["POST", "/endpoints/{EndpointName}/invocations-response-stream", 200],
+    },
+    () => InvokeEndpointWithResponseStreamInput,
+    () => InvokeEndpointWithResponseStreamOutput,
+];
 
 class InvokeEndpointAsyncCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonSageMakerRuntime", "InvokeEndpointAsync", {})
     .n("SageMakerRuntimeClient", "InvokeEndpointAsyncCommand")
-    .f(InvokeEndpointAsyncInputFilterSensitiveLog, void 0)
-    .ser(se_InvokeEndpointAsyncCommand)
-    .de(de_InvokeEndpointAsyncCommand)
+    .sc(InvokeEndpointAsync)
     .build() {
 }
 
@@ -651,16 +785,11 @@ class InvokeEndpointCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonSageMakerRuntime", "InvokeEndpoint", {})
     .n("SageMakerRuntimeClient", "InvokeEndpointCommand")
-    .f(InvokeEndpointInputFilterSensitiveLog, InvokeEndpointOutputFilterSensitiveLog)
-    .ser(se_InvokeEndpointCommand)
-    .de(de_InvokeEndpointCommand)
+    .sc(InvokeEndpoint)
     .build() {
 }
 
@@ -668,10 +797,7 @@ class InvokeEndpointWithResponseStreamCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonSageMakerRuntime", "InvokeEndpointWithResponseStream", {
     eventStream: {
@@ -679,9 +805,7 @@ class InvokeEndpointWithResponseStreamCommand extends smithyClient.Command
     },
 })
     .n("SageMakerRuntimeClient", "InvokeEndpointWithResponseStreamCommand")
-    .f(InvokeEndpointWithResponseStreamInputFilterSensitiveLog, InvokeEndpointWithResponseStreamOutputFilterSensitiveLog)
-    .ser(se_InvokeEndpointWithResponseStreamCommand)
-    .de(de_InvokeEndpointWithResponseStreamCommand)
+    .sc(InvokeEndpointWithResponseStream)
     .build() {
 }
 
@@ -702,24 +826,17 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.InternalDependencyException = InternalDependencyException;
-exports.InternalFailure = InternalFailure;
-exports.InternalStreamFailure = InternalStreamFailure;
+exports.InternalDependencyException = InternalDependencyException$1;
+exports.InternalFailure = InternalFailure$1;
+exports.InternalStreamFailure = InternalStreamFailure$1;
 exports.InvokeEndpointAsyncCommand = InvokeEndpointAsyncCommand;
-exports.InvokeEndpointAsyncInputFilterSensitiveLog = InvokeEndpointAsyncInputFilterSensitiveLog;
 exports.InvokeEndpointCommand = InvokeEndpointCommand;
-exports.InvokeEndpointInputFilterSensitiveLog = InvokeEndpointInputFilterSensitiveLog;
-exports.InvokeEndpointOutputFilterSensitiveLog = InvokeEndpointOutputFilterSensitiveLog;
 exports.InvokeEndpointWithResponseStreamCommand = InvokeEndpointWithResponseStreamCommand;
-exports.InvokeEndpointWithResponseStreamInputFilterSensitiveLog = InvokeEndpointWithResponseStreamInputFilterSensitiveLog;
-exports.InvokeEndpointWithResponseStreamOutputFilterSensitiveLog = InvokeEndpointWithResponseStreamOutputFilterSensitiveLog;
-exports.ModelError = ModelError;
-exports.ModelNotReadyException = ModelNotReadyException;
-exports.ModelStreamError = ModelStreamError;
-exports.PayloadPartFilterSensitiveLog = PayloadPartFilterSensitiveLog;
-exports.ResponseStreamFilterSensitiveLog = ResponseStreamFilterSensitiveLog;
+exports.ModelError = ModelError$1;
+exports.ModelNotReadyException = ModelNotReadyException$1;
+exports.ModelStreamError = ModelStreamError$1;
 exports.SageMakerRuntime = SageMakerRuntime;
 exports.SageMakerRuntimeClient = SageMakerRuntimeClient;
-exports.SageMakerRuntimeServiceException = SageMakerRuntimeServiceException;
-exports.ServiceUnavailable = ServiceUnavailable;
-exports.ValidationError = ValidationError;
+exports.SageMakerRuntimeServiceException = SageMakerRuntimeServiceException$1;
+exports.ServiceUnavailable = ServiceUnavailable$1;
+exports.ValidationError = ValidationError$1;