@aws-sdk/client-auto-scaling 3.226.0 → 3.229.0

package/dist-es/protocols/Aws_query.js

@@ -39,6 +39,18 @@ export const serializeAws_queryAttachLoadBalancerTargetGroupsCommand = async (in
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_queryAttachTrafficSourcesCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_queryAttachTrafficSourcesType(input, context),
+        Action: "AttachTrafficSources",
+        Version: "2011-01-01",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_queryBatchDeleteScheduledActionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -433,6 +445,18 @@ export const serializeAws_queryDescribeTerminationPolicyTypesCommand = async (in
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_queryDescribeTrafficSourcesCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_queryDescribeTrafficSourcesRequest(input, context),
+        Action: "DescribeTrafficSources",
+        Version: "2011-01-01",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_queryDescribeWarmPoolCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -481,6 +505,18 @@ export const serializeAws_queryDetachLoadBalancerTargetGroupsCommand = async (in
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_queryDetachTrafficSourcesCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_queryDetachTrafficSourcesType(input, context),
+        Action: "DetachTrafficSources",
+        Version: "2011-01-01",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_queryDisableMetricsCollectionCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -826,6 +862,42 @@ const deserializeAws_queryAttachLoadBalancerTargetGroupsCommandError = async (ou
             });
     }
 };
+export const deserializeAws_queryAttachTrafficSourcesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_queryAttachTrafficSourcesCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_queryAttachTrafficSourcesResultType(data.AttachTrafficSourcesResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_queryAttachTrafficSourcesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ResourceContention":
+        case "com.amazonaws.autoscaling#ResourceContentionFault":
+            throw await deserializeAws_queryResourceContentionFaultResponse(parsedOutput, context);
+        case "ServiceLinkedRoleFailure":
+        case "com.amazonaws.autoscaling#ServiceLinkedRoleFailure":
+            throw await deserializeAws_queryServiceLinkedRoleFailureResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody: parsedBody.Error,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_queryBatchDeleteScheduledActionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_queryBatchDeleteScheduledActionCommandError(output, context);
@@ -2017,6 +2089,42 @@ const deserializeAws_queryDescribeTerminationPolicyTypesCommandError = async (ou
             });
     }
 };
+export const deserializeAws_queryDescribeTrafficSourcesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_queryDescribeTrafficSourcesCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_queryDescribeTrafficSourcesResponse(data.DescribeTrafficSourcesResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_queryDescribeTrafficSourcesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidNextToken":
+        case "com.amazonaws.autoscaling#InvalidNextToken":
+            throw await deserializeAws_queryInvalidNextTokenResponse(parsedOutput, context);
+        case "ResourceContention":
+        case "com.amazonaws.autoscaling#ResourceContentionFault":
+            throw await deserializeAws_queryResourceContentionFaultResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody: parsedBody.Error,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_queryDescribeWarmPoolCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_queryDescribeWarmPoolCommandError(output, context);
@@ -2155,6 +2263,39 @@ const deserializeAws_queryDetachLoadBalancerTargetGroupsCommandError = async (ou
             });
     }
 };
+export const deserializeAws_queryDetachTrafficSourcesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_queryDetachTrafficSourcesCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_queryDetachTrafficSourcesResultType(data.DetachTrafficSourcesResult, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_queryDetachTrafficSourcesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ResourceContention":
+        case "com.amazonaws.autoscaling#ResourceContentionFault":
+            throw await deserializeAws_queryResourceContentionFaultResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody: parsedBody.Error,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_queryDisableMetricsCollectionCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_queryDisableMetricsCollectionCommandError(output, context);
@@ -3051,6 +3192,23 @@ const serializeAws_queryAttachLoadBalancerTargetGroupsType = (input, context) =>
     }
     return entries;
 };
+const serializeAws_queryAttachTrafficSourcesType = (input, context) => {
+    const entries = {};
+    if (input.AutoScalingGroupName != null) {
+        entries["AutoScalingGroupName"] = input.AutoScalingGroupName;
+    }
+    if (input.TrafficSources != null) {
+        const memberEntries = serializeAws_queryTrafficSources(input.TrafficSources, context);
+        if (input.TrafficSources?.length === 0) {
+            entries.TrafficSources = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TrafficSources.${key}`;
+            entries[loc] = value;
+        });
+    }
+    return entries;
+};
 const serializeAws_queryAutoScalingGroupNames = (input, context) => {
     const entries = {};
     let counter = 1;
@@ -3388,6 +3546,16 @@ const serializeAws_queryCreateAutoScalingGroupType = (input, context) => {
     if (input.DefaultInstanceWarmup != null) {
         entries["DefaultInstanceWarmup"] = input.DefaultInstanceWarmup;
     }
+    if (input.TrafficSources != null) {
+        const memberEntries = serializeAws_queryTrafficSources(input.TrafficSources, context);
+        if (input.TrafficSources?.length === 0) {
+            entries.TrafficSources = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TrafficSources.${key}`;
+            entries[loc] = value;
+        });
+    }
     return entries;
 };
 const serializeAws_queryCreateLaunchConfigurationType = (input, context) => {
@@ -3518,6 +3686,16 @@ const serializeAws_queryCustomizedMetricSpecification = (input, context) => {
     if (input.Unit != null) {
         entries["Unit"] = input.Unit;
     }
+    if (input.Metrics != null) {
+        const memberEntries = serializeAws_queryTargetTrackingMetricDataQueries(input.Metrics, context);
+        if (input.Metrics?.length === 0) {
+            entries.Metrics = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Metrics.${key}`;
+            entries[loc] = value;
+        });
+    }
     return entries;
 };
 const serializeAws_queryDeleteAutoScalingGroupType = (input, context) => {
@@ -3808,6 +3986,22 @@ const serializeAws_queryDescribeTagsType = (input, context) => {
     }
     return entries;
 };
+const serializeAws_queryDescribeTrafficSourcesRequest = (input, context) => {
+    const entries = {};
+    if (input.AutoScalingGroupName != null) {
+        entries["AutoScalingGroupName"] = input.AutoScalingGroupName;
+    }
+    if (input.TrafficSourceType != null) {
+        entries["TrafficSourceType"] = input.TrafficSourceType;
+    }
+    if (input.NextToken != null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.MaxRecords != null) {
+        entries["MaxRecords"] = input.MaxRecords;
+    }
+    return entries;
+};
 const serializeAws_queryDescribeWarmPoolType = (input, context) => {
     const entries = {};
     if (input.AutoScalingGroupName != null) {
@@ -3893,6 +4087,23 @@ const serializeAws_queryDetachLoadBalancerTargetGroupsType = (input, context) =>
     }
     return entries;
 };
+const serializeAws_queryDetachTrafficSourcesType = (input, context) => {
+    const entries = {};
+    if (input.AutoScalingGroupName != null) {
+        entries["AutoScalingGroupName"] = input.AutoScalingGroupName;
+    }
+    if (input.TrafficSources != null) {
+        const memberEntries = serializeAws_queryTrafficSources(input.TrafficSources, context);
+        if (input.TrafficSources?.length === 0) {
+            entries.TrafficSources = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TrafficSources.${key}`;
+            entries[loc] = value;
+        });
+    }
+    return entries;
+};
 const serializeAws_queryDisableMetricsCollectionQuery = (input, context) => {
     const entries = {};
     if (input.AutoScalingGroupName != null) {
@@ -5347,6 +5558,61 @@ const serializeAws_queryTargetTrackingConfiguration = (input, context) => {
     }
     return entries;
 };
+const serializeAws_queryTargetTrackingMetricDataQueries = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        const memberEntries = serializeAws_queryTargetTrackingMetricDataQuery(entry, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            entries[`member.${counter}.${key}`] = value;
+        });
+        counter++;
+    }
+    return entries;
+};
+const serializeAws_queryTargetTrackingMetricDataQuery = (input, context) => {
+    const entries = {};
+    if (input.Id != null) {
+        entries["Id"] = input.Id;
+    }
+    if (input.Expression != null) {
+        entries["Expression"] = input.Expression;
+    }
+    if (input.MetricStat != null) {
+        const memberEntries = serializeAws_queryTargetTrackingMetricStat(input.MetricStat, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `MetricStat.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.Label != null) {
+        entries["Label"] = input.Label;
+    }
+    if (input.ReturnData != null) {
+        entries["ReturnData"] = input.ReturnData;
+    }
+    return entries;
+};
+const serializeAws_queryTargetTrackingMetricStat = (input, context) => {
+    const entries = {};
+    if (input.Metric != null) {
+        const memberEntries = serializeAws_queryMetric(input.Metric, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Metric.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.Stat != null) {
+        entries["Stat"] = input.Stat;
+    }
+    if (input.Unit != null) {
+        entries["Unit"] = input.Unit;
+    }
+    return entries;
+};
 const serializeAws_queryTerminateInstanceInAutoScalingGroupType = (input, context) => {
     const entries = {};
     if (input.InstanceId != null) {
@@ -5379,6 +5645,28 @@ const serializeAws_queryTotalLocalStorageGBRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_queryTrafficSourceIdentifier = (input, context) => {
+    const entries = {};
+    if (input.Identifier != null) {
+        entries["Identifier"] = input.Identifier;
+    }
+    return entries;
+};
+const serializeAws_queryTrafficSources = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        const memberEntries = serializeAws_queryTrafficSourceIdentifier(entry, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            entries[`member.${counter}.${key}`] = value;
+        });
+        counter++;
+    }
+    return entries;
+};
 const serializeAws_queryUpdateAutoScalingGroupType = (input, context) => {
     const entries = {};
     if (input.AutoScalingGroupName != null) {
@@ -5691,6 +5979,10 @@ const deserializeAws_queryAttachLoadBalancerTargetGroupsResultType = (output, co
     const contents = {};
     return contents;
 };
+const deserializeAws_queryAttachTrafficSourcesResultType = (output, context) => {
+    const contents = {};
+    return contents;
+};
 const deserializeAws_queryAutoScalingGroup = (output, context) => {
     const contents = {
         AutoScalingGroupName: undefined,
@@ -5726,6 +6018,7 @@ const deserializeAws_queryAutoScalingGroup = (output, context) => {
         Context: undefined,
         DesiredCapacityType: undefined,
         DefaultInstanceWarmup: undefined,
+        TrafficSources: undefined,
     };
     if (output["AutoScalingGroupName"] !== undefined) {
         contents.AutoScalingGroupName = __expectString(output["AutoScalingGroupName"]);
@@ -5850,6 +6143,12 @@ const deserializeAws_queryAutoScalingGroup = (output, context) => {
     if (output["DefaultInstanceWarmup"] !== undefined) {
         contents.DefaultInstanceWarmup = __strictParseInt32(output["DefaultInstanceWarmup"]);
     }
+    if (output.TrafficSources === "") {
+        contents.TrafficSources = [];
+    }
+    else if (output["TrafficSources"] !== undefined && output["TrafficSources"]["member"] !== undefined) {
+        contents.TrafficSources = deserializeAws_queryTrafficSources(__getArrayIfSingleItem(output["TrafficSources"]["member"]), context);
+    }
     return contents;
 };
 const deserializeAws_queryAutoScalingGroups = (output, context) => {
@@ -6084,6 +6383,7 @@ const deserializeAws_queryCustomizedMetricSpecification = (output, context) => {
         Dimensions: undefined,
         Statistic: undefined,
         Unit: undefined,
+        Metrics: undefined,
     };
     if (output["MetricName"] !== undefined) {
         contents.MetricName = __expectString(output["MetricName"]);
@@ -6103,6 +6403,12 @@ const deserializeAws_queryCustomizedMetricSpecification = (output, context) => {
     if (output["Unit"] !== undefined) {
         contents.Unit = __expectString(output["Unit"]);
     }
+    if (output.Metrics === "") {
+        contents.Metrics = [];
+    }
+    else if (output["Metrics"] !== undefined && output["Metrics"]["member"] !== undefined) {
+        contents.Metrics = deserializeAws_queryTargetTrackingMetricDataQueries(__getArrayIfSingleItem(output["Metrics"]["member"]), context);
+    }
     return contents;
 };
 const deserializeAws_queryDeleteLifecycleHookAnswer = (output, context) => {
@@ -6281,6 +6587,22 @@ const deserializeAws_queryDescribeTerminationPolicyTypesAnswer = (output, contex
     }
     return contents;
 };
+const deserializeAws_queryDescribeTrafficSourcesResponse = (output, context) => {
+    const contents = {
+        TrafficSources: undefined,
+        NextToken: undefined,
+    };
+    if (output.TrafficSources === "") {
+        contents.TrafficSources = [];
+    }
+    else if (output["TrafficSources"] !== undefined && output["TrafficSources"]["member"] !== undefined) {
+        contents.TrafficSources = deserializeAws_queryTrafficSourceStates(__getArrayIfSingleItem(output["TrafficSources"]["member"]), context);
+    }
+    if (output["NextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["NextToken"]);
+    }
+    return contents;
+};
 const deserializeAws_queryDescribeWarmPoolAnswer = (output, context) => {
     const contents = {
         WarmPoolConfiguration: undefined,
@@ -6334,6 +6656,10 @@ const deserializeAws_queryDetachLoadBalancerTargetGroupsResultType = (output, co
     const contents = {};
     return contents;
 };
+const deserializeAws_queryDetachTrafficSourcesResultType = (output, context) => {
+    const contents = {};
+    return contents;
+};
 const deserializeAws_queryEbs = (output, context) => {
     const contents = {
         SnapshotId: undefined,
@@ -7947,6 +8273,55 @@ const deserializeAws_queryTargetTrackingConfiguration = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_queryTargetTrackingMetricDataQueries = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_queryTargetTrackingMetricDataQuery(entry, context);
+    });
+};
+const deserializeAws_queryTargetTrackingMetricDataQuery = (output, context) => {
+    const contents = {
+        Id: undefined,
+        Expression: undefined,
+        MetricStat: undefined,
+        Label: undefined,
+        ReturnData: undefined,
+    };
+    if (output["Id"] !== undefined) {
+        contents.Id = __expectString(output["Id"]);
+    }
+    if (output["Expression"] !== undefined) {
+        contents.Expression = __expectString(output["Expression"]);
+    }
+    if (output["MetricStat"] !== undefined) {
+        contents.MetricStat = deserializeAws_queryTargetTrackingMetricStat(output["MetricStat"], context);
+    }
+    if (output["Label"] !== undefined) {
+        contents.Label = __expectString(output["Label"]);
+    }
+    if (output["ReturnData"] !== undefined) {
+        contents.ReturnData = __parseBoolean(output["ReturnData"]);
+    }
+    return contents;
+};
+const deserializeAws_queryTargetTrackingMetricStat = (output, context) => {
+    const contents = {
+        Metric: undefined,
+        Stat: undefined,
+        Unit: undefined,
+    };
+    if (output["Metric"] !== undefined) {
+        contents.Metric = deserializeAws_queryMetric(output["Metric"], context);
+    }
+    if (output["Stat"] !== undefined) {
+        contents.Stat = __expectString(output["Stat"]);
+    }
+    if (output["Unit"] !== undefined) {
+        contents.Unit = __expectString(output["Unit"]);
+    }
+    return contents;
+};
 const deserializeAws_queryTerminationPolicies = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
@@ -7967,6 +8342,42 @@ const deserializeAws_queryTotalLocalStorageGBRequest = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_queryTrafficSourceIdentifier = (output, context) => {
+    const contents = {
+        Identifier: undefined,
+    };
+    if (output["Identifier"] !== undefined) {
+        contents.Identifier = __expectString(output["Identifier"]);
+    }
+    return contents;
+};
+const deserializeAws_queryTrafficSources = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_queryTrafficSourceIdentifier(entry, context);
+    });
+};
+const deserializeAws_queryTrafficSourceState = (output, context) => {
+    const contents = {
+        TrafficSource: undefined,
+        State: undefined,
+    };
+    if (output["TrafficSource"] !== undefined) {
+        contents.TrafficSource = __expectString(output["TrafficSource"]);
+    }
+    if (output["State"] !== undefined) {
+        contents.State = __expectString(output["State"]);
+    }
+    return contents;
+};
+const deserializeAws_queryTrafficSourceStates = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_queryTrafficSourceState(entry, context);
+    });
+};
 const deserializeAws_queryVCpuCountRequest = (output, context) => {
     const contents = {
         Min: undefined,

package/dist-es/runtimeConfig.browser.js

@@ -3,8 +3,8 @@ import { Sha256 } from "@aws-crypto/sha256-browser";
 import { DEFAULT_USE_DUALSTACK_ENDPOINT, DEFAULT_USE_FIPS_ENDPOINT } from "@aws-sdk/config-resolver";
 import { FetchHttpHandler as RequestHandler, streamCollector } from "@aws-sdk/fetch-http-handler";
 import { invalidProvider } from "@aws-sdk/invalid-dependency";
-import { DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE } from "@aws-sdk/middleware-retry";
 import { calculateBodyLength } from "@aws-sdk/util-body-length-browser";
+import { DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE } from "@aws-sdk/util-retry";
 import { defaultUserAgent } from "@aws-sdk/util-user-agent-browser";
 import { fromUtf8, toUtf8 } from "@aws-sdk/util-utf8-browser";
 import { getRuntimeConfig as getSharedRuntimeConfig } from "./runtimeConfig.shared";

package/dist-es/runtimeConfig.js

@@ -3,10 +3,11 @@ import { decorateDefaultCredentialProvider } from "@aws-sdk/client-sts";
 import { NODE_REGION_CONFIG_FILE_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, } from "@aws-sdk/config-resolver";
 import { defaultProvider as credentialDefaultProvider } from "@aws-sdk/credential-provider-node";
 import { Hash } from "@aws-sdk/hash-node";
-import { DEFAULT_RETRY_MODE, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, NODE_RETRY_MODE_CONFIG_OPTIONS, } from "@aws-sdk/middleware-retry";
+import { NODE_MAX_ATTEMPT_CONFIG_OPTIONS, NODE_RETRY_MODE_CONFIG_OPTIONS } from "@aws-sdk/middleware-retry";
 import { loadConfig as loadNodeConfig } from "@aws-sdk/node-config-provider";
 import { NodeHttpHandler as RequestHandler, streamCollector } from "@aws-sdk/node-http-handler";
 import { calculateBodyLength } from "@aws-sdk/util-body-length-node";
+import { DEFAULT_RETRY_MODE } from "@aws-sdk/util-retry";
 import { defaultUserAgent } from "@aws-sdk/util-user-agent-node";
 import { fromUtf8, toUtf8 } from "@aws-sdk/util-utf8-node";
 import { getRuntimeConfig as getSharedRuntimeConfig } from "./runtimeConfig.shared";