@cdklabs/cdk-ssm-documents 0.0.64 → 0.0.66

package/node_modules/@smithy/core/dist-cjs/submodules/protocols/index.js

@@ -1,19 +1,23 @@
-'use strict';
-
-var serde = require('@smithy/core/serde');
-var schema = require('@smithy/core/schema');
-var transport = require('@smithy/core/transport');
-var types = require('@smithy/types');
+const { Uint8ArrayBlobAdapter, sdkStreamMixin, splitEvery, splitHeader, fromBase64, _parseEpochTimestamp, _parseRfc7231DateTime, _parseRfc3339DateTimeWithOffset, LazyJsonString, NumericValue, toUtf8, fromUtf8, generateIdempotencyToken, toBase64, dateToUtcString, quoteHeader } = require("@smithy/core/serde");
+const { TypeRegistry, NormalizedSchema, translateTraits } = require("@smithy/core/schema");
+const { HttpRequest, HttpResponse } = require("@smithy/core/transport");
+const { isValidHostname, parseQueryString, parseUrl } = require("@smithy/core/transport");
+exports.HttpRequest = HttpRequest;
+exports.HttpResponse = HttpResponse;
+exports.isValidHostname = isValidHostname;
+exports.parseQueryString = parseQueryString;
+exports.parseUrl = parseUrl;
+const { FieldPosition } = require("@smithy/types");
 
 const collectBody = async (streamBody = new Uint8Array(), context) => {
     if (streamBody instanceof Uint8Array) {
-        return serde.Uint8ArrayBlobAdapter.mutate(streamBody);
+        return Uint8ArrayBlobAdapter.mutate(streamBody);
     }
     if (!streamBody) {
-        return serde.Uint8ArrayBlobAdapter.mutate(new Uint8Array());
+        return Uint8ArrayBlobAdapter.mutate(new Uint8Array());
     }
     const fromContext = context.streamCollector(streamBody);
-    return serde.Uint8ArrayBlobAdapter.mutate(await fromContext);
+    return Uint8ArrayBlobAdapter.mutate(await fromContext);
 };
 
 function extendedEncodeURIComponent(str) {
@@ -35,16 +39,16 @@ class HttpProtocol extends SerdeContext {
     constructor(options) {
         super();
         this.options = options;
-        this.compositeErrorRegistry = schema.TypeRegistry.for(options.defaultNamespace);
+        this.compositeErrorRegistry = TypeRegistry.for(options.defaultNamespace);
         for (const etr of options.errorTypeRegistries ?? []) {
             this.compositeErrorRegistry.copyFrom(etr);
         }
     }
     getRequestType() {
-        return transport.HttpRequest;
+        return HttpRequest;
     }
     getResponseType() {
-        return transport.HttpResponse;
+        return HttpResponse;
     }
     setSerdeContext(serdeContext) {
         this.serdeContext = serdeContext;
@@ -96,8 +100,8 @@ class HttpProtocol extends SerdeContext {
         if (this.serdeContext?.disableHostPrefix) {
             return;
         }
-        const inputNs = schema.NormalizedSchema.of(operationSchema.input);
-        const opTraits = schema.translateTraits(operationSchema.traits ?? {});
+        const inputNs = NormalizedSchema.of(operationSchema.input);
+        const opTraits = translateTraits(operationSchema.traits ?? {});
         if (opTraits.endpoint) {
             let hostPrefix = opTraits.endpoint?.[0];
             if (typeof hostPrefix === "string") {
@@ -140,15 +144,23 @@ class HttpProtocol extends SerdeContext {
         });
     }
     async loadEventStreamCapability() {
-        const { EventStreamSerde } = await import('@smithy/core/event-streams');
+        const { EventStreamSerde, eventStreamSerdeProvider } = require('@smithy/core/event-streams');
+        const marshaller = this.resolveEventStreamMarshaller(eventStreamSerdeProvider);
         return new EventStreamSerde({
-            marshaller: this.getEventStreamMarshaller(),
+            marshaller,
             serializer: this.serializer,
             deserializer: this.deserializer,
             serdeContext: this.serdeContext,
             defaultContentType: this.getDefaultContentType(),
         });
     }
+    resolveEventStreamMarshaller(importedProvider) {
+        const context = this.serdeContext;
+        if (context.eventStreamMarshaller) {
+            return context.eventStreamMarshaller;
+        }
+        return importedProvider(this.serdeContext);
+    }
     getDefaultContentType() {
         throw new Error(`@smithy/core/protocols - ${this.constructor.name} getDefaultContentType() implementation missing.`);
     }
@@ -171,12 +183,12 @@ class HttpBindingProtocol extends HttpProtocol {
         const query = {};
         const headers = {};
         const endpoint = await context.endpoint();
-        const ns = schema.NormalizedSchema.of(operationSchema?.input);
+        const ns = NormalizedSchema.of(operationSchema?.input);
         const payloadMemberNames = [];
         const payloadMemberSchemas = [];
         let hasNonHttpBindingMember = false;
         let payload;
-        const request = new transport.HttpRequest({
+        const request = new HttpRequest({
             protocol: "",
             hostname: "",
             port: undefined,
@@ -189,7 +201,7 @@ class HttpBindingProtocol extends HttpProtocol {
         if (endpoint) {
             this.updateServiceEndpoint(request, endpoint);
             this.setHostPrefix(request, operationSchema, input);
-            const opTraits = schema.translateTraits(operationSchema.traits);
+            const opTraits = translateTraits(operationSchema.traits);
             if (opTraits.http) {
                 request.method = opTraits.http[0];
                 const [path, search] = opTraits.http[1].split("?");
@@ -331,7 +343,7 @@ class HttpBindingProtocol extends HttpProtocol {
     }
     async deserializeResponse(operationSchema, context, response) {
         const deserializer = this.deserializer;
-        const ns = schema.NormalizedSchema.of(operationSchema.output);
+        const ns = NormalizedSchema.of(operationSchema.output);
         const dataObject = {};
         if (response.statusCode >= 300) {
             const bytes = await collectBody(response.body, context);
@@ -364,7 +376,7 @@ class HttpBindingProtocol extends HttpProtocol {
         dataObject.$metadata = this.deserializeMetadata(response);
         return dataObject;
     }
-    async deserializeHttpMessage(schema$1, context, response, arg4, arg5) {
+    async deserializeHttpMessage(schema, context, response, arg4, arg5) {
         let dataObject;
         if (arg4 instanceof Set) {
             dataObject = arg5;
@@ -374,7 +386,7 @@ class HttpBindingProtocol extends HttpProtocol {
         }
         let discardResponseBody = true;
         const deserializer = this.deserializer;
-        const ns = schema.NormalizedSchema.of(schema$1);
+        const ns = NormalizedSchema.of(schema);
         const nonHttpBindingMembers = [];
         for (const [memberName, memberSchema] of ns.structIterator()) {
             const memberTraits = memberSchema.getMemberTraits();
@@ -390,7 +402,7 @@ class HttpBindingProtocol extends HttpProtocol {
                         });
                     }
                     else {
-                        dataObject[memberName] = serde.sdkStreamMixin(response.body);
+                        dataObject[memberName] = sdkStreamMixin(response.body);
                     }
                 }
                 else if (response.body) {
@@ -410,10 +422,10 @@ class HttpBindingProtocol extends HttpProtocol {
                         let sections;
                         if (headerListValueSchema.isTimestampSchema() &&
                             headerListValueSchema.getSchema() === 4) {
-                            sections = serde.splitEvery(value, ",", 2);
+                            sections = splitEvery(value, ",", 2);
                         }
                         else {
-                            sections = serde.splitHeader(value);
+                            sections = splitHeader(value);
                         }
                         const list = [];
                         for (const section of sections) {
@@ -455,11 +467,11 @@ class RpcProtocol extends HttpProtocol {
         const query = {};
         const headers = {};
         const endpoint = await context.endpoint();
-        const ns = schema.NormalizedSchema.of(operationSchema?.input);
-        const schema$1 = ns.getSchema();
+        const ns = NormalizedSchema.of(operationSchema?.input);
+        const schema = ns.getSchema();
         let payload;
         const input = _input && typeof _input === "object" ? _input : {};
-        const request = new transport.HttpRequest({
+        const request = new HttpRequest({
             protocol: "",
             hostname: "",
             port: undefined,
@@ -492,7 +504,7 @@ class RpcProtocol extends HttpProtocol {
                 }
             }
             else {
-                serializer.write(schema$1, input);
+                serializer.write(schema, input);
                 payload = serializer.flush();
             }
         }
@@ -504,7 +516,7 @@ class RpcProtocol extends HttpProtocol {
     }
     async deserializeResponse(operationSchema, context, response) {
         const deserializer = this.deserializer;
-        const ns = schema.NormalizedSchema.of(operationSchema.output);
+        const ns = NormalizedSchema.of(operationSchema.output);
         const dataObject = {};
         if (response.statusCode >= 300) {
             const bytes = await collectBody(response.body, context);
@@ -580,7 +592,7 @@ class RequestBuilder {
         for (const resolvePath of this.resolvePathStack) {
             resolvePath(this.path);
         }
-        return new transport.HttpRequest({
+        return new HttpRequest({
             protocol,
             hostname: this.hostname || hostname,
             port,
@@ -652,22 +664,22 @@ class FromStringShapeDeserializer extends SerdeContext {
         this.settings = settings;
     }
     read(_schema, data) {
-        const ns = schema.NormalizedSchema.of(_schema);
+        const ns = NormalizedSchema.of(_schema);
         if (ns.isListSchema()) {
-            return serde.splitHeader(data).map((item) => this.read(ns.getValueSchema(), item));
+            return splitHeader(data).map((item) => this.read(ns.getValueSchema(), item));
         }
         if (ns.isBlobSchema()) {
-            return (this.serdeContext?.base64Decoder ?? serde.fromBase64)(data);
+            return (this.serdeContext?.base64Decoder ?? fromBase64)(data);
         }
         if (ns.isTimestampSchema()) {
             const format = determineTimestampFormat(ns, this.settings);
             switch (format) {
                 case 5:
-                    return serde._parseRfc3339DateTimeWithOffset(data);
+                    return _parseRfc3339DateTimeWithOffset(data);
                 case 6:
-                    return serde._parseRfc7231DateTime(data);
+                    return _parseRfc7231DateTime(data);
                 case 7:
-                    return serde._parseEpochTimestamp(data);
+                    return _parseEpochTimestamp(data);
                 default:
                     console.warn("Missing timestamp format, parsing value with Date constructor:", data);
                     return new Date(data);
@@ -682,7 +694,7 @@ class FromStringShapeDeserializer extends SerdeContext {
                 }
                 const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
                 if (isJson) {
-                    intermediateValue = serde.LazyJsonString.from(intermediateValue);
+                    intermediateValue = LazyJsonString.from(intermediateValue);
                 }
                 return intermediateValue;
             }
@@ -694,7 +706,7 @@ class FromStringShapeDeserializer extends SerdeContext {
             return BigInt(data);
         }
         if (ns.isBigDecimalSchema()) {
-            return new serde.NumericValue(data, "bigDecimal");
+            return new NumericValue(data, "bigDecimal");
         }
         if (ns.isBooleanSchema()) {
             return String(data).toLowerCase() === "true";
@@ -702,7 +714,7 @@ class FromStringShapeDeserializer extends SerdeContext {
         return data;
     }
     base64ToUtf8(base64String) {
-        return (this.serdeContext?.utf8Encoder ?? serde.toUtf8)((this.serdeContext?.base64Decoder ?? serde.fromBase64)(base64String));
+        return (this.serdeContext?.utf8Encoder ?? toUtf8)((this.serdeContext?.base64Decoder ?? fromBase64)(base64String));
     }
 }
 
@@ -719,16 +731,16 @@ class HttpInterceptingShapeDeserializer extends SerdeContext {
         this.codecDeserializer.setSerdeContext(serdeContext);
         this.serdeContext = serdeContext;
     }
-    read(schema$1, data) {
-        const ns = schema.NormalizedSchema.of(schema$1);
+    read(schema, data) {
+        const ns = NormalizedSchema.of(schema);
         const traits = ns.getMergedTraits();
-        const toString = this.serdeContext?.utf8Encoder ?? serde.toUtf8;
+        const toString = this.serdeContext?.utf8Encoder ?? toUtf8;
         if (traits.httpHeader || traits.httpResponseCode) {
             return this.stringDeserializer.read(ns, toString(data));
         }
         if (traits.httpPayload) {
             if (ns.isBlobSchema()) {
-                const toBytes = this.serdeContext?.utf8Decoder ?? serde.fromUtf8;
+                const toBytes = this.serdeContext?.utf8Decoder ?? fromUtf8;
                 if (typeof data === "string") {
                     return toBytes(data);
                 }
@@ -752,8 +764,8 @@ class ToStringShapeSerializer extends SerdeContext {
         super();
         this.settings = settings;
     }
-    write(schema$1, value) {
-        const ns = schema.NormalizedSchema.of(schema$1);
+    write(schema, value) {
+        const ns = NormalizedSchema.of(schema);
         switch (typeof value) {
             case "object":
                 if (value === null) {
@@ -770,7 +782,7 @@ class ToStringShapeSerializer extends SerdeContext {
                             this.stringBuffer = value.toISOString().replace(".000Z", "Z");
                             break;
                         case 6:
-                            this.stringBuffer = serde.dateToUtcString(value);
+                            this.stringBuffer = dateToUtcString(value);
                             break;
                         case 7:
                             this.stringBuffer = String(value.getTime() / 1000);
@@ -782,7 +794,7 @@ class ToStringShapeSerializer extends SerdeContext {
                     return;
                 }
                 if (ns.isBlobSchema() && "byteLength" in value) {
-                    this.stringBuffer = (this.serdeContext?.base64Encoder ?? serde.toBase64)(value);
+                    this.stringBuffer = (this.serdeContext?.base64Encoder ?? toBase64)(value);
                     return;
                 }
                 if (ns.isListSchema() && Array.isArray(value)) {
@@ -790,7 +802,7 @@ class ToStringShapeSerializer extends SerdeContext {
                     for (const item of value) {
                         this.write([ns.getValueSchema(), ns.getMergedTraits()], item);
                         const headerItem = this.flush();
-                        const serialized = ns.getValueSchema().isTimestampSchema() ? headerItem : serde.quoteHeader(headerItem);
+                        const serialized = ns.getValueSchema().isTimestampSchema() ? headerItem : quoteHeader(headerItem);
                         if (buffer !== "") {
                             buffer += ", ";
                         }
@@ -807,10 +819,10 @@ class ToStringShapeSerializer extends SerdeContext {
                 if (mediaType) {
                     const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
                     if (isJson) {
-                        intermediateValue = serde.LazyJsonString.from(intermediateValue);
+                        intermediateValue = LazyJsonString.from(intermediateValue);
                     }
                     if (ns.getMergedTraits().httpHeader) {
-                        this.stringBuffer = (this.serdeContext?.base64Encoder ?? serde.toBase64)(intermediateValue.toString());
+                        this.stringBuffer = (this.serdeContext?.base64Encoder ?? toBase64)(intermediateValue.toString());
                         return;
                     }
                 }
@@ -818,7 +830,7 @@ class ToStringShapeSerializer extends SerdeContext {
                 break;
             default:
                 if (ns.isIdempotencyToken()) {
-                    this.stringBuffer = serde.generateIdempotencyToken();
+                    this.stringBuffer = generateIdempotencyToken();
                 }
                 else {
                     this.stringBuffer = String(value);
@@ -844,8 +856,8 @@ class HttpInterceptingShapeSerializer {
         this.codecSerializer.setSerdeContext(serdeContext);
         this.stringSerializer.setSerdeContext(serdeContext);
     }
-    write(schema$1, value) {
-        const ns = schema.NormalizedSchema.of(schema$1);
+    write(schema, value) {
+        const ns = NormalizedSchema.of(schema);
         const traits = ns.getMergedTraits();
         if (traits.httpHeader || traits.httpLabel || traits.httpQuery) {
             this.stringSerializer.write(ns, value);
@@ -868,7 +880,7 @@ class Field {
     name;
     kind;
     values;
-    constructor({ name, kind = types.FieldPosition.HEADER, values = [] }) {
+    constructor({ name, kind = FieldPosition.HEADER, values = [] }) {
         this.name = name;
         this.kind = kind;
         this.values = values;
@@ -937,7 +949,7 @@ const CONTENT_LENGTH_HEADER = "content-length";
 function contentLengthMiddleware(bodyLengthChecker) {
     return (next) => async (args) => {
         const request = args.request;
-        if (transport.HttpRequest.isInstance(request)) {
+        if (HttpRequest.isInstance(request)) {
             const { body, headers } = request;
             if (body &&
                 Object.keys(headers)
@@ -998,11 +1010,6 @@ function buildQueryString(query) {
     return parts.join("&");
 }
 
-exports.HttpRequest = transport.HttpRequest;
-exports.HttpResponse = transport.HttpResponse;
-exports.isValidHostname = transport.isValidHostname;
-exports.parseQueryString = transport.parseQueryString;
-exports.parseUrl = transport.parseUrl;
 exports.Field = Field;
 exports.Fields = Fields;
 exports.FromStringShapeDeserializer = FromStringShapeDeserializer;

package/node_modules/@smithy/core/dist-cjs/submodules/retry/index.browser.js

@@ -1,8 +1,6 @@
-'use strict';
-
-var client = require('@smithy/core/client');
-var protocols = require('@smithy/core/protocols');
-var serde = require('@smithy/core/serde');
+const { NoOpLogger, normalizeProvider } = require("@smithy/core/client");
+const { HttpResponse, HttpRequest } = require("@smithy/core/protocols");
+const { parseRfc7231DateTime, v4 } = require("@smithy/core/serde");
 
 const isStreamingPayload = (request) => request?.body instanceof ReadableStream;
 
@@ -90,7 +88,7 @@ const INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
 const REQUEST_HEADER = "amz-sdk-request";
 
 function parseRetryAfterHeader(response, logger) {
-    if (!protocols.HttpResponse.isInstance(response)) {
+    if (!HttpResponse.isInstance(response)) {
         return;
     }
     for (const header of Object.keys(response.headers)) {
@@ -100,7 +98,7 @@ function parseRetryAfterHeader(response, logger) {
             let retryAfterSeconds = NaN;
             if (retryAfter.endsWith("GMT")) {
                 try {
-                    const date = serde.parseRfc7231DateTime(retryAfter);
+                    const date = parseRfc7231DateTime(retryAfter);
                     retryAfterSeconds = (date.getTime() - Date.now()) / 1000;
                 }
                 catch (e) {
@@ -158,9 +156,9 @@ function bindRetryMiddleware(isStreamingPayload) {
             let attempts = 0;
             let totalRetryDelay = 0;
             const { request } = args;
-            const isRequest = protocols.HttpRequest.isInstance(request);
+            const isRequest = HttpRequest.isInstance(request);
             if (isRequest) {
-                request.headers[INVOCATION_ID_HEADER] = serde.v4();
+                request.headers[INVOCATION_ID_HEADER] = v4();
             }
             while (true) {
                 try {
@@ -177,7 +175,7 @@ function bindRetryMiddleware(isStreamingPayload) {
                     const retryErrorInfo = getRetryErrorInfo(e, options.logger);
                     lastError = asSdkError(e);
                     if (isRequest && isStreamingPayload(request)) {
-                        (context.logger instanceof client.NoOpLogger ? console : context.logger)?.warn("An error was encountered in a non-retryable streaming request.");
+                        (context.logger instanceof NoOpLogger ? console : context.logger)?.warn("An error was encountered in a non-retryable streaming request.");
                         throw lastError;
                     }
                     try {
@@ -250,7 +248,7 @@ function bindGetRetryPlugin(isStreamingPayload) {
 }
 
 class DefaultRateLimiter {
-    static setTimeoutFn = setTimeout;
+    static setTimeoutFn = (fn, delay) => setTimeout(fn, delay);
     beta;
     minCapacity;
     minFillRate;
@@ -420,13 +418,13 @@ class DefaultRetryToken {
     }
 }
 
-exports.RETRY_MODES = void 0;
+var RETRY_MODES;
 (function (RETRY_MODES) {
     RETRY_MODES["STANDARD"] = "standard";
     RETRY_MODES["ADAPTIVE"] = "adaptive";
-})(exports.RETRY_MODES || (exports.RETRY_MODES = {}));
+})(RETRY_MODES || (RETRY_MODES = {}));
 const DEFAULT_MAX_ATTEMPTS = 3;
-const DEFAULT_RETRY_MODE = exports.RETRY_MODES.STANDARD;
+const DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;
 
 const refusal = {
     incompatible: 1,
@@ -434,7 +432,7 @@ const refusal = {
     capacity: 3,
 };
 let StandardRetryStrategy$1 = class StandardRetryStrategy {
-    mode = exports.RETRY_MODES.STANDARD;
+    mode = RETRY_MODES.STANDARD;
     retryBackoffStrategy;
     capacity = INITIAL_RETRY_TOKENS;
     maxAttemptsProvider;
@@ -522,7 +520,7 @@ let StandardRetryStrategy$1 = class StandardRetryStrategy {
 };
 
 let AdaptiveRetryStrategy$1 = class AdaptiveRetryStrategy {
-    mode = exports.RETRY_MODES.ADAPTIVE;
+    mode = RETRY_MODES.ADAPTIVE;
     rateLimiter;
     standardRetryStrategy;
     constructor(maxAttemptsProvider, options) {
@@ -613,7 +611,7 @@ class StandardRetryStrategy {
     retryDecider;
     delayDecider;
     retryQuota;
-    mode = exports.RETRY_MODES.STANDARD;
+    mode = RETRY_MODES.STANDARD;
     constructor(maxAttemptsProvider, options) {
         this.maxAttemptsProvider = maxAttemptsProvider;
         this.retryDecider = options?.retryDecider ?? defaultRetryDecider;
@@ -639,12 +637,12 @@ class StandardRetryStrategy {
         let totalDelay = 0;
         const maxAttempts = await this.getMaxAttempts();
         const { request } = args;
-        if (protocols.HttpRequest.isInstance(request)) {
-            request.headers[INVOCATION_ID_HEADER] = serde.v4();
+        if (HttpRequest.isInstance(request)) {
+            request.headers[INVOCATION_ID_HEADER] = v4();
         }
         while (true) {
             try {
-                if (protocols.HttpRequest.isInstance(request)) {
+                if (HttpRequest.isInstance(request)) {
                     request.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
                 }
                 if (options?.beforeRequest) {
@@ -682,7 +680,7 @@ class StandardRetryStrategy {
     }
 }
 const getDelayFromRetryAfterHeader = (response) => {
-    if (!protocols.HttpResponse.isInstance(response))
+    if (!HttpResponse.isInstance(response))
         return;
     const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
     if (!retryAfterHeaderName)
@@ -690,9 +688,9 @@ const getDelayFromRetryAfterHeader = (response) => {
     const retryAfter = response.headers[retryAfterHeaderName];
     const retryAfterSeconds = Number(retryAfter);
     if (!Number.isNaN(retryAfterSeconds))
-        return retryAfterSeconds * 1000;
+        return Math.min(retryAfterSeconds * 1000, 20_000);
     const retryAfterDate = new Date(retryAfter);
-    return retryAfterDate.getTime() - Date.now();
+    return Math.min(retryAfterDate.getTime() - Date.now(), 20_000);
 };
 
 class AdaptiveRetryStrategy extends StandardRetryStrategy {
@@ -701,7 +699,7 @@ class AdaptiveRetryStrategy extends StandardRetryStrategy {
         const { rateLimiter, ...superOptions } = options ?? {};
         super(maxAttemptsProvider, superOptions);
         this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
-        this.mode = exports.RETRY_MODES.ADAPTIVE;
+        this.mode = RETRY_MODES.ADAPTIVE;
     }
     async retry(next, args) {
         return super.retry(next, args, {
@@ -718,13 +716,13 @@ class AdaptiveRetryStrategy extends StandardRetryStrategy {
 const resolveRetryConfig = (input, defaults) => {
     const { retryStrategy, retryMode } = input;
     const { defaultMaxAttempts = DEFAULT_MAX_ATTEMPTS, defaultBaseDelay = Retry.delay() } = defaults ?? {};
-    const maxAttemptsProvider = client.normalizeProvider(input.maxAttempts ?? defaultMaxAttempts);
+    const maxAttemptsProvider = normalizeProvider(input.maxAttempts ?? defaultMaxAttempts);
     let controller = retryStrategy
         ? Promise.resolve(retryStrategy)
         : undefined;
     const getDefault = async () => {
         const maxAttempts = await maxAttemptsProvider();
-        const adaptive = (await client.normalizeProvider(retryMode)()) === exports.RETRY_MODES.ADAPTIVE;
+        const adaptive = (await normalizeProvider(retryMode)()) === RETRY_MODES.ADAPTIVE;
         if (adaptive) {
             return new AdaptiveRetryStrategy$1(maxAttemptsProvider, {
                 maxAttempts,
@@ -744,7 +742,7 @@ const resolveRetryConfig = (input, defaults) => {
 
 const omitRetryHeadersMiddleware = () => (next) => async (args) => {
     const { request } = args;
-    if (protocols.HttpRequest.isInstance(request)) {
+    if (HttpRequest.isInstance(request)) {
         delete request.headers[INVOCATION_ID_HEADER];
         delete request.headers[REQUEST_HEADER];
     }
@@ -793,6 +791,7 @@ exports.NODE_RETRY_MODE_CONFIG_OPTIONS = NODE_RETRY_MODE_CONFIG_OPTIONS;
 exports.NO_RETRY_INCREMENT = NO_RETRY_INCREMENT;
 exports.REQUEST_HEADER = REQUEST_HEADER;
 exports.RETRY_COST = RETRY_COST;
+exports.RETRY_MODES = RETRY_MODES;
 exports.Retry = Retry;
 exports.StandardRetryStrategy = StandardRetryStrategy$1;
 exports.THROTTLING_RETRY_DELAY_BASE = THROTTLING_RETRY_DELAY_BASE;