@senpiper/sp-agent 0.1.6 → 0.1.7

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

@@ -1,23 +1,18 @@
-const { Uint8ArrayBlobAdapter, sdkStreamMixin, splitEvery, splitHeader, fromBase64, _parseEpochTimestamp, _parseRfc7231DateTime, _parseRfc3339DateTimeWithOffset, LazyJsonString, NumericValue, toUtf8, fromUtf8, generateIdempotencyToken, toBase64, dateToUtcString, quoteHeader } = require("@smithy/core/serde");
-const { HttpRequest, HttpResponse, hasOwn, isValidHostname } = require("@smithy/core/transport");
-const { parseQueryString, parseUrl } = require("@smithy/core/transport");
-exports.HttpRequest = HttpRequest;
-exports.HttpResponse = HttpResponse;
-exports.isValidHostname = isValidHostname;
-exports.parseQueryString = parseQueryString;
-exports.parseUrl = parseUrl;
-const { TypeRegistry, NormalizedSchema, translateTraits } = require("@smithy/core/schema");
-const { FieldPosition } = require("@smithy/types");
+'use strict';
+
+var serde = require('@smithy/core/serde');
+var schema = require('@smithy/core/schema');
+var types = require('@smithy/types');
 
 const collectBody = async (streamBody = new Uint8Array(), context) => {
     if (streamBody instanceof Uint8Array) {
-        return Uint8ArrayBlobAdapter.mutate(streamBody);
+        return serde.Uint8ArrayBlobAdapter.mutate(streamBody);
     }
     if (!streamBody) {
-        return Uint8ArrayBlobAdapter.mutate(new Uint8Array());
+        return serde.Uint8ArrayBlobAdapter.mutate(new Uint8Array());
     }
     const fromContext = context.streamCollector(streamBody);
-    return Uint8ArrayBlobAdapter.mutate(await fromContext);
+    return serde.Uint8ArrayBlobAdapter.mutate(await fromContext);
 };
 
 function extendedEncodeURIComponent(str) {
@@ -33,13 +28,97 @@ class SerdeContext {
     }
 }
 
+class HttpRequest {
+    method;
+    protocol;
+    hostname;
+    port;
+    path;
+    query;
+    headers;
+    username;
+    password;
+    fragment;
+    body;
+    constructor(options) {
+        this.method = options.method || "GET";
+        this.hostname = options.hostname || "localhost";
+        this.port = options.port;
+        this.query = options.query || {};
+        this.headers = options.headers || {};
+        this.body = options.body;
+        this.protocol = options.protocol
+            ? options.protocol.slice(-1) !== ":"
+                ? `${options.protocol}:`
+                : options.protocol
+            : "https:";
+        this.path = options.path ? (options.path.charAt(0) !== "/" ? `/${options.path}` : options.path) : "/";
+        this.username = options.username;
+        this.password = options.password;
+        this.fragment = options.fragment;
+    }
+    static clone(request) {
+        const cloned = new HttpRequest({
+            ...request,
+            headers: { ...request.headers },
+        });
+        if (cloned.query) {
+            cloned.query = cloneQuery(cloned.query);
+        }
+        return cloned;
+    }
+    static isInstance(request) {
+        if (!request) {
+            return false;
+        }
+        const req = request;
+        return ("method" in req &&
+            "protocol" in req &&
+            "hostname" in req &&
+            "path" in req &&
+            typeof req["query"] === "object" &&
+            typeof req["headers"] === "object");
+    }
+    clone() {
+        return HttpRequest.clone(this);
+    }
+}
+function cloneQuery(query) {
+    return Object.keys(query).reduce((carry, paramName) => {
+        const param = query[paramName];
+        return {
+            ...carry,
+            [paramName]: Array.isArray(param) ? [...param] : param,
+        };
+    }, {});
+}
+
+class HttpResponse {
+    statusCode;
+    reason;
+    headers;
+    body;
+    constructor(options) {
+        this.statusCode = options.statusCode;
+        this.reason = options.reason;
+        this.headers = options.headers || {};
+        this.body = options.body;
+    }
+    static isInstance(response) {
+        if (!response)
+            return false;
+        const resp = response;
+        return typeof resp.statusCode === "number" && typeof resp.headers === "object";
+    }
+}
+
 class HttpProtocol extends SerdeContext {
     options;
     compositeErrorRegistry;
     constructor(options) {
         super();
         this.options = options;
-        this.compositeErrorRegistry = TypeRegistry.for(options.defaultNamespace);
+        this.compositeErrorRegistry = schema.TypeRegistry.for(options.defaultNamespace);
         for (const etr of options.errorTypeRegistries ?? []) {
             this.compositeErrorRegistry.copyFrom(etr);
         }
@@ -75,8 +154,6 @@ class HttpProtocol extends SerdeContext {
             }
             if (endpoint.headers) {
                 for (const name in endpoint.headers) {
-                    if (!hasOwn(endpoint.headers, name))
-                        continue;
                     request.headers[name] = endpoint.headers[name].join(", ");
                 }
             }
@@ -92,8 +169,6 @@ class HttpProtocol extends SerdeContext {
             };
             if (endpoint.headers) {
                 for (const name in endpoint.headers) {
-                    if (!hasOwn(endpoint.headers, name))
-                        continue;
                     request.headers[name] = endpoint.headers[name];
                 }
             }
@@ -104,8 +179,8 @@ class HttpProtocol extends SerdeContext {
         if (this.serdeContext?.disableHostPrefix) {
             return;
         }
-        const inputNs = NormalizedSchema.of(operationSchema.input);
-        const opTraits = translateTraits(operationSchema.traits ?? {});
+        const inputNs = schema.NormalizedSchema.of(operationSchema.input);
+        const opTraits = schema.translateTraits(operationSchema.traits ?? {});
         if (opTraits.endpoint) {
             let hostPrefix = opTraits.endpoint?.[0];
             if (typeof hostPrefix === "string") {
@@ -120,9 +195,6 @@ class HttpProtocol extends SerdeContext {
                     hostPrefix = hostPrefix.replace(`{${name}}`, replacement);
                 }
                 request.hostname = hostPrefix + request.hostname;
-                if (!isValidHostname(request.hostname)) {
-                    throw new Error(`[${request.hostname}] is not a valid hostname.`);
-                }
             }
         }
     }
@@ -151,24 +223,15 @@ class HttpProtocol extends SerdeContext {
         });
     }
     async loadEventStreamCapability() {
-        const { EventStreamSerde, eventStreamSerdeProvider } = require('@smithy/core/event-streams');
-        const marshaller = this.resolveEventStreamMarshaller(eventStreamSerdeProvider);
+        const { EventStreamSerde } = await import('@smithy/core/event-streams');
         return new EventStreamSerde({
-            marshaller,
+            marshaller: this.getEventStreamMarshaller(),
             serializer: this.serializer,
             deserializer: this.deserializer,
             serdeContext: this.serdeContext,
             defaultContentType: this.getDefaultContentType(),
-            compositeErrorRegistry: this.compositeErrorRegistry,
         });
     }
-    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.`);
     }
@@ -191,7 +254,7 @@ class HttpBindingProtocol extends HttpProtocol {
         const query = {};
         const headers = {};
         const endpoint = await context.endpoint();
-        const ns = NormalizedSchema.of(operationSchema?.input);
+        const ns = schema.NormalizedSchema.of(operationSchema?.input);
         const payloadMemberNames = [];
         const payloadMemberSchemas = [];
         let hasNonHttpBindingMember = false;
@@ -209,7 +272,7 @@ class HttpBindingProtocol extends HttpProtocol {
         if (endpoint) {
             this.updateServiceEndpoint(request, endpoint);
             this.setHostPrefix(request, operationSchema, input);
-            const opTraits = translateTraits(operationSchema.traits);
+            const opTraits = schema.translateTraits(operationSchema.traits);
             if (opTraits.http) {
                 request.method = opTraits.http[0];
                 const [path, search] = opTraits.http[1].split("?");
@@ -273,8 +336,6 @@ class HttpBindingProtocol extends HttpProtocol {
             }
             else if (typeof memberTraits.httpPrefixHeaders === "string") {
                 for (const key in inputMemberValue) {
-                    if (!hasOwn(inputMemberValue, key))
-                        continue;
                     const val = inputMemberValue[key];
                     const amalgam = memberTraits.httpPrefixHeaders + key;
                     serializer.write([memberNs.getValueSchema(), { httpHeader: amalgam }], val);
@@ -321,8 +382,6 @@ class HttpBindingProtocol extends HttpProtocol {
         const traits = ns.getMergedTraits();
         if (traits.httpQueryParams) {
             for (const key in data) {
-                if (!hasOwn(data, key))
-                    continue;
                 if (!(key in query)) {
                     const val = data[key];
                     const valueSchema = ns.getValueSchema();
@@ -355,7 +414,7 @@ class HttpBindingProtocol extends HttpProtocol {
     }
     async deserializeResponse(operationSchema, context, response) {
         const deserializer = this.deserializer;
-        const ns = NormalizedSchema.of(operationSchema.output);
+        const ns = schema.NormalizedSchema.of(operationSchema.output);
         const dataObject = {};
         if (response.statusCode >= 300) {
             const bytes = await collectBody(response.body, context);
@@ -366,8 +425,6 @@ class HttpBindingProtocol extends HttpProtocol {
             throw new Error("@smithy/core/protocols - HTTP Protocol error handler failed to throw.");
         }
         for (const header in response.headers) {
-            if (!hasOwn(response.headers, header))
-                continue;
             const value = response.headers[header];
             delete response.headers[header];
             response.headers[header.toLowerCase()] = value;
@@ -390,7 +447,7 @@ class HttpBindingProtocol extends HttpProtocol {
         dataObject.$metadata = this.deserializeMetadata(response);
         return dataObject;
     }
-    async deserializeHttpMessage(schema, context, response, arg4, arg5) {
+    async deserializeHttpMessage(schema$1, context, response, arg4, arg5) {
         let dataObject;
         if (arg4 instanceof Set) {
             dataObject = arg5;
@@ -400,7 +457,7 @@ class HttpBindingProtocol extends HttpProtocol {
         }
         let discardResponseBody = true;
         const deserializer = this.deserializer;
-        const ns = NormalizedSchema.of(schema);
+        const ns = schema.NormalizedSchema.of(schema$1);
         const nonHttpBindingMembers = [];
         for (const [memberName, memberSchema] of ns.structIterator()) {
             const memberTraits = memberSchema.getMemberTraits();
@@ -416,7 +473,7 @@ class HttpBindingProtocol extends HttpProtocol {
                         });
                     }
                     else {
-                        dataObject[memberName] = sdkStreamMixin(response.body);
+                        dataObject[memberName] = serde.sdkStreamMixin(response.body);
                     }
                 }
                 else if (response.body) {
@@ -436,10 +493,10 @@ class HttpBindingProtocol extends HttpProtocol {
                         let sections;
                         if (headerListValueSchema.isTimestampSchema() &&
                             headerListValueSchema.getSchema() === 4) {
-                            sections = splitEvery(value, ",", 2);
+                            sections = serde.splitEvery(value, ",", 2);
                         }
                         else {
-                            sections = splitHeader(value);
+                            sections = serde.splitHeader(value);
                         }
                         const list = [];
                         for (const section of sections) {
@@ -455,8 +512,6 @@ class HttpBindingProtocol extends HttpProtocol {
             else if (memberTraits.httpPrefixHeaders !== undefined) {
                 dataObject[memberName] = {};
                 for (const header in response.headers) {
-                    if (!hasOwn(response.headers, header))
-                        continue;
                     if (header.startsWith(memberTraits.httpPrefixHeaders)) {
                         const value = response.headers[header];
                         const valueSchema = memberSchema.getValueSchema();
@@ -483,8 +538,8 @@ class RpcProtocol extends HttpProtocol {
         const query = {};
         const headers = {};
         const endpoint = await context.endpoint();
-        const ns = NormalizedSchema.of(operationSchema?.input);
-        const schema = ns.getSchema();
+        const ns = schema.NormalizedSchema.of(operationSchema?.input);
+        const schema$1 = ns.getSchema();
         let payload;
         const input = _input && typeof _input === "object" ? _input : {};
         const request = new HttpRequest({
@@ -506,9 +561,10 @@ class RpcProtocol extends HttpProtocol {
             if (eventStreamMember) {
                 if (input[eventStreamMember]) {
                     const initialRequest = {};
-                    for (const [memberName] of ns.structIterator()) {
-                        if (memberName !== eventStreamMember && input[memberName] != null) {
-                            initialRequest[memberName] = input[memberName];
+                    for (const [memberName, memberSchema] of ns.structIterator()) {
+                        if (memberName !== eventStreamMember && input[memberName]) {
+                            serializer.write(memberSchema, input[memberName]);
+                            initialRequest[memberName] = serializer.flush();
                         }
                     }
                     payload = await this.serializeEventStream({
@@ -519,7 +575,7 @@ class RpcProtocol extends HttpProtocol {
                 }
             }
             else {
-                serializer.write(schema, input);
+                serializer.write(schema$1, input);
                 payload = serializer.flush();
             }
         }
@@ -531,7 +587,7 @@ class RpcProtocol extends HttpProtocol {
     }
     async deserializeResponse(operationSchema, context, response) {
         const deserializer = this.deserializer;
-        const ns = NormalizedSchema.of(operationSchema.output);
+        const ns = schema.NormalizedSchema.of(operationSchema.output);
         const dataObject = {};
         if (response.statusCode >= 300) {
             const bytes = await collectBody(response.body, context);
@@ -542,8 +598,6 @@ class RpcProtocol extends HttpProtocol {
             throw new Error("@smithy/core/protocols - RPC Protocol error handler failed to throw.");
         }
         for (const header in response.headers) {
-            if (!hasOwn(response.headers, header))
-                continue;
             const value = response.headers[header];
             delete response.headers[header];
             response.headers[header.toLowerCase()] = value;
@@ -681,22 +735,22 @@ class FromStringShapeDeserializer extends SerdeContext {
         this.settings = settings;
     }
     read(_schema, data) {
-        const ns = NormalizedSchema.of(_schema);
+        const ns = schema.NormalizedSchema.of(_schema);
         if (ns.isListSchema()) {
-            return splitHeader(data).map((item) => this.read(ns.getValueSchema(), item));
+            return serde.splitHeader(data).map((item) => this.read(ns.getValueSchema(), item));
         }
         if (ns.isBlobSchema()) {
-            return (this.serdeContext?.base64Decoder ?? fromBase64)(data);
+            return (this.serdeContext?.base64Decoder ?? serde.fromBase64)(data);
         }
         if (ns.isTimestampSchema()) {
             const format = determineTimestampFormat(ns, this.settings);
             switch (format) {
                 case 5:
-                    return _parseRfc3339DateTimeWithOffset(data);
+                    return serde._parseRfc3339DateTimeWithOffset(data);
                 case 6:
-                    return _parseRfc7231DateTime(data);
+                    return serde._parseRfc7231DateTime(data);
                 case 7:
-                    return _parseEpochTimestamp(data);
+                    return serde._parseEpochTimestamp(data);
                 default:
                     console.warn("Missing timestamp format, parsing value with Date constructor:", data);
                     return new Date(data);
@@ -711,7 +765,7 @@ class FromStringShapeDeserializer extends SerdeContext {
                 }
                 const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
                 if (isJson) {
-                    intermediateValue = LazyJsonString.from(intermediateValue);
+                    intermediateValue = serde.LazyJsonString.from(intermediateValue);
                 }
                 return intermediateValue;
             }
@@ -723,7 +777,7 @@ class FromStringShapeDeserializer extends SerdeContext {
             return BigInt(data);
         }
         if (ns.isBigDecimalSchema()) {
-            return new NumericValue(data, "bigDecimal");
+            return new serde.NumericValue(data, "bigDecimal");
         }
         if (ns.isBooleanSchema()) {
             return String(data).toLowerCase() === "true";
@@ -731,7 +785,7 @@ class FromStringShapeDeserializer extends SerdeContext {
         return data;
     }
     base64ToUtf8(base64String) {
-        return (this.serdeContext?.utf8Encoder ?? toUtf8)((this.serdeContext?.base64Decoder ?? fromBase64)(base64String));
+        return (this.serdeContext?.utf8Encoder ?? serde.toUtf8)((this.serdeContext?.base64Decoder ?? serde.fromBase64)(base64String));
     }
 }
 
@@ -748,16 +802,16 @@ class HttpInterceptingShapeDeserializer extends SerdeContext {
         this.codecDeserializer.setSerdeContext(serdeContext);
         this.serdeContext = serdeContext;
     }
-    read(schema, data) {
-        const ns = NormalizedSchema.of(schema);
+    read(schema$1, data) {
+        const ns = schema.NormalizedSchema.of(schema$1);
         const traits = ns.getMergedTraits();
-        const toString = this.serdeContext?.utf8Encoder ?? toUtf8;
+        const toString = this.serdeContext?.utf8Encoder ?? serde.toUtf8;
         if (traits.httpHeader || traits.httpResponseCode) {
             return this.stringDeserializer.read(ns, toString(data));
         }
         if (traits.httpPayload) {
             if (ns.isBlobSchema()) {
-                const toBytes = this.serdeContext?.utf8Decoder ?? fromUtf8;
+                const toBytes = this.serdeContext?.utf8Decoder ?? serde.fromUtf8;
                 if (typeof data === "string") {
                     return toBytes(data);
                 }
@@ -781,8 +835,8 @@ class ToStringShapeSerializer extends SerdeContext {
         super();
         this.settings = settings;
     }
-    write(schema, value) {
-        const ns = NormalizedSchema.of(schema);
+    write(schema$1, value) {
+        const ns = schema.NormalizedSchema.of(schema$1);
         switch (typeof value) {
             case "object":
                 if (value === null) {
@@ -799,7 +853,7 @@ class ToStringShapeSerializer extends SerdeContext {
                             this.stringBuffer = value.toISOString().replace(".000Z", "Z");
                             break;
                         case 6:
-                            this.stringBuffer = dateToUtcString(value);
+                            this.stringBuffer = serde.dateToUtcString(value);
                             break;
                         case 7:
                             this.stringBuffer = String(value.getTime() / 1000);
@@ -811,7 +865,7 @@ class ToStringShapeSerializer extends SerdeContext {
                     return;
                 }
                 if (ns.isBlobSchema() && "byteLength" in value) {
-                    this.stringBuffer = (this.serdeContext?.base64Encoder ?? toBase64)(value);
+                    this.stringBuffer = (this.serdeContext?.base64Encoder ?? serde.toBase64)(value);
                     return;
                 }
                 if (ns.isListSchema() && Array.isArray(value)) {
@@ -819,7 +873,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 : quoteHeader(headerItem);
+                        const serialized = ns.getValueSchema().isTimestampSchema() ? headerItem : serde.quoteHeader(headerItem);
                         if (buffer !== "") {
                             buffer += ", ";
                         }
@@ -836,10 +890,10 @@ class ToStringShapeSerializer extends SerdeContext {
                 if (mediaType) {
                     const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
                     if (isJson) {
-                        intermediateValue = LazyJsonString.from(intermediateValue);
+                        intermediateValue = serde.LazyJsonString.from(intermediateValue);
                     }
                     if (ns.getMergedTraits().httpHeader) {
-                        this.stringBuffer = (this.serdeContext?.base64Encoder ?? toBase64)(intermediateValue.toString());
+                        this.stringBuffer = (this.serdeContext?.base64Encoder ?? serde.toBase64)(intermediateValue.toString());
                         return;
                     }
                 }
@@ -847,7 +901,7 @@ class ToStringShapeSerializer extends SerdeContext {
                 break;
             default:
                 if (ns.isIdempotencyToken()) {
-                    this.stringBuffer = generateIdempotencyToken();
+                    this.stringBuffer = serde.generateIdempotencyToken();
                 }
                 else {
                     this.stringBuffer = String(value);
@@ -873,8 +927,8 @@ class HttpInterceptingShapeSerializer {
         this.codecSerializer.setSerdeContext(serdeContext);
         this.stringSerializer.setSerdeContext(serdeContext);
     }
-    write(schema, value) {
-        const ns = NormalizedSchema.of(schema);
+    write(schema$1, value) {
+        const ns = schema.NormalizedSchema.of(schema$1);
         const traits = ns.getMergedTraits();
         if (traits.httpHeader || traits.httpLabel || traits.httpQuery) {
             this.stringSerializer.write(ns, value);
@@ -897,7 +951,7 @@ class Field {
     name;
     kind;
     values;
-    constructor({ name, kind = FieldPosition.HEADER, values = [] }) {
+    constructor({ name, kind = types.FieldPosition.HEADER, values = [] }) {
         this.name = name;
         this.kind = kind;
         this.values = values;
@@ -940,28 +994,30 @@ class Fields {
     }
 }
 
+function isValidHostname(hostname) {
+    const hostPattern = /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/;
+    return hostPattern.test(hostname);
+}
+
 const getHttpHandlerExtensionConfiguration = (runtimeConfig) => {
-    if (runtimeConfig.logger && runtimeConfig.logger.constructor?.name !== "NoOpLogger") {
-        runtimeConfig.requestHandler?.updateHttpClientConfig?.(Symbol.for("logger"), runtimeConfig.logger);
-    }
     return {
         setHttpHandler(handler) {
-            runtimeConfig.requestHandler = handler;
+            runtimeConfig.httpHandler = handler;
         },
         httpHandler() {
-            return runtimeConfig.requestHandler;
+            return runtimeConfig.httpHandler;
         },
         updateHttpClientConfig(key, value) {
-            runtimeConfig.requestHandler?.updateHttpClientConfig(key, value);
+            runtimeConfig.httpHandler?.updateHttpClientConfig(key, value);
         },
         httpHandlerConfigs() {
-            return runtimeConfig.requestHandler.httpHandlerConfigs();
+            return runtimeConfig.httpHandler.httpHandlerConfigs();
         },
     };
 };
 const resolveHttpHandlerRuntimeConfig = (httpHandlerExtensionConfiguration) => {
     return {
-        requestHandler: httpHandlerExtensionConfiguration.httpHandler(),
+        httpHandler: httpHandlerExtensionConfiguration.httpHandler(),
     };
 };
 
@@ -977,14 +1033,12 @@ function contentLengthMiddleware(bodyLengthChecker) {
                     .indexOf(CONTENT_LENGTH_HEADER) === -1) {
                 try {
                     const length = bodyLengthChecker(body);
-                    if (length != null) {
-                        request.headers = {
-                            ...request.headers,
-                            [CONTENT_LENGTH_HEADER]: String(length),
-                        };
-                    }
+                    request.headers = {
+                        ...request.headers,
+                        [CONTENT_LENGTH_HEADER]: String(length),
+                    };
                 }
-                catch (ignored) {
+                catch (error) {
                 }
             }
         }
@@ -1032,6 +1086,48 @@ function buildQueryString(query) {
     return parts.join("&");
 }
 
+function parseQueryString(querystring) {
+    const query = {};
+    querystring = querystring.replace(/^\?/, "");
+    if (querystring) {
+        for (const pair of querystring.split("&")) {
+            let [key, value = null] = pair.split("=");
+            key = decodeURIComponent(key);
+            if (value) {
+                value = decodeURIComponent(value);
+            }
+            if (!(key in query)) {
+                query[key] = value;
+            }
+            else if (Array.isArray(query[key])) {
+                query[key].push(value);
+            }
+            else {
+                query[key] = [query[key], value];
+            }
+        }
+    }
+    return query;
+}
+
+const parseUrl = (url) => {
+    if (typeof url === "string") {
+        return parseUrl(new URL(url));
+    }
+    const { hostname, pathname, port, protocol, search } = url;
+    let query;
+    if (search) {
+        query = parseQueryString(search);
+    }
+    return {
+        hostname,
+        port: port ? parseInt(port) : undefined,
+        protocol,
+        path: pathname,
+        query,
+    };
+};
+
 exports.Field = Field;
 exports.Fields = Fields;
 exports.FromStringShapeDeserializer = FromStringShapeDeserializer;
@@ -1039,6 +1135,8 @@ exports.HttpBindingProtocol = HttpBindingProtocol;
 exports.HttpInterceptingShapeDeserializer = HttpInterceptingShapeDeserializer;
 exports.HttpInterceptingShapeSerializer = HttpInterceptingShapeSerializer;
 exports.HttpProtocol = HttpProtocol;
+exports.HttpRequest = HttpRequest;
+exports.HttpResponse = HttpResponse;
 exports.RequestBuilder = RequestBuilder;
 exports.RpcProtocol = RpcProtocol;
 exports.SerdeContext = SerdeContext;
@@ -1053,6 +1151,9 @@ exports.escapeUriPath = escapeUriPath;
 exports.extendedEncodeURIComponent = extendedEncodeURIComponent;
 exports.getContentLengthPlugin = getContentLengthPlugin;
 exports.getHttpHandlerExtensionConfiguration = getHttpHandlerExtensionConfiguration;
+exports.isValidHostname = isValidHostname;
+exports.parseQueryString = parseQueryString;
+exports.parseUrl = parseUrl;
 exports.requestBuilder = requestBuilder;
 exports.resolveHttpHandlerRuntimeConfig = resolveHttpHandlerRuntimeConfig;
 exports.resolvedPath = resolvedPath;