@aws-sdk/client-proton 3.926.0 → 3.928.0

package/dist-cjs/runtimeConfig.shared.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRuntimeConfig = void 0;
 const core_1 = require("@aws-sdk/core");
+const protocols_1 = require("@aws-sdk/core/protocols");
 const smithy_client_1 = require("@smithy/smithy-client");
 const url_parser_1 = require("@smithy/url-parser");
 const util_base64_1 = require("@smithy/util-base64");
@@ -25,6 +26,12 @@ const getRuntimeConfig = (config) => {
             },
         ],
         logger: config?.logger ?? new smithy_client_1.NoOpLogger(),
+        protocol: config?.protocol ??
+            new protocols_1.AwsJson1_0Protocol({
+                defaultNamespace: "com.amazonaws.proton",
+                serviceTarget: "AwsProton20200720",
+                awsQueryCompatible: false,
+            }),
         serviceId: config?.serviceId ?? "Proton",
         urlParser: config?.urlParser ?? url_parser_1.parseUrl,
         utf8Decoder: config?.utf8Decoder ?? util_utf8_1.fromUtf8,

package/dist-es/ProtonClient.js

@@ -4,6 +4,7 @@ import { getRecursionDetectionPlugin } from "@aws-sdk/middleware-recursion-detec
 import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
 import { resolveRegionConfig } from "@smithy/config-resolver";
 import { DefaultIdentityProviderConfig, getHttpAuthSchemeEndpointRuleSetPlugin, getHttpSigningPlugin, } from "@smithy/core";
+import { getSchemaSerdePlugin } from "@smithy/core/schema";
 import { getContentLengthPlugin } from "@smithy/middleware-content-length";
 import { resolveEndpointConfig } from "@smithy/middleware-endpoint";
 import { getRetryPlugin, resolveRetryConfig } from "@smithy/middleware-retry";
@@ -28,6 +29,7 @@ export class ProtonClient extends __Client {
         const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(getUserAgentPlugin(this.config));
         this.middlewareStack.use(getRetryPlugin(this.config));
         this.middlewareStack.use(getContentLengthPlugin(this.config));

package/dist-es/commands/AcceptEnvironmentAccountConnectionCommand.js

@@ -1,22 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { de_AcceptEnvironmentAccountConnectionCommand, se_AcceptEnvironmentAccountConnectionCommand, } from "../protocols/Aws_json1_0";
+import { AcceptEnvironmentAccountConnection } from "../schemas/schemas_0";
 export { $Command };
 export class AcceptEnvironmentAccountConnectionCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "AcceptEnvironmentAccountConnection", {})
     .n("ProtonClient", "AcceptEnvironmentAccountConnectionCommand")
-    .f(void 0, void 0)
-    .ser(se_AcceptEnvironmentAccountConnectionCommand)
-    .de(de_AcceptEnvironmentAccountConnectionCommand)
+    .sc(AcceptEnvironmentAccountConnection)
     .build() {
 }

package/dist-es/commands/CancelComponentDeploymentCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CancelComponentDeploymentOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_CancelComponentDeploymentCommand, se_CancelComponentDeploymentCommand } from "../protocols/Aws_json1_0";
+import { CancelComponentDeployment } from "../schemas/schemas_0";
 export { $Command };
 export class CancelComponentDeploymentCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CancelComponentDeployment", {})
     .n("ProtonClient", "CancelComponentDeploymentCommand")
-    .f(void 0, CancelComponentDeploymentOutputFilterSensitiveLog)
-    .ser(se_CancelComponentDeploymentCommand)
-    .de(de_CancelComponentDeploymentCommand)
+    .sc(CancelComponentDeployment)
     .build() {
 }

package/dist-es/commands/CancelEnvironmentDeploymentCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CancelEnvironmentDeploymentOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_CancelEnvironmentDeploymentCommand, se_CancelEnvironmentDeploymentCommand } from "../protocols/Aws_json1_0";
+import { CancelEnvironmentDeployment } from "../schemas/schemas_0";
 export { $Command };
 export class CancelEnvironmentDeploymentCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CancelEnvironmentDeployment", {})
     .n("ProtonClient", "CancelEnvironmentDeploymentCommand")
-    .f(void 0, CancelEnvironmentDeploymentOutputFilterSensitiveLog)
-    .ser(se_CancelEnvironmentDeploymentCommand)
-    .de(de_CancelEnvironmentDeploymentCommand)
+    .sc(CancelEnvironmentDeployment)
     .build() {
 }

package/dist-es/commands/CancelServiceInstanceDeploymentCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CancelServiceInstanceDeploymentOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_CancelServiceInstanceDeploymentCommand, se_CancelServiceInstanceDeploymentCommand, } from "../protocols/Aws_json1_0";
+import { CancelServiceInstanceDeployment } from "../schemas/schemas_0";
 export { $Command };
 export class CancelServiceInstanceDeploymentCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CancelServiceInstanceDeployment", {})
     .n("ProtonClient", "CancelServiceInstanceDeploymentCommand")
-    .f(void 0, CancelServiceInstanceDeploymentOutputFilterSensitiveLog)
-    .ser(se_CancelServiceInstanceDeploymentCommand)
-    .de(de_CancelServiceInstanceDeploymentCommand)
+    .sc(CancelServiceInstanceDeployment)
     .build() {
 }

package/dist-es/commands/CancelServicePipelineDeploymentCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CancelServicePipelineDeploymentOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_CancelServicePipelineDeploymentCommand, se_CancelServicePipelineDeploymentCommand, } from "../protocols/Aws_json1_0";
+import { CancelServicePipelineDeployment } from "../schemas/schemas_0";
 export { $Command };
 export class CancelServicePipelineDeploymentCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CancelServicePipelineDeployment", {})
     .n("ProtonClient", "CancelServicePipelineDeploymentCommand")
-    .f(void 0, CancelServicePipelineDeploymentOutputFilterSensitiveLog)
-    .ser(se_CancelServicePipelineDeploymentCommand)
-    .de(de_CancelServicePipelineDeploymentCommand)
+    .sc(CancelServicePipelineDeployment)
     .build() {
 }

package/dist-es/commands/CreateComponentCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CreateComponentInputFilterSensitiveLog, CreateComponentOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_CreateComponentCommand, se_CreateComponentCommand } from "../protocols/Aws_json1_0";
+import { CreateComponent } from "../schemas/schemas_0";
 export { $Command };
 export class CreateComponentCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CreateComponent", {})
     .n("ProtonClient", "CreateComponentCommand")
-    .f(CreateComponentInputFilterSensitiveLog, CreateComponentOutputFilterSensitiveLog)
-    .ser(se_CreateComponentCommand)
-    .de(de_CreateComponentCommand)
+    .sc(CreateComponent)
     .build() {
 }

package/dist-es/commands/CreateEnvironmentAccountConnectionCommand.js

@@ -1,22 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { de_CreateEnvironmentAccountConnectionCommand, se_CreateEnvironmentAccountConnectionCommand, } from "../protocols/Aws_json1_0";
+import { CreateEnvironmentAccountConnection } from "../schemas/schemas_0";
 export { $Command };
 export class CreateEnvironmentAccountConnectionCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CreateEnvironmentAccountConnection", {})
     .n("ProtonClient", "CreateEnvironmentAccountConnectionCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateEnvironmentAccountConnectionCommand)
-    .de(de_CreateEnvironmentAccountConnectionCommand)
+    .sc(CreateEnvironmentAccountConnection)
     .build() {
 }

package/dist-es/commands/CreateEnvironmentCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CreateEnvironmentInputFilterSensitiveLog, CreateEnvironmentOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_CreateEnvironmentCommand, se_CreateEnvironmentCommand } from "../protocols/Aws_json1_0";
+import { CreateEnvironment } from "../schemas/schemas_0";
 export { $Command };
 export class CreateEnvironmentCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CreateEnvironment", {})
     .n("ProtonClient", "CreateEnvironmentCommand")
-    .f(CreateEnvironmentInputFilterSensitiveLog, CreateEnvironmentOutputFilterSensitiveLog)
-    .ser(se_CreateEnvironmentCommand)
-    .de(de_CreateEnvironmentCommand)
+    .sc(CreateEnvironment)
     .build() {
 }

package/dist-es/commands/CreateEnvironmentTemplateCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CreateEnvironmentTemplateInputFilterSensitiveLog, CreateEnvironmentTemplateOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_CreateEnvironmentTemplateCommand, se_CreateEnvironmentTemplateCommand } from "../protocols/Aws_json1_0";
+import { CreateEnvironmentTemplate } from "../schemas/schemas_0";
 export { $Command };
 export class CreateEnvironmentTemplateCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CreateEnvironmentTemplate", {})
     .n("ProtonClient", "CreateEnvironmentTemplateCommand")
-    .f(CreateEnvironmentTemplateInputFilterSensitiveLog, CreateEnvironmentTemplateOutputFilterSensitiveLog)
-    .ser(se_CreateEnvironmentTemplateCommand)
-    .de(de_CreateEnvironmentTemplateCommand)
+    .sc(CreateEnvironmentTemplate)
     .build() {
 }

package/dist-es/commands/CreateEnvironmentTemplateVersionCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CreateEnvironmentTemplateVersionInputFilterSensitiveLog, CreateEnvironmentTemplateVersionOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_CreateEnvironmentTemplateVersionCommand, se_CreateEnvironmentTemplateVersionCommand, } from "../protocols/Aws_json1_0";
+import { CreateEnvironmentTemplateVersion } from "../schemas/schemas_0";
 export { $Command };
 export class CreateEnvironmentTemplateVersionCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CreateEnvironmentTemplateVersion", {})
     .n("ProtonClient", "CreateEnvironmentTemplateVersionCommand")
-    .f(CreateEnvironmentTemplateVersionInputFilterSensitiveLog, CreateEnvironmentTemplateVersionOutputFilterSensitiveLog)
-    .ser(se_CreateEnvironmentTemplateVersionCommand)
-    .de(de_CreateEnvironmentTemplateVersionCommand)
+    .sc(CreateEnvironmentTemplateVersion)
     .build() {
 }

package/dist-es/commands/CreateRepositoryCommand.js

@@ -1,22 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { de_CreateRepositoryCommand, se_CreateRepositoryCommand } from "../protocols/Aws_json1_0";
+import { CreateRepository } from "../schemas/schemas_0";
 export { $Command };
 export class CreateRepositoryCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CreateRepository", {})
     .n("ProtonClient", "CreateRepositoryCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateRepositoryCommand)
-    .de(de_CreateRepositoryCommand)
+    .sc(CreateRepository)
     .build() {
 }

package/dist-es/commands/CreateServiceCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CreateServiceInputFilterSensitiveLog, CreateServiceOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_CreateServiceCommand, se_CreateServiceCommand } from "../protocols/Aws_json1_0";
+import { CreateService } from "../schemas/schemas_0";
 export { $Command };
 export class CreateServiceCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CreateService", {})
     .n("ProtonClient", "CreateServiceCommand")
-    .f(CreateServiceInputFilterSensitiveLog, CreateServiceOutputFilterSensitiveLog)
-    .ser(se_CreateServiceCommand)
-    .de(de_CreateServiceCommand)
+    .sc(CreateService)
     .build() {
 }

package/dist-es/commands/CreateServiceInstanceCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CreateServiceInstanceInputFilterSensitiveLog, CreateServiceInstanceOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_CreateServiceInstanceCommand, se_CreateServiceInstanceCommand } from "../protocols/Aws_json1_0";
+import { CreateServiceInstance } from "../schemas/schemas_0";
 export { $Command };
 export class CreateServiceInstanceCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CreateServiceInstance", {})
     .n("ProtonClient", "CreateServiceInstanceCommand")
-    .f(CreateServiceInstanceInputFilterSensitiveLog, CreateServiceInstanceOutputFilterSensitiveLog)
-    .ser(se_CreateServiceInstanceCommand)
-    .de(de_CreateServiceInstanceCommand)
+    .sc(CreateServiceInstance)
     .build() {
 }

package/dist-es/commands/CreateServiceSyncConfigCommand.js

@@ -1,22 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { de_CreateServiceSyncConfigCommand, se_CreateServiceSyncConfigCommand } from "../protocols/Aws_json1_0";
+import { CreateServiceSyncConfig } from "../schemas/schemas_0";
 export { $Command };
 export class CreateServiceSyncConfigCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CreateServiceSyncConfig", {})
     .n("ProtonClient", "CreateServiceSyncConfigCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateServiceSyncConfigCommand)
-    .de(de_CreateServiceSyncConfigCommand)
+    .sc(CreateServiceSyncConfig)
     .build() {
 }

package/dist-es/commands/CreateServiceTemplateCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CreateServiceTemplateInputFilterSensitiveLog, CreateServiceTemplateOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_CreateServiceTemplateCommand, se_CreateServiceTemplateCommand } from "../protocols/Aws_json1_0";
+import { CreateServiceTemplate } from "../schemas/schemas_0";
 export { $Command };
 export class CreateServiceTemplateCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CreateServiceTemplate", {})
     .n("ProtonClient", "CreateServiceTemplateCommand")
-    .f(CreateServiceTemplateInputFilterSensitiveLog, CreateServiceTemplateOutputFilterSensitiveLog)
-    .ser(se_CreateServiceTemplateCommand)
-    .de(de_CreateServiceTemplateCommand)
+    .sc(CreateServiceTemplate)
     .build() {
 }

package/dist-es/commands/CreateServiceTemplateVersionCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { CreateServiceTemplateVersionInputFilterSensitiveLog, CreateServiceTemplateVersionOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_CreateServiceTemplateVersionCommand, se_CreateServiceTemplateVersionCommand, } from "../protocols/Aws_json1_0";
+import { CreateServiceTemplateVersion } from "../schemas/schemas_0";
 export { $Command };
 export class CreateServiceTemplateVersionCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CreateServiceTemplateVersion", {})
     .n("ProtonClient", "CreateServiceTemplateVersionCommand")
-    .f(CreateServiceTemplateVersionInputFilterSensitiveLog, CreateServiceTemplateVersionOutputFilterSensitiveLog)
-    .ser(se_CreateServiceTemplateVersionCommand)
-    .de(de_CreateServiceTemplateVersionCommand)
+    .sc(CreateServiceTemplateVersion)
     .build() {
 }

package/dist-es/commands/CreateTemplateSyncConfigCommand.js

@@ -1,22 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { de_CreateTemplateSyncConfigCommand, se_CreateTemplateSyncConfigCommand } from "../protocols/Aws_json1_0";
+import { CreateTemplateSyncConfig } from "../schemas/schemas_0";
 export { $Command };
 export class CreateTemplateSyncConfigCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "CreateTemplateSyncConfig", {})
     .n("ProtonClient", "CreateTemplateSyncConfigCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateTemplateSyncConfigCommand)
-    .de(de_CreateTemplateSyncConfigCommand)
+    .sc(CreateTemplateSyncConfig)
     .build() {
 }

package/dist-es/commands/DeleteComponentCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { DeleteComponentOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_DeleteComponentCommand, se_DeleteComponentCommand } from "../protocols/Aws_json1_0";
+import { DeleteComponent } from "../schemas/schemas_0";
 export { $Command };
 export class DeleteComponentCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "DeleteComponent", {})
     .n("ProtonClient", "DeleteComponentCommand")
-    .f(void 0, DeleteComponentOutputFilterSensitiveLog)
-    .ser(se_DeleteComponentCommand)
-    .de(de_DeleteComponentCommand)
+    .sc(DeleteComponent)
     .build() {
 }

package/dist-es/commands/DeleteDeploymentCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { DeleteDeploymentOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_DeleteDeploymentCommand, se_DeleteDeploymentCommand } from "../protocols/Aws_json1_0";
+import { DeleteDeployment } from "../schemas/schemas_0";
 export { $Command };
 export class DeleteDeploymentCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "DeleteDeployment", {})
     .n("ProtonClient", "DeleteDeploymentCommand")
-    .f(void 0, DeleteDeploymentOutputFilterSensitiveLog)
-    .ser(se_DeleteDeploymentCommand)
-    .de(de_DeleteDeploymentCommand)
+    .sc(DeleteDeployment)
     .build() {
 }

package/dist-es/commands/DeleteEnvironmentAccountConnectionCommand.js

@@ -1,22 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { de_DeleteEnvironmentAccountConnectionCommand, se_DeleteEnvironmentAccountConnectionCommand, } from "../protocols/Aws_json1_0";
+import { DeleteEnvironmentAccountConnection } from "../schemas/schemas_0";
 export { $Command };
 export class DeleteEnvironmentAccountConnectionCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "DeleteEnvironmentAccountConnection", {})
     .n("ProtonClient", "DeleteEnvironmentAccountConnectionCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteEnvironmentAccountConnectionCommand)
-    .de(de_DeleteEnvironmentAccountConnectionCommand)
+    .sc(DeleteEnvironmentAccountConnection)
     .build() {
 }

package/dist-es/commands/DeleteEnvironmentCommand.js

@@ -1,23 +1,16 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
-import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { DeleteEnvironmentOutputFilterSensitiveLog, } from "../models/models_0";
-import { de_DeleteEnvironmentCommand, se_DeleteEnvironmentCommand } from "../protocols/Aws_json1_0";
+import { DeleteEnvironment } from "../schemas/schemas_0";
 export { $Command };
 export class DeleteEnvironmentCommand extends $Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        getSerdePlugin(config, this.serialize, this.deserialize),
-        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AwsProton20200720", "DeleteEnvironment", {})
     .n("ProtonClient", "DeleteEnvironmentCommand")
-    .f(void 0, DeleteEnvironmentOutputFilterSensitiveLog)
-    .ser(se_DeleteEnvironmentCommand)
-    .de(de_DeleteEnvironmentCommand)
+    .sc(DeleteEnvironment)
     .build() {
 }