@aws-sdk/client-appsync 3.476.0 → 3.478.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,84 +1,60 @@
-import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, take, withBaseException, } from "@smithy/smithy-client";
+import { requestBuilder as rb } from "@smithy/core";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@smithy/smithy-client";
 import { AppSyncServiceException as __BaseException } from "../models/AppSyncServiceException";
 import { AccessDeniedException, ApiKeyLimitExceededException, ApiKeyValidityOutOfBoundsException, ApiLimitExceededException, BadRequestException, ConcurrentModificationException, GraphQLSchemaException, InternalFailureException, LimitExceededException, NotFoundException, UnauthorizedException, } from "../models/models_0";
 export const se_AssociateApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/domainnames/{domainName}/apiassociation";
-    resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/v1/domainnames/{domainName}/apiassociation");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     let body;
     body = JSON.stringify(take(input, {
         apiId: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_AssociateMergedGraphqlApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/sourceApis/{sourceApiIdentifier}/mergedApiAssociations";
-    resolvedPath = __resolvedPath(resolvedPath, input, "sourceApiIdentifier", () => input.sourceApiIdentifier, "{sourceApiIdentifier}", false);
+    b.bp("/v1/sourceApis/{sourceApiIdentifier}/mergedApiAssociations");
+    b.p("sourceApiIdentifier", () => input.sourceApiIdentifier, "{sourceApiIdentifier}", false);
     let body;
     body = JSON.stringify(take(input, {
         description: [],
         mergedApiIdentifier: [],
         sourceApiAssociationConfig: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_AssociateSourceGraphqlApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations";
-    resolvedPath = __resolvedPath(resolvedPath, input, "mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
+    b.bp("/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations");
+    b.p("mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
     let body;
     body = JSON.stringify(take(input, {
         description: [],
         sourceApiAssociationConfig: (_) => _json(_),
         sourceApiIdentifier: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateApiCacheCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/ApiCaches";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/ApiCaches");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
     body = JSON.stringify(take(input, {
         apiCachingBehavior: [],
@@ -87,45 +63,31 @@ export const se_CreateApiCacheCommand = async (input, context) => {
         ttl: [],
         type: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateApiKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/apikeys";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/apikeys");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
     body = JSON.stringify(take(input, {
         description: [],
         expires: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateDataSourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/datasources";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/datasources");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
     body = JSON.stringify(take(input, {
         description: [],
@@ -140,45 +102,31 @@ export const se_CreateDataSourceCommand = async (input, context) => {
         serviceRoleArn: [],
         type: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateDomainNameCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domainnames";
+    b.bp("/v1/domainnames");
     let body;
     body = JSON.stringify(take(input, {
         certificateArn: [],
         description: [],
         domainName: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateFunctionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/functions";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/functions");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
     body = JSON.stringify(take(input, {
         code: [],
@@ -192,57 +140,45 @@ export const se_CreateFunctionCommand = async (input, context) => {
         runtime: (_) => _json(_),
         syncConfig: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateGraphqlApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis";
+    b.bp("/v1/apis");
     let body;
     body = JSON.stringify(take(input, {
         additionalAuthenticationProviders: (_) => _json(_),
         apiType: [],
         authenticationType: [],
+        introspectionConfig: [],
         lambdaAuthorizerConfig: (_) => _json(_),
         logConfig: (_) => _json(_),
         mergedApiExecutionRoleArn: [],
         name: [],
         openIDConnectConfig: (_) => _json(_),
         ownerContact: [],
+        queryDepthLimit: [],
+        resolverCountLimit: [],
         tags: (_) => _json(_),
         userPoolConfig: (_) => _json(_),
         visibility: [],
         xrayEnabled: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateResolverCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/apis/{apiId}/types/{typeName}/resolvers";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "typeName", () => input.typeName, "{typeName}", false);
+    b.bp("/v1/apis/{apiId}/types/{typeName}/resolvers");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("typeName", () => input.typeName, "{typeName}", false);
     let body;
     body = JSON.stringify(take(input, {
         cachingConfig: (_) => _json(_),
@@ -257,232 +193,137 @@ export const se_CreateResolverCommand = async (input, context) => {
         runtime: (_) => _json(_),
         syncConfig: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_CreateTypeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/types";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/types");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
     body = JSON.stringify(take(input, {
         definition: [],
         format: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteApiCacheCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/ApiCaches";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/ApiCaches");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteApiKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/apikeys/{id}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    b.bp("/v1/apis/{apiId}/apikeys/{id}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("id", () => input.id, "{id}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteDataSourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/datasources/{name}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
+    b.bp("/v1/apis/{apiId}/datasources/{name}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("name", () => input.name, "{name}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteDomainNameCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domainnames/{domainName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/v1/domainnames/{domainName}");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteFunctionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/functions/{functionId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "functionId", () => input.functionId, "{functionId}", false);
+    b.bp("/v1/apis/{apiId}/functions/{functionId}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("functionId", () => input.functionId, "{functionId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteGraphqlApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteResolverCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/apis/{apiId}/types/{typeName}/resolvers/{fieldName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "typeName", () => input.typeName, "{typeName}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "fieldName", () => input.fieldName, "{fieldName}", false);
+    b.bp("/v1/apis/{apiId}/types/{typeName}/resolvers/{fieldName}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("typeName", () => input.typeName, "{typeName}", false);
+    b.p("fieldName", () => input.fieldName, "{fieldName}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DeleteTypeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/types/{typeName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "typeName", () => input.typeName, "{typeName}", false);
+    b.bp("/v1/apis/{apiId}/types/{typeName}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("typeName", () => input.typeName, "{typeName}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DisassociateApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/domainnames/{domainName}/apiassociation";
-    resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/v1/domainnames/{domainName}/apiassociation");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DisassociateMergedGraphqlApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/sourceApis/{sourceApiIdentifier}/mergedApiAssociations/{associationId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "sourceApiIdentifier", () => input.sourceApiIdentifier, "{sourceApiIdentifier}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "associationId", () => input.associationId, "{associationId}", false);
+    b.bp("/v1/sourceApis/{sourceApiIdentifier}/mergedApiAssociations/{associationId}");
+    b.p("sourceApiIdentifier", () => input.sourceApiIdentifier, "{sourceApiIdentifier}", false);
+    b.p("associationId", () => input.associationId, "{associationId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_DisassociateSourceGraphqlApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "associationId", () => input.associationId, "{associationId}", false);
+    b.bp("/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}");
+    b.p("mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
+    b.p("associationId", () => input.associationId, "{associationId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_EvaluateCodeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/dataplane-evaluatecode";
+    b.bp("/v1/dataplane-evaluatecode");
     let body;
     body = JSON.stringify(take(input, {
         code: [],
@@ -490,661 +331,408 @@ export const se_EvaluateCodeCommand = async (input, context) => {
         function: [],
         runtime: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_EvaluateMappingTemplateCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/dataplane-evaluatetemplate";
+    b.bp("/v1/dataplane-evaluatetemplate");
     let body;
     body = JSON.stringify(take(input, {
         context: [],
         template: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_FlushApiCacheCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/FlushCache";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/FlushCache");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
 };
 export const se_GetApiAssociationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/domainnames/{domainName}/apiassociation";
-    resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/v1/domainnames/{domainName}/apiassociation");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetApiCacheCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/ApiCaches";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/ApiCaches");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetDataSourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/datasources/{name}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
+    b.bp("/v1/apis/{apiId}/datasources/{name}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("name", () => input.name, "{name}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetDataSourceIntrospectionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/datasources/introspections/{introspectionId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "introspectionId", () => input.introspectionId, "{introspectionId}", false);
+    b.bp("/v1/datasources/introspections/{introspectionId}");
+    b.p("introspectionId", () => input.introspectionId, "{introspectionId}", false);
     const query = map({
-        includeModelsSDL: [() => input.includeModelsSDL !== void 0, () => input.includeModelsSDL.toString()],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_iMSDL]: [() => input.includeModelsSDL !== void 0, () => input[_iMSDL].toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetDomainNameCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domainnames/{domainName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/v1/domainnames/{domainName}");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetFunctionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/functions/{functionId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "functionId", () => input.functionId, "{functionId}", false);
+    b.bp("/v1/apis/{apiId}/functions/{functionId}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("functionId", () => input.functionId, "{functionId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetGraphqlApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetIntrospectionSchemaCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/schema";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/schema");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     const query = map({
-        format: [, __expectNonNull(input.format, `format`)],
-        includeDirectives: [() => input.includeDirectives !== void 0, () => input.includeDirectives.toString()],
+        [_f]: [, __expectNonNull(input[_f], `format`)],
+        [_iD]: [() => input.includeDirectives !== void 0, () => input[_iD].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_GetResolverCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/apis/{apiId}/types/{typeName}/resolvers/{fieldName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "typeName", () => input.typeName, "{typeName}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "fieldName", () => input.fieldName, "{fieldName}", false);
+    b.bp("/v1/apis/{apiId}/types/{typeName}/resolvers/{fieldName}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("typeName", () => input.typeName, "{typeName}", false);
+    b.p("fieldName", () => input.fieldName, "{fieldName}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetSchemaCreationStatusCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/schemacreation";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/schemacreation");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetSourceApiAssociationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "associationId", () => input.associationId, "{associationId}", false);
+    b.bp("/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}");
+    b.p("mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
+    b.p("associationId", () => input.associationId, "{associationId}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_GetTypeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/types/{typeName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "typeName", () => input.typeName, "{typeName}", false);
+    b.bp("/v1/apis/{apiId}/types/{typeName}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("typeName", () => input.typeName, "{typeName}", false);
     const query = map({
-        format: [, __expectNonNull(input.format, `format`)],
+        [_f]: [, __expectNonNull(input[_f], `format`)],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ListApiKeysCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/apikeys";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/apikeys");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     const query = map({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ListDataSourcesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/datasources";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/datasources");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     const query = map({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ListDomainNamesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domainnames";
+    b.bp("/v1/domainnames");
     const query = map({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ListFunctionsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/functions";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/functions");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     const query = map({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ListGraphqlApisCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis";
+    b.bp("/v1/apis");
     const query = map({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
-        apiType: [, input.apiType],
-        owner: [, input.owner],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+        [_aT]: [, input[_aT]],
+        [_o]: [, input[_o]],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ListResolversCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/apis/{apiId}/types/{typeName}/resolvers";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "typeName", () => input.typeName, "{typeName}", false);
+    b.bp("/v1/apis/{apiId}/types/{typeName}/resolvers");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("typeName", () => input.typeName, "{typeName}", false);
     const query = map({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ListResolversByFunctionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/apis/{apiId}/functions/{functionId}/resolvers";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "functionId", () => input.functionId, "{functionId}", false);
+    b.bp("/v1/apis/{apiId}/functions/{functionId}/resolvers");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("functionId", () => input.functionId, "{functionId}", false);
     const query = map({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ListSourceApiAssociationsCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/sourceApiAssociations";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/sourceApiAssociations");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     const query = map({
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ListTagsForResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    b.bp("/v1/tags/{resourceArn}");
+    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("GET").h(headers).b(body);
+    return b.build();
 };
 export const se_ListTypesCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/types";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/types");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     const query = map({
-        format: [, __expectNonNull(input.format, `format`)],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_f]: [, __expectNonNull(input[_f], `format`)],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_ListTypesByAssociationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}/types";
-    resolvedPath = __resolvedPath(resolvedPath, input, "mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "associationId", () => input.associationId, "{associationId}", false);
+    b.bp("/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}/types");
+    b.p("mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
+    b.p("associationId", () => input.associationId, "{associationId}", false);
     const query = map({
-        format: [, __expectNonNull(input.format, `format`)],
-        nextToken: [, input.nextToken],
-        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        [_f]: [, __expectNonNull(input[_f], `format`)],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "GET",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_StartDataSourceIntrospectionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/datasources/introspections";
+    b.bp("/v1/datasources/introspections");
     let body;
     body = JSON.stringify(take(input, {
         rdsDataApiConfig: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_StartSchemaCreationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/schemacreation";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/schemacreation");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
     body = JSON.stringify(take(input, {
         definition: (_) => context.base64Encoder(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_StartSchemaMergeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}/merge";
-    resolvedPath = __resolvedPath(resolvedPath, input, "associationId", () => input.associationId, "{associationId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
+    b.bp("/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}/merge");
+    b.p("associationId", () => input.associationId, "{associationId}", false);
+    b.p("mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_TagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    b.bp("/v1/tags/{resourceArn}");
+    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
     let body;
     body = JSON.stringify(take(input, {
         tags: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_UntagResourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {};
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/tags/{resourceArn}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    b.bp("/v1/tags/{resourceArn}");
+    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
     const query = map({
-        tagKeys: [
+        [_tK]: [
             __expectNonNull(input.tagKeys, `tagKeys`) != null,
-            () => (input.tagKeys || []).map((_entry) => _entry),
+            () => (input[_tK] || []).map((_entry) => _entry),
         ],
     });
     let body;
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "DELETE",
-        headers,
-        path: resolvedPath,
-        query,
-        body,
-    });
+    b.m("DELETE").h(headers).q(query).b(body);
+    return b.build();
 };
 export const se_UpdateApiCacheCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/ApiCaches/update";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}/ApiCaches/update");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
     body = JSON.stringify(take(input, {
         apiCachingBehavior: [],
         ttl: [],
         type: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateApiKeyCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/apikeys/{id}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "id", () => input.id, "{id}", false);
+    b.bp("/v1/apis/{apiId}/apikeys/{id}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("id", () => input.id, "{id}", false);
     let body;
     body = JSON.stringify(take(input, {
         description: [],
         expires: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateDataSourceCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/datasources/{name}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "name", () => input.name, "{name}", false);
+    b.bp("/v1/apis/{apiId}/datasources/{name}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("name", () => input.name, "{name}", false);
     let body;
     body = JSON.stringify(take(input, {
         description: [],
@@ -1158,45 +746,31 @@ export const se_UpdateDataSourceCommand = async (input, context) => {
         serviceRoleArn: [],
         type: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateDomainNameCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domainnames/{domainName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "domainName", () => input.domainName, "{domainName}", false);
+    b.bp("/v1/domainnames/{domainName}");
+    b.p("domainName", () => input.domainName, "{domainName}", false);
     let body;
     body = JSON.stringify(take(input, {
         description: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateFunctionCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/functions/{functionId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "functionId", () => input.functionId, "{functionId}", false);
+    b.bp("/v1/apis/{apiId}/functions/{functionId}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("functionId", () => input.functionId, "{functionId}", false);
     let body;
     body = JSON.stringify(take(input, {
         code: [],
@@ -1210,56 +784,44 @@ export const se_UpdateFunctionCommand = async (input, context) => {
         runtime: (_) => _json(_),
         syncConfig: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateGraphqlApiCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
+    b.bp("/v1/apis/{apiId}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
     let body;
     body = JSON.stringify(take(input, {
         additionalAuthenticationProviders: (_) => _json(_),
         authenticationType: [],
+        introspectionConfig: [],
         lambdaAuthorizerConfig: (_) => _json(_),
         logConfig: (_) => _json(_),
         mergedApiExecutionRoleArn: [],
         name: [],
         openIDConnectConfig: (_) => _json(_),
         ownerContact: [],
+        queryDepthLimit: [],
+        resolverCountLimit: [],
         userPoolConfig: (_) => _json(_),
         xrayEnabled: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateResolverCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/apis/{apiId}/types/{typeName}/resolvers/{fieldName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "typeName", () => input.typeName, "{typeName}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "fieldName", () => input.fieldName, "{fieldName}", false);
+    b.bp("/v1/apis/{apiId}/types/{typeName}/resolvers/{fieldName}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("typeName", () => input.typeName, "{typeName}", false);
+    b.p("fieldName", () => input.fieldName, "{fieldName}", false);
     let body;
     body = JSON.stringify(take(input, {
         cachingConfig: (_) => _json(_),
@@ -1273,62 +835,40 @@ export const se_UpdateResolverCommand = async (input, context) => {
         runtime: (_) => _json(_),
         syncConfig: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateSourceApiAssociationCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
-        "/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "associationId", () => input.associationId, "{associationId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
+    b.bp("/v1/mergedApis/{mergedApiIdentifier}/sourceApiAssociations/{associationId}");
+    b.p("associationId", () => input.associationId, "{associationId}", false);
+    b.p("mergedApiIdentifier", () => input.mergedApiIdentifier, "{mergedApiIdentifier}", false);
     let body;
     body = JSON.stringify(take(input, {
         description: [],
         sourceApiAssociationConfig: (_) => _json(_),
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const se_UpdateTypeCommand = async (input, context) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const b = rb(input, context);
     const headers = {
         "content-type": "application/json",
     };
-    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v1/apis/{apiId}/types/{typeName}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "apiId", () => input.apiId, "{apiId}", false);
-    resolvedPath = __resolvedPath(resolvedPath, input, "typeName", () => input.typeName, "{typeName}", false);
+    b.bp("/v1/apis/{apiId}/types/{typeName}");
+    b.p("apiId", () => input.apiId, "{apiId}", false);
+    b.p("typeName", () => input.typeName, "{typeName}", false);
     let body;
     body = JSON.stringify(take(input, {
         definition: [],
         format: [],
     }));
-    return new __HttpRequest({
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        headers,
-        path: resolvedPath,
-        body,
-    });
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
 export const de_AssociateApiCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -4242,6 +3782,14 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
     value !== "" &&
     (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
     (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const _aT = "apiType";
+const _f = "format";
+const _iD = "includeDirectives";
+const _iMSDL = "includeModelsSDL";
+const _mR = "maxResults";
+const _nT = "nextToken";
+const _o = "owner";
+const _tK = "tagKeys";
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
     if (encoded.length) {
         return JSON.parse(encoded);