@aws-sdk/client-codeartifact 3.141.0 → 3.142.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -10,12 +10,12 @@ const serializeAws_restJson1AssociateExternalConnectionCommand = async (input, c
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/repository/external-connection";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.externalConnection !== undefined && { "external-connection": input.externalConnection }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        "external-connection": [, input.externalConnection],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -35,15 +35,15 @@ const serializeAws_restJson1CopyPackageVersionsCommand = async (input, context)
         "content-type": "application/json",
     };
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/package/versions/copy";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.sourceRepository !== undefined && { "source-repository": input.sourceRepository }),
-        ...(input.destinationRepository !== undefined && { "destination-repository": input.destinationRepository }),
-        ...(input.format !== undefined && { format: input.format }),
-        ...(input.namespace !== undefined && { namespace: input.namespace }),
-        ...(input.package !== undefined && { package: input.package }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        "source-repository": [, input.sourceRepository],
+        "destination-repository": [, input.destinationRepository],
+        format: [, input.format],
+        namespace: [, input.namespace],
+        package: [, input.package],
+    });
     let body;
     body = JSON.stringify({
         ...(input.allowOverwrite != null && { allowOverwrite: input.allowOverwrite }),
@@ -71,9 +71,9 @@ const serializeAws_restJson1CreateDomainCommand = async (input, context) => {
         "content-type": "application/json",
     };
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domain";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-    };
+    const query = map({
+        domain: [, input.domain],
+    });
     let body;
     body = JSON.stringify({
         ...(input.encryptionKey != null && { encryptionKey: input.encryptionKey }),
@@ -97,11 +97,11 @@ const serializeAws_restJson1CreateRepositoryCommand = async (input, context) =>
         "content-type": "application/json",
     };
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/repository";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+    });
     let body;
     body = JSON.stringify({
         ...(input.description != null && { description: input.description }),
@@ -126,10 +126,10 @@ const serializeAws_restJson1DeleteDomainCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domain";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -147,11 +147,11 @@ const serializeAws_restJson1DeleteDomainPermissionsPolicyCommand = async (input,
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domain/permissions/policy";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.policyRevision !== undefined && { "policy-revision": input.policyRevision }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        "policy-revision": [, input.policyRevision],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -171,14 +171,14 @@ const serializeAws_restJson1DeletePackageVersionsCommand = async (input, context
         "content-type": "application/json",
     };
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/package/versions/delete";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.format !== undefined && { format: input.format }),
-        ...(input.namespace !== undefined && { namespace: input.namespace }),
-        ...(input.package !== undefined && { package: input.package }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        format: [, input.format],
+        namespace: [, input.namespace],
+        package: [, input.package],
+    });
     let body;
     body = JSON.stringify({
         ...(input.expectedStatus != null && { expectedStatus: input.expectedStatus }),
@@ -200,11 +200,11 @@ const serializeAws_restJson1DeleteRepositoryCommand = async (input, context) =>
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/repository";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -222,12 +222,12 @@ const serializeAws_restJson1DeleteRepositoryPermissionsPolicyCommand = async (in
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/repository/permissions/policies";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.policyRevision !== undefined && { "policy-revision": input.policyRevision }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        "policy-revision": [, input.policyRevision],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -245,10 +245,10 @@ const serializeAws_restJson1DescribeDomainCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domain";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -266,14 +266,14 @@ const serializeAws_restJson1DescribePackageCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/package";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.format !== undefined && { format: input.format }),
-        ...(input.namespace !== undefined && { namespace: input.namespace }),
-        ...(input.package !== undefined && { package: input.package }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        format: [, input.format],
+        namespace: [, input.namespace],
+        package: [, input.package],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -291,15 +291,15 @@ const serializeAws_restJson1DescribePackageVersionCommand = async (input, contex
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/package/version";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.format !== undefined && { format: input.format }),
-        ...(input.namespace !== undefined && { namespace: input.namespace }),
-        ...(input.package !== undefined && { package: input.package }),
-        ...(input.packageVersion !== undefined && { version: input.packageVersion }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        format: [, input.format],
+        namespace: [, input.namespace],
+        package: [, input.package],
+        version: [, input.packageVersion],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -317,11 +317,11 @@ const serializeAws_restJson1DescribeRepositoryCommand = async (input, context) =
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/repository";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -339,12 +339,12 @@ const serializeAws_restJson1DisassociateExternalConnectionCommand = async (input
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/repository/external-connection";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.externalConnection !== undefined && { "external-connection": input.externalConnection }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        "external-connection": [, input.externalConnection],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -364,14 +364,14 @@ const serializeAws_restJson1DisposePackageVersionsCommand = async (input, contex
         "content-type": "application/json",
     };
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/package/versions/dispose";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.format !== undefined && { format: input.format }),
-        ...(input.namespace !== undefined && { namespace: input.namespace }),
-        ...(input.package !== undefined && { package: input.package }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        format: [, input.format],
+        namespace: [, input.namespace],
+        package: [, input.package],
+    });
     let body;
     body = JSON.stringify({
         ...(input.expectedStatus != null && { expectedStatus: input.expectedStatus }),
@@ -396,11 +396,11 @@ const serializeAws_restJson1GetAuthorizationTokenCommand = async (input, context
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/authorization-token";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.durationSeconds !== undefined && { duration: input.durationSeconds.toString() }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        duration: [() => input.durationSeconds !== void 0, () => input.durationSeconds.toString()],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -418,10 +418,10 @@ const serializeAws_restJson1GetDomainPermissionsPolicyCommand = async (input, co
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domain/permissions/policy";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -439,17 +439,17 @@ const serializeAws_restJson1GetPackageVersionAssetCommand = async (input, contex
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/package/version/asset";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.format !== undefined && { format: input.format }),
-        ...(input.namespace !== undefined && { namespace: input.namespace }),
-        ...(input.package !== undefined && { package: input.package }),
-        ...(input.packageVersion !== undefined && { version: input.packageVersion }),
-        ...(input.asset !== undefined && { asset: input.asset }),
-        ...(input.packageVersionRevision !== undefined && { revision: input.packageVersionRevision }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        format: [, input.format],
+        namespace: [, input.namespace],
+        package: [, input.package],
+        version: [, input.packageVersion],
+        asset: [, input.asset],
+        revision: [, input.packageVersionRevision],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -467,15 +467,15 @@ const serializeAws_restJson1GetPackageVersionReadmeCommand = async (input, conte
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/package/version/readme";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.format !== undefined && { format: input.format }),
-        ...(input.namespace !== undefined && { namespace: input.namespace }),
-        ...(input.package !== undefined && { package: input.package }),
-        ...(input.packageVersion !== undefined && { version: input.packageVersion }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        format: [, input.format],
+        namespace: [, input.namespace],
+        package: [, input.package],
+        version: [, input.packageVersion],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -493,12 +493,12 @@ const serializeAws_restJson1GetRepositoryEndpointCommand = async (input, context
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/repository/endpoint";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.format !== undefined && { format: input.format }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        format: [, input.format],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -516,11 +516,11 @@ const serializeAws_restJson1GetRepositoryPermissionsPolicyCommand = async (input
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/repository/permissions/policy";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -560,18 +560,18 @@ const serializeAws_restJson1ListPackagesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/packages";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.format !== undefined && { format: input.format }),
-        ...(input.namespace !== undefined && { namespace: input.namespace }),
-        ...(input.packagePrefix !== undefined && { "package-prefix": input.packagePrefix }),
-        ...(input.maxResults !== undefined && { "max-results": input.maxResults.toString() }),
-        ...(input.nextToken !== undefined && { "next-token": input.nextToken }),
-        ...(input.publish !== undefined && { publish: input.publish }),
-        ...(input.upstream !== undefined && { upstream: input.upstream }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        format: [, input.format],
+        namespace: [, input.namespace],
+        "package-prefix": [, input.packagePrefix],
+        "max-results": [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        "next-token": [, input.nextToken],
+        publish: [, input.publish],
+        upstream: [, input.upstream],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -589,17 +589,17 @@ const serializeAws_restJson1ListPackageVersionAssetsCommand = async (input, cont
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/package/version/assets";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.format !== undefined && { format: input.format }),
-        ...(input.namespace !== undefined && { namespace: input.namespace }),
-        ...(input.package !== undefined && { package: input.package }),
-        ...(input.packageVersion !== undefined && { version: input.packageVersion }),
-        ...(input.maxResults !== undefined && { "max-results": input.maxResults.toString() }),
-        ...(input.nextToken !== undefined && { "next-token": input.nextToken }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        format: [, input.format],
+        namespace: [, input.namespace],
+        package: [, input.package],
+        version: [, input.packageVersion],
+        "max-results": [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        "next-token": [, input.nextToken],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -617,16 +617,16 @@ const serializeAws_restJson1ListPackageVersionDependenciesCommand = async (input
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/package/version/dependencies";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.format !== undefined && { format: input.format }),
-        ...(input.namespace !== undefined && { namespace: input.namespace }),
-        ...(input.package !== undefined && { package: input.package }),
-        ...(input.packageVersion !== undefined && { version: input.packageVersion }),
-        ...(input.nextToken !== undefined && { "next-token": input.nextToken }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        format: [, input.format],
+        namespace: [, input.namespace],
+        package: [, input.package],
+        version: [, input.packageVersion],
+        "next-token": [, input.nextToken],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -644,19 +644,19 @@ const serializeAws_restJson1ListPackageVersionsCommand = async (input, context)
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/package/versions";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.format !== undefined && { format: input.format }),
-        ...(input.namespace !== undefined && { namespace: input.namespace }),
-        ...(input.package !== undefined && { package: input.package }),
-        ...(input.status !== undefined && { status: input.status }),
-        ...(input.sortBy !== undefined && { sortBy: input.sortBy }),
-        ...(input.maxResults !== undefined && { "max-results": input.maxResults.toString() }),
-        ...(input.nextToken !== undefined && { "next-token": input.nextToken }),
-        ...(input.originType !== undefined && { originType: input.originType }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        format: [, input.format],
+        namespace: [, input.namespace],
+        package: [, input.package],
+        status: [, input.status],
+        sortBy: [, input.sortBy],
+        "max-results": [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        "next-token": [, input.nextToken],
+        originType: [, input.originType],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -674,11 +674,11 @@ const serializeAws_restJson1ListRepositoriesCommand = async (input, context) =>
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/repositories";
-    const query = {
-        ...(input.repositoryPrefix !== undefined && { "repository-prefix": input.repositoryPrefix }),
-        ...(input.maxResults !== undefined && { "max-results": input.maxResults.toString() }),
-        ...(input.nextToken !== undefined && { "next-token": input.nextToken }),
-    };
+    const query = map({
+        "repository-prefix": [, input.repositoryPrefix],
+        "max-results": [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        "next-token": [, input.nextToken],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -696,14 +696,14 @@ const serializeAws_restJson1ListRepositoriesInDomainCommand = async (input, cont
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/domain/repositories";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.administratorAccount !== undefined && { "administrator-account": input.administratorAccount }),
-        ...(input.repositoryPrefix !== undefined && { "repository-prefix": input.repositoryPrefix }),
-        ...(input.maxResults !== undefined && { "max-results": input.maxResults.toString() }),
-        ...(input.nextToken !== undefined && { "next-token": input.nextToken }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        "administrator-account": [, input.administratorAccount],
+        "repository-prefix": [, input.repositoryPrefix],
+        "max-results": [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        "next-token": [, input.nextToken],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -721,9 +721,9 @@ const serializeAws_restJson1ListTagsForResourceCommand = async (input, context)
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/tags";
-    const query = {
-        ...(input.resourceArn !== undefined && { resourceArn: input.resourceArn }),
-    };
+    const query = map({
+        resourceArn: [, input.resourceArn],
+    });
     let body;
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -767,14 +767,14 @@ const serializeAws_restJson1PutPackageOriginConfigurationCommand = async (input,
         "content-type": "application/json",
     };
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/package";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.format !== undefined && { format: input.format }),
-        ...(input.namespace !== undefined && { namespace: input.namespace }),
-        ...(input.package !== undefined && { package: input.package }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        format: [, input.format],
+        namespace: [, input.namespace],
+        package: [, input.package],
+    });
     let body;
     body = JSON.stringify({
         ...(input.restrictions != null && {
@@ -799,11 +799,11 @@ const serializeAws_restJson1PutRepositoryPermissionsPolicyCommand = async (input
         "content-type": "application/json",
     };
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/repository/permissions/policy";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+    });
     let body;
     body = JSON.stringify({
         ...(input.policyDocument != null && { policyDocument: input.policyDocument }),
@@ -827,9 +827,9 @@ const serializeAws_restJson1TagResourceCommand = async (input, context) => {
         "content-type": "application/json",
     };
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/tag";
-    const query = {
-        ...(input.resourceArn !== undefined && { resourceArn: input.resourceArn }),
-    };
+    const query = map({
+        resourceArn: [, input.resourceArn],
+    });
     let body;
     body = JSON.stringify({
         ...(input.tags != null && { tags: serializeAws_restJson1TagList(input.tags, context) }),
@@ -852,9 +852,9 @@ const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
         "content-type": "application/json",
     };
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/untag";
-    const query = {
-        ...(input.resourceArn !== undefined && { resourceArn: input.resourceArn }),
-    };
+    const query = map({
+        resourceArn: [, input.resourceArn],
+    });
     let body;
     body = JSON.stringify({
         ...(input.tagKeys != null && { tagKeys: serializeAws_restJson1TagKeyList(input.tagKeys, context) }),
@@ -877,14 +877,14 @@ const serializeAws_restJson1UpdatePackageVersionsStatusCommand = async (input, c
         "content-type": "application/json",
     };
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/package/versions/update_status";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-        ...(input.format !== undefined && { format: input.format }),
-        ...(input.namespace !== undefined && { namespace: input.namespace }),
-        ...(input.package !== undefined && { package: input.package }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+        format: [, input.format],
+        namespace: [, input.namespace],
+        package: [, input.package],
+    });
     let body;
     body = JSON.stringify({
         ...(input.expectedStatus != null && { expectedStatus: input.expectedStatus }),
@@ -912,11 +912,11 @@ const serializeAws_restJson1UpdateRepositoryCommand = async (input, context) =>
         "content-type": "application/json",
     };
     const resolvedPath = `${(basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}` + "/v1/repository";
-    const query = {
-        ...(input.domain !== undefined && { domain: input.domain }),
-        ...(input.domainOwner !== undefined && { "domain-owner": input.domainOwner }),
-        ...(input.repository !== undefined && { repository: input.repository }),
-    };
+    const query = map({
+        domain: [, input.domain],
+        "domain-owner": [, input.domainOwner],
+        repository: [, input.repository],
+    });
     let body;
     body = JSON.stringify({
         ...(input.description != null && { description: input.description }),
@@ -940,15 +940,14 @@ const deserializeAws_restJson1AssociateExternalConnectionCommand = async (output
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1AssociateExternalConnectionCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        repository: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.repository !== undefined && data.repository !== null) {
+    if (data.repository != null) {
         contents.repository = deserializeAws_restJson1RepositoryDescription(data.repository, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1AssociateExternalConnectionCommand = deserializeAws_restJson1AssociateExternalConnectionCommand;
 const deserializeAws_restJson1AssociateExternalConnectionCommandError = async (output, context) => {
@@ -956,7 +955,6 @@ const deserializeAws_restJson1AssociateExternalConnectionCommandError = async (o
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -982,33 +980,29 @@ const deserializeAws_restJson1AssociateExternalConnectionCommandError = async (o
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1CopyPackageVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1CopyPackageVersionsCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        failedVersions: undefined,
-        successfulVersions: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.failedVersions !== undefined && data.failedVersions !== null) {
+    if (data.failedVersions != null) {
         contents.failedVersions = deserializeAws_restJson1PackageVersionErrorMap(data.failedVersions, context);
     }
-    if (data.successfulVersions !== undefined && data.successfulVersions !== null) {
+    if (data.successfulVersions != null) {
         contents.successfulVersions = deserializeAws_restJson1SuccessfulPackageVersionInfoMap(data.successfulVersions, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1CopyPackageVersionsCommand = deserializeAws_restJson1CopyPackageVersionsCommand;
 const deserializeAws_restJson1CopyPackageVersionsCommandError = async (output, context) => {
@@ -1016,7 +1010,6 @@ const deserializeAws_restJson1CopyPackageVersionsCommandError = async (output, c
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1042,29 +1035,26 @@ const deserializeAws_restJson1CopyPackageVersionsCommandError = async (output, c
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1CreateDomainCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1CreateDomainCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        domain: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.domain !== undefined && data.domain !== null) {
+    if (data.domain != null) {
         contents.domain = deserializeAws_restJson1DomainDescription(data.domain, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1CreateDomainCommand = deserializeAws_restJson1CreateDomainCommand;
 const deserializeAws_restJson1CreateDomainCommandError = async (output, context) => {
@@ -1072,7 +1062,6 @@ const deserializeAws_restJson1CreateDomainCommandError = async (output, context)
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1098,29 +1087,26 @@ const deserializeAws_restJson1CreateDomainCommandError = async (output, context)
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1CreateRepositoryCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1CreateRepositoryCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        repository: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.repository !== undefined && data.repository !== null) {
+    if (data.repository != null) {
         contents.repository = deserializeAws_restJson1RepositoryDescription(data.repository, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1CreateRepositoryCommand = deserializeAws_restJson1CreateRepositoryCommand;
 const deserializeAws_restJson1CreateRepositoryCommandError = async (output, context) => {
@@ -1128,7 +1114,6 @@ const deserializeAws_restJson1CreateRepositoryCommandError = async (output, cont
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1154,29 +1139,26 @@ const deserializeAws_restJson1CreateRepositoryCommandError = async (output, cont
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1DeleteDomainCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DeleteDomainCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        domain: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.domain !== undefined && data.domain !== null) {
+    if (data.domain != null) {
         contents.domain = deserializeAws_restJson1DomainDescription(data.domain, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1DeleteDomainCommand = deserializeAws_restJson1DeleteDomainCommand;
 const deserializeAws_restJson1DeleteDomainCommandError = async (output, context) => {
@@ -1184,7 +1166,6 @@ const deserializeAws_restJson1DeleteDomainCommandError = async (output, context)
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1204,29 +1185,26 @@ const deserializeAws_restJson1DeleteDomainCommandError = async (output, context)
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1DeleteDomainPermissionsPolicyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DeleteDomainPermissionsPolicyCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        policy: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.policy !== undefined && data.policy !== null) {
+    if (data.policy != null) {
         contents.policy = deserializeAws_restJson1ResourcePolicy(data.policy, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1DeleteDomainPermissionsPolicyCommand = deserializeAws_restJson1DeleteDomainPermissionsPolicyCommand;
 const deserializeAws_restJson1DeleteDomainPermissionsPolicyCommandError = async (output, context) => {
@@ -1234,7 +1212,6 @@ const deserializeAws_restJson1DeleteDomainPermissionsPolicyCommandError = async
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1257,33 +1234,29 @@ const deserializeAws_restJson1DeleteDomainPermissionsPolicyCommandError = async
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1DeletePackageVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DeletePackageVersionsCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        failedVersions: undefined,
-        successfulVersions: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.failedVersions !== undefined && data.failedVersions !== null) {
+    if (data.failedVersions != null) {
         contents.failedVersions = deserializeAws_restJson1PackageVersionErrorMap(data.failedVersions, context);
     }
-    if (data.successfulVersions !== undefined && data.successfulVersions !== null) {
+    if (data.successfulVersions != null) {
         contents.successfulVersions = deserializeAws_restJson1SuccessfulPackageVersionInfoMap(data.successfulVersions, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1DeletePackageVersionsCommand = deserializeAws_restJson1DeletePackageVersionsCommand;
 const deserializeAws_restJson1DeletePackageVersionsCommandError = async (output, context) => {
@@ -1291,7 +1264,6 @@ const deserializeAws_restJson1DeletePackageVersionsCommandError = async (output,
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1314,29 +1286,26 @@ const deserializeAws_restJson1DeletePackageVersionsCommandError = async (output,
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1DeleteRepositoryCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DeleteRepositoryCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        repository: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.repository !== undefined && data.repository !== null) {
+    if (data.repository != null) {
         contents.repository = deserializeAws_restJson1RepositoryDescription(data.repository, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1DeleteRepositoryCommand = deserializeAws_restJson1DeleteRepositoryCommand;
 const deserializeAws_restJson1DeleteRepositoryCommandError = async (output, context) => {
@@ -1344,7 +1313,6 @@ const deserializeAws_restJson1DeleteRepositoryCommandError = async (output, cont
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1367,29 +1335,26 @@ const deserializeAws_restJson1DeleteRepositoryCommandError = async (output, cont
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1DeleteRepositoryPermissionsPolicyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DeleteRepositoryPermissionsPolicyCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        policy: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.policy !== undefined && data.policy !== null) {
+    if (data.policy != null) {
         contents.policy = deserializeAws_restJson1ResourcePolicy(data.policy, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1DeleteRepositoryPermissionsPolicyCommand = deserializeAws_restJson1DeleteRepositoryPermissionsPolicyCommand;
 const deserializeAws_restJson1DeleteRepositoryPermissionsPolicyCommandError = async (output, context) => {
@@ -1397,7 +1362,6 @@ const deserializeAws_restJson1DeleteRepositoryPermissionsPolicyCommandError = as
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1420,29 +1384,26 @@ const deserializeAws_restJson1DeleteRepositoryPermissionsPolicyCommandError = as
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1DescribeDomainCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DescribeDomainCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        domain: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.domain !== undefined && data.domain !== null) {
+    if (data.domain != null) {
         contents.domain = deserializeAws_restJson1DomainDescription(data.domain, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1DescribeDomainCommand = deserializeAws_restJson1DescribeDomainCommand;
 const deserializeAws_restJson1DescribeDomainCommandError = async (output, context) => {
@@ -1450,7 +1411,6 @@ const deserializeAws_restJson1DescribeDomainCommandError = async (output, contex
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1470,29 +1430,26 @@ const deserializeAws_restJson1DescribeDomainCommandError = async (output, contex
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1DescribePackageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DescribePackageCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        package: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.package !== undefined && data.package !== null) {
+    if (data.package != null) {
         contents.package = deserializeAws_restJson1PackageDescription(data.package, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1DescribePackageCommand = deserializeAws_restJson1DescribePackageCommand;
 const deserializeAws_restJson1DescribePackageCommandError = async (output, context) => {
@@ -1500,7 +1457,6 @@ const deserializeAws_restJson1DescribePackageCommandError = async (output, conte
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1520,29 +1476,26 @@ const deserializeAws_restJson1DescribePackageCommandError = async (output, conte
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1DescribePackageVersionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DescribePackageVersionCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        packageVersion: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.packageVersion !== undefined && data.packageVersion !== null) {
+    if (data.packageVersion != null) {
         contents.packageVersion = deserializeAws_restJson1PackageVersionDescription(data.packageVersion, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1DescribePackageVersionCommand = deserializeAws_restJson1DescribePackageVersionCommand;
 const deserializeAws_restJson1DescribePackageVersionCommandError = async (output, context) => {
@@ -1550,7 +1503,6 @@ const deserializeAws_restJson1DescribePackageVersionCommandError = async (output
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1573,29 +1525,26 @@ const deserializeAws_restJson1DescribePackageVersionCommandError = async (output
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1DescribeRepositoryCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DescribeRepositoryCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        repository: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.repository !== undefined && data.repository !== null) {
+    if (data.repository != null) {
         contents.repository = deserializeAws_restJson1RepositoryDescription(data.repository, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1DescribeRepositoryCommand = deserializeAws_restJson1DescribeRepositoryCommand;
 const deserializeAws_restJson1DescribeRepositoryCommandError = async (output, context) => {
@@ -1603,7 +1552,6 @@ const deserializeAws_restJson1DescribeRepositoryCommandError = async (output, co
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1623,29 +1571,26 @@ const deserializeAws_restJson1DescribeRepositoryCommandError = async (output, co
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1DisassociateExternalConnectionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DisassociateExternalConnectionCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        repository: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.repository !== undefined && data.repository !== null) {
+    if (data.repository != null) {
         contents.repository = deserializeAws_restJson1RepositoryDescription(data.repository, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1DisassociateExternalConnectionCommand = deserializeAws_restJson1DisassociateExternalConnectionCommand;
 const deserializeAws_restJson1DisassociateExternalConnectionCommandError = async (output, context) => {
@@ -1653,7 +1598,6 @@ const deserializeAws_restJson1DisassociateExternalConnectionCommandError = async
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1679,33 +1623,29 @@ const deserializeAws_restJson1DisassociateExternalConnectionCommandError = async
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1DisposePackageVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1DisposePackageVersionsCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        failedVersions: undefined,
-        successfulVersions: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.failedVersions !== undefined && data.failedVersions !== null) {
+    if (data.failedVersions != null) {
         contents.failedVersions = deserializeAws_restJson1PackageVersionErrorMap(data.failedVersions, context);
     }
-    if (data.successfulVersions !== undefined && data.successfulVersions !== null) {
+    if (data.successfulVersions != null) {
         contents.successfulVersions = deserializeAws_restJson1SuccessfulPackageVersionInfoMap(data.successfulVersions, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1DisposePackageVersionsCommand = deserializeAws_restJson1DisposePackageVersionsCommand;
 const deserializeAws_restJson1DisposePackageVersionsCommandError = async (output, context) => {
@@ -1713,7 +1653,6 @@ const deserializeAws_restJson1DisposePackageVersionsCommandError = async (output
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1736,33 +1675,29 @@ const deserializeAws_restJson1DisposePackageVersionsCommandError = async (output
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1GetAuthorizationTokenCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1GetAuthorizationTokenCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        authorizationToken: undefined,
-        expiration: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.authorizationToken !== undefined && data.authorizationToken !== null) {
+    if (data.authorizationToken != null) {
         contents.authorizationToken = (0, smithy_client_1.expectString)(data.authorizationToken);
     }
-    if (data.expiration !== undefined && data.expiration !== null) {
+    if (data.expiration != null) {
         contents.expiration = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(data.expiration)));
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1GetAuthorizationTokenCommand = deserializeAws_restJson1GetAuthorizationTokenCommand;
 const deserializeAws_restJson1GetAuthorizationTokenCommandError = async (output, context) => {
@@ -1770,7 +1705,6 @@ const deserializeAws_restJson1GetAuthorizationTokenCommandError = async (output,
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1790,29 +1724,26 @@ const deserializeAws_restJson1GetAuthorizationTokenCommandError = async (output,
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1GetDomainPermissionsPolicyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1GetDomainPermissionsPolicyCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        policy: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.policy !== undefined && data.policy !== null) {
+    if (data.policy != null) {
         contents.policy = deserializeAws_restJson1ResourcePolicy(data.policy, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1GetDomainPermissionsPolicyCommand = deserializeAws_restJson1GetDomainPermissionsPolicyCommand;
 const deserializeAws_restJson1GetDomainPermissionsPolicyCommandError = async (output, context) => {
@@ -1820,7 +1751,6 @@ const deserializeAws_restJson1GetDomainPermissionsPolicyCommandError = async (ou
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1840,39 +1770,27 @@ const deserializeAws_restJson1GetDomainPermissionsPolicyCommandError = async (ou
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1GetPackageVersionAssetCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1GetPackageVersionAssetCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        asset: undefined,
-        assetName: undefined,
-        packageVersion: undefined,
-        packageVersionRevision: undefined,
-    };
-    if (output.headers["x-assetname"] !== undefined) {
-        contents.assetName = output.headers["x-assetname"];
-    }
-    if (output.headers["x-packageversion"] !== undefined) {
-        contents.packageVersion = output.headers["x-packageversion"];
-    }
-    if (output.headers["x-packageversionrevision"] !== undefined) {
-        contents.packageVersionRevision = output.headers["x-packageversionrevision"];
-    }
+        assetName: [, output.headers["x-assetname"]],
+        packageVersion: [, output.headers["x-packageversion"]],
+        packageVersionRevision: [, output.headers["x-packageversionrevision"]],
+    });
     const data = output.body;
     contents.asset = data;
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1GetPackageVersionAssetCommand = deserializeAws_restJson1GetPackageVersionAssetCommand;
 const deserializeAws_restJson1GetPackageVersionAssetCommandError = async (output, context) => {
@@ -1880,7 +1798,6 @@ const deserializeAws_restJson1GetPackageVersionAssetCommandError = async (output
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1903,49 +1820,41 @@ const deserializeAws_restJson1GetPackageVersionAssetCommandError = async (output
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1GetPackageVersionReadmeCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1GetPackageVersionReadmeCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        format: undefined,
-        namespace: undefined,
-        package: undefined,
-        readme: undefined,
-        version: undefined,
-        versionRevision: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.format !== undefined && data.format !== null) {
+    if (data.format != null) {
         contents.format = (0, smithy_client_1.expectString)(data.format);
     }
-    if (data.namespace !== undefined && data.namespace !== null) {
+    if (data.namespace != null) {
         contents.namespace = (0, smithy_client_1.expectString)(data.namespace);
     }
-    if (data.package !== undefined && data.package !== null) {
+    if (data.package != null) {
         contents.package = (0, smithy_client_1.expectString)(data.package);
     }
-    if (data.readme !== undefined && data.readme !== null) {
+    if (data.readme != null) {
         contents.readme = (0, smithy_client_1.expectString)(data.readme);
     }
-    if (data.version !== undefined && data.version !== null) {
+    if (data.version != null) {
         contents.version = (0, smithy_client_1.expectString)(data.version);
     }
-    if (data.versionRevision !== undefined && data.versionRevision !== null) {
+    if (data.versionRevision != null) {
         contents.versionRevision = (0, smithy_client_1.expectString)(data.versionRevision);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1GetPackageVersionReadmeCommand = deserializeAws_restJson1GetPackageVersionReadmeCommand;
 const deserializeAws_restJson1GetPackageVersionReadmeCommandError = async (output, context) => {
@@ -1953,7 +1862,6 @@ const deserializeAws_restJson1GetPackageVersionReadmeCommandError = async (outpu
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -1973,29 +1881,26 @@ const deserializeAws_restJson1GetPackageVersionReadmeCommandError = async (outpu
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1GetRepositoryEndpointCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1GetRepositoryEndpointCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        repositoryEndpoint: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.repositoryEndpoint !== undefined && data.repositoryEndpoint !== null) {
+    if (data.repositoryEndpoint != null) {
         contents.repositoryEndpoint = (0, smithy_client_1.expectString)(data.repositoryEndpoint);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1GetRepositoryEndpointCommand = deserializeAws_restJson1GetRepositoryEndpointCommand;
 const deserializeAws_restJson1GetRepositoryEndpointCommandError = async (output, context) => {
@@ -2003,7 +1908,6 @@ const deserializeAws_restJson1GetRepositoryEndpointCommandError = async (output,
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2023,29 +1927,26 @@ const deserializeAws_restJson1GetRepositoryEndpointCommandError = async (output,
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1GetRepositoryPermissionsPolicyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1GetRepositoryPermissionsPolicyCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        policy: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.policy !== undefined && data.policy !== null) {
+    if (data.policy != null) {
         contents.policy = deserializeAws_restJson1ResourcePolicy(data.policy, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1GetRepositoryPermissionsPolicyCommand = deserializeAws_restJson1GetRepositoryPermissionsPolicyCommand;
 const deserializeAws_restJson1GetRepositoryPermissionsPolicyCommandError = async (output, context) => {
@@ -2053,7 +1954,6 @@ const deserializeAws_restJson1GetRepositoryPermissionsPolicyCommandError = async
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2073,33 +1973,29 @@ const deserializeAws_restJson1GetRepositoryPermissionsPolicyCommandError = async
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1ListDomainsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ListDomainsCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        domains: undefined,
-        nextToken: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.domains !== undefined && data.domains !== null) {
+    if (data.domains != null) {
         contents.domains = deserializeAws_restJson1DomainSummaryList(data.domains, context);
     }
-    if (data.nextToken !== undefined && data.nextToken !== null) {
+    if (data.nextToken != null) {
         contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1ListDomainsCommand = deserializeAws_restJson1ListDomainsCommand;
 const deserializeAws_restJson1ListDomainsCommandError = async (output, context) => {
@@ -2107,7 +2003,6 @@ const deserializeAws_restJson1ListDomainsCommandError = async (output, context)
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2124,33 +2019,29 @@ const deserializeAws_restJson1ListDomainsCommandError = async (output, context)
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1ListPackagesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ListPackagesCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        nextToken: undefined,
-        packages: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.nextToken !== undefined && data.nextToken !== null) {
+    if (data.nextToken != null) {
         contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
     }
-    if (data.packages !== undefined && data.packages !== null) {
+    if (data.packages != null) {
         contents.packages = deserializeAws_restJson1PackageSummaryList(data.packages, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1ListPackagesCommand = deserializeAws_restJson1ListPackagesCommand;
 const deserializeAws_restJson1ListPackagesCommandError = async (output, context) => {
@@ -2158,7 +2049,6 @@ const deserializeAws_restJson1ListPackagesCommandError = async (output, context)
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2178,53 +2068,44 @@ const deserializeAws_restJson1ListPackagesCommandError = async (output, context)
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1ListPackageVersionAssetsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ListPackageVersionAssetsCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        assets: undefined,
-        format: undefined,
-        namespace: undefined,
-        nextToken: undefined,
-        package: undefined,
-        version: undefined,
-        versionRevision: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.assets !== undefined && data.assets !== null) {
+    if (data.assets != null) {
         contents.assets = deserializeAws_restJson1AssetSummaryList(data.assets, context);
     }
-    if (data.format !== undefined && data.format !== null) {
+    if (data.format != null) {
         contents.format = (0, smithy_client_1.expectString)(data.format);
     }
-    if (data.namespace !== undefined && data.namespace !== null) {
+    if (data.namespace != null) {
         contents.namespace = (0, smithy_client_1.expectString)(data.namespace);
     }
-    if (data.nextToken !== undefined && data.nextToken !== null) {
+    if (data.nextToken != null) {
         contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
     }
-    if (data.package !== undefined && data.package !== null) {
+    if (data.package != null) {
         contents.package = (0, smithy_client_1.expectString)(data.package);
     }
-    if (data.version !== undefined && data.version !== null) {
+    if (data.version != null) {
         contents.version = (0, smithy_client_1.expectString)(data.version);
     }
-    if (data.versionRevision !== undefined && data.versionRevision !== null) {
+    if (data.versionRevision != null) {
         contents.versionRevision = (0, smithy_client_1.expectString)(data.versionRevision);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1ListPackageVersionAssetsCommand = deserializeAws_restJson1ListPackageVersionAssetsCommand;
 const deserializeAws_restJson1ListPackageVersionAssetsCommandError = async (output, context) => {
@@ -2232,7 +2113,6 @@ const deserializeAws_restJson1ListPackageVersionAssetsCommandError = async (outp
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2252,53 +2132,44 @@ const deserializeAws_restJson1ListPackageVersionAssetsCommandError = async (outp
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1ListPackageVersionDependenciesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ListPackageVersionDependenciesCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        dependencies: undefined,
-        format: undefined,
-        namespace: undefined,
-        nextToken: undefined,
-        package: undefined,
-        version: undefined,
-        versionRevision: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.dependencies !== undefined && data.dependencies !== null) {
+    if (data.dependencies != null) {
         contents.dependencies = deserializeAws_restJson1PackageDependencyList(data.dependencies, context);
     }
-    if (data.format !== undefined && data.format !== null) {
+    if (data.format != null) {
         contents.format = (0, smithy_client_1.expectString)(data.format);
     }
-    if (data.namespace !== undefined && data.namespace !== null) {
+    if (data.namespace != null) {
         contents.namespace = (0, smithy_client_1.expectString)(data.namespace);
     }
-    if (data.nextToken !== undefined && data.nextToken !== null) {
+    if (data.nextToken != null) {
         contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
     }
-    if (data.package !== undefined && data.package !== null) {
+    if (data.package != null) {
         contents.package = (0, smithy_client_1.expectString)(data.package);
     }
-    if (data.version !== undefined && data.version !== null) {
+    if (data.version != null) {
         contents.version = (0, smithy_client_1.expectString)(data.version);
     }
-    if (data.versionRevision !== undefined && data.versionRevision !== null) {
+    if (data.versionRevision != null) {
         contents.versionRevision = (0, smithy_client_1.expectString)(data.versionRevision);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1ListPackageVersionDependenciesCommand = deserializeAws_restJson1ListPackageVersionDependenciesCommand;
 const deserializeAws_restJson1ListPackageVersionDependenciesCommandError = async (output, context) => {
@@ -2306,7 +2177,6 @@ const deserializeAws_restJson1ListPackageVersionDependenciesCommandError = async
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2326,49 +2196,41 @@ const deserializeAws_restJson1ListPackageVersionDependenciesCommandError = async
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1ListPackageVersionsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ListPackageVersionsCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        defaultDisplayVersion: undefined,
-        format: undefined,
-        namespace: undefined,
-        nextToken: undefined,
-        package: undefined,
-        versions: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.defaultDisplayVersion !== undefined && data.defaultDisplayVersion !== null) {
+    if (data.defaultDisplayVersion != null) {
         contents.defaultDisplayVersion = (0, smithy_client_1.expectString)(data.defaultDisplayVersion);
     }
-    if (data.format !== undefined && data.format !== null) {
+    if (data.format != null) {
         contents.format = (0, smithy_client_1.expectString)(data.format);
     }
-    if (data.namespace !== undefined && data.namespace !== null) {
+    if (data.namespace != null) {
         contents.namespace = (0, smithy_client_1.expectString)(data.namespace);
     }
-    if (data.nextToken !== undefined && data.nextToken !== null) {
+    if (data.nextToken != null) {
         contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
     }
-    if (data.package !== undefined && data.package !== null) {
+    if (data.package != null) {
         contents.package = (0, smithy_client_1.expectString)(data.package);
     }
-    if (data.versions !== undefined && data.versions !== null) {
+    if (data.versions != null) {
         contents.versions = deserializeAws_restJson1PackageVersionSummaryList(data.versions, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1ListPackageVersionsCommand = deserializeAws_restJson1ListPackageVersionsCommand;
 const deserializeAws_restJson1ListPackageVersionsCommandError = async (output, context) => {
@@ -2376,7 +2238,6 @@ const deserializeAws_restJson1ListPackageVersionsCommandError = async (output, c
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2396,33 +2257,29 @@ const deserializeAws_restJson1ListPackageVersionsCommandError = async (output, c
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1ListRepositoriesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ListRepositoriesCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        nextToken: undefined,
-        repositories: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.nextToken !== undefined && data.nextToken !== null) {
+    if (data.nextToken != null) {
         contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
     }
-    if (data.repositories !== undefined && data.repositories !== null) {
+    if (data.repositories != null) {
         contents.repositories = deserializeAws_restJson1RepositorySummaryList(data.repositories, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1ListRepositoriesCommand = deserializeAws_restJson1ListRepositoriesCommand;
 const deserializeAws_restJson1ListRepositoriesCommandError = async (output, context) => {
@@ -2430,7 +2287,6 @@ const deserializeAws_restJson1ListRepositoriesCommandError = async (output, cont
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2447,33 +2303,29 @@ const deserializeAws_restJson1ListRepositoriesCommandError = async (output, cont
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1ListRepositoriesInDomainCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ListRepositoriesInDomainCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        nextToken: undefined,
-        repositories: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.nextToken !== undefined && data.nextToken !== null) {
+    if (data.nextToken != null) {
         contents.nextToken = (0, smithy_client_1.expectString)(data.nextToken);
     }
-    if (data.repositories !== undefined && data.repositories !== null) {
+    if (data.repositories != null) {
         contents.repositories = deserializeAws_restJson1RepositorySummaryList(data.repositories, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1ListRepositoriesInDomainCommand = deserializeAws_restJson1ListRepositoriesInDomainCommand;
 const deserializeAws_restJson1ListRepositoriesInDomainCommandError = async (output, context) => {
@@ -2481,7 +2333,6 @@ const deserializeAws_restJson1ListRepositoriesInDomainCommandError = async (outp
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2501,29 +2352,26 @@ const deserializeAws_restJson1ListRepositoriesInDomainCommandError = async (outp
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        tags: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.tags !== undefined && data.tags !== null) {
+    if (data.tags != null) {
         contents.tags = deserializeAws_restJson1TagList(data.tags, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1ListTagsForResourceCommand = deserializeAws_restJson1ListTagsForResourceCommand;
 const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
@@ -2531,7 +2379,6 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2548,29 +2395,26 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1PutDomainPermissionsPolicyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1PutDomainPermissionsPolicyCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        policy: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.policy !== undefined && data.policy !== null) {
+    if (data.policy != null) {
         contents.policy = deserializeAws_restJson1ResourcePolicy(data.policy, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1PutDomainPermissionsPolicyCommand = deserializeAws_restJson1PutDomainPermissionsPolicyCommand;
 const deserializeAws_restJson1PutDomainPermissionsPolicyCommandError = async (output, context) => {
@@ -2578,7 +2422,6 @@ const deserializeAws_restJson1PutDomainPermissionsPolicyCommandError = async (ou
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2604,29 +2447,26 @@ const deserializeAws_restJson1PutDomainPermissionsPolicyCommandError = async (ou
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1PutPackageOriginConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1PutPackageOriginConfigurationCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        originConfiguration: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.originConfiguration !== undefined && data.originConfiguration !== null) {
+    if (data.originConfiguration != null) {
         contents.originConfiguration = deserializeAws_restJson1PackageOriginConfiguration(data.originConfiguration, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1PutPackageOriginConfigurationCommand = deserializeAws_restJson1PutPackageOriginConfigurationCommand;
 const deserializeAws_restJson1PutPackageOriginConfigurationCommandError = async (output, context) => {
@@ -2634,7 +2474,6 @@ const deserializeAws_restJson1PutPackageOriginConfigurationCommandError = async
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2654,29 +2493,26 @@ const deserializeAws_restJson1PutPackageOriginConfigurationCommandError = async
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1PutRepositoryPermissionsPolicyCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1PutRepositoryPermissionsPolicyCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        policy: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.policy !== undefined && data.policy !== null) {
+    if (data.policy != null) {
         contents.policy = deserializeAws_restJson1ResourcePolicy(data.policy, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1PutRepositoryPermissionsPolicyCommand = deserializeAws_restJson1PutRepositoryPermissionsPolicyCommand;
 const deserializeAws_restJson1PutRepositoryPermissionsPolicyCommandError = async (output, context) => {
@@ -2684,7 +2520,6 @@ const deserializeAws_restJson1PutRepositoryPermissionsPolicyCommandError = async
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2710,25 +2545,23 @@ const deserializeAws_restJson1PutRepositoryPermissionsPolicyCommandError = async
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1TagResourceCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-    };
+    });
     await collectBody(output.body, context);
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1TagResourceCommand = deserializeAws_restJson1TagResourceCommand;
 const deserializeAws_restJson1TagResourceCommandError = async (output, context) => {
@@ -2736,7 +2569,6 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2756,25 +2588,23 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1UntagResourceCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-    };
+    });
     await collectBody(output.body, context);
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1UntagResourceCommand = deserializeAws_restJson1UntagResourceCommand;
 const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
@@ -2782,7 +2612,6 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2799,33 +2628,29 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1UpdatePackageVersionsStatusCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1UpdatePackageVersionsStatusCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        failedVersions: undefined,
-        successfulVersions: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.failedVersions !== undefined && data.failedVersions !== null) {
+    if (data.failedVersions != null) {
         contents.failedVersions = deserializeAws_restJson1PackageVersionErrorMap(data.failedVersions, context);
     }
-    if (data.successfulVersions !== undefined && data.successfulVersions !== null) {
+    if (data.successfulVersions != null) {
         contents.successfulVersions = deserializeAws_restJson1SuccessfulPackageVersionInfoMap(data.successfulVersions, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1UpdatePackageVersionsStatusCommand = deserializeAws_restJson1UpdatePackageVersionsStatusCommand;
 const deserializeAws_restJson1UpdatePackageVersionsStatusCommandError = async (output, context) => {
@@ -2833,7 +2658,6 @@ const deserializeAws_restJson1UpdatePackageVersionsStatusCommandError = async (o
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2856,29 +2680,26 @@ const deserializeAws_restJson1UpdatePackageVersionsStatusCommandError = async (o
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1UpdateRepositoryCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1UpdateRepositoryCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        repository: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.repository !== undefined && data.repository !== null) {
+    if (data.repository != null) {
         contents.repository = deserializeAws_restJson1RepositoryDescription(data.repository, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1UpdateRepositoryCommand = deserializeAws_restJson1UpdateRepositoryCommand;
 const deserializeAws_restJson1UpdateRepositoryCommandError = async (output, context) => {
@@ -2886,7 +2707,6 @@ const deserializeAws_restJson1UpdateRepositoryCommandError = async (output, cont
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -2912,20 +2732,19 @@ const deserializeAws_restJson1UpdateRepositoryCommandError = async (output, cont
             throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new CodeartifactServiceException_1.CodeartifactServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: CodeartifactServiceException_1.CodeartifactServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
+const map = smithy_client_1.map;
 const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
+    const contents = map({});
     const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
+    if (data.message != null) {
         contents.message = (0, smithy_client_1.expectString)(data.message);
     }
     const exception = new models_0_1.AccessDeniedException({
@@ -2935,15 +2754,15 @@ const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutpu
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
 const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
+    const contents = map({});
     const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
+    if (data.message != null) {
         contents.message = (0, smithy_client_1.expectString)(data.message);
     }
-    if (data.resourceId !== undefined && data.resourceId !== null) {
+    if (data.resourceId != null) {
         contents.resourceId = (0, smithy_client_1.expectString)(data.resourceId);
     }
-    if (data.resourceType !== undefined && data.resourceType !== null) {
+    if (data.resourceType != null) {
         contents.resourceType = (0, smithy_client_1.expectString)(data.resourceType);
     }
     const exception = new models_0_1.ConflictException({
@@ -2953,9 +2772,9 @@ const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, c
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
 const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
+    const contents = map({});
     const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
+    if (data.message != null) {
         contents.message = (0, smithy_client_1.expectString)(data.message);
     }
     const exception = new models_0_1.InternalServerException({
@@ -2965,15 +2784,15 @@ const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOut
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
 const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
+    const contents = map({});
     const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
+    if (data.message != null) {
         contents.message = (0, smithy_client_1.expectString)(data.message);
     }
-    if (data.resourceId !== undefined && data.resourceId !== null) {
+    if (data.resourceId != null) {
         contents.resourceId = (0, smithy_client_1.expectString)(data.resourceId);
     }
-    if (data.resourceType !== undefined && data.resourceType !== null) {
+    if (data.resourceType != null) {
         contents.resourceType = (0, smithy_client_1.expectString)(data.resourceType);
     }
     const exception = new models_0_1.ResourceNotFoundException({
@@ -2983,15 +2802,15 @@ const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedO
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
 const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
+    const contents = map({});
     const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
+    if (data.message != null) {
         contents.message = (0, smithy_client_1.expectString)(data.message);
     }
-    if (data.resourceId !== undefined && data.resourceId !== null) {
+    if (data.resourceId != null) {
         contents.resourceId = (0, smithy_client_1.expectString)(data.resourceId);
     }
-    if (data.resourceType !== undefined && data.resourceType !== null) {
+    if (data.resourceType != null) {
         contents.resourceType = (0, smithy_client_1.expectString)(data.resourceType);
     }
     const exception = new models_0_1.ServiceQuotaExceededException({
@@ -3001,12 +2820,14 @@ const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (par
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
 const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
-    if (parsedOutput.headers["retry-after"] !== undefined) {
-        contents.retryAfterSeconds = (0, smithy_client_1.strictParseInt32)(parsedOutput.headers["retry-after"]);
-    }
+    const contents = map({
+        retryAfterSeconds: [
+            () => void 0 !== parsedOutput.headers["retry-after"],
+            () => (0, smithy_client_1.strictParseInt32)(parsedOutput.headers["retry-after"]),
+        ],
+    });
     const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
+    if (data.message != null) {
         contents.message = (0, smithy_client_1.expectString)(data.message);
     }
     const exception = new models_0_1.ThrottlingException({
@@ -3016,12 +2837,12 @@ const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput,
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
 const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
+    const contents = map({});
     const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
+    if (data.message != null) {
         contents.message = (0, smithy_client_1.expectString)(data.message);
     }
-    if (data.reason !== undefined && data.reason !== null) {
+    if (data.reason != null) {
         contents.reason = (0, smithy_client_1.expectString)(data.reason);
     }
     const exception = new models_0_1.ValidationException({
@@ -3040,9 +2861,6 @@ const serializeAws_restJson1PackageVersionList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return entry;
     });
 };
@@ -3067,9 +2885,6 @@ const serializeAws_restJson1TagKeyList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return entry;
     });
 };
@@ -3077,9 +2892,6 @@ const serializeAws_restJson1TagList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return serializeAws_restJson1Tag(entry, context);
     });
 };
@@ -3092,9 +2904,6 @@ const serializeAws_restJson1UpstreamRepositoryList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return serializeAws_restJson1UpstreamRepository(entry, context);
     });
 };