@aws-sdk/client-supplychain 3.927.0 → 3.929.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,9 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
-var uuid = require('@smithy/uuid');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -92,6 +90,7 @@ class SupplyChainClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -111,14 +110,14 @@ class SupplyChainClient extends smithyClient.Client {
     }
 }
 
-class SupplyChainServiceException extends smithyClient.ServiceException {
+let SupplyChainServiceException$1 = class SupplyChainServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, SupplyChainServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends SupplyChainServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends SupplyChainServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -129,7 +128,7 @@ class AccessDeniedException extends SupplyChainServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
+};
 const ConfigurationJobStatus = {
     FAILED: "FAILED",
     IN_PROGRESS: "IN_PROGRESS",
@@ -137,7 +136,7 @@ const ConfigurationJobStatus = {
     QUEUED: "QUEUED",
     SUCCESS: "SUCCESS",
 };
-class ConflictException extends SupplyChainServiceException {
+let ConflictException$1 = class ConflictException extends SupplyChainServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     constructor(opts) {
@@ -148,8 +147,8 @@ class ConflictException extends SupplyChainServiceException {
         });
         Object.setPrototypeOf(this, ConflictException.prototype);
     }
-}
-class InternalServerException extends SupplyChainServiceException {
+};
+let InternalServerException$1 = class InternalServerException extends SupplyChainServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     $retryable = {};
@@ -161,8 +160,8 @@ class InternalServerException extends SupplyChainServiceException {
         });
         Object.setPrototypeOf(this, InternalServerException.prototype);
     }
-}
-class ResourceNotFoundException extends SupplyChainServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends SupplyChainServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -173,8 +172,8 @@ class ResourceNotFoundException extends SupplyChainServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
-class ServiceQuotaExceededException extends SupplyChainServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends SupplyChainServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     constructor(opts) {
@@ -185,8 +184,8 @@ class ServiceQuotaExceededException extends SupplyChainServiceException {
         });
         Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
     }
-}
-class ThrottlingException extends SupplyChainServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends SupplyChainServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     $retryable = {
@@ -200,8 +199,8 @@ class ThrottlingException extends SupplyChainServiceException {
         });
         Object.setPrototypeOf(this, ThrottlingException.prototype);
     }
-}
-class ValidationException extends SupplyChainServiceException {
+};
+let ValidationException$1 = class ValidationException extends SupplyChainServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     constructor(opts) {
@@ -212,7 +211,7 @@ class ValidationException extends SupplyChainServiceException {
         });
         Object.setPrototypeOf(this, ValidationException.prototype);
     }
-}
+};
 const DataIntegrationFlowFieldPriorityDedupeSortOrder = {
     ASC: "ASC",
     DESC: "DESC",
@@ -296,1146 +295,1363 @@ const DataIntegrationFlowExecutionStatus = {
     IN_PROGRESS: "IN_PROGRESS",
     SUCCEEDED: "SUCCEEDED",
 };
-const DataIntegrationFlowSQLTransformationConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.query && { query: smithyClient.SENSITIVE_STRING }),
-});
-const DataIntegrationFlowTransformationFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.sqlTransformation && {
-        sqlTransformation: DataIntegrationFlowSQLTransformationConfigurationFilterSensitiveLog(obj.sqlTransformation),
-    }),
-});
-const CreateDataIntegrationFlowRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.transformation && {
-        transformation: DataIntegrationFlowTransformationFilterSensitiveLog(obj.transformation),
-    }),
-});
-const DataIntegrationFlowFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.transformation && {
-        transformation: DataIntegrationFlowTransformationFilterSensitiveLog(obj.transformation),
-    }),
-});
-const GetDataIntegrationFlowResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.flow && { flow: DataIntegrationFlowFilterSensitiveLog(obj.flow) }),
-});
-const ListDataIntegrationFlowsResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.flows && { flows: obj.flows.map((item) => DataIntegrationFlowFilterSensitiveLog(item)) }),
-});
-const UpdateDataIntegrationFlowRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.transformation && {
-        transformation: DataIntegrationFlowTransformationFilterSensitiveLog(obj.transformation),
-    }),
-});
-const UpdateDataIntegrationFlowResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.flow && { flow: DataIntegrationFlowFilterSensitiveLog(obj.flow) }),
-});
-const SendDataIntegrationEventRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.data && { data: smithyClient.SENSITIVE_STRING }),
-});
 
-const se_CreateBillOfMaterialsImportJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/api/configuration/instances/{instanceId}/bill-of-materials-import-jobs");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        s3uri: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateDataIntegrationFlowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/api/data-integration/instance/{instanceId}/data-integration-flows/{name}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("name", () => input.name, "{name}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        sources: (_) => smithyClient._json(_),
-        tags: (_) => smithyClient._json(_),
-        target: (_) => smithyClient._json(_),
-        transformation: (_) => smithyClient._json(_),
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_CreateDataLakeDatasetCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/api/datalake/instance/{instanceId}/namespaces/{namespace}/datasets/{name}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("namespace", () => input.namespace, "{namespace}", false);
-    b.p("name", () => input.name, "{name}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        description: [],
-        partitionSpec: (_) => smithyClient._json(_),
-        schema: (_) => smithyClient._json(_),
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_CreateDataLakeNamespaceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/api/datalake/instance/{instanceId}/namespaces/{name}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("name", () => input.name, "{name}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        description: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_CreateInstanceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/api/instance");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        instanceDescription: [],
-        instanceName: [],
-        kmsKeyArn: [],
-        tags: (_) => smithyClient._json(_),
-        webAppDnsDomain: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteDataIntegrationFlowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/data-integration/instance/{instanceId}/data-integration-flows/{name}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("name", () => input.name, "{name}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteDataLakeDatasetCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/datalake/instance/{instanceId}/namespaces/{namespace}/datasets/{name}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("namespace", () => input.namespace, "{namespace}", false);
-    b.p("name", () => input.name, "{name}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteDataLakeNamespaceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/datalake/instance/{instanceId}/namespaces/{name}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("name", () => input.name, "{name}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteInstanceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/instance/{instanceId}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_GetBillOfMaterialsImportJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/configuration/instances/{instanceId}/bill-of-materials-import-jobs/{jobId}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("jobId", () => input.jobId, "{jobId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetDataIntegrationEventCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api-data/data-integration/instance/{instanceId}/data-integration-events/{eventId}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("eventId", () => input.eventId, "{eventId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetDataIntegrationFlowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/data-integration/instance/{instanceId}/data-integration-flows/{name}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("name", () => input.name, "{name}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetDataIntegrationFlowExecutionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api-data/data-integration/instance/{instanceId}/data-integration-flows/{flowName}/executions/{executionId}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("flowName", () => input.flowName, "{flowName}", false);
-    b.p("executionId", () => input.executionId, "{executionId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetDataLakeDatasetCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/datalake/instance/{instanceId}/namespaces/{namespace}/datasets/{name}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("namespace", () => input.namespace, "{namespace}", false);
-    b.p("name", () => input.name, "{name}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetDataLakeNamespaceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/datalake/instance/{instanceId}/namespaces/{name}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("name", () => input.name, "{name}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetInstanceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/instance/{instanceId}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_ListDataIntegrationEventsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api-data/data-integration/instance/{instanceId}/data-integration-events");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    const query = smithyClient.map({
-        [_eT]: [, input[_eT]],
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListDataIntegrationFlowExecutionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api-data/data-integration/instance/{instanceId}/data-integration-flows/{flowName}/executions");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("flowName", () => input.flowName, "{flowName}", false);
-    const query = smithyClient.map({
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListDataIntegrationFlowsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/data-integration/instance/{instanceId}/data-integration-flows");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    const query = smithyClient.map({
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListDataLakeDatasetsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/datalake/instance/{instanceId}/namespaces/{namespace}/datasets");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("namespace", () => input.namespace, "{namespace}", false);
-    const query = smithyClient.map({
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListDataLakeNamespacesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/datalake/instance/{instanceId}/namespaces");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    const query = smithyClient.map({
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListInstancesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/instance");
-    const query = smithyClient.map({
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-        [_iNF]: [() => input.instanceNameFilter !== void 0, () => input[_iNF] || []],
-        [_iSF]: [() => input.instanceStateFilter !== void 0, () => input[_iSF] || []],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_SendDataIntegrationEventCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/api-data/data-integration/instance/{instanceId}/data-integration-events");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        data: [],
-        datasetTarget: (_) => smithyClient._json(_),
-        eventGroupId: [],
-        eventTimestamp: (_) => _.getTime() / 1_000,
-        eventType: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/api/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/api/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_UpdateDataIntegrationFlowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/api/data-integration/instance/{instanceId}/data-integration-flows/{name}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("name", () => input.name, "{name}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        sources: (_) => smithyClient._json(_),
-        target: (_) => smithyClient._json(_),
-        transformation: (_) => smithyClient._json(_),
-    }));
-    b.m("PATCH").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateDataLakeDatasetCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/api/datalake/instance/{instanceId}/namespaces/{namespace}/datasets/{name}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("namespace", () => input.namespace, "{namespace}", false);
-    b.p("name", () => input.name, "{name}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        description: [],
-    }));
-    b.m("PATCH").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateDataLakeNamespaceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/api/datalake/instance/{instanceId}/namespaces/{name}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    b.p("name", () => input.name, "{name}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        description: [],
-    }));
-    b.m("PATCH").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateInstanceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/api/instance/{instanceId}");
-    b.p("instanceId", () => input.instanceId, "{instanceId}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        instanceDescription: [],
-        instanceName: [],
-    }));
-    b.m("PATCH").h(headers).b(body);
-    return b.build();
-};
-const de_CreateBillOfMaterialsImportJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        jobId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateDataIntegrationFlowCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        instanceId: smithyClient.expectString,
-        name: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateDataLakeDatasetCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        dataset: (_) => de_DataLakeDataset(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateDataLakeNamespaceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        namespace: (_) => de_DataLakeNamespace(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateInstanceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        instance: (_) => de_Instance(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteDataIntegrationFlowCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        instanceId: smithyClient.expectString,
-        name: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteDataLakeDatasetCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        instanceId: smithyClient.expectString,
-        name: smithyClient.expectString,
-        namespace: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteDataLakeNamespaceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        instanceId: smithyClient.expectString,
-        name: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteInstanceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        instance: (_) => de_Instance(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetBillOfMaterialsImportJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        job: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetDataIntegrationEventCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        event: (_) => de_DataIntegrationEvent(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetDataIntegrationFlowCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        flow: (_) => de_DataIntegrationFlow(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetDataIntegrationFlowExecutionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        flowExecution: (_) => de_DataIntegrationFlowExecution(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetDataLakeDatasetCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        dataset: (_) => de_DataLakeDataset(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetDataLakeNamespaceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        namespace: (_) => de_DataLakeNamespace(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetInstanceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        instance: (_) => de_Instance(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListDataIntegrationEventsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        events: (_) => de_DataIntegrationEventList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListDataIntegrationFlowExecutionsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        flowExecutions: (_) => de_DataIntegrationFlowExecutionList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListDataIntegrationFlowsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        flows: (_) => de_DataIntegrationFlowList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListDataLakeDatasetsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        datasets: (_) => de_DataLakeDatasetList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListDataLakeNamespacesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        namespaces: (_) => de_DataLakeNamespaceList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListInstancesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        instances: (_) => de_InstanceList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_SendDataIntegrationEventCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        eventId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateDataIntegrationFlowCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        flow: (_) => de_DataIntegrationFlow(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateDataLakeDatasetCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        dataset: (_) => de_DataLakeDataset(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateDataLakeNamespaceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        namespace: (_) => de_DataLakeNamespace(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateInstanceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        instance: (_) => de_Instance(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.supplychain#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.supplychain#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.supplychain#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.supplychain#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.supplychain#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.supplychain#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.supplychain#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(SupplyChainServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_DataIntegrationEvent = (output, context) => {
-    return smithyClient.take(output, {
-        datasetTargetDetails: smithyClient._json,
-        eventGroupId: smithyClient.expectString,
-        eventId: smithyClient.expectString,
-        eventTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        eventType: smithyClient.expectString,
-        instanceId: smithyClient.expectString,
-    });
-};
-const de_DataIntegrationEventList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DataIntegrationEvent(entry);
-    });
-    return retVal;
-};
-const de_DataIntegrationFlow = (output, context) => {
-    return smithyClient.take(output, {
-        createdTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        instanceId: smithyClient.expectString,
-        lastModifiedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        name: smithyClient.expectString,
-        sources: smithyClient._json,
-        target: smithyClient._json,
-        transformation: smithyClient._json,
-    });
-};
-const de_DataIntegrationFlowExecution = (output, context) => {
-    return smithyClient.take(output, {
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        executionId: smithyClient.expectString,
-        flowName: smithyClient.expectString,
-        instanceId: smithyClient.expectString,
-        message: smithyClient.expectString,
-        outputMetadata: smithyClient._json,
-        sourceInfo: smithyClient._json,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        status: smithyClient.expectString,
-    });
-};
-const de_DataIntegrationFlowExecutionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DataIntegrationFlowExecution(entry);
-    });
-    return retVal;
-};
-const de_DataIntegrationFlowList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DataIntegrationFlow(entry);
-    });
-    return retVal;
-};
-const de_DataLakeDataset = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        createdTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        instanceId: smithyClient.expectString,
-        lastModifiedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        name: smithyClient.expectString,
-        namespace: smithyClient.expectString,
-        partitionSpec: smithyClient._json,
-        schema: smithyClient._json,
-    });
-};
-const de_DataLakeDatasetList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DataLakeDataset(entry);
-    });
-    return retVal;
-};
-const de_DataLakeNamespace = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        createdTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        instanceId: smithyClient.expectString,
-        lastModifiedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        name: smithyClient.expectString,
-    });
-};
-const de_DataLakeNamespaceList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DataLakeNamespace(entry);
-    });
-    return retVal;
-};
-const de_Instance = (output, context) => {
-    return smithyClient.take(output, {
-        awsAccountId: smithyClient.expectString,
-        createdTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        errorMessage: smithyClient.expectString,
-        instanceDescription: smithyClient.expectString,
-        instanceId: smithyClient.expectString,
-        instanceName: smithyClient.expectString,
-        kmsKeyArn: smithyClient.expectString,
-        lastModifiedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        state: smithyClient.expectString,
-        versionNumber: smithyClient.limitedParseDouble,
-        webAppDnsDomain: smithyClient.expectString,
-    });
-};
-const de_InstanceList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Instance(entry);
-    });
-    return retVal;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
+const _ADE = "AccessDeniedException";
+const _BOMIJ = "BillOfMaterialsImportJob";
+const _CBOMIJ = "CreateBillOfMaterialsImportJob";
+const _CBOMIJR = "CreateBillOfMaterialsImportJobRequest";
+const _CBOMIJRr = "CreateBillOfMaterialsImportJobResponse";
+const _CDIF = "CreateDataIntegrationFlow";
+const _CDIFR = "CreateDataIntegrationFlowRequest";
+const _CDIFRr = "CreateDataIntegrationFlowResponse";
+const _CDLD = "CreateDataLakeDataset";
+const _CDLDR = "CreateDataLakeDatasetRequest";
+const _CDLDRr = "CreateDataLakeDatasetResponse";
+const _CDLN = "CreateDataLakeNamespace";
+const _CDLNR = "CreateDataLakeNamespaceRequest";
+const _CDLNRr = "CreateDataLakeNamespaceResponse";
+const _CE = "ConflictException";
+const _CI = "CreateInstance";
+const _CIR = "CreateInstanceRequest";
+const _CIRr = "CreateInstanceResponse";
+const _DDIF = "DeleteDataIntegrationFlow";
+const _DDIFR = "DeleteDataIntegrationFlowRequest";
+const _DDIFRe = "DeleteDataIntegrationFlowResponse";
+const _DDLD = "DeleteDataLakeDataset";
+const _DDLDR = "DeleteDataLakeDatasetRequest";
+const _DDLDRe = "DeleteDataLakeDatasetResponse";
+const _DDLN = "DeleteDataLakeNamespace";
+const _DDLNR = "DeleteDataLakeNamespaceRequest";
+const _DDLNRe = "DeleteDataLakeNamespaceResponse";
+const _DI = "DeleteInstance";
+const _DIE = "DataIntegrationEvent";
+const _DIED = "DataIntegrationEventData";
+const _DIEDLED = "DataIntegrationEventDatasetLoadExecutionDetails";
+const _DIEDTC = "DataIntegrationEventDatasetTargetConfiguration";
+const _DIEDTD = "DataIntegrationEventDatasetTargetDetails";
+const _DIEL = "DataIntegrationEventList";
+const _DIF = "DataIntegrationFlow";
+const _DIFDO = "DataIntegrationFlowDatasetOptions";
+const _DIFDS = "DataIntegrationFlowDatasetSource";
+const _DIFDSC = "DataIntegrationFlowDatasetSourceConfiguration";
+const _DIFDSa = "DataIntegrationFlowDedupeStrategy";
+const _DIFDTC = "DataIntegrationFlowDatasetTargetConfiguration";
+const _DIFE = "DataIntegrationFlowExecution";
+const _DIFEL = "DataIntegrationFlowExecutionList";
+const _DIFEOM = "DataIntegrationFlowExecutionOutputMetadata";
+const _DIFESI = "DataIntegrationFlowExecutionSourceInfo";
+const _DIFFPDF = "DataIntegrationFlowFieldPriorityDedupeField";
+const _DIFFPDFL = "DataIntegrationFlowFieldPriorityDedupeFieldList";
+const _DIFFPDSC = "DataIntegrationFlowFieldPriorityDedupeStrategyConfiguration";
+const _DIFL = "DataIntegrationFlowList";
+const _DIFS = "DataIntegrationFlowSource";
+const _DIFSL = "DataIntegrationFlowSourceList";
+const _DIFSO = "DataIntegrationFlowS3Options";
+const _DIFSQLQ = "DataIntegrationFlowSQLQuery";
+const _DIFSQLTC = "DataIntegrationFlowSQLTransformationConfiguration";
+const _DIFSS = "DataIntegrationFlowS3Source";
+const _DIFSSC = "DataIntegrationFlowS3SourceConfiguration";
+const _DIFSTC = "DataIntegrationFlowS3TargetConfiguration";
+const _DIFT = "DataIntegrationFlowTarget";
+const _DIFTa = "DataIntegrationFlowTransformation";
+const _DIR = "DeleteInstanceRequest";
+const _DIRe = "DeleteInstanceResponse";
+const _DLD = "DataLakeDataset";
+const _DLDL = "DataLakeDatasetList";
+const _DLDPF = "DataLakeDatasetPartitionField";
+const _DLDPFL = "DataLakeDatasetPartitionFieldList";
+const _DLDPFT = "DataLakeDatasetPartitionFieldTransform";
+const _DLDPKF = "DataLakeDatasetPrimaryKeyField";
+const _DLDPKFL = "DataLakeDatasetPrimaryKeyFieldList";
+const _DLDPS = "DataLakeDatasetPartitionSpec";
+const _DLDS = "DataLakeDatasetSchema";
+const _DLDSF = "DataLakeDatasetSchemaField";
+const _DLDSFL = "DataLakeDatasetSchemaFieldList";
+const _DLN = "DataLakeNamespace";
+const _DLNL = "DataLakeNamespaceList";
+const _GBOMIJ = "GetBillOfMaterialsImportJob";
+const _GBOMIJR = "GetBillOfMaterialsImportJobRequest";
+const _GBOMIJRe = "GetBillOfMaterialsImportJobResponse";
+const _GDIE = "GetDataIntegrationEvent";
+const _GDIER = "GetDataIntegrationEventRequest";
+const _GDIERe = "GetDataIntegrationEventResponse";
+const _GDIF = "GetDataIntegrationFlow";
+const _GDIFE = "GetDataIntegrationFlowExecution";
+const _GDIFER = "GetDataIntegrationFlowExecutionRequest";
+const _GDIFERe = "GetDataIntegrationFlowExecutionResponse";
+const _GDIFR = "GetDataIntegrationFlowRequest";
+const _GDIFRe = "GetDataIntegrationFlowResponse";
+const _GDLD = "GetDataLakeDataset";
+const _GDLDR = "GetDataLakeDatasetRequest";
+const _GDLDRe = "GetDataLakeDatasetResponse";
+const _GDLN = "GetDataLakeNamespace";
+const _GDLNR = "GetDataLakeNamespaceRequest";
+const _GDLNRe = "GetDataLakeNamespaceResponse";
+const _GI = "GetInstance";
+const _GIR = "GetInstanceRequest";
+const _GIRe = "GetInstanceResponse";
+const _I = "Instance";
+const _IL = "InstanceList";
+const _ISE = "InternalServerException";
+const _LDIE = "ListDataIntegrationEvents";
+const _LDIER = "ListDataIntegrationEventsRequest";
+const _LDIERi = "ListDataIntegrationEventsResponse";
+const _LDIF = "ListDataIntegrationFlows";
+const _LDIFE = "ListDataIntegrationFlowExecutions";
+const _LDIFER = "ListDataIntegrationFlowExecutionsRequest";
+const _LDIFERi = "ListDataIntegrationFlowExecutionsResponse";
+const _LDIFR = "ListDataIntegrationFlowsRequest";
+const _LDIFRi = "ListDataIntegrationFlowsResponse";
+const _LDLD = "ListDataLakeDatasets";
+const _LDLDR = "ListDataLakeDatasetsRequest";
+const _LDLDRi = "ListDataLakeDatasetsResponse";
+const _LDLN = "ListDataLakeNamespaces";
+const _LDLNR = "ListDataLakeNamespacesRequest";
+const _LDLNRi = "ListDataLakeNamespacesResponse";
+const _LI = "ListInstances";
+const _LIR = "ListInstancesRequest";
+const _LIRi = "ListInstancesResponse";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _RNFE = "ResourceNotFoundException";
+const _SDIE = "SendDataIntegrationEvent";
+const _SDIER = "SendDataIntegrationEventRequest";
+const _SDIERe = "SendDataIntegrationEventResponse";
+const _SQEE = "ServiceQuotaExceededException";
+const _TE = "ThrottlingException";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _UDIF = "UpdateDataIntegrationFlow";
+const _UDIFR = "UpdateDataIntegrationFlowRequest";
+const _UDIFRp = "UpdateDataIntegrationFlowResponse";
+const _UDLD = "UpdateDataLakeDataset";
+const _UDLDR = "UpdateDataLakeDatasetRequest";
+const _UDLDRp = "UpdateDataLakeDatasetResponse";
+const _UDLN = "UpdateDataLakeNamespace";
+const _UDLNR = "UpdateDataLakeNamespaceRequest";
+const _UDLNRp = "UpdateDataLakeNamespaceResponse";
+const _UI = "UpdateInstance";
+const _UIR = "UpdateInstanceRequest";
+const _UIRp = "UpdateInstanceResponse";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _VE = "ValidationException";
+const _a = "arn";
+const _aAI = "awsAccountId";
+const _bN = "bucketName";
+const _c = "client";
+const _cT = "clientToken";
+const _cTr = "createdTime";
+const _d = "description";
+const _dI = "datasetIdentifier";
+const _dLE = "datasetLoadExecution";
+const _dR = "dedupeRecords";
+const _dRRSURI = "diagnosticReportsRootS3URI";
+const _dS = "dedupeStrategy";
+const _dSa = "datasetSource";
+const _dT = "datasetTarget";
+const _dTD = "datasetTargetDetails";
+const _da = "dataset";
+const _dat = "datasets";
+const _data = "data";
+const _e = "error";
+const _eGI = "eventGroupId";
+const _eI = "eventId";
+const _eIx = "executionId";
+const _eM = "errorMessage";
 const _eT = "eventType";
+const _eTn = "endTime";
+const _eTv = "eventTimestamp";
+const _ev = "event";
+const _eve = "events";
+const _f = "fields";
+const _fE = "flowExecution";
+const _fEl = "flowExecutions";
+const _fN = "flowName";
+const _fP = "fieldPriority";
+const _fT = "fileType";
+const _fl = "flow";
+const _flo = "flows";
+const _h = "http";
+const _hE = "httpError";
+const _hQ = "httpQuery";
+const _i = "instance";
+const _iD = "instanceDescription";
+const _iI = "instanceId";
+const _iN = "instanceName";
 const _iNF = "instanceNameFilter";
+const _iR = "isRequired";
 const _iSF = "instanceStateFilter";
+const _in = "instances";
+const _j = "job";
+const _jI = "jobId";
+const _k = "key";
+const _kKA = "kmsKeyArn";
+const _lMT = "lastModifiedTime";
+const _lT = "loadType";
+const _m = "message";
 const _mR = "maxResults";
+const _n = "name";
 const _nT = "nextToken";
+const _na = "namespace";
+const _nam = "namespaces";
+const _o = "options";
+const _oM = "outputMetadata";
+const _oT = "operationType";
+const _p = "prefix";
+const _pK = "primaryKeys";
+const _pS = "partitionSpec";
+const _q = "query";
+const _rA = "resourceArn";
+const _s = "status";
+const _sI = "sourceInfo";
+const _sN = "sourceName";
+const _sO = "sortOrder";
+const _sS = "s3Source";
+const _sT = "startTime";
+const _sTa = "s3Target";
+const _sTo = "sourceType";
+const _sTq = "sqlTransformation";
+const _sc = "schema";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.supplychain";
+const _so = "sources";
+const _st = "state";
+const _su = "s3uri";
+const _t = "transformation";
 const _tK = "tagKeys";
+const _tT = "targetType";
+const _tTr = "transformationType";
+const _ta = "target";
+const _tag = "tags";
+const _tr = "transform";
+const _ty = "type";
+const _vN = "versionNumber";
+const _wADD = "webAppDnsDomain";
+const n0 = "com.amazonaws.supplychain";
+var DataIntegrationEventData = [0, n0, _DIED, 8, 0];
+var DataIntegrationFlowSQLQuery = [0, n0, _DIFSQLQ, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var BillOfMaterialsImportJob = [
+    3,
+    n0,
+    _BOMIJ,
+    0,
+    [_iI, _jI, _s, _su, _m],
+    [0, 0, 0, 0, 0],
+];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateBillOfMaterialsImportJobRequest = [
+    3,
+    n0,
+    _CBOMIJR,
+    0,
+    [_iI, _su, _cT],
+    [[0, 1], 0, [0, 4]],
+];
+var CreateBillOfMaterialsImportJobResponse = [3, n0, _CBOMIJRr, 0, [_jI], [0]];
+var CreateDataIntegrationFlowRequest = [
+    3,
+    n0,
+    _CDIFR,
+    0,
+    [_iI, _n, _so, _t, _ta, _tag],
+    [
+        [0, 1],
+        [0, 1],
+        () => DataIntegrationFlowSourceList,
+        [() => DataIntegrationFlowTransformation, 0],
+        () => DataIntegrationFlowTarget,
+        128 | 0,
+    ],
+];
+var CreateDataIntegrationFlowResponse = [3, n0, _CDIFRr, 0, [_iI, _n], [0, 0]];
+var CreateDataLakeDatasetRequest = [
+    3,
+    n0,
+    _CDLDR,
+    0,
+    [_iI, _na, _n, _sc, _d, _pS, _tag],
+    [[0, 1], [0, 1], [0, 1], () => DataLakeDatasetSchema, 0, () => DataLakeDatasetPartitionSpec, 128 | 0],
+];
+var CreateDataLakeDatasetResponse = [3, n0, _CDLDRr, 0, [_da], [() => DataLakeDataset]];
+var CreateDataLakeNamespaceRequest = [
+    3,
+    n0,
+    _CDLNR,
+    0,
+    [_iI, _n, _d, _tag],
+    [[0, 1], [0, 1], 0, 128 | 0],
+];
+var CreateDataLakeNamespaceResponse = [
+    3,
+    n0,
+    _CDLNRr,
+    0,
+    [_na],
+    [() => DataLakeNamespace],
+];
+var CreateInstanceRequest = [
+    3,
+    n0,
+    _CIR,
+    0,
+    [_iN, _iD, _kKA, _wADD, _tag, _cT],
+    [0, 0, 0, 0, 128 | 0, [0, 4]],
+];
+var CreateInstanceResponse = [3, n0, _CIRr, 0, [_i], [() => Instance]];
+var DataIntegrationEvent = [
+    3,
+    n0,
+    _DIE,
+    0,
+    [_iI, _eI, _eT, _eGI, _eTv, _dTD],
+    [0, 0, 0, 0, 4, () => DataIntegrationEventDatasetTargetDetails],
+];
+var DataIntegrationEventDatasetLoadExecutionDetails = [
+    3,
+    n0,
+    _DIEDLED,
+    0,
+    [_s, _m],
+    [0, 0],
+];
+var DataIntegrationEventDatasetTargetConfiguration = [
+    3,
+    n0,
+    _DIEDTC,
+    0,
+    [_dI, _oT],
+    [0, 0],
+];
+var DataIntegrationEventDatasetTargetDetails = [
+    3,
+    n0,
+    _DIEDTD,
+    0,
+    [_dI, _oT, _dLE],
+    [0, 0, () => DataIntegrationEventDatasetLoadExecutionDetails],
+];
+var DataIntegrationFlow = [
+    3,
+    n0,
+    _DIF,
+    0,
+    [_iI, _n, _so, _t, _ta, _cTr, _lMT],
+    [
+        0,
+        0,
+        () => DataIntegrationFlowSourceList,
+        [() => DataIntegrationFlowTransformation, 0],
+        () => DataIntegrationFlowTarget,
+        4,
+        4,
+    ],
+];
+var DataIntegrationFlowDatasetOptions = [
+    3,
+    n0,
+    _DIFDO,
+    0,
+    [_lT, _dR, _dS],
+    [0, 2, () => DataIntegrationFlowDedupeStrategy],
+];
+var DataIntegrationFlowDatasetSource = [3, n0, _DIFDS, 0, [_dI], [0]];
+var DataIntegrationFlowDatasetSourceConfiguration = [
+    3,
+    n0,
+    _DIFDSC,
+    0,
+    [_dI, _o],
+    [0, () => DataIntegrationFlowDatasetOptions],
+];
+var DataIntegrationFlowDatasetTargetConfiguration = [
+    3,
+    n0,
+    _DIFDTC,
+    0,
+    [_dI, _o],
+    [0, () => DataIntegrationFlowDatasetOptions],
+];
+var DataIntegrationFlowDedupeStrategy = [
+    3,
+    n0,
+    _DIFDSa,
+    0,
+    [_ty, _fP],
+    [0, () => DataIntegrationFlowFieldPriorityDedupeStrategyConfiguration],
+];
+var DataIntegrationFlowExecution = [
+    3,
+    n0,
+    _DIFE,
+    0,
+    [_iI, _fN, _eIx, _s, _sI, _m, _sT, _eTn, _oM],
+    [0, 0, 0, 0, () => DataIntegrationFlowExecutionSourceInfo, 0, 4, 4, () => DataIntegrationFlowExecutionOutputMetadata],
+];
+var DataIntegrationFlowExecutionOutputMetadata = [3, n0, _DIFEOM, 0, [_dRRSURI], [0]];
+var DataIntegrationFlowExecutionSourceInfo = [
+    3,
+    n0,
+    _DIFESI,
+    0,
+    [_sTo, _sS, _dSa],
+    [0, () => DataIntegrationFlowS3Source, () => DataIntegrationFlowDatasetSource],
+];
+var DataIntegrationFlowFieldPriorityDedupeField = [3, n0, _DIFFPDF, 0, [_n, _sO], [0, 0]];
+var DataIntegrationFlowFieldPriorityDedupeStrategyConfiguration = [
+    3,
+    n0,
+    _DIFFPDSC,
+    0,
+    [_f],
+    [() => DataIntegrationFlowFieldPriorityDedupeFieldList],
+];
+var DataIntegrationFlowS3Options = [3, n0, _DIFSO, 0, [_fT], [0]];
+var DataIntegrationFlowS3Source = [3, n0, _DIFSS, 0, [_bN, _k], [0, 0]];
+var DataIntegrationFlowS3SourceConfiguration = [
+    3,
+    n0,
+    _DIFSSC,
+    0,
+    [_bN, _p, _o],
+    [0, 0, () => DataIntegrationFlowS3Options],
+];
+var DataIntegrationFlowS3TargetConfiguration = [
+    3,
+    n0,
+    _DIFSTC,
+    0,
+    [_bN, _p, _o],
+    [0, 0, () => DataIntegrationFlowS3Options],
+];
+var DataIntegrationFlowSource = [
+    3,
+    n0,
+    _DIFS,
+    0,
+    [_sTo, _sN, _sS, _dSa],
+    [0, 0, () => DataIntegrationFlowS3SourceConfiguration, () => DataIntegrationFlowDatasetSourceConfiguration],
+];
+var DataIntegrationFlowSQLTransformationConfiguration = [
+    3,
+    n0,
+    _DIFSQLTC,
+    0,
+    [_q],
+    [[() => DataIntegrationFlowSQLQuery, 0]],
+];
+var DataIntegrationFlowTarget = [
+    3,
+    n0,
+    _DIFT,
+    0,
+    [_tT, _sTa, _dT],
+    [0, () => DataIntegrationFlowS3TargetConfiguration, () => DataIntegrationFlowDatasetTargetConfiguration],
+];
+var DataIntegrationFlowTransformation = [
+    3,
+    n0,
+    _DIFTa,
+    0,
+    [_tTr, _sTq],
+    [0, [() => DataIntegrationFlowSQLTransformationConfiguration, 0]],
+];
+var DataLakeDataset = [
+    3,
+    n0,
+    _DLD,
+    0,
+    [_iI, _na, _n, _a, _sc, _d, _pS, _cTr, _lMT],
+    [0, 0, 0, 0, () => DataLakeDatasetSchema, 0, () => DataLakeDatasetPartitionSpec, 4, 4],
+];
+var DataLakeDatasetPartitionField = [
+    3,
+    n0,
+    _DLDPF,
+    0,
+    [_n, _tr],
+    [0, () => DataLakeDatasetPartitionFieldTransform],
+];
+var DataLakeDatasetPartitionFieldTransform = [3, n0, _DLDPFT, 0, [_ty], [0]];
+var DataLakeDatasetPartitionSpec = [
+    3,
+    n0,
+    _DLDPS,
+    0,
+    [_f],
+    [() => DataLakeDatasetPartitionFieldList],
+];
+var DataLakeDatasetPrimaryKeyField = [3, n0, _DLDPKF, 0, [_n], [0]];
+var DataLakeDatasetSchema = [
+    3,
+    n0,
+    _DLDS,
+    0,
+    [_n, _f, _pK],
+    [0, () => DataLakeDatasetSchemaFieldList, () => DataLakeDatasetPrimaryKeyFieldList],
+];
+var DataLakeDatasetSchemaField = [3, n0, _DLDSF, 0, [_n, _ty, _iR], [0, 0, 2]];
+var DataLakeNamespace = [
+    3,
+    n0,
+    _DLN,
+    0,
+    [_iI, _n, _a, _d, _cTr, _lMT],
+    [0, 0, 0, 0, 4, 4],
+];
+var DeleteDataIntegrationFlowRequest = [
+    3,
+    n0,
+    _DDIFR,
+    0,
+    [_iI, _n],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var DeleteDataIntegrationFlowResponse = [3, n0, _DDIFRe, 0, [_iI, _n], [0, 0]];
+var DeleteDataLakeDatasetRequest = [
+    3,
+    n0,
+    _DDLDR,
+    0,
+    [_iI, _na, _n],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ],
+];
+var DeleteDataLakeDatasetResponse = [3, n0, _DDLDRe, 0, [_iI, _na, _n], [0, 0, 0]];
+var DeleteDataLakeNamespaceRequest = [
+    3,
+    n0,
+    _DDLNR,
+    0,
+    [_iI, _n],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var DeleteDataLakeNamespaceResponse = [3, n0, _DDLNRe, 0, [_iI, _n], [0, 0]];
+var DeleteInstanceRequest = [3, n0, _DIR, 0, [_iI], [[0, 1]]];
+var DeleteInstanceResponse = [3, n0, _DIRe, 0, [_i], [() => Instance]];
+var GetBillOfMaterialsImportJobRequest = [
+    3,
+    n0,
+    _GBOMIJR,
+    0,
+    [_iI, _jI],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var GetBillOfMaterialsImportJobResponse = [
+    3,
+    n0,
+    _GBOMIJRe,
+    0,
+    [_j],
+    [() => BillOfMaterialsImportJob],
+];
+var GetDataIntegrationEventRequest = [
+    3,
+    n0,
+    _GDIER,
+    0,
+    [_iI, _eI],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var GetDataIntegrationEventResponse = [
+    3,
+    n0,
+    _GDIERe,
+    0,
+    [_ev],
+    [() => DataIntegrationEvent],
+];
+var GetDataIntegrationFlowExecutionRequest = [
+    3,
+    n0,
+    _GDIFER,
+    0,
+    [_iI, _fN, _eIx],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ],
+];
+var GetDataIntegrationFlowExecutionResponse = [
+    3,
+    n0,
+    _GDIFERe,
+    0,
+    [_fE],
+    [() => DataIntegrationFlowExecution],
+];
+var GetDataIntegrationFlowRequest = [
+    3,
+    n0,
+    _GDIFR,
+    0,
+    [_iI, _n],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var GetDataIntegrationFlowResponse = [
+    3,
+    n0,
+    _GDIFRe,
+    0,
+    [_fl],
+    [[() => DataIntegrationFlow, 0]],
+];
+var GetDataLakeDatasetRequest = [
+    3,
+    n0,
+    _GDLDR,
+    0,
+    [_iI, _na, _n],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ],
+];
+var GetDataLakeDatasetResponse = [3, n0, _GDLDRe, 0, [_da], [() => DataLakeDataset]];
+var GetDataLakeNamespaceRequest = [
+    3,
+    n0,
+    _GDLNR,
+    0,
+    [_iI, _n],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var GetDataLakeNamespaceResponse = [3, n0, _GDLNRe, 0, [_na], [() => DataLakeNamespace]];
+var GetInstanceRequest = [3, n0, _GIR, 0, [_iI], [[0, 1]]];
+var GetInstanceResponse = [3, n0, _GIRe, 0, [_i], [() => Instance]];
+var Instance = [
+    3,
+    n0,
+    _I,
+    0,
+    [_iI, _aAI, _st, _eM, _wADD, _cTr, _lMT, _iN, _iD, _kKA, _vN],
+    [0, 0, 0, 0, 0, 4, 4, 0, 0, 0, 1],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var ListDataIntegrationEventsRequest = [
+    3,
+    n0,
+    _LDIER,
+    0,
+    [_iI, _eT, _nT, _mR],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _eT,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListDataIntegrationEventsResponse = [
+    3,
+    n0,
+    _LDIERi,
+    0,
+    [_eve, _nT],
+    [() => DataIntegrationEventList, 0],
+];
+var ListDataIntegrationFlowExecutionsRequest = [
+    3,
+    n0,
+    _LDIFER,
+    0,
+    [_iI, _fN, _nT, _mR],
+    [
+        [0, 1],
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListDataIntegrationFlowExecutionsResponse = [
+    3,
+    n0,
+    _LDIFERi,
+    0,
+    [_fEl, _nT],
+    [() => DataIntegrationFlowExecutionList, 0],
+];
+var ListDataIntegrationFlowsRequest = [
+    3,
+    n0,
+    _LDIFR,
+    0,
+    [_iI, _nT, _mR],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListDataIntegrationFlowsResponse = [
+    3,
+    n0,
+    _LDIFRi,
+    0,
+    [_flo, _nT],
+    [[() => DataIntegrationFlowList, 0], 0],
+];
+var ListDataLakeDatasetsRequest = [
+    3,
+    n0,
+    _LDLDR,
+    0,
+    [_iI, _na, _nT, _mR],
+    [
+        [0, 1],
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListDataLakeDatasetsResponse = [
+    3,
+    n0,
+    _LDLDRi,
+    0,
+    [_dat, _nT],
+    [() => DataLakeDatasetList, 0],
+];
+var ListDataLakeNamespacesRequest = [
+    3,
+    n0,
+    _LDLNR,
+    0,
+    [_iI, _nT, _mR],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListDataLakeNamespacesResponse = [
+    3,
+    n0,
+    _LDLNRi,
+    0,
+    [_nam, _nT],
+    [() => DataLakeNamespaceList, 0],
+];
+var ListInstancesRequest = [
+    3,
+    n0,
+    _LIR,
+    0,
+    [_nT, _mR, _iNF, _iSF],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            64 | 0,
+            {
+                [_hQ]: _iNF,
+            },
+        ],
+        [
+            64 | 0,
+            {
+                [_hQ]: _iSF,
+            },
+        ],
+    ],
+];
+var ListInstancesResponse = [3, n0, _LIRi, 0, [_in, _nT], [() => InstanceList, 0]];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_rA], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_tag], [128 | 0]];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var SendDataIntegrationEventRequest = [
+    3,
+    n0,
+    _SDIER,
+    0,
+    [_iI, _eT, _data, _eGI, _eTv, _cT, _dT],
+    [[0, 1], 0, [() => DataIntegrationEventData, 0], 0, 7, [0, 4], () => DataIntegrationEventDatasetTargetConfiguration],
+];
+var SendDataIntegrationEventResponse = [3, n0, _SDIERe, 0, [_eI], [0]];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var TagResourceRequest = [3, n0, _TRR, 0, [_rA, _tag], [[0, 1], 128 | 0]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_rA, _tK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateDataIntegrationFlowRequest = [
+    3,
+    n0,
+    _UDIFR,
+    0,
+    [_iI, _n, _so, _t, _ta],
+    [
+        [0, 1],
+        [0, 1],
+        () => DataIntegrationFlowSourceList,
+        [() => DataIntegrationFlowTransformation, 0],
+        () => DataIntegrationFlowTarget,
+    ],
+];
+var UpdateDataIntegrationFlowResponse = [
+    3,
+    n0,
+    _UDIFRp,
+    0,
+    [_fl],
+    [[() => DataIntegrationFlow, 0]],
+];
+var UpdateDataLakeDatasetRequest = [
+    3,
+    n0,
+    _UDLDR,
+    0,
+    [_iI, _na, _n, _d],
+    [[0, 1], [0, 1], [0, 1], 0],
+];
+var UpdateDataLakeDatasetResponse = [3, n0, _UDLDRp, 0, [_da], [() => DataLakeDataset]];
+var UpdateDataLakeNamespaceRequest = [
+    3,
+    n0,
+    _UDLNR,
+    0,
+    [_iI, _n, _d],
+    [[0, 1], [0, 1], 0],
+];
+var UpdateDataLakeNamespaceResponse = [
+    3,
+    n0,
+    _UDLNRp,
+    0,
+    [_na],
+    [() => DataLakeNamespace],
+];
+var UpdateInstanceRequest = [3, n0, _UIR, 0, [_iI, _iN, _iD], [[0, 1], 0, 0]];
+var UpdateInstanceResponse = [3, n0, _UIRp, 0, [_i], [() => Instance]];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var SupplyChainServiceException = [-3, _sm, "SupplyChainServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(SupplyChainServiceException, SupplyChainServiceException$1);
+var DataIntegrationEventList = [1, n0, _DIEL, 0, () => DataIntegrationEvent];
+var DataIntegrationFlowExecutionList = [1, n0, _DIFEL, 0, () => DataIntegrationFlowExecution];
+var DataIntegrationFlowFieldPriorityDedupeFieldList = [
+    1,
+    n0,
+    _DIFFPDFL,
+    0,
+    () => DataIntegrationFlowFieldPriorityDedupeField,
+];
+var DataIntegrationFlowList = [1, n0, _DIFL, 0, [() => DataIntegrationFlow, 0]];
+var DataIntegrationFlowSourceList = [1, n0, _DIFSL, 0, () => DataIntegrationFlowSource];
+var DataLakeDatasetList = [1, n0, _DLDL, 0, () => DataLakeDataset];
+var DataLakeDatasetPartitionFieldList = [
+    1,
+    n0,
+    _DLDPFL,
+    0,
+    () => DataLakeDatasetPartitionField,
+];
+var DataLakeDatasetPrimaryKeyFieldList = [
+    1,
+    n0,
+    _DLDPKFL,
+    0,
+    () => DataLakeDatasetPrimaryKeyField,
+];
+var DataLakeDatasetSchemaFieldList = [1, n0, _DLDSFL, 0, () => DataLakeDatasetSchemaField];
+var DataLakeNamespaceList = [1, n0, _DLNL, 0, () => DataLakeNamespace];
+var InstanceList = [1, n0, _IL, 0, () => Instance];
+var CreateBillOfMaterialsImportJob = [
+    9,
+    n0,
+    _CBOMIJ,
+    {
+        [_h]: ["POST", "/api/configuration/instances/{instanceId}/bill-of-materials-import-jobs", 200],
+    },
+    () => CreateBillOfMaterialsImportJobRequest,
+    () => CreateBillOfMaterialsImportJobResponse,
+];
+var CreateDataIntegrationFlow = [
+    9,
+    n0,
+    _CDIF,
+    {
+        [_h]: ["PUT", "/api/data-integration/instance/{instanceId}/data-integration-flows/{name}", 200],
+    },
+    () => CreateDataIntegrationFlowRequest,
+    () => CreateDataIntegrationFlowResponse,
+];
+var CreateDataLakeDataset = [
+    9,
+    n0,
+    _CDLD,
+    {
+        [_h]: ["PUT", "/api/datalake/instance/{instanceId}/namespaces/{namespace}/datasets/{name}", 200],
+    },
+    () => CreateDataLakeDatasetRequest,
+    () => CreateDataLakeDatasetResponse,
+];
+var CreateDataLakeNamespace = [
+    9,
+    n0,
+    _CDLN,
+    {
+        [_h]: ["PUT", "/api/datalake/instance/{instanceId}/namespaces/{name}", 200],
+    },
+    () => CreateDataLakeNamespaceRequest,
+    () => CreateDataLakeNamespaceResponse,
+];
+var CreateInstance = [
+    9,
+    n0,
+    _CI,
+    {
+        [_h]: ["POST", "/api/instance", 200],
+    },
+    () => CreateInstanceRequest,
+    () => CreateInstanceResponse,
+];
+var DeleteDataIntegrationFlow = [
+    9,
+    n0,
+    _DDIF,
+    {
+        [_h]: ["DELETE", "/api/data-integration/instance/{instanceId}/data-integration-flows/{name}", 200],
+    },
+    () => DeleteDataIntegrationFlowRequest,
+    () => DeleteDataIntegrationFlowResponse,
+];
+var DeleteDataLakeDataset = [
+    9,
+    n0,
+    _DDLD,
+    {
+        [_h]: ["DELETE", "/api/datalake/instance/{instanceId}/namespaces/{namespace}/datasets/{name}", 200],
+    },
+    () => DeleteDataLakeDatasetRequest,
+    () => DeleteDataLakeDatasetResponse,
+];
+var DeleteDataLakeNamespace = [
+    9,
+    n0,
+    _DDLN,
+    {
+        [_h]: ["DELETE", "/api/datalake/instance/{instanceId}/namespaces/{name}", 200],
+    },
+    () => DeleteDataLakeNamespaceRequest,
+    () => DeleteDataLakeNamespaceResponse,
+];
+var DeleteInstance = [
+    9,
+    n0,
+    _DI,
+    {
+        [_h]: ["DELETE", "/api/instance/{instanceId}", 200],
+    },
+    () => DeleteInstanceRequest,
+    () => DeleteInstanceResponse,
+];
+var GetBillOfMaterialsImportJob = [
+    9,
+    n0,
+    _GBOMIJ,
+    {
+        [_h]: ["GET", "/api/configuration/instances/{instanceId}/bill-of-materials-import-jobs/{jobId}", 200],
+    },
+    () => GetBillOfMaterialsImportJobRequest,
+    () => GetBillOfMaterialsImportJobResponse,
+];
+var GetDataIntegrationEvent = [
+    9,
+    n0,
+    _GDIE,
+    {
+        [_h]: ["GET", "/api-data/data-integration/instance/{instanceId}/data-integration-events/{eventId}", 200],
+    },
+    () => GetDataIntegrationEventRequest,
+    () => GetDataIntegrationEventResponse,
+];
+var GetDataIntegrationFlow = [
+    9,
+    n0,
+    _GDIF,
+    {
+        [_h]: ["GET", "/api/data-integration/instance/{instanceId}/data-integration-flows/{name}", 200],
+    },
+    () => GetDataIntegrationFlowRequest,
+    () => GetDataIntegrationFlowResponse,
+];
+var GetDataIntegrationFlowExecution = [
+    9,
+    n0,
+    _GDIFE,
+    {
+        [_h]: [
+            "GET",
+            "/api-data/data-integration/instance/{instanceId}/data-integration-flows/{flowName}/executions/{executionId}",
+            200,
+        ],
+    },
+    () => GetDataIntegrationFlowExecutionRequest,
+    () => GetDataIntegrationFlowExecutionResponse,
+];
+var GetDataLakeDataset = [
+    9,
+    n0,
+    _GDLD,
+    {
+        [_h]: ["GET", "/api/datalake/instance/{instanceId}/namespaces/{namespace}/datasets/{name}", 200],
+    },
+    () => GetDataLakeDatasetRequest,
+    () => GetDataLakeDatasetResponse,
+];
+var GetDataLakeNamespace = [
+    9,
+    n0,
+    _GDLN,
+    {
+        [_h]: ["GET", "/api/datalake/instance/{instanceId}/namespaces/{name}", 200],
+    },
+    () => GetDataLakeNamespaceRequest,
+    () => GetDataLakeNamespaceResponse,
+];
+var GetInstance = [
+    9,
+    n0,
+    _GI,
+    {
+        [_h]: ["GET", "/api/instance/{instanceId}", 200],
+    },
+    () => GetInstanceRequest,
+    () => GetInstanceResponse,
+];
+var ListDataIntegrationEvents = [
+    9,
+    n0,
+    _LDIE,
+    {
+        [_h]: ["GET", "/api-data/data-integration/instance/{instanceId}/data-integration-events", 200],
+    },
+    () => ListDataIntegrationEventsRequest,
+    () => ListDataIntegrationEventsResponse,
+];
+var ListDataIntegrationFlowExecutions = [
+    9,
+    n0,
+    _LDIFE,
+    {
+        [_h]: ["GET", "/api-data/data-integration/instance/{instanceId}/data-integration-flows/{flowName}/executions", 200],
+    },
+    () => ListDataIntegrationFlowExecutionsRequest,
+    () => ListDataIntegrationFlowExecutionsResponse,
+];
+var ListDataIntegrationFlows = [
+    9,
+    n0,
+    _LDIF,
+    {
+        [_h]: ["GET", "/api/data-integration/instance/{instanceId}/data-integration-flows", 200],
+    },
+    () => ListDataIntegrationFlowsRequest,
+    () => ListDataIntegrationFlowsResponse,
+];
+var ListDataLakeDatasets = [
+    9,
+    n0,
+    _LDLD,
+    {
+        [_h]: ["GET", "/api/datalake/instance/{instanceId}/namespaces/{namespace}/datasets", 200],
+    },
+    () => ListDataLakeDatasetsRequest,
+    () => ListDataLakeDatasetsResponse,
+];
+var ListDataLakeNamespaces = [
+    9,
+    n0,
+    _LDLN,
+    {
+        [_h]: ["GET", "/api/datalake/instance/{instanceId}/namespaces", 200],
+    },
+    () => ListDataLakeNamespacesRequest,
+    () => ListDataLakeNamespacesResponse,
+];
+var ListInstances = [
+    9,
+    n0,
+    _LI,
+    {
+        [_h]: ["GET", "/api/instance", 200],
+    },
+    () => ListInstancesRequest,
+    () => ListInstancesResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/api/tags/{resourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var SendDataIntegrationEvent = [
+    9,
+    n0,
+    _SDIE,
+    {
+        [_h]: ["POST", "/api-data/data-integration/instance/{instanceId}/data-integration-events", 200],
+    },
+    () => SendDataIntegrationEventRequest,
+    () => SendDataIntegrationEventResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/api/tags/{resourceArn}", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["DELETE", "/api/tags/{resourceArn}", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateDataIntegrationFlow = [
+    9,
+    n0,
+    _UDIF,
+    {
+        [_h]: ["PATCH", "/api/data-integration/instance/{instanceId}/data-integration-flows/{name}", 200],
+    },
+    () => UpdateDataIntegrationFlowRequest,
+    () => UpdateDataIntegrationFlowResponse,
+];
+var UpdateDataLakeDataset = [
+    9,
+    n0,
+    _UDLD,
+    {
+        [_h]: ["PATCH", "/api/datalake/instance/{instanceId}/namespaces/{namespace}/datasets/{name}", 200],
+    },
+    () => UpdateDataLakeDatasetRequest,
+    () => UpdateDataLakeDatasetResponse,
+];
+var UpdateDataLakeNamespace = [
+    9,
+    n0,
+    _UDLN,
+    {
+        [_h]: ["PATCH", "/api/datalake/instance/{instanceId}/namespaces/{name}", 200],
+    },
+    () => UpdateDataLakeNamespaceRequest,
+    () => UpdateDataLakeNamespaceResponse,
+];
+var UpdateInstance = [
+    9,
+    n0,
+    _UI,
+    {
+        [_h]: ["PATCH", "/api/instance/{instanceId}", 200],
+    },
+    () => UpdateInstanceRequest,
+    () => UpdateInstanceResponse,
+];
 
 class CreateBillOfMaterialsImportJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "CreateBillOfMaterialsImportJob", {})
     .n("SupplyChainClient", "CreateBillOfMaterialsImportJobCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateBillOfMaterialsImportJobCommand)
-    .de(de_CreateBillOfMaterialsImportJobCommand)
+    .sc(CreateBillOfMaterialsImportJob)
     .build() {
 }
 
@@ -1443,16 +1659,11 @@ class CreateDataIntegrationFlowCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "CreateDataIntegrationFlow", {})
     .n("SupplyChainClient", "CreateDataIntegrationFlowCommand")
-    .f(CreateDataIntegrationFlowRequestFilterSensitiveLog, void 0)
-    .ser(se_CreateDataIntegrationFlowCommand)
-    .de(de_CreateDataIntegrationFlowCommand)
+    .sc(CreateDataIntegrationFlow)
     .build() {
 }
 
@@ -1460,16 +1671,11 @@ class CreateDataLakeDatasetCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "CreateDataLakeDataset", {})
     .n("SupplyChainClient", "CreateDataLakeDatasetCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateDataLakeDatasetCommand)
-    .de(de_CreateDataLakeDatasetCommand)
+    .sc(CreateDataLakeDataset)
     .build() {
 }
 
@@ -1477,16 +1683,11 @@ class CreateDataLakeNamespaceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "CreateDataLakeNamespace", {})
     .n("SupplyChainClient", "CreateDataLakeNamespaceCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateDataLakeNamespaceCommand)
-    .de(de_CreateDataLakeNamespaceCommand)
+    .sc(CreateDataLakeNamespace)
     .build() {
 }
 
@@ -1494,16 +1695,11 @@ class CreateInstanceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "CreateInstance", {})
     .n("SupplyChainClient", "CreateInstanceCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateInstanceCommand)
-    .de(de_CreateInstanceCommand)
+    .sc(CreateInstance)
     .build() {
 }
 
@@ -1511,16 +1707,11 @@ class DeleteDataIntegrationFlowCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "DeleteDataIntegrationFlow", {})
     .n("SupplyChainClient", "DeleteDataIntegrationFlowCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteDataIntegrationFlowCommand)
-    .de(de_DeleteDataIntegrationFlowCommand)
+    .sc(DeleteDataIntegrationFlow)
     .build() {
 }
 
@@ -1528,16 +1719,11 @@ class DeleteDataLakeDatasetCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "DeleteDataLakeDataset", {})
     .n("SupplyChainClient", "DeleteDataLakeDatasetCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteDataLakeDatasetCommand)
-    .de(de_DeleteDataLakeDatasetCommand)
+    .sc(DeleteDataLakeDataset)
     .build() {
 }
 
@@ -1545,16 +1731,11 @@ class DeleteDataLakeNamespaceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "DeleteDataLakeNamespace", {})
     .n("SupplyChainClient", "DeleteDataLakeNamespaceCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteDataLakeNamespaceCommand)
-    .de(de_DeleteDataLakeNamespaceCommand)
+    .sc(DeleteDataLakeNamespace)
     .build() {
 }
 
@@ -1562,16 +1743,11 @@ class DeleteInstanceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "DeleteInstance", {})
     .n("SupplyChainClient", "DeleteInstanceCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteInstanceCommand)
-    .de(de_DeleteInstanceCommand)
+    .sc(DeleteInstance)
     .build() {
 }
 
@@ -1579,16 +1755,11 @@ class GetBillOfMaterialsImportJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "GetBillOfMaterialsImportJob", {})
     .n("SupplyChainClient", "GetBillOfMaterialsImportJobCommand")
-    .f(void 0, void 0)
-    .ser(se_GetBillOfMaterialsImportJobCommand)
-    .de(de_GetBillOfMaterialsImportJobCommand)
+    .sc(GetBillOfMaterialsImportJob)
     .build() {
 }
 
@@ -1596,16 +1767,11 @@ class GetDataIntegrationEventCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "GetDataIntegrationEvent", {})
     .n("SupplyChainClient", "GetDataIntegrationEventCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDataIntegrationEventCommand)
-    .de(de_GetDataIntegrationEventCommand)
+    .sc(GetDataIntegrationEvent)
     .build() {
 }
 
@@ -1613,16 +1779,11 @@ class GetDataIntegrationFlowCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "GetDataIntegrationFlow", {})
     .n("SupplyChainClient", "GetDataIntegrationFlowCommand")
-    .f(void 0, GetDataIntegrationFlowResponseFilterSensitiveLog)
-    .ser(se_GetDataIntegrationFlowCommand)
-    .de(de_GetDataIntegrationFlowCommand)
+    .sc(GetDataIntegrationFlow)
     .build() {
 }
 
@@ -1630,16 +1791,11 @@ class GetDataIntegrationFlowExecutionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "GetDataIntegrationFlowExecution", {})
     .n("SupplyChainClient", "GetDataIntegrationFlowExecutionCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDataIntegrationFlowExecutionCommand)
-    .de(de_GetDataIntegrationFlowExecutionCommand)
+    .sc(GetDataIntegrationFlowExecution)
     .build() {
 }
 
@@ -1647,16 +1803,11 @@ class GetDataLakeDatasetCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "GetDataLakeDataset", {})
     .n("SupplyChainClient", "GetDataLakeDatasetCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDataLakeDatasetCommand)
-    .de(de_GetDataLakeDatasetCommand)
+    .sc(GetDataLakeDataset)
     .build() {
 }
 
@@ -1664,16 +1815,11 @@ class GetDataLakeNamespaceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "GetDataLakeNamespace", {})
     .n("SupplyChainClient", "GetDataLakeNamespaceCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDataLakeNamespaceCommand)
-    .de(de_GetDataLakeNamespaceCommand)
+    .sc(GetDataLakeNamespace)
     .build() {
 }
 
@@ -1681,16 +1827,11 @@ class GetInstanceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "GetInstance", {})
     .n("SupplyChainClient", "GetInstanceCommand")
-    .f(void 0, void 0)
-    .ser(se_GetInstanceCommand)
-    .de(de_GetInstanceCommand)
+    .sc(GetInstance)
     .build() {
 }
 
@@ -1698,16 +1839,11 @@ class ListDataIntegrationEventsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "ListDataIntegrationEvents", {})
     .n("SupplyChainClient", "ListDataIntegrationEventsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDataIntegrationEventsCommand)
-    .de(de_ListDataIntegrationEventsCommand)
+    .sc(ListDataIntegrationEvents)
     .build() {
 }
 
@@ -1715,16 +1851,11 @@ class ListDataIntegrationFlowExecutionsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "ListDataIntegrationFlowExecutions", {})
     .n("SupplyChainClient", "ListDataIntegrationFlowExecutionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDataIntegrationFlowExecutionsCommand)
-    .de(de_ListDataIntegrationFlowExecutionsCommand)
+    .sc(ListDataIntegrationFlowExecutions)
     .build() {
 }
 
@@ -1732,16 +1863,11 @@ class ListDataIntegrationFlowsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "ListDataIntegrationFlows", {})
     .n("SupplyChainClient", "ListDataIntegrationFlowsCommand")
-    .f(void 0, ListDataIntegrationFlowsResponseFilterSensitiveLog)
-    .ser(se_ListDataIntegrationFlowsCommand)
-    .de(de_ListDataIntegrationFlowsCommand)
+    .sc(ListDataIntegrationFlows)
     .build() {
 }
 
@@ -1749,16 +1875,11 @@ class ListDataLakeDatasetsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "ListDataLakeDatasets", {})
     .n("SupplyChainClient", "ListDataLakeDatasetsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDataLakeDatasetsCommand)
-    .de(de_ListDataLakeDatasetsCommand)
+    .sc(ListDataLakeDatasets)
     .build() {
 }
 
@@ -1766,16 +1887,11 @@ class ListDataLakeNamespacesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "ListDataLakeNamespaces", {})
     .n("SupplyChainClient", "ListDataLakeNamespacesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDataLakeNamespacesCommand)
-    .de(de_ListDataLakeNamespacesCommand)
+    .sc(ListDataLakeNamespaces)
     .build() {
 }
 
@@ -1783,16 +1899,11 @@ class ListInstancesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "ListInstances", {})
     .n("SupplyChainClient", "ListInstancesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListInstancesCommand)
-    .de(de_ListInstancesCommand)
+    .sc(ListInstances)
     .build() {
 }
 
@@ -1800,16 +1911,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "ListTagsForResource", {})
     .n("SupplyChainClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1817,16 +1923,11 @@ class SendDataIntegrationEventCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "SendDataIntegrationEvent", {})
     .n("SupplyChainClient", "SendDataIntegrationEventCommand")
-    .f(SendDataIntegrationEventRequestFilterSensitiveLog, void 0)
-    .ser(se_SendDataIntegrationEventCommand)
-    .de(de_SendDataIntegrationEventCommand)
+    .sc(SendDataIntegrationEvent)
     .build() {
 }
 
@@ -1834,16 +1935,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "TagResource", {})
     .n("SupplyChainClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1851,16 +1947,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "UntagResource", {})
     .n("SupplyChainClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1868,16 +1959,11 @@ class UpdateDataIntegrationFlowCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "UpdateDataIntegrationFlow", {})
     .n("SupplyChainClient", "UpdateDataIntegrationFlowCommand")
-    .f(UpdateDataIntegrationFlowRequestFilterSensitiveLog, UpdateDataIntegrationFlowResponseFilterSensitiveLog)
-    .ser(se_UpdateDataIntegrationFlowCommand)
-    .de(de_UpdateDataIntegrationFlowCommand)
+    .sc(UpdateDataIntegrationFlow)
     .build() {
 }
 
@@ -1885,16 +1971,11 @@ class UpdateDataLakeDatasetCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "UpdateDataLakeDataset", {})
     .n("SupplyChainClient", "UpdateDataLakeDatasetCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateDataLakeDatasetCommand)
-    .de(de_UpdateDataLakeDatasetCommand)
+    .sc(UpdateDataLakeDataset)
     .build() {
 }
 
@@ -1902,16 +1983,11 @@ class UpdateDataLakeNamespaceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "UpdateDataLakeNamespace", {})
     .n("SupplyChainClient", "UpdateDataLakeNamespaceCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateDataLakeNamespaceCommand)
-    .de(de_UpdateDataLakeNamespaceCommand)
+    .sc(UpdateDataLakeNamespace)
     .build() {
 }
 
@@ -1919,16 +1995,11 @@ class UpdateInstanceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("GalaxyPublicAPIGateway", "UpdateInstance", {})
     .n("SupplyChainClient", "UpdateInstanceCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateInstanceCommand)
-    .de(de_UpdateInstanceCommand)
+    .sc(UpdateInstance)
     .build() {
 }
 
@@ -1988,12 +2059,11 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.ConfigurationJobStatus = ConfigurationJobStatus;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.CreateBillOfMaterialsImportJobCommand = CreateBillOfMaterialsImportJobCommand;
 exports.CreateDataIntegrationFlowCommand = CreateDataIntegrationFlowCommand;
-exports.CreateDataIntegrationFlowRequestFilterSensitiveLog = CreateDataIntegrationFlowRequestFilterSensitiveLog;
 exports.CreateDataLakeDatasetCommand = CreateDataLakeDatasetCommand;
 exports.CreateDataLakeNamespaceCommand = CreateDataLakeNamespaceCommand;
 exports.CreateInstanceCommand = CreateInstanceCommand;
@@ -2004,12 +2074,9 @@ exports.DataIntegrationFlowDedupeStrategyType = DataIntegrationFlowDedupeStrateg
 exports.DataIntegrationFlowExecutionStatus = DataIntegrationFlowExecutionStatus;
 exports.DataIntegrationFlowFieldPriorityDedupeSortOrder = DataIntegrationFlowFieldPriorityDedupeSortOrder;
 exports.DataIntegrationFlowFileType = DataIntegrationFlowFileType;
-exports.DataIntegrationFlowFilterSensitiveLog = DataIntegrationFlowFilterSensitiveLog;
 exports.DataIntegrationFlowLoadType = DataIntegrationFlowLoadType;
-exports.DataIntegrationFlowSQLTransformationConfigurationFilterSensitiveLog = DataIntegrationFlowSQLTransformationConfigurationFilterSensitiveLog;
 exports.DataIntegrationFlowSourceType = DataIntegrationFlowSourceType;
 exports.DataIntegrationFlowTargetType = DataIntegrationFlowTargetType;
-exports.DataIntegrationFlowTransformationFilterSensitiveLog = DataIntegrationFlowTransformationFilterSensitiveLog;
 exports.DataIntegrationFlowTransformationType = DataIntegrationFlowTransformationType;
 exports.DataLakeDatasetPartitionTransformType = DataLakeDatasetPartitionTransformType;
 exports.DataLakeDatasetSchemaFieldType = DataLakeDatasetSchemaFieldType;
@@ -2021,37 +2088,32 @@ exports.GetBillOfMaterialsImportJobCommand = GetBillOfMaterialsImportJobCommand;
 exports.GetDataIntegrationEventCommand = GetDataIntegrationEventCommand;
 exports.GetDataIntegrationFlowCommand = GetDataIntegrationFlowCommand;
 exports.GetDataIntegrationFlowExecutionCommand = GetDataIntegrationFlowExecutionCommand;
-exports.GetDataIntegrationFlowResponseFilterSensitiveLog = GetDataIntegrationFlowResponseFilterSensitiveLog;
 exports.GetDataLakeDatasetCommand = GetDataLakeDatasetCommand;
 exports.GetDataLakeNamespaceCommand = GetDataLakeNamespaceCommand;
 exports.GetInstanceCommand = GetInstanceCommand;
 exports.InstanceState = InstanceState;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.ListDataIntegrationEventsCommand = ListDataIntegrationEventsCommand;
 exports.ListDataIntegrationFlowExecutionsCommand = ListDataIntegrationFlowExecutionsCommand;
 exports.ListDataIntegrationFlowsCommand = ListDataIntegrationFlowsCommand;
-exports.ListDataIntegrationFlowsResponseFilterSensitiveLog = ListDataIntegrationFlowsResponseFilterSensitiveLog;
 exports.ListDataLakeDatasetsCommand = ListDataLakeDatasetsCommand;
 exports.ListDataLakeNamespacesCommand = ListDataLakeNamespacesCommand;
 exports.ListInstancesCommand = ListInstancesCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.SendDataIntegrationEventCommand = SendDataIntegrationEventCommand;
-exports.SendDataIntegrationEventRequestFilterSensitiveLog = SendDataIntegrationEventRequestFilterSensitiveLog;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.SupplyChain = SupplyChain;
 exports.SupplyChainClient = SupplyChainClient;
-exports.SupplyChainServiceException = SupplyChainServiceException;
+exports.SupplyChainServiceException = SupplyChainServiceException$1;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateDataIntegrationFlowCommand = UpdateDataIntegrationFlowCommand;
-exports.UpdateDataIntegrationFlowRequestFilterSensitiveLog = UpdateDataIntegrationFlowRequestFilterSensitiveLog;
-exports.UpdateDataIntegrationFlowResponseFilterSensitiveLog = UpdateDataIntegrationFlowResponseFilterSensitiveLog;
 exports.UpdateDataLakeDatasetCommand = UpdateDataLakeDatasetCommand;
 exports.UpdateDataLakeNamespaceCommand = UpdateDataLakeNamespaceCommand;
 exports.UpdateInstanceCommand = UpdateInstanceCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.paginateListDataIntegrationEvents = paginateListDataIntegrationEvents;
 exports.paginateListDataIntegrationFlowExecutions = paginateListDataIntegrationFlowExecutions;
 exports.paginateListDataIntegrationFlows = paginateListDataIntegrationFlows;