@aws-sdk/client-entityresolution 3.928.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,8 +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');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class EntityResolutionClient 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));
@@ -110,14 +110,14 @@ class EntityResolutionClient extends smithyClient.Client {
     }
 }
 
-class EntityResolutionServiceException extends smithyClient.ServiceException {
+let EntityResolutionServiceException$1 = class EntityResolutionServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, EntityResolutionServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends EntityResolutionServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends EntityResolutionServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -128,12 +128,12 @@ class AccessDeniedException extends EntityResolutionServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
+};
 const StatementEffect = {
     Allow: "Allow",
     Deny: "Deny",
 };
-class ConflictException extends EntityResolutionServiceException {
+let ConflictException$1 = class ConflictException extends EntityResolutionServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     constructor(opts) {
@@ -144,8 +144,8 @@ class ConflictException extends EntityResolutionServiceException {
         });
         Object.setPrototypeOf(this, ConflictException.prototype);
     }
-}
-class InternalServerException extends EntityResolutionServiceException {
+};
+let InternalServerException$1 = class InternalServerException extends EntityResolutionServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     $retryable = {};
@@ -157,8 +157,8 @@ class InternalServerException extends EntityResolutionServiceException {
         });
         Object.setPrototypeOf(this, InternalServerException.prototype);
     }
-}
-class ResourceNotFoundException extends EntityResolutionServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends EntityResolutionServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -169,8 +169,8 @@ class ResourceNotFoundException extends EntityResolutionServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
-class ThrottlingException extends EntityResolutionServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends EntityResolutionServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     $retryable = {
@@ -184,8 +184,8 @@ class ThrottlingException extends EntityResolutionServiceException {
         });
         Object.setPrototypeOf(this, ThrottlingException.prototype);
     }
-}
-class ValidationException extends EntityResolutionServiceException {
+};
+let ValidationException$1 = class ValidationException extends EntityResolutionServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     constructor(opts) {
@@ -196,7 +196,7 @@ class ValidationException extends EntityResolutionServiceException {
         });
         Object.setPrototypeOf(this, ValidationException.prototype);
     }
-}
+};
 const AttributeMatchingModel = {
     MANY_TO_MANY: "MANY_TO_MANY",
     ONE_TO_ONE: "ONE_TO_ONE",
@@ -228,7 +228,7 @@ const IdNamespaceType = {
     SOURCE: "SOURCE",
     TARGET: "TARGET",
 };
-class ExceedsLimitException extends EntityResolutionServiceException {
+let ExceedsLimitException$1 = class ExceedsLimitException extends EntityResolutionServiceException$1 {
     name = "ExceedsLimitException";
     $fault = "client";
     quotaName;
@@ -243,7 +243,7 @@ class ExceedsLimitException extends EntityResolutionServiceException {
         this.quotaName = opts.quotaName;
         this.quotaValue = opts.quotaValue;
     }
-}
+};
 const IncrementalRunType = {
     IMMEDIATE: "IMMEDIATE",
 };
@@ -309,1506 +309,1688 @@ const ServiceType = {
     ASSIGNMENT: "ASSIGNMENT",
     ID_MAPPING: "ID_MAPPING",
 };
-const _RecordFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.recordAttributeMap && { recordAttributeMap: smithyClient.SENSITIVE_STRING }),
-});
-const GenerateMatchIdInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.records && { records: obj.records.map((item) => _RecordFilterSensitiveLog(item)) }),
-});
-const GetMatchIdInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.record && { record: smithyClient.SENSITIVE_STRING }),
-});
 
-const se_AddPolicyStatementCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/policies/{arn}/{statementId}");
-    b.p("arn", () => input.arn, "{arn}", false);
-    b.p("statementId", () => input.statementId, "{statementId}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        action: (_) => smithyClient._json(_),
-        condition: [],
-        effect: [],
-        principal: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_BatchDeleteUniqueIdCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        [_i]: input[_iS],
-        [_u]: [() => smithyClient.isSerializableHeaderValue(input[_uI]), () => (input[_uI] || []).map(smithyClient.quoteHeader).join(", ")],
-    });
-    b.bp("/matchingworkflows/{workflowName}/uniqueids");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_CreateIdMappingWorkflowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/idmappingworkflows");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        description: [],
-        idMappingTechniques: (_) => se_IdMappingTechniques(_),
-        incrementalRunConfig: (_) => smithyClient._json(_),
-        inputSourceConfig: (_) => smithyClient._json(_),
-        outputSourceConfig: (_) => smithyClient._json(_),
-        roleArn: [],
-        tags: (_) => smithyClient._json(_),
-        workflowName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateIdNamespaceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/idnamespaces");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        description: [],
-        idMappingWorkflowProperties: (_) => se_IdNamespaceIdMappingWorkflowPropertiesList(_),
-        idNamespaceName: [],
-        inputSourceConfig: (_) => smithyClient._json(_),
-        roleArn: [],
-        tags: (_) => smithyClient._json(_),
-        type: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateMatchingWorkflowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/matchingworkflows");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        description: [],
-        incrementalRunConfig: (_) => smithyClient._json(_),
-        inputSourceConfig: (_) => smithyClient._json(_),
-        outputSourceConfig: (_) => smithyClient._json(_),
-        resolutionTechniques: (_) => se_ResolutionTechniques(_),
-        roleArn: [],
-        tags: (_) => smithyClient._json(_),
-        workflowName: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateSchemaMappingCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/schemas");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        description: [],
-        mappedInputFields: (_) => smithyClient._json(_),
-        schemaName: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteIdMappingWorkflowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/idmappingworkflows/{workflowName}");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteIdNamespaceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/idnamespaces/{idNamespaceName}");
-    b.p("idNamespaceName", () => input.idNamespaceName, "{idNamespaceName}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteMatchingWorkflowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/matchingworkflows/{workflowName}");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeletePolicyStatementCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/policies/{arn}/{statementId}");
-    b.p("arn", () => input.arn, "{arn}", false);
-    b.p("statementId", () => input.statementId, "{statementId}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteSchemaMappingCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/schemas/{schemaName}");
-    b.p("schemaName", () => input.schemaName, "{schemaName}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_GenerateMatchIdCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/matchingworkflows/{workflowName}/generateMatches");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        processingType: [],
-        records: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetIdMappingJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/idmappingworkflows/{workflowName}/jobs/{jobId}");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", false);
-    b.p("jobId", () => input.jobId, "{jobId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetIdMappingWorkflowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/idmappingworkflows/{workflowName}");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetIdNamespaceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/idnamespaces/{idNamespaceName}");
-    b.p("idNamespaceName", () => input.idNamespaceName, "{idNamespaceName}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetMatchIdCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/matchingworkflows/{workflowName}/matches");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        applyNormalization: [],
-        record: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetMatchingJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/matchingworkflows/{workflowName}/jobs/{jobId}");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", false);
-    b.p("jobId", () => input.jobId, "{jobId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetMatchingWorkflowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/matchingworkflows/{workflowName}");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetPolicyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/policies/{arn}");
-    b.p("arn", () => input.arn, "{arn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetProviderServiceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/providerservices/{providerName}/{providerServiceName}");
-    b.p("providerName", () => input.providerName, "{providerName}", false);
-    b.p("providerServiceName", () => input.providerServiceName, "{providerServiceName}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetSchemaMappingCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/schemas/{schemaName}");
-    b.p("schemaName", () => input.schemaName, "{schemaName}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_ListIdMappingJobsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/idmappingworkflows/{workflowName}/jobs");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", 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_ListIdMappingWorkflowsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/idmappingworkflows");
-    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_ListIdNamespacesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/idnamespaces");
-    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_ListMatchingJobsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/matchingworkflows/{workflowName}/jobs");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", 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_ListMatchingWorkflowsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/matchingworkflows");
-    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_ListProviderServicesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/providerservices");
-    const query = smithyClient.map({
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-        [_pN]: [, input[_pN]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListSchemaMappingsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/schemas");
-    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_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_PutPolicyCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/policies/{arn}");
-    b.p("arn", () => input.arn, "{arn}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        policy: [],
-        token: [],
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_StartIdMappingJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/idmappingworkflows/{workflowName}/jobs");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        jobType: [],
-        outputSourceConfig: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartMatchingJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/matchingworkflows/{workflowName}/jobs");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", false);
-    let body;
-    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("/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("/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_UpdateIdMappingWorkflowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/idmappingworkflows/{workflowName}");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        description: [],
-        idMappingTechniques: (_) => se_IdMappingTechniques(_),
-        incrementalRunConfig: (_) => smithyClient._json(_),
-        inputSourceConfig: (_) => smithyClient._json(_),
-        outputSourceConfig: (_) => smithyClient._json(_),
-        roleArn: [],
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateIdNamespaceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/idnamespaces/{idNamespaceName}");
-    b.p("idNamespaceName", () => input.idNamespaceName, "{idNamespaceName}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        description: [],
-        idMappingWorkflowProperties: (_) => se_IdNamespaceIdMappingWorkflowPropertiesList(_),
-        inputSourceConfig: (_) => smithyClient._json(_),
-        roleArn: [],
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateMatchingWorkflowCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/matchingworkflows/{workflowName}");
-    b.p("workflowName", () => input.workflowName, "{workflowName}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        description: [],
-        incrementalRunConfig: (_) => smithyClient._json(_),
-        inputSourceConfig: (_) => smithyClient._json(_),
-        outputSourceConfig: (_) => smithyClient._json(_),
-        resolutionTechniques: (_) => se_ResolutionTechniques(_),
-        roleArn: [],
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateSchemaMappingCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/schemas/{schemaName}");
-    b.p("schemaName", () => input.schemaName, "{schemaName}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        description: [],
-        mappedInputFields: (_) => smithyClient._json(_),
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const de_AddPolicyStatementCommand = 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, {
-        arn: smithyClient.expectString,
-        policy: smithyClient.expectString,
-        token: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_BatchDeleteUniqueIdCommand = 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, {
-        deleted: smithyClient._json,
-        disconnectedUniqueIds: smithyClient._json,
-        errors: smithyClient._json,
-        status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateIdMappingWorkflowCommand = 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, {
-        description: smithyClient.expectString,
-        idMappingTechniques: (_) => de_IdMappingTechniques(_),
-        incrementalRunConfig: smithyClient._json,
-        inputSourceConfig: smithyClient._json,
-        outputSourceConfig: smithyClient._json,
-        roleArn: smithyClient.expectString,
-        workflowArn: smithyClient.expectString,
-        workflowName: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateIdNamespaceCommand = 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, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        idMappingWorkflowProperties: (_) => de_IdNamespaceIdMappingWorkflowPropertiesList(_),
-        idNamespaceArn: smithyClient.expectString,
-        idNamespaceName: smithyClient.expectString,
-        inputSourceConfig: smithyClient._json,
-        roleArn: smithyClient.expectString,
-        tags: smithyClient._json,
-        type: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateMatchingWorkflowCommand = 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, {
-        description: smithyClient.expectString,
-        incrementalRunConfig: smithyClient._json,
-        inputSourceConfig: smithyClient._json,
-        outputSourceConfig: smithyClient._json,
-        resolutionTechniques: (_) => de_ResolutionTechniques(_),
-        roleArn: smithyClient.expectString,
-        workflowArn: smithyClient.expectString,
-        workflowName: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateSchemaMappingCommand = 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, {
-        description: smithyClient.expectString,
-        mappedInputFields: smithyClient._json,
-        schemaArn: smithyClient.expectString,
-        schemaName: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteIdMappingWorkflowCommand = 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, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteIdNamespaceCommand = 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, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteMatchingWorkflowCommand = 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, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeletePolicyStatementCommand = 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, {
-        arn: smithyClient.expectString,
-        policy: smithyClient.expectString,
-        token: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteSchemaMappingCommand = 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, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GenerateMatchIdCommand = 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, {
-        failedRecords: smithyClient._json,
-        matchGroups: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetIdMappingJobCommand = 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, {
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        errorDetails: smithyClient._json,
-        jobId: smithyClient.expectString,
-        jobType: smithyClient.expectString,
-        metrics: smithyClient._json,
-        outputSourceConfig: smithyClient._json,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetIdMappingWorkflowCommand = 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, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        idMappingTechniques: (_) => de_IdMappingTechniques(_),
-        incrementalRunConfig: smithyClient._json,
-        inputSourceConfig: smithyClient._json,
-        outputSourceConfig: smithyClient._json,
-        roleArn: smithyClient.expectString,
-        tags: smithyClient._json,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        workflowArn: smithyClient.expectString,
-        workflowName: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetIdNamespaceCommand = 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, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        idMappingWorkflowProperties: (_) => de_IdNamespaceIdMappingWorkflowPropertiesList(_),
-        idNamespaceArn: smithyClient.expectString,
-        idNamespaceName: smithyClient.expectString,
-        inputSourceConfig: smithyClient._json,
-        roleArn: smithyClient.expectString,
-        tags: smithyClient._json,
-        type: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetMatchIdCommand = 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, {
-        matchId: smithyClient.expectString,
-        matchRule: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetMatchingJobCommand = 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, {
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        errorDetails: smithyClient._json,
-        jobId: smithyClient.expectString,
-        metrics: smithyClient._json,
-        outputSourceConfig: smithyClient._json,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetMatchingWorkflowCommand = 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, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        incrementalRunConfig: smithyClient._json,
-        inputSourceConfig: smithyClient._json,
-        outputSourceConfig: smithyClient._json,
-        resolutionTechniques: (_) => de_ResolutionTechniques(_),
-        roleArn: smithyClient.expectString,
-        tags: smithyClient._json,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        workflowArn: smithyClient.expectString,
-        workflowName: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetPolicyCommand = 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, {
-        arn: smithyClient.expectString,
-        policy: smithyClient.expectString,
-        token: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetProviderServiceCommand = 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, {
-        anonymizedOutput: smithyClient.expectBoolean,
-        providerComponentSchema: smithyClient._json,
-        providerConfigurationDefinition: (_) => de_Document(_),
-        providerEndpointConfiguration: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
-        providerEntityOutputDefinition: (_) => de_Document(_),
-        providerIdNameSpaceConfiguration: (_) => de_ProviderIdNameSpaceConfiguration(_),
-        providerIntermediateDataAccessConfiguration: smithyClient._json,
-        providerJobConfiguration: (_) => de_Document(_),
-        providerName: smithyClient.expectString,
-        providerServiceArn: smithyClient.expectString,
-        providerServiceDisplayName: smithyClient.expectString,
-        providerServiceName: smithyClient.expectString,
-        providerServiceType: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetSchemaMappingCommand = 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, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        hasWorkflows: smithyClient.expectBoolean,
-        mappedInputFields: smithyClient._json,
-        schemaArn: smithyClient.expectString,
-        schemaName: smithyClient.expectString,
-        tags: smithyClient._json,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListIdMappingJobsCommand = 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, {
-        jobs: (_) => de_JobList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListIdMappingWorkflowsCommand = 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, {
-        nextToken: smithyClient.expectString,
-        workflowSummaries: (_) => de_IdMappingWorkflowList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListIdNamespacesCommand = 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, {
-        idNamespaceSummaries: (_) => de_IdNamespaceList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListMatchingJobsCommand = 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, {
-        jobs: (_) => de_JobList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListMatchingWorkflowsCommand = 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, {
-        nextToken: smithyClient.expectString,
-        workflowSummaries: (_) => de_MatchingWorkflowList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListProviderServicesCommand = 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, {
-        nextToken: smithyClient.expectString,
-        providerServiceSummaries: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListSchemaMappingsCommand = 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, {
-        nextToken: smithyClient.expectString,
-        schemaList: (_) => de_SchemaMappingList(_),
-    });
-    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_PutPolicyCommand = 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, {
-        arn: smithyClient.expectString,
-        policy: smithyClient.expectString,
-        token: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartIdMappingJobCommand = 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,
-        jobType: smithyClient.expectString,
-        outputSourceConfig: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartMatchingJobCommand = 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_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_UpdateIdMappingWorkflowCommand = 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, {
-        description: smithyClient.expectString,
-        idMappingTechniques: (_) => de_IdMappingTechniques(_),
-        incrementalRunConfig: smithyClient._json,
-        inputSourceConfig: smithyClient._json,
-        outputSourceConfig: smithyClient._json,
-        roleArn: smithyClient.expectString,
-        workflowArn: smithyClient.expectString,
-        workflowName: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateIdNamespaceCommand = 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, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        idMappingWorkflowProperties: (_) => de_IdNamespaceIdMappingWorkflowPropertiesList(_),
-        idNamespaceArn: smithyClient.expectString,
-        idNamespaceName: smithyClient.expectString,
-        inputSourceConfig: smithyClient._json,
-        roleArn: smithyClient.expectString,
-        type: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateMatchingWorkflowCommand = 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, {
-        description: smithyClient.expectString,
-        incrementalRunConfig: smithyClient._json,
-        inputSourceConfig: smithyClient._json,
-        outputSourceConfig: smithyClient._json,
-        resolutionTechniques: (_) => de_ResolutionTechniques(_),
-        roleArn: smithyClient.expectString,
-        workflowName: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateSchemaMappingCommand = 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, {
-        description: smithyClient.expectString,
-        mappedInputFields: smithyClient._json,
-        schemaArn: smithyClient.expectString,
-        schemaName: smithyClient.expectString,
-    });
-    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.entityresolution#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.entityresolution#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.entityresolution#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.entityresolution#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.entityresolution#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.entityresolution#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ExceedsLimitException":
-        case "com.amazonaws.entityresolution#ExceedsLimitException":
-            throw await de_ExceedsLimitExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(EntityResolutionServiceException);
-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_ExceedsLimitExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        quotaName: smithyClient.expectString,
-        quotaValue: smithyClient.expectInt32,
-    });
-    Object.assign(contents, doc);
-    const exception = new ExceedsLimitException({
-        $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_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 se_IdMappingTechniques = (input, context) => {
-    return smithyClient.take(input, {
-        idMappingType: [],
-        providerProperties: (_) => se_ProviderProperties(_),
-        ruleBasedProperties: smithyClient._json,
-    });
-};
-const se_IdNamespaceIdMappingWorkflowProperties = (input, context) => {
-    return smithyClient.take(input, {
-        idMappingType: [],
-        providerProperties: (_) => se_NamespaceProviderProperties(_),
-        ruleBasedProperties: smithyClient._json,
-    });
-};
-const se_IdNamespaceIdMappingWorkflowPropertiesList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_IdNamespaceIdMappingWorkflowProperties(entry);
-    });
-};
-const se_NamespaceProviderProperties = (input, context) => {
-    return smithyClient.take(input, {
-        providerConfiguration: (_) => se_Document(_),
-        providerServiceArn: [],
-    });
-};
-const se_ProviderProperties = (input, context) => {
-    return smithyClient.take(input, {
-        intermediateSourceConfiguration: smithyClient._json,
-        providerConfiguration: (_) => se_Document(_),
-        providerServiceArn: [],
-    });
-};
-const se_ResolutionTechniques = (input, context) => {
-    return smithyClient.take(input, {
-        providerProperties: (_) => se_ProviderProperties(_),
-        resolutionType: [],
-        ruleBasedProperties: smithyClient._json,
-        ruleConditionProperties: smithyClient._json,
-    });
-};
-const se_Document = (input, context) => {
-    return input;
-};
-const de_IdMappingTechniques = (output, context) => {
-    return smithyClient.take(output, {
-        idMappingType: smithyClient.expectString,
-        providerProperties: (_) => de_ProviderProperties(_),
-        ruleBasedProperties: smithyClient._json,
-    });
-};
-const de_IdMappingWorkflowList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_IdMappingWorkflowSummary(entry);
-    });
-    return retVal;
-};
-const de_IdMappingWorkflowSummary = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        workflowArn: smithyClient.expectString,
-        workflowName: smithyClient.expectString,
-    });
-};
-const de_IdNamespaceIdMappingWorkflowProperties = (output, context) => {
-    return smithyClient.take(output, {
-        idMappingType: smithyClient.expectString,
-        providerProperties: (_) => de_NamespaceProviderProperties(_),
-        ruleBasedProperties: smithyClient._json,
-    });
-};
-const de_IdNamespaceIdMappingWorkflowPropertiesList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_IdNamespaceIdMappingWorkflowProperties(entry);
-    });
-    return retVal;
-};
-const de_IdNamespaceList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_IdNamespaceSummary(entry);
-    });
-    return retVal;
-};
-const de_IdNamespaceSummary = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        idMappingWorkflowProperties: smithyClient._json,
-        idNamespaceArn: smithyClient.expectString,
-        idNamespaceName: smithyClient.expectString,
-        type: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_JobList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_JobSummary(entry);
-    });
-    return retVal;
-};
-const de_JobSummary = (output, context) => {
-    return smithyClient.take(output, {
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        jobId: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        status: smithyClient.expectString,
-    });
-};
-const de_MatchingWorkflowList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_MatchingWorkflowSummary(entry);
-    });
-    return retVal;
-};
-const de_MatchingWorkflowSummary = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        resolutionType: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        workflowArn: smithyClient.expectString,
-        workflowName: smithyClient.expectString,
-    });
-};
-const de_NamespaceProviderProperties = (output, context) => {
-    return smithyClient.take(output, {
-        providerConfiguration: (_) => de_Document(_),
-        providerServiceArn: smithyClient.expectString,
-    });
-};
-const de_ProviderIdNameSpaceConfiguration = (output, context) => {
-    return smithyClient.take(output, {
-        description: smithyClient.expectString,
-        providerSourceConfigurationDefinition: (_) => de_Document(_),
-        providerTargetConfigurationDefinition: (_) => de_Document(_),
-    });
-};
-const de_ProviderProperties = (output, context) => {
-    return smithyClient.take(output, {
-        intermediateSourceConfiguration: smithyClient._json,
-        providerConfiguration: (_) => de_Document(_),
-        providerServiceArn: smithyClient.expectString,
-    });
-};
-const de_ResolutionTechniques = (output, context) => {
-    return smithyClient.take(output, {
-        providerProperties: (_) => de_ProviderProperties(_),
-        resolutionType: smithyClient.expectString,
-        ruleBasedProperties: smithyClient._json,
-        ruleConditionProperties: smithyClient._json,
-    });
-};
-const de_SchemaMappingList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_SchemaMappingSummary(entry);
-    });
-    return retVal;
-};
-const de_SchemaMappingSummary = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        hasWorkflows: smithyClient.expectBoolean,
-        schemaArn: smithyClient.expectString,
-        schemaName: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_Document = (output, context) => {
-    return output;
-};
-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 _i = "inputsource";
+const _ADE = "AccessDeniedException";
+const _APS = "AddPolicyStatement";
+const _APSI = "AddPolicyStatementInput";
+const _APSO = "AddPolicyStatementOutput";
+const _BDUI = "BatchDeleteUniqueId";
+const _BDUII = "BatchDeleteUniqueIdInput";
+const _BDUIO = "BatchDeleteUniqueIdOutput";
+const _CE = "ConflictException";
+const _CIMW = "CreateIdMappingWorkflow";
+const _CIMWI = "CreateIdMappingWorkflowInput";
+const _CIMWO = "CreateIdMappingWorkflowOutput";
+const _CIN = "CreateIdNamespace";
+const _CINI = "CreateIdNamespaceInput";
+const _CINO = "CreateIdNamespaceOutput";
+const _CMW = "CreateMatchingWorkflow";
+const _CMWI = "CreateMatchingWorkflowInput";
+const _CMWO = "CreateMatchingWorkflowOutput";
+const _CSM = "CreateSchemaMapping";
+const _CSMI = "CreateSchemaMappingInput";
+const _CSMO = "CreateSchemaMappingOutput";
+const _DIMW = "DeleteIdMappingWorkflow";
+const _DIMWI = "DeleteIdMappingWorkflowInput";
+const _DIMWO = "DeleteIdMappingWorkflowOutput";
+const _DIN = "DeleteIdNamespace";
+const _DINI = "DeleteIdNamespaceInput";
+const _DINO = "DeleteIdNamespaceOutput";
+const _DMW = "DeleteMatchingWorkflow";
+const _DMWI = "DeleteMatchingWorkflowInput";
+const _DMWO = "DeleteMatchingWorkflowOutput";
+const _DPS = "DeletePolicyStatement";
+const _DPSI = "DeletePolicyStatementInput";
+const _DPSO = "DeletePolicyStatementOutput";
+const _DSM = "DeleteSchemaMapping";
+const _DSMI = "DeleteSchemaMappingInput";
+const _DSMO = "DeleteSchemaMappingOutput";
+const _DUI = "DeletedUniqueId";
+const _DUIE = "DeleteUniqueIdError";
+const _DUIEL = "DeleteUniqueIdErrorsList";
+const _DUIL = "DeletedUniqueIdList";
+const _ED = "ErrorDetails";
+const _ELE = "ExceedsLimitException";
+const _FR = "FailedRecord";
+const _FRL = "FailedRecordsList";
+const _GIMJ = "GetIdMappingJob";
+const _GIMJI = "GetIdMappingJobInput";
+const _GIMJO = "GetIdMappingJobOutput";
+const _GIMW = "GetIdMappingWorkflow";
+const _GIMWI = "GetIdMappingWorkflowInput";
+const _GIMWO = "GetIdMappingWorkflowOutput";
+const _GIN = "GetIdNamespace";
+const _GINI = "GetIdNamespaceInput";
+const _GINO = "GetIdNamespaceOutput";
+const _GMI = "GenerateMatchId";
+const _GMII = "GenerateMatchIdInput";
+const _GMIIe = "GetMatchIdInput";
+const _GMIO = "GenerateMatchIdOutput";
+const _GMIOe = "GetMatchIdOutput";
+const _GMIe = "GetMatchId";
+const _GMJ = "GetMatchingJob";
+const _GMJI = "GetMatchingJobInput";
+const _GMJO = "GetMatchingJobOutput";
+const _GMW = "GetMatchingWorkflow";
+const _GMWI = "GetMatchingWorkflowInput";
+const _GMWO = "GetMatchingWorkflowOutput";
+const _GP = "GetPolicy";
+const _GPI = "GetPolicyInput";
+const _GPO = "GetPolicyOutput";
+const _GPS = "GetProviderService";
+const _GPSI = "GetProviderServiceInput";
+const _GPSO = "GetProviderServiceOutput";
+const _GSM = "GetSchemaMapping";
+const _GSMI = "GetSchemaMappingInput";
+const _GSMO = "GetSchemaMappingOutput";
+const _IMIRC = "IdMappingIncrementalRunConfig";
+const _IMJM = "IdMappingJobMetrics";
+const _IMJOS = "IdMappingJobOutputSource";
+const _IMJOSC = "IdMappingJobOutputSourceConfig";
+const _IMRBP = "IdMappingRuleBasedProperties";
+const _IMT = "IdMappingTechniques";
+const _IMWIS = "IdMappingWorkflowInputSource";
+const _IMWISC = "IdMappingWorkflowInputSourceConfig";
+const _IMWL = "IdMappingWorkflowList";
+const _IMWOS = "IdMappingWorkflowOutputSource";
+const _IMWOSC = "IdMappingWorkflowOutputSourceConfig";
+const _IMWS = "IdMappingWorkflowSummary";
+const _INIMWM = "IdNamespaceIdMappingWorkflowMetadata";
+const _INIMWML = "IdNamespaceIdMappingWorkflowMetadataList";
+const _INIMWP = "IdNamespaceIdMappingWorkflowProperties";
+const _INIMWPL = "IdNamespaceIdMappingWorkflowPropertiesList";
+const _INIS = "IdNamespaceInputSource";
+const _INISC = "IdNamespaceInputSourceConfig";
+const _INL = "IdNamespaceList";
+const _INS = "IdNamespaceSummary";
+const _IRC = "IncrementalRunConfig";
+const _IS = "InputSource";
+const _ISC = "IntermediateSourceConfiguration";
+const _ISCn = "InputSourceConfig";
+const _ISE = "InternalServerException";
+const _JL = "JobList";
+const _JM = "JobMetrics";
+const _JOS = "JobOutputSource";
+const _JOSC = "JobOutputSourceConfig";
+const _JS = "JobSummary";
+const _KMSA = "KMSArn";
+const _LIMJ = "ListIdMappingJobs";
+const _LIMJI = "ListIdMappingJobsInput";
+const _LIMJO = "ListIdMappingJobsOutput";
+const _LIMW = "ListIdMappingWorkflows";
+const _LIMWI = "ListIdMappingWorkflowsInput";
+const _LIMWO = "ListIdMappingWorkflowsOutput";
+const _LIN = "ListIdNamespaces";
+const _LINI = "ListIdNamespacesInput";
+const _LINO = "ListIdNamespacesOutput";
+const _LMJ = "ListMatchingJobs";
+const _LMJI = "ListMatchingJobsInput";
+const _LMJO = "ListMatchingJobsOutput";
+const _LMW = "ListMatchingWorkflows";
+const _LMWI = "ListMatchingWorkflowsInput";
+const _LMWO = "ListMatchingWorkflowsOutput";
+const _LPS = "ListProviderServices";
+const _LPSI = "ListProviderServicesInput";
+const _LPSO = "ListProviderServicesOutput";
+const _LSM = "ListSchemaMappings";
+const _LSMI = "ListSchemaMappingsInput";
+const _LSMO = "ListSchemaMappingsOutput";
+const _LTFR = "ListTagsForResource";
+const _LTFRI = "ListTagsForResourceInput";
+const _LTFRO = "ListTagsForResourceOutput";
+const _MG = "MatchGroup";
+const _MGL = "MatchGroupsList";
+const _MR = "MatchedRecord";
+const _MRL = "MatchedRecordsList";
+const _MWL = "MatchingWorkflowList";
+const _MWS = "MatchingWorkflowSummary";
+const _NPP = "NamespaceProviderProperties";
+const _NRBP = "NamespaceRuleBasedProperties";
+const _OA = "OutputAttribute";
+const _OAu = "OutputAttributes";
+const _OS = "OutputSource";
+const _OSC = "OutputSourceConfig";
+const _PCS = "ProviderComponentSchema";
+const _PEC = "ProviderEndpointConfiguration";
+const _PIDAC = "ProviderIntermediateDataAccessConfiguration";
+const _PINSC = "ProviderIdNameSpaceConfiguration";
+const _PMC = "ProviderMarketplaceConfiguration";
+const _PP = "ProviderProperties";
+const _PPI = "PutPolicyInput";
+const _PPO = "PutPolicyOutput";
+const _PPu = "PutPolicy";
+const _PSA = "ProviderSchemaAttribute";
+const _PSAr = "ProviderSchemaAttributes";
+const _PSL = "ProviderServiceList";
+const _PSS = "ProviderServiceSummary";
+const _R = "Record";
+const _RAM = "RecordAttributeMap";
+const _RAMS = "RecordAttributeMapString255";
+const _RBP = "RuleBasedProperties";
+const _RC = "RuleCondition";
+const _RCL = "RuleConditionList";
+const _RCP = "RuleConditionProperties";
+const _RL = "RecordList";
+const _RLu = "RuleList";
+const _RNFE = "ResourceNotFoundException";
+const _RT = "ResolutionTechniques";
+const _Ru = "Rule";
+const _S = "Schemas";
+const _SIA = "SchemaInputAttribute";
+const _SIAc = "SchemaInputAttributes";
+const _SIMJ = "StartIdMappingJob";
+const _SIMJI = "StartIdMappingJobInput";
+const _SIMJO = "StartIdMappingJobOutput";
+const _SMJ = "StartMatchingJob";
+const _SMJI = "StartMatchingJobInput";
+const _SMJO = "StartMatchingJobOutput";
+const _SML = "SchemaMappingList";
+const _SMS = "SchemaMappingSummary";
+const _TE = "ThrottlingException";
+const _TR = "TagResource";
+const _TRI = "TagResourceInput";
+const _TRO = "TagResourceOutput";
+const _UIMW = "UpdateIdMappingWorkflow";
+const _UIMWI = "UpdateIdMappingWorkflowInput";
+const _UIMWO = "UpdateIdMappingWorkflowOutput";
+const _UIN = "UpdateIdNamespace";
+const _UINI = "UpdateIdNamespaceInput";
+const _UINO = "UpdateIdNamespaceOutput";
+const _UMW = "UpdateMatchingWorkflow";
+const _UMWI = "UpdateMatchingWorkflowInput";
+const _UMWO = "UpdateMatchingWorkflowOutput";
+const _UR = "UntagResource";
+const _URI = "UntagResourceInput";
+const _URO = "UntagResourceOutput";
+const _USM = "UpdateSchemaMapping";
+const _USMI = "UpdateSchemaMappingInput";
+const _USMO = "UpdateSchemaMappingOutput";
+const _VE = "ValidationException";
+const _a = "arn";
+const _aAI = "awsAccountIds";
+const _aI = "assetId";
+const _aMM = "attributeMatchingModel";
+const _aN = "applyNormalization";
+const _aO = "anonymizedOutput";
+const _ac = "action";
+const _c = "client";
+const _cA = "createdAt";
+const _co = "condition";
+const _d = "deleted";
+const _dRP = "deleteRecordsProcessed";
+const _dSI = "dataSetId";
+const _dUI = "disconnectedUniqueIds";
+const _de = "description";
+const _e = "error";
+const _eD = "errorDetails";
+const _eM = "errorMessage";
+const _eT = "errorType";
+const _eTn = "endTime";
+const _ef = "effect";
+const _er = "errors";
+const _fN = "fieldName";
+const _fR = "failedRecords";
+const _gN = "groupName";
+const _h = "hashed";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
+const _hW = "hasWorkflows";
+const _ha = "hashing";
+const _ht = "http";
+const _iMT = "idMappingTechniques";
+const _iMTd = "idMappingType";
+const _iMWP = "idMappingWorkflowProperties";
+const _iNA = "idNamespaceArn";
+const _iNN = "idNamespaceName";
+const _iNS = "idNamespaceSummaries";
+const _iR = "inputRecords";
+const _iRC = "incrementalRunConfig";
+const _iRT = "incrementalRunType";
 const _iS = "inputSource";
-const _mR = "maxResults";
+const _iSARN = "inputSourceARN";
+const _iSC = "inputSourceConfig";
+const _iSCn = "intermediateSourceConfiguration";
+const _iSP = "intermediateS3Path";
+const _j = "jobs";
+const _jI = "jobId";
+const _jT = "jobType";
+const _lI = "listingId";
+const _m = "message";
+const _mC = "marketplaceConfiguration";
+const _mG = "matchGroups";
+const _mI = "matchId";
+const _mID = "matchIDs";
+const _mIF = "mappedInputFields";
+const _mK = "matchingKeys";
+const _mKa = "matchKey";
+const _mP = "matchPurpose";
+const _mR = "matchRule";
+const _mRR = "mappedRecordsRemoved";
+const _mRa = "maxResults";
+const _mSRR = "mappedSourceRecordsRemoved";
+const _mTRR = "mappedTargetRecordsRemoved";
+const _me = "metrics";
+const _n = "name";
+const _nMR = "newMappedRecords";
+const _nMSR = "newMappedSourceRecords";
+const _nMTR = "newMappedTargetRecords";
 const _nT = "nextToken";
+const _nURL = "newUniqueRecordsLoaded";
+const _o = "output";
+const _oSC = "outputSourceConfig";
+const _oSP = "outputS3Path";
+const _p = "principal";
+const _pC = "providerConfiguration";
+const _pCD = "providerConfigurationDefinition";
+const _pCS = "providerComponentSchema";
+const _pEC = "providerEndpointConfiguration";
+const _pEOD = "providerEntityOutputDefinition";
+const _pIDAC = "providerIntermediateDataAccessConfiguration";
+const _pINSC = "providerIdNameSpaceConfiguration";
+const _pJC = "providerJobConfiguration";
 const _pN = "providerName";
+const _pP = "providerProperties";
+const _pSA = "providerServiceArn";
+const _pSAr = "providerSchemaAttributes";
+const _pSCD = "providerSourceConfigurationDefinition";
+const _pSDN = "providerServiceDisplayName";
+const _pSN = "providerServiceName";
+const _pSS = "providerServiceSummaries";
+const _pST = "providerServiceType";
+const _pT = "processingType";
+const _pTCD = "providerTargetConfigurationDefinition";
+const _po = "policy";
+const _qN = "quotaName";
+const _qV = "quotaValue";
+const _r = "records";
+const _rA = "roleArn";
+const _rAM = "recordAttributeMap";
+const _rAe = "resourceArn";
+const _rBA = "requiredBucketActions";
+const _rBP = "ruleBasedProperties";
+const _rCP = "ruleConditionProperties";
+const _rDT = "ruleDefinitionType";
+const _rDTu = "ruleDefinitionTypes";
+const _rI = "recordId";
+const _rIe = "revisionId";
+const _rMM = "recordMatchingModel";
+const _rMMe = "recordMatchingModels";
+const _rN = "ruleName";
+const _rNP = "recordsNotProcessed";
+const _rT = "resolutionTechniques";
+const _rTe = "resolutionType";
+const _re = "record";
+const _ru = "rules";
+const _s = "status";
+const _sA = "schemaArn";
+const _sI = "statementId";
+const _sL = "schemaList";
+const _sN = "schemaName";
+const _sT = "startTime";
+const _sTu = "subType";
+const _sc = "schemas";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.entityresolution";
+const _t = "token";
 const _tK = "tagKeys";
-const _u = "uniqueids";
+const _tMR = "totalMappedRecords";
+const _tMSR = "totalMappedSourceRecords";
+const _tMTR = "totalMappedTargetRecords";
+const _tRP = "totalRecordsProcessed";
+const _ta = "tags";
+const _ty = "type";
+const _uA = "updatedAt";
 const _uI = "uniqueIds";
+const _uIn = "uniqueId";
+const _uRL = "uniqueRecordsLoaded";
+const _wA = "workflowArn";
+const _wN = "workflowName";
+const _wS = "workflowSummaries";
+const n0 = "com.amazonaws.entityresolution";
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AddPolicyStatementInput = [
+    3,
+    n0,
+    _APSI,
+    0,
+    [_a, _sI, _ef, _ac, _p, _co],
+    [[0, 1], [0, 1], 0, 64 | 0, 64 | 0, 0],
+];
+var AddPolicyStatementOutput = [3, n0, _APSO, 0, [_a, _t, _po], [0, 0, 0]];
+var BatchDeleteUniqueIdInput = [
+    3,
+    n0,
+    _BDUII,
+    0,
+    [_wN, _iS, _uI],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hH]: _iS,
+            },
+        ],
+        [
+            64 | 0,
+            {
+                [_hH]: _uI,
+            },
+        ],
+    ],
+];
+var BatchDeleteUniqueIdOutput = [
+    3,
+    n0,
+    _BDUIO,
+    0,
+    [_s, _er, _d, _dUI],
+    [0, () => DeleteUniqueIdErrorsList, () => DeletedUniqueIdList, 64 | 0],
+];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateIdMappingWorkflowInput = [
+    3,
+    n0,
+    _CIMWI,
+    0,
+    [_wN, _de, _iSC, _oSC, _iMT, _iRC, _rA, _ta],
+    [
+        0,
+        0,
+        () => IdMappingWorkflowInputSourceConfig,
+        () => IdMappingWorkflowOutputSourceConfig,
+        () => IdMappingTechniques,
+        () => IdMappingIncrementalRunConfig,
+        0,
+        128 | 0,
+    ],
+];
+var CreateIdMappingWorkflowOutput = [
+    3,
+    n0,
+    _CIMWO,
+    0,
+    [_wN, _wA, _de, _iSC, _oSC, _iMT, _iRC, _rA],
+    [
+        0,
+        0,
+        0,
+        () => IdMappingWorkflowInputSourceConfig,
+        () => IdMappingWorkflowOutputSourceConfig,
+        () => IdMappingTechniques,
+        () => IdMappingIncrementalRunConfig,
+        0,
+    ],
+];
+var CreateIdNamespaceInput = [
+    3,
+    n0,
+    _CINI,
+    0,
+    [_iNN, _de, _iSC, _iMWP, _ty, _rA, _ta],
+    [0, 0, () => IdNamespaceInputSourceConfig, () => IdNamespaceIdMappingWorkflowPropertiesList, 0, 0, 128 | 0],
+];
+var CreateIdNamespaceOutput = [
+    3,
+    n0,
+    _CINO,
+    0,
+    [_iNN, _iNA, _de, _iSC, _iMWP, _ty, _rA, _cA, _uA, _ta],
+    [0, 0, 0, () => IdNamespaceInputSourceConfig, () => IdNamespaceIdMappingWorkflowPropertiesList, 0, 0, 4, 4, 128 | 0],
+];
+var CreateMatchingWorkflowInput = [
+    3,
+    n0,
+    _CMWI,
+    0,
+    [_wN, _de, _iSC, _oSC, _rT, _iRC, _rA, _ta],
+    [
+        0,
+        0,
+        () => InputSourceConfig,
+        () => OutputSourceConfig,
+        () => ResolutionTechniques,
+        () => IncrementalRunConfig,
+        0,
+        128 | 0,
+    ],
+];
+var CreateMatchingWorkflowOutput = [
+    3,
+    n0,
+    _CMWO,
+    0,
+    [_wN, _wA, _de, _iSC, _oSC, _rT, _iRC, _rA],
+    [
+        0,
+        0,
+        0,
+        () => InputSourceConfig,
+        () => OutputSourceConfig,
+        () => ResolutionTechniques,
+        () => IncrementalRunConfig,
+        0,
+    ],
+];
+var CreateSchemaMappingInput = [
+    3,
+    n0,
+    _CSMI,
+    0,
+    [_sN, _de, _mIF, _ta],
+    [0, 0, () => SchemaInputAttributes, 128 | 0],
+];
+var CreateSchemaMappingOutput = [
+    3,
+    n0,
+    _CSMO,
+    0,
+    [_sN, _sA, _de, _mIF],
+    [0, 0, 0, () => SchemaInputAttributes],
+];
+var DeletedUniqueId = [3, n0, _DUI, 0, [_uIn], [0]];
+var DeleteIdMappingWorkflowInput = [3, n0, _DIMWI, 0, [_wN], [[0, 1]]];
+var DeleteIdMappingWorkflowOutput = [3, n0, _DIMWO, 0, [_m], [0]];
+var DeleteIdNamespaceInput = [3, n0, _DINI, 0, [_iNN], [[0, 1]]];
+var DeleteIdNamespaceOutput = [3, n0, _DINO, 0, [_m], [0]];
+var DeleteMatchingWorkflowInput = [3, n0, _DMWI, 0, [_wN], [[0, 1]]];
+var DeleteMatchingWorkflowOutput = [3, n0, _DMWO, 0, [_m], [0]];
+var DeletePolicyStatementInput = [
+    3,
+    n0,
+    _DPSI,
+    0,
+    [_a, _sI],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var DeletePolicyStatementOutput = [3, n0, _DPSO, 0, [_a, _t, _po], [0, 0, 0]];
+var DeleteSchemaMappingInput = [3, n0, _DSMI, 0, [_sN], [[0, 1]]];
+var DeleteSchemaMappingOutput = [3, n0, _DSMO, 0, [_m], [0]];
+var DeleteUniqueIdError = [3, n0, _DUIE, 0, [_uIn, _eT], [0, 0]];
+var ErrorDetails = [3, n0, _ED, 0, [_eM], [0]];
+var ExceedsLimitException = [
+    -3,
+    n0,
+    _ELE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_m, _qN, _qV],
+    [0, 0, 1],
+];
+schema.TypeRegistry.for(n0).registerError(ExceedsLimitException, ExceedsLimitException$1);
+var FailedRecord = [3, n0, _FR, 0, [_iSARN, _uIn, _eM], [0, 0, 0]];
+var GenerateMatchIdInput = [
+    3,
+    n0,
+    _GMII,
+    0,
+    [_wN, _r, _pT],
+    [[0, 1], [() => RecordList, 0], 0],
+];
+var GenerateMatchIdOutput = [
+    3,
+    n0,
+    _GMIO,
+    0,
+    [_mG, _fR],
+    [() => MatchGroupsList, () => FailedRecordsList],
+];
+var GetIdMappingJobInput = [
+    3,
+    n0,
+    _GIMJI,
+    0,
+    [_wN, _jI],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var GetIdMappingJobOutput = [
+    3,
+    n0,
+    _GIMJO,
+    0,
+    [_jI, _s, _sT, _eTn, _me, _eD, _oSC, _jT],
+    [0, 0, 4, 4, () => IdMappingJobMetrics, () => ErrorDetails, () => IdMappingJobOutputSourceConfig, 0],
+];
+var GetIdMappingWorkflowInput = [3, n0, _GIMWI, 0, [_wN], [[0, 1]]];
+var GetIdMappingWorkflowOutput = [
+    3,
+    n0,
+    _GIMWO,
+    0,
+    [_wN, _wA, _de, _iSC, _oSC, _iMT, _cA, _uA, _iRC, _rA, _ta],
+    [
+        0,
+        0,
+        0,
+        () => IdMappingWorkflowInputSourceConfig,
+        () => IdMappingWorkflowOutputSourceConfig,
+        () => IdMappingTechniques,
+        4,
+        4,
+        () => IdMappingIncrementalRunConfig,
+        0,
+        128 | 0,
+    ],
+];
+var GetIdNamespaceInput = [3, n0, _GINI, 0, [_iNN], [[0, 1]]];
+var GetIdNamespaceOutput = [
+    3,
+    n0,
+    _GINO,
+    0,
+    [_iNN, _iNA, _de, _iSC, _iMWP, _ty, _rA, _cA, _uA, _ta],
+    [0, 0, 0, () => IdNamespaceInputSourceConfig, () => IdNamespaceIdMappingWorkflowPropertiesList, 0, 0, 4, 4, 128 | 0],
+];
+var GetMatchIdInput = [
+    3,
+    n0,
+    _GMIIe,
+    0,
+    [_wN, _re, _aN],
+    [[0, 1], [() => RecordAttributeMap, 0], 2],
+];
+var GetMatchIdOutput = [3, n0, _GMIOe, 0, [_mI, _mR], [0, 0]];
+var GetMatchingJobInput = [
+    3,
+    n0,
+    _GMJI,
+    0,
+    [_wN, _jI],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var GetMatchingJobOutput = [
+    3,
+    n0,
+    _GMJO,
+    0,
+    [_jI, _s, _sT, _eTn, _me, _eD, _oSC],
+    [0, 0, 4, 4, () => JobMetrics, () => ErrorDetails, () => JobOutputSourceConfig],
+];
+var GetMatchingWorkflowInput = [3, n0, _GMWI, 0, [_wN], [[0, 1]]];
+var GetMatchingWorkflowOutput = [
+    3,
+    n0,
+    _GMWO,
+    0,
+    [_wN, _wA, _de, _iSC, _oSC, _rT, _cA, _uA, _iRC, _rA, _ta],
+    [
+        0,
+        0,
+        0,
+        () => InputSourceConfig,
+        () => OutputSourceConfig,
+        () => ResolutionTechniques,
+        4,
+        4,
+        () => IncrementalRunConfig,
+        0,
+        128 | 0,
+    ],
+];
+var GetPolicyInput = [3, n0, _GPI, 0, [_a], [[0, 1]]];
+var GetPolicyOutput = [3, n0, _GPO, 0, [_a, _t, _po], [0, 0, 0]];
+var GetProviderServiceInput = [
+    3,
+    n0,
+    _GPSI,
+    0,
+    [_pN, _pSN],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var GetProviderServiceOutput = [
+    3,
+    n0,
+    _GPSO,
+    0,
+    [_pN, _pSN, _pSDN, _pST, _pSA, _pCD, _pINSC, _pJC, _pEC, _aO, _pEOD, _pIDAC, _pCS],
+    [
+        0,
+        0,
+        0,
+        0,
+        0,
+        15,
+        () => ProviderIdNameSpaceConfiguration,
+        15,
+        () => ProviderEndpointConfiguration,
+        2,
+        15,
+        () => ProviderIntermediateDataAccessConfiguration,
+        () => ProviderComponentSchema,
+    ],
+];
+var GetSchemaMappingInput = [3, n0, _GSMI, 0, [_sN], [[0, 1]]];
+var GetSchemaMappingOutput = [
+    3,
+    n0,
+    _GSMO,
+    0,
+    [_sN, _sA, _de, _mIF, _cA, _uA, _ta, _hW],
+    [0, 0, 0, () => SchemaInputAttributes, 4, 4, 128 | 0, 2],
+];
+var IdMappingIncrementalRunConfig = [3, n0, _IMIRC, 0, [_iRT], [0]];
+var IdMappingJobMetrics = [
+    3,
+    n0,
+    _IMJM,
+    0,
+    [_iR, _tRP, _rNP, _dRP, _tMR, _tMSR, _tMTR, _uRL, _nMR, _nMSR, _nMTR, _nURL, _mRR, _mSRR, _mTRR],
+    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+];
+var IdMappingJobOutputSource = [3, n0, _IMJOS, 0, [_rA, _oSP, _KMSA], [0, 0, 0]];
+var IdMappingRuleBasedProperties = [
+    3,
+    n0,
+    _IMRBP,
+    0,
+    [_ru, _rDT, _aMM, _rMM],
+    [() => RuleList, 0, 0, 0],
+];
+var IdMappingTechniques = [
+    3,
+    n0,
+    _IMT,
+    0,
+    [_iMTd, _rBP, _pP],
+    [0, () => IdMappingRuleBasedProperties, () => ProviderProperties],
+];
+var IdMappingWorkflowInputSource = [3, n0, _IMWIS, 0, [_iSARN, _sN, _ty], [0, 0, 0]];
+var IdMappingWorkflowOutputSource = [3, n0, _IMWOS, 0, [_oSP, _KMSA], [0, 0]];
+var IdMappingWorkflowSummary = [3, n0, _IMWS, 0, [_wN, _wA, _cA, _uA], [0, 0, 4, 4]];
+var IdNamespaceIdMappingWorkflowMetadata = [3, n0, _INIMWM, 0, [_iMTd], [0]];
+var IdNamespaceIdMappingWorkflowProperties = [
+    3,
+    n0,
+    _INIMWP,
+    0,
+    [_iMTd, _rBP, _pP],
+    [0, () => NamespaceRuleBasedProperties, () => NamespaceProviderProperties],
+];
+var IdNamespaceInputSource = [3, n0, _INIS, 0, [_iSARN, _sN], [0, 0]];
+var IdNamespaceSummary = [
+    3,
+    n0,
+    _INS,
+    0,
+    [_iNN, _iNA, _de, _iMWP, _ty, _cA, _uA],
+    [0, 0, 0, () => IdNamespaceIdMappingWorkflowMetadataList, 0, 4, 4],
+];
+var IncrementalRunConfig = [3, n0, _IRC, 0, [_iRT], [0]];
+var InputSource = [3, n0, _IS, 0, [_iSARN, _sN, _aN], [0, 0, 2]];
+var IntermediateSourceConfiguration = [3, n0, _ISC, 0, [_iSP], [0]];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var JobMetrics = [3, n0, _JM, 0, [_iR, _tRP, _rNP, _dRP, _mID], [1, 1, 1, 1, 1]];
+var JobOutputSource = [3, n0, _JOS, 0, [_rA, _oSP, _KMSA], [0, 0, 0]];
+var JobSummary = [3, n0, _JS, 0, [_jI, _s, _sT, _eTn], [0, 0, 4, 4]];
+var ListIdMappingJobsInput = [
+    3,
+    n0,
+    _LIMJI,
+    0,
+    [_wN, _nT, _mRa],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mRa,
+            },
+        ],
+    ],
+];
+var ListIdMappingJobsOutput = [3, n0, _LIMJO, 0, [_j, _nT], [() => JobList, 0]];
+var ListIdMappingWorkflowsInput = [
+    3,
+    n0,
+    _LIMWI,
+    0,
+    [_nT, _mRa],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mRa,
+            },
+        ],
+    ],
+];
+var ListIdMappingWorkflowsOutput = [
+    3,
+    n0,
+    _LIMWO,
+    0,
+    [_wS, _nT],
+    [() => IdMappingWorkflowList, 0],
+];
+var ListIdNamespacesInput = [
+    3,
+    n0,
+    _LINI,
+    0,
+    [_nT, _mRa],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mRa,
+            },
+        ],
+    ],
+];
+var ListIdNamespacesOutput = [3, n0, _LINO, 0, [_iNS, _nT], [() => IdNamespaceList, 0]];
+var ListMatchingJobsInput = [
+    3,
+    n0,
+    _LMJI,
+    0,
+    [_wN, _nT, _mRa],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mRa,
+            },
+        ],
+    ],
+];
+var ListMatchingJobsOutput = [3, n0, _LMJO, 0, [_j, _nT], [() => JobList, 0]];
+var ListMatchingWorkflowsInput = [
+    3,
+    n0,
+    _LMWI,
+    0,
+    [_nT, _mRa],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mRa,
+            },
+        ],
+    ],
+];
+var ListMatchingWorkflowsOutput = [
+    3,
+    n0,
+    _LMWO,
+    0,
+    [_wS, _nT],
+    [() => MatchingWorkflowList, 0],
+];
+var ListProviderServicesInput = [
+    3,
+    n0,
+    _LPSI,
+    0,
+    [_nT, _mRa, _pN],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mRa,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _pN,
+            },
+        ],
+    ],
+];
+var ListProviderServicesOutput = [
+    3,
+    n0,
+    _LPSO,
+    0,
+    [_pSS, _nT],
+    [() => ProviderServiceList, 0],
+];
+var ListSchemaMappingsInput = [
+    3,
+    n0,
+    _LSMI,
+    0,
+    [_nT, _mRa],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mRa,
+            },
+        ],
+    ],
+];
+var ListSchemaMappingsOutput = [
+    3,
+    n0,
+    _LSMO,
+    0,
+    [_sL, _nT],
+    [() => SchemaMappingList, 0],
+];
+var ListTagsForResourceInput = [3, n0, _LTFRI, 0, [_rAe], [[0, 1]]];
+var ListTagsForResourceOutput = [3, n0, _LTFRO, 0, [_ta], [128 | 0]];
+var MatchedRecord = [3, n0, _MR, 0, [_iSARN, _rI], [0, 0]];
+var MatchGroup = [3, n0, _MG, 0, [_r, _mI, _mR], [() => MatchedRecordsList, 0, 0]];
+var MatchingWorkflowSummary = [
+    3,
+    n0,
+    _MWS,
+    0,
+    [_wN, _wA, _cA, _uA, _rTe],
+    [0, 0, 4, 4, 0],
+];
+var NamespaceProviderProperties = [3, n0, _NPP, 0, [_pSA, _pC], [0, 15]];
+var NamespaceRuleBasedProperties = [
+    3,
+    n0,
+    _NRBP,
+    0,
+    [_ru, _rDTu, _aMM, _rMMe],
+    [() => RuleList, 64 | 0, 0, 64 | 0],
+];
+var OutputAttribute = [3, n0, _OA, 0, [_n, _h], [0, 2]];
+var OutputSource = [
+    3,
+    n0,
+    _OS,
+    0,
+    [_oSP, _KMSA, _o, _aN],
+    [0, 0, () => OutputAttributes, 2],
+];
+var ProviderComponentSchema = [
+    3,
+    n0,
+    _PCS,
+    0,
+    [_sc, _pSAr],
+    [[1, n0, _S, 0, 64 | 0], () => ProviderSchemaAttributes],
+];
+var ProviderIdNameSpaceConfiguration = [
+    3,
+    n0,
+    _PINSC,
+    0,
+    [_de, _pTCD, _pSCD],
+    [0, 15, 15],
+];
+var ProviderIntermediateDataAccessConfiguration = [
+    3,
+    n0,
+    _PIDAC,
+    0,
+    [_aAI, _rBA],
+    [64 | 0, 64 | 0],
+];
+var ProviderMarketplaceConfiguration = [
+    3,
+    n0,
+    _PMC,
+    0,
+    [_dSI, _rIe, _aI, _lI],
+    [0, 0, 0, 0],
+];
+var ProviderProperties = [
+    3,
+    n0,
+    _PP,
+    0,
+    [_pSA, _pC, _iSCn],
+    [0, 15, () => IntermediateSourceConfiguration],
+];
+var ProviderSchemaAttribute = [3, n0, _PSA, 0, [_fN, _ty, _sTu, _ha], [0, 0, 0, 2]];
+var ProviderServiceSummary = [
+    3,
+    n0,
+    _PSS,
+    0,
+    [_pSA, _pN, _pSDN, _pSN, _pST],
+    [0, 0, 0, 0, 0],
+];
+var PutPolicyInput = [3, n0, _PPI, 0, [_a, _t, _po], [[0, 1], 0, 0]];
+var PutPolicyOutput = [3, n0, _PPO, 0, [_a, _t, _po], [0, 0, 0]];
+var _Record = [
+    3,
+    n0,
+    _R,
+    0,
+    [_iSARN, _uIn, _rAM],
+    [0, 0, [() => RecordAttributeMapString255, 0]],
+];
+var ResolutionTechniques = [
+    3,
+    n0,
+    _RT,
+    0,
+    [_rTe, _rBP, _rCP, _pP],
+    [0, () => RuleBasedProperties, () => RuleConditionProperties, () => ProviderProperties],
+];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var Rule = [3, n0, _Ru, 0, [_rN, _mK], [0, 64 | 0]];
+var RuleBasedProperties = [3, n0, _RBP, 0, [_ru, _aMM, _mP], [() => RuleList, 0, 0]];
+var RuleCondition = [3, n0, _RC, 0, [_rN, _co], [0, 0]];
+var RuleConditionProperties = [3, n0, _RCP, 0, [_ru], [() => RuleConditionList]];
+var SchemaInputAttribute = [
+    3,
+    n0,
+    _SIA,
+    0,
+    [_fN, _ty, _gN, _mKa, _sTu, _h],
+    [0, 0, 0, 0, 0, 2],
+];
+var SchemaMappingSummary = [3, n0, _SMS, 0, [_sN, _sA, _cA, _uA, _hW], [0, 0, 4, 4, 2]];
+var StartIdMappingJobInput = [
+    3,
+    n0,
+    _SIMJI,
+    0,
+    [_wN, _oSC, _jT],
+    [[0, 1], () => IdMappingJobOutputSourceConfig, 0],
+];
+var StartIdMappingJobOutput = [
+    3,
+    n0,
+    _SIMJO,
+    0,
+    [_jI, _oSC, _jT],
+    [0, () => IdMappingJobOutputSourceConfig, 0],
+];
+var StartMatchingJobInput = [3, n0, _SMJI, 0, [_wN], [[0, 1]]];
+var StartMatchingJobOutput = [3, n0, _SMJO, 0, [_jI], [0]];
+var TagResourceInput = [3, n0, _TRI, 0, [_rAe, _ta], [[0, 1], 128 | 0]];
+var TagResourceOutput = [3, n0, _TRO, 0, [], []];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var UntagResourceInput = [
+    3,
+    n0,
+    _URI,
+    0,
+    [_rAe, _tK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceOutput = [3, n0, _URO, 0, [], []];
+var UpdateIdMappingWorkflowInput = [
+    3,
+    n0,
+    _UIMWI,
+    0,
+    [_wN, _de, _iSC, _oSC, _iMT, _iRC, _rA],
+    [
+        [0, 1],
+        0,
+        () => IdMappingWorkflowInputSourceConfig,
+        () => IdMappingWorkflowOutputSourceConfig,
+        () => IdMappingTechniques,
+        () => IdMappingIncrementalRunConfig,
+        0,
+    ],
+];
+var UpdateIdMappingWorkflowOutput = [
+    3,
+    n0,
+    _UIMWO,
+    0,
+    [_wN, _wA, _de, _iSC, _oSC, _iMT, _iRC, _rA],
+    [
+        0,
+        0,
+        0,
+        () => IdMappingWorkflowInputSourceConfig,
+        () => IdMappingWorkflowOutputSourceConfig,
+        () => IdMappingTechniques,
+        () => IdMappingIncrementalRunConfig,
+        0,
+    ],
+];
+var UpdateIdNamespaceInput = [
+    3,
+    n0,
+    _UINI,
+    0,
+    [_iNN, _de, _iSC, _iMWP, _rA],
+    [[0, 1], 0, () => IdNamespaceInputSourceConfig, () => IdNamespaceIdMappingWorkflowPropertiesList, 0],
+];
+var UpdateIdNamespaceOutput = [
+    3,
+    n0,
+    _UINO,
+    0,
+    [_iNN, _iNA, _de, _iSC, _iMWP, _ty, _rA, _cA, _uA],
+    [0, 0, 0, () => IdNamespaceInputSourceConfig, () => IdNamespaceIdMappingWorkflowPropertiesList, 0, 0, 4, 4],
+];
+var UpdateMatchingWorkflowInput = [
+    3,
+    n0,
+    _UMWI,
+    0,
+    [_wN, _de, _iSC, _oSC, _rT, _iRC, _rA],
+    [
+        [0, 1],
+        0,
+        () => InputSourceConfig,
+        () => OutputSourceConfig,
+        () => ResolutionTechniques,
+        () => IncrementalRunConfig,
+        0,
+    ],
+];
+var UpdateMatchingWorkflowOutput = [
+    3,
+    n0,
+    _UMWO,
+    0,
+    [_wN, _de, _iSC, _oSC, _rT, _iRC, _rA],
+    [0, 0, () => InputSourceConfig, () => OutputSourceConfig, () => ResolutionTechniques, () => IncrementalRunConfig, 0],
+];
+var UpdateSchemaMappingInput = [
+    3,
+    n0,
+    _USMI,
+    0,
+    [_sN, _de, _mIF],
+    [[0, 1], 0, () => SchemaInputAttributes],
+];
+var UpdateSchemaMappingOutput = [
+    3,
+    n0,
+    _USMO,
+    0,
+    [_sN, _sA, _de, _mIF],
+    [0, 0, 0, () => SchemaInputAttributes],
+];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var EntityResolutionServiceException = [
+    -3,
+    _sm,
+    "EntityResolutionServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_sm).registerError(EntityResolutionServiceException, EntityResolutionServiceException$1);
+var DeletedUniqueIdList = [1, n0, _DUIL, 0, () => DeletedUniqueId];
+var DeleteUniqueIdErrorsList = [1, n0, _DUIEL, 0, () => DeleteUniqueIdError];
+var FailedRecordsList = [1, n0, _FRL, 0, () => FailedRecord];
+var IdMappingJobOutputSourceConfig = [1, n0, _IMJOSC, 0, () => IdMappingJobOutputSource];
+var IdMappingWorkflowInputSourceConfig = [
+    1,
+    n0,
+    _IMWISC,
+    0,
+    () => IdMappingWorkflowInputSource,
+];
+var IdMappingWorkflowList = [1, n0, _IMWL, 0, () => IdMappingWorkflowSummary];
+var IdMappingWorkflowOutputSourceConfig = [
+    1,
+    n0,
+    _IMWOSC,
+    0,
+    () => IdMappingWorkflowOutputSource,
+];
+var IdNamespaceIdMappingWorkflowMetadataList = [
+    1,
+    n0,
+    _INIMWML,
+    0,
+    () => IdNamespaceIdMappingWorkflowMetadata,
+];
+var IdNamespaceIdMappingWorkflowPropertiesList = [
+    1,
+    n0,
+    _INIMWPL,
+    0,
+    () => IdNamespaceIdMappingWorkflowProperties,
+];
+var IdNamespaceInputSourceConfig = [1, n0, _INISC, 0, () => IdNamespaceInputSource];
+var IdNamespaceList = [1, n0, _INL, 0, () => IdNamespaceSummary];
+var InputSourceConfig = [1, n0, _ISCn, 0, () => InputSource];
+var JobList = [1, n0, _JL, 0, () => JobSummary];
+var JobOutputSourceConfig = [1, n0, _JOSC, 0, () => JobOutputSource];
+var MatchedRecordsList = [1, n0, _MRL, 0, () => MatchedRecord];
+var MatchGroupsList = [1, n0, _MGL, 0, () => MatchGroup];
+var MatchingWorkflowList = [1, n0, _MWL, 0, () => MatchingWorkflowSummary];
+var OutputAttributes = [1, n0, _OAu, 0, () => OutputAttribute];
+var OutputSourceConfig = [1, n0, _OSC, 0, () => OutputSource];
+var ProviderSchemaAttributes = [1, n0, _PSAr, 0, () => ProviderSchemaAttribute];
+var ProviderServiceList = [1, n0, _PSL, 0, () => ProviderServiceSummary];
+var RecordList = [1, n0, _RL, 0, [() => _Record, 0]];
+var RuleConditionList = [1, n0, _RCL, 0, () => RuleCondition];
+var RuleList = [1, n0, _RLu, 0, () => Rule];
+var SchemaInputAttributes = [1, n0, _SIAc, 0, () => SchemaInputAttribute];
+var SchemaMappingList = [1, n0, _SML, 0, () => SchemaMappingSummary];
+var RecordAttributeMap = [2, n0, _RAM, 8, 0, 0];
+var RecordAttributeMapString255 = [2, n0, _RAMS, 8, 0, 0];
+var ProviderEndpointConfiguration = [
+    3,
+    n0,
+    _PEC,
+    0,
+    [_mC],
+    [() => ProviderMarketplaceConfiguration],
+];
+var AddPolicyStatement = [
+    9,
+    n0,
+    _APS,
+    {
+        [_ht]: ["POST", "/policies/{arn}/{statementId}", 200],
+    },
+    () => AddPolicyStatementInput,
+    () => AddPolicyStatementOutput,
+];
+var BatchDeleteUniqueId = [
+    9,
+    n0,
+    _BDUI,
+    {
+        [_ht]: ["DELETE", "/matchingworkflows/{workflowName}/uniqueids", 200],
+    },
+    () => BatchDeleteUniqueIdInput,
+    () => BatchDeleteUniqueIdOutput,
+];
+var CreateIdMappingWorkflow = [
+    9,
+    n0,
+    _CIMW,
+    {
+        [_ht]: ["POST", "/idmappingworkflows", 200],
+    },
+    () => CreateIdMappingWorkflowInput,
+    () => CreateIdMappingWorkflowOutput,
+];
+var CreateIdNamespace = [
+    9,
+    n0,
+    _CIN,
+    {
+        [_ht]: ["POST", "/idnamespaces", 200],
+    },
+    () => CreateIdNamespaceInput,
+    () => CreateIdNamespaceOutput,
+];
+var CreateMatchingWorkflow = [
+    9,
+    n0,
+    _CMW,
+    {
+        [_ht]: ["POST", "/matchingworkflows", 200],
+    },
+    () => CreateMatchingWorkflowInput,
+    () => CreateMatchingWorkflowOutput,
+];
+var CreateSchemaMapping = [
+    9,
+    n0,
+    _CSM,
+    {
+        [_ht]: ["POST", "/schemas", 200],
+    },
+    () => CreateSchemaMappingInput,
+    () => CreateSchemaMappingOutput,
+];
+var DeleteIdMappingWorkflow = [
+    9,
+    n0,
+    _DIMW,
+    {
+        [_ht]: ["DELETE", "/idmappingworkflows/{workflowName}", 200],
+    },
+    () => DeleteIdMappingWorkflowInput,
+    () => DeleteIdMappingWorkflowOutput,
+];
+var DeleteIdNamespace = [
+    9,
+    n0,
+    _DIN,
+    {
+        [_ht]: ["DELETE", "/idnamespaces/{idNamespaceName}", 200],
+    },
+    () => DeleteIdNamespaceInput,
+    () => DeleteIdNamespaceOutput,
+];
+var DeleteMatchingWorkflow = [
+    9,
+    n0,
+    _DMW,
+    {
+        [_ht]: ["DELETE", "/matchingworkflows/{workflowName}", 200],
+    },
+    () => DeleteMatchingWorkflowInput,
+    () => DeleteMatchingWorkflowOutput,
+];
+var DeletePolicyStatement = [
+    9,
+    n0,
+    _DPS,
+    {
+        [_ht]: ["DELETE", "/policies/{arn}/{statementId}", 200],
+    },
+    () => DeletePolicyStatementInput,
+    () => DeletePolicyStatementOutput,
+];
+var DeleteSchemaMapping = [
+    9,
+    n0,
+    _DSM,
+    {
+        [_ht]: ["DELETE", "/schemas/{schemaName}", 200],
+    },
+    () => DeleteSchemaMappingInput,
+    () => DeleteSchemaMappingOutput,
+];
+var GenerateMatchId = [
+    9,
+    n0,
+    _GMI,
+    {
+        [_ht]: ["POST", "/matchingworkflows/{workflowName}/generateMatches", 200],
+    },
+    () => GenerateMatchIdInput,
+    () => GenerateMatchIdOutput,
+];
+var GetIdMappingJob = [
+    9,
+    n0,
+    _GIMJ,
+    {
+        [_ht]: ["GET", "/idmappingworkflows/{workflowName}/jobs/{jobId}", 200],
+    },
+    () => GetIdMappingJobInput,
+    () => GetIdMappingJobOutput,
+];
+var GetIdMappingWorkflow = [
+    9,
+    n0,
+    _GIMW,
+    {
+        [_ht]: ["GET", "/idmappingworkflows/{workflowName}", 200],
+    },
+    () => GetIdMappingWorkflowInput,
+    () => GetIdMappingWorkflowOutput,
+];
+var GetIdNamespace = [
+    9,
+    n0,
+    _GIN,
+    {
+        [_ht]: ["GET", "/idnamespaces/{idNamespaceName}", 200],
+    },
+    () => GetIdNamespaceInput,
+    () => GetIdNamespaceOutput,
+];
+var GetMatchId = [
+    9,
+    n0,
+    _GMIe,
+    {
+        [_ht]: ["POST", "/matchingworkflows/{workflowName}/matches", 200],
+    },
+    () => GetMatchIdInput,
+    () => GetMatchIdOutput,
+];
+var GetMatchingJob = [
+    9,
+    n0,
+    _GMJ,
+    {
+        [_ht]: ["GET", "/matchingworkflows/{workflowName}/jobs/{jobId}", 200],
+    },
+    () => GetMatchingJobInput,
+    () => GetMatchingJobOutput,
+];
+var GetMatchingWorkflow = [
+    9,
+    n0,
+    _GMW,
+    {
+        [_ht]: ["GET", "/matchingworkflows/{workflowName}", 200],
+    },
+    () => GetMatchingWorkflowInput,
+    () => GetMatchingWorkflowOutput,
+];
+var GetPolicy = [
+    9,
+    n0,
+    _GP,
+    {
+        [_ht]: ["GET", "/policies/{arn}", 200],
+    },
+    () => GetPolicyInput,
+    () => GetPolicyOutput,
+];
+var GetProviderService = [
+    9,
+    n0,
+    _GPS,
+    {
+        [_ht]: ["GET", "/providerservices/{providerName}/{providerServiceName}", 200],
+    },
+    () => GetProviderServiceInput,
+    () => GetProviderServiceOutput,
+];
+var GetSchemaMapping = [
+    9,
+    n0,
+    _GSM,
+    {
+        [_ht]: ["GET", "/schemas/{schemaName}", 200],
+    },
+    () => GetSchemaMappingInput,
+    () => GetSchemaMappingOutput,
+];
+var ListIdMappingJobs = [
+    9,
+    n0,
+    _LIMJ,
+    {
+        [_ht]: ["GET", "/idmappingworkflows/{workflowName}/jobs", 200],
+    },
+    () => ListIdMappingJobsInput,
+    () => ListIdMappingJobsOutput,
+];
+var ListIdMappingWorkflows = [
+    9,
+    n0,
+    _LIMW,
+    {
+        [_ht]: ["GET", "/idmappingworkflows", 200],
+    },
+    () => ListIdMappingWorkflowsInput,
+    () => ListIdMappingWorkflowsOutput,
+];
+var ListIdNamespaces = [
+    9,
+    n0,
+    _LIN,
+    {
+        [_ht]: ["GET", "/idnamespaces", 200],
+    },
+    () => ListIdNamespacesInput,
+    () => ListIdNamespacesOutput,
+];
+var ListMatchingJobs = [
+    9,
+    n0,
+    _LMJ,
+    {
+        [_ht]: ["GET", "/matchingworkflows/{workflowName}/jobs", 200],
+    },
+    () => ListMatchingJobsInput,
+    () => ListMatchingJobsOutput,
+];
+var ListMatchingWorkflows = [
+    9,
+    n0,
+    _LMW,
+    {
+        [_ht]: ["GET", "/matchingworkflows", 200],
+    },
+    () => ListMatchingWorkflowsInput,
+    () => ListMatchingWorkflowsOutput,
+];
+var ListProviderServices = [
+    9,
+    n0,
+    _LPS,
+    {
+        [_ht]: ["GET", "/providerservices", 200],
+    },
+    () => ListProviderServicesInput,
+    () => ListProviderServicesOutput,
+];
+var ListSchemaMappings = [
+    9,
+    n0,
+    _LSM,
+    {
+        [_ht]: ["GET", "/schemas", 200],
+    },
+    () => ListSchemaMappingsInput,
+    () => ListSchemaMappingsOutput,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_ht]: ["GET", "/tags/{resourceArn}", 200],
+    },
+    () => ListTagsForResourceInput,
+    () => ListTagsForResourceOutput,
+];
+var PutPolicy = [
+    9,
+    n0,
+    _PPu,
+    {
+        [_ht]: ["PUT", "/policies/{arn}", 200],
+    },
+    () => PutPolicyInput,
+    () => PutPolicyOutput,
+];
+var StartIdMappingJob = [
+    9,
+    n0,
+    _SIMJ,
+    {
+        [_ht]: ["POST", "/idmappingworkflows/{workflowName}/jobs", 200],
+    },
+    () => StartIdMappingJobInput,
+    () => StartIdMappingJobOutput,
+];
+var StartMatchingJob = [
+    9,
+    n0,
+    _SMJ,
+    {
+        [_ht]: ["POST", "/matchingworkflows/{workflowName}/jobs", 200],
+    },
+    () => StartMatchingJobInput,
+    () => StartMatchingJobOutput,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_ht]: ["POST", "/tags/{resourceArn}", 200],
+    },
+    () => TagResourceInput,
+    () => TagResourceOutput,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_ht]: ["DELETE", "/tags/{resourceArn}", 200],
+    },
+    () => UntagResourceInput,
+    () => UntagResourceOutput,
+];
+var UpdateIdMappingWorkflow = [
+    9,
+    n0,
+    _UIMW,
+    {
+        [_ht]: ["PUT", "/idmappingworkflows/{workflowName}", 200],
+    },
+    () => UpdateIdMappingWorkflowInput,
+    () => UpdateIdMappingWorkflowOutput,
+];
+var UpdateIdNamespace = [
+    9,
+    n0,
+    _UIN,
+    {
+        [_ht]: ["PUT", "/idnamespaces/{idNamespaceName}", 200],
+    },
+    () => UpdateIdNamespaceInput,
+    () => UpdateIdNamespaceOutput,
+];
+var UpdateMatchingWorkflow = [
+    9,
+    n0,
+    _UMW,
+    {
+        [_ht]: ["PUT", "/matchingworkflows/{workflowName}", 200],
+    },
+    () => UpdateMatchingWorkflowInput,
+    () => UpdateMatchingWorkflowOutput,
+];
+var UpdateSchemaMapping = [
+    9,
+    n0,
+    _USM,
+    {
+        [_ht]: ["PUT", "/schemas/{schemaName}", 200],
+    },
+    () => UpdateSchemaMappingInput,
+    () => UpdateSchemaMappingOutput,
+];
 
 class AddPolicyStatementCommand 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("AWSVeniceService", "AddPolicyStatement", {})
     .n("EntityResolutionClient", "AddPolicyStatementCommand")
-    .f(void 0, void 0)
-    .ser(se_AddPolicyStatementCommand)
-    .de(de_AddPolicyStatementCommand)
+    .sc(AddPolicyStatement)
     .build() {
 }
 
@@ -1816,16 +1998,11 @@ class BatchDeleteUniqueIdCommand 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("AWSVeniceService", "BatchDeleteUniqueId", {})
     .n("EntityResolutionClient", "BatchDeleteUniqueIdCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchDeleteUniqueIdCommand)
-    .de(de_BatchDeleteUniqueIdCommand)
+    .sc(BatchDeleteUniqueId)
     .build() {
 }
 
@@ -1833,16 +2010,11 @@ class CreateIdMappingWorkflowCommand 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("AWSVeniceService", "CreateIdMappingWorkflow", {})
     .n("EntityResolutionClient", "CreateIdMappingWorkflowCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateIdMappingWorkflowCommand)
-    .de(de_CreateIdMappingWorkflowCommand)
+    .sc(CreateIdMappingWorkflow)
     .build() {
 }
 
@@ -1850,16 +2022,11 @@ class CreateIdNamespaceCommand 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("AWSVeniceService", "CreateIdNamespace", {})
     .n("EntityResolutionClient", "CreateIdNamespaceCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateIdNamespaceCommand)
-    .de(de_CreateIdNamespaceCommand)
+    .sc(CreateIdNamespace)
     .build() {
 }
 
@@ -1867,16 +2034,11 @@ class CreateMatchingWorkflowCommand 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("AWSVeniceService", "CreateMatchingWorkflow", {})
     .n("EntityResolutionClient", "CreateMatchingWorkflowCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateMatchingWorkflowCommand)
-    .de(de_CreateMatchingWorkflowCommand)
+    .sc(CreateMatchingWorkflow)
     .build() {
 }
 
@@ -1884,16 +2046,11 @@ class CreateSchemaMappingCommand 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("AWSVeniceService", "CreateSchemaMapping", {})
     .n("EntityResolutionClient", "CreateSchemaMappingCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateSchemaMappingCommand)
-    .de(de_CreateSchemaMappingCommand)
+    .sc(CreateSchemaMapping)
     .build() {
 }
 
@@ -1901,16 +2058,11 @@ class DeleteIdMappingWorkflowCommand 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("AWSVeniceService", "DeleteIdMappingWorkflow", {})
     .n("EntityResolutionClient", "DeleteIdMappingWorkflowCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteIdMappingWorkflowCommand)
-    .de(de_DeleteIdMappingWorkflowCommand)
+    .sc(DeleteIdMappingWorkflow)
     .build() {
 }
 
@@ -1918,16 +2070,11 @@ class DeleteIdNamespaceCommand 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("AWSVeniceService", "DeleteIdNamespace", {})
     .n("EntityResolutionClient", "DeleteIdNamespaceCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteIdNamespaceCommand)
-    .de(de_DeleteIdNamespaceCommand)
+    .sc(DeleteIdNamespace)
     .build() {
 }
 
@@ -1935,16 +2082,11 @@ class DeleteMatchingWorkflowCommand 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("AWSVeniceService", "DeleteMatchingWorkflow", {})
     .n("EntityResolutionClient", "DeleteMatchingWorkflowCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteMatchingWorkflowCommand)
-    .de(de_DeleteMatchingWorkflowCommand)
+    .sc(DeleteMatchingWorkflow)
     .build() {
 }
 
@@ -1952,16 +2094,11 @@ class DeletePolicyStatementCommand 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("AWSVeniceService", "DeletePolicyStatement", {})
     .n("EntityResolutionClient", "DeletePolicyStatementCommand")
-    .f(void 0, void 0)
-    .ser(se_DeletePolicyStatementCommand)
-    .de(de_DeletePolicyStatementCommand)
+    .sc(DeletePolicyStatement)
     .build() {
 }
 
@@ -1969,16 +2106,11 @@ class DeleteSchemaMappingCommand 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("AWSVeniceService", "DeleteSchemaMapping", {})
     .n("EntityResolutionClient", "DeleteSchemaMappingCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteSchemaMappingCommand)
-    .de(de_DeleteSchemaMappingCommand)
+    .sc(DeleteSchemaMapping)
     .build() {
 }
 
@@ -1986,16 +2118,11 @@ class GenerateMatchIdCommand 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("AWSVeniceService", "GenerateMatchId", {})
     .n("EntityResolutionClient", "GenerateMatchIdCommand")
-    .f(GenerateMatchIdInputFilterSensitiveLog, void 0)
-    .ser(se_GenerateMatchIdCommand)
-    .de(de_GenerateMatchIdCommand)
+    .sc(GenerateMatchId)
     .build() {
 }
 
@@ -2003,16 +2130,11 @@ class GetIdMappingJobCommand 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("AWSVeniceService", "GetIdMappingJob", {})
     .n("EntityResolutionClient", "GetIdMappingJobCommand")
-    .f(void 0, void 0)
-    .ser(se_GetIdMappingJobCommand)
-    .de(de_GetIdMappingJobCommand)
+    .sc(GetIdMappingJob)
     .build() {
 }
 
@@ -2020,16 +2142,11 @@ class GetIdMappingWorkflowCommand 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("AWSVeniceService", "GetIdMappingWorkflow", {})
     .n("EntityResolutionClient", "GetIdMappingWorkflowCommand")
-    .f(void 0, void 0)
-    .ser(se_GetIdMappingWorkflowCommand)
-    .de(de_GetIdMappingWorkflowCommand)
+    .sc(GetIdMappingWorkflow)
     .build() {
 }
 
@@ -2037,16 +2154,11 @@ class GetIdNamespaceCommand 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("AWSVeniceService", "GetIdNamespace", {})
     .n("EntityResolutionClient", "GetIdNamespaceCommand")
-    .f(void 0, void 0)
-    .ser(se_GetIdNamespaceCommand)
-    .de(de_GetIdNamespaceCommand)
+    .sc(GetIdNamespace)
     .build() {
 }
 
@@ -2054,16 +2166,11 @@ class GetMatchIdCommand 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("AWSVeniceService", "GetMatchId", {})
     .n("EntityResolutionClient", "GetMatchIdCommand")
-    .f(GetMatchIdInputFilterSensitiveLog, void 0)
-    .ser(se_GetMatchIdCommand)
-    .de(de_GetMatchIdCommand)
+    .sc(GetMatchId)
     .build() {
 }
 
@@ -2071,16 +2178,11 @@ class GetMatchingJobCommand 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("AWSVeniceService", "GetMatchingJob", {})
     .n("EntityResolutionClient", "GetMatchingJobCommand")
-    .f(void 0, void 0)
-    .ser(se_GetMatchingJobCommand)
-    .de(de_GetMatchingJobCommand)
+    .sc(GetMatchingJob)
     .build() {
 }
 
@@ -2088,16 +2190,11 @@ class GetMatchingWorkflowCommand 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("AWSVeniceService", "GetMatchingWorkflow", {})
     .n("EntityResolutionClient", "GetMatchingWorkflowCommand")
-    .f(void 0, void 0)
-    .ser(se_GetMatchingWorkflowCommand)
-    .de(de_GetMatchingWorkflowCommand)
+    .sc(GetMatchingWorkflow)
     .build() {
 }
 
@@ -2105,16 +2202,11 @@ class GetPolicyCommand 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("AWSVeniceService", "GetPolicy", {})
     .n("EntityResolutionClient", "GetPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_GetPolicyCommand)
-    .de(de_GetPolicyCommand)
+    .sc(GetPolicy)
     .build() {
 }
 
@@ -2122,16 +2214,11 @@ class GetProviderServiceCommand 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("AWSVeniceService", "GetProviderService", {})
     .n("EntityResolutionClient", "GetProviderServiceCommand")
-    .f(void 0, void 0)
-    .ser(se_GetProviderServiceCommand)
-    .de(de_GetProviderServiceCommand)
+    .sc(GetProviderService)
     .build() {
 }
 
@@ -2139,16 +2226,11 @@ class GetSchemaMappingCommand 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("AWSVeniceService", "GetSchemaMapping", {})
     .n("EntityResolutionClient", "GetSchemaMappingCommand")
-    .f(void 0, void 0)
-    .ser(se_GetSchemaMappingCommand)
-    .de(de_GetSchemaMappingCommand)
+    .sc(GetSchemaMapping)
     .build() {
 }
 
@@ -2156,16 +2238,11 @@ class ListIdMappingJobsCommand 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("AWSVeniceService", "ListIdMappingJobs", {})
     .n("EntityResolutionClient", "ListIdMappingJobsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListIdMappingJobsCommand)
-    .de(de_ListIdMappingJobsCommand)
+    .sc(ListIdMappingJobs)
     .build() {
 }
 
@@ -2173,16 +2250,11 @@ class ListIdMappingWorkflowsCommand 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("AWSVeniceService", "ListIdMappingWorkflows", {})
     .n("EntityResolutionClient", "ListIdMappingWorkflowsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListIdMappingWorkflowsCommand)
-    .de(de_ListIdMappingWorkflowsCommand)
+    .sc(ListIdMappingWorkflows)
     .build() {
 }
 
@@ -2190,16 +2262,11 @@ class ListIdNamespacesCommand 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("AWSVeniceService", "ListIdNamespaces", {})
     .n("EntityResolutionClient", "ListIdNamespacesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListIdNamespacesCommand)
-    .de(de_ListIdNamespacesCommand)
+    .sc(ListIdNamespaces)
     .build() {
 }
 
@@ -2207,16 +2274,11 @@ class ListMatchingJobsCommand 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("AWSVeniceService", "ListMatchingJobs", {})
     .n("EntityResolutionClient", "ListMatchingJobsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListMatchingJobsCommand)
-    .de(de_ListMatchingJobsCommand)
+    .sc(ListMatchingJobs)
     .build() {
 }
 
@@ -2224,16 +2286,11 @@ class ListMatchingWorkflowsCommand 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("AWSVeniceService", "ListMatchingWorkflows", {})
     .n("EntityResolutionClient", "ListMatchingWorkflowsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListMatchingWorkflowsCommand)
-    .de(de_ListMatchingWorkflowsCommand)
+    .sc(ListMatchingWorkflows)
     .build() {
 }
 
@@ -2241,16 +2298,11 @@ class ListProviderServicesCommand 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("AWSVeniceService", "ListProviderServices", {})
     .n("EntityResolutionClient", "ListProviderServicesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListProviderServicesCommand)
-    .de(de_ListProviderServicesCommand)
+    .sc(ListProviderServices)
     .build() {
 }
 
@@ -2258,16 +2310,11 @@ class ListSchemaMappingsCommand 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("AWSVeniceService", "ListSchemaMappings", {})
     .n("EntityResolutionClient", "ListSchemaMappingsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListSchemaMappingsCommand)
-    .de(de_ListSchemaMappingsCommand)
+    .sc(ListSchemaMappings)
     .build() {
 }
 
@@ -2275,16 +2322,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("AWSVeniceService", "ListTagsForResource", {})
     .n("EntityResolutionClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -2292,16 +2334,11 @@ class PutPolicyCommand 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("AWSVeniceService", "PutPolicy", {})
     .n("EntityResolutionClient", "PutPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_PutPolicyCommand)
-    .de(de_PutPolicyCommand)
+    .sc(PutPolicy)
     .build() {
 }
 
@@ -2309,16 +2346,11 @@ class StartIdMappingJobCommand 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("AWSVeniceService", "StartIdMappingJob", {})
     .n("EntityResolutionClient", "StartIdMappingJobCommand")
-    .f(void 0, void 0)
-    .ser(se_StartIdMappingJobCommand)
-    .de(de_StartIdMappingJobCommand)
+    .sc(StartIdMappingJob)
     .build() {
 }
 
@@ -2326,16 +2358,11 @@ class StartMatchingJobCommand 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("AWSVeniceService", "StartMatchingJob", {})
     .n("EntityResolutionClient", "StartMatchingJobCommand")
-    .f(void 0, void 0)
-    .ser(se_StartMatchingJobCommand)
-    .de(de_StartMatchingJobCommand)
+    .sc(StartMatchingJob)
     .build() {
 }
 
@@ -2343,16 +2370,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("AWSVeniceService", "TagResource", {})
     .n("EntityResolutionClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -2360,16 +2382,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("AWSVeniceService", "UntagResource", {})
     .n("EntityResolutionClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -2377,16 +2394,11 @@ class UpdateIdMappingWorkflowCommand 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("AWSVeniceService", "UpdateIdMappingWorkflow", {})
     .n("EntityResolutionClient", "UpdateIdMappingWorkflowCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateIdMappingWorkflowCommand)
-    .de(de_UpdateIdMappingWorkflowCommand)
+    .sc(UpdateIdMappingWorkflow)
     .build() {
 }
 
@@ -2394,16 +2406,11 @@ class UpdateIdNamespaceCommand 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("AWSVeniceService", "UpdateIdNamespace", {})
     .n("EntityResolutionClient", "UpdateIdNamespaceCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateIdNamespaceCommand)
-    .de(de_UpdateIdNamespaceCommand)
+    .sc(UpdateIdNamespace)
     .build() {
 }
 
@@ -2411,16 +2418,11 @@ class UpdateMatchingWorkflowCommand 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("AWSVeniceService", "UpdateMatchingWorkflow", {})
     .n("EntityResolutionClient", "UpdateMatchingWorkflowCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateMatchingWorkflowCommand)
-    .de(de_UpdateMatchingWorkflowCommand)
+    .sc(UpdateMatchingWorkflow)
     .build() {
 }
 
@@ -2428,16 +2430,11 @@ class UpdateSchemaMappingCommand 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("AWSVeniceService", "UpdateSchemaMapping", {})
     .n("EntityResolutionClient", "UpdateSchemaMappingCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateSchemaMappingCommand)
-    .de(de_UpdateSchemaMappingCommand)
+    .sc(UpdateSchemaMapping)
     .build() {
 }
 
@@ -2507,11 +2504,11 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AddPolicyStatementCommand = AddPolicyStatementCommand;
 exports.AttributeMatchingModel = AttributeMatchingModel;
 exports.BatchDeleteUniqueIdCommand = BatchDeleteUniqueIdCommand;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.CreateIdMappingWorkflowCommand = CreateIdMappingWorkflowCommand;
 exports.CreateIdNamespaceCommand = CreateIdNamespaceCommand;
 exports.CreateMatchingWorkflowCommand = CreateMatchingWorkflowCommand;
@@ -2525,15 +2522,13 @@ exports.DeleteUniqueIdErrorType = DeleteUniqueIdErrorType;
 exports.DeleteUniqueIdStatus = DeleteUniqueIdStatus;
 exports.EntityResolution = EntityResolution;
 exports.EntityResolutionClient = EntityResolutionClient;
-exports.EntityResolutionServiceException = EntityResolutionServiceException;
-exports.ExceedsLimitException = ExceedsLimitException;
+exports.EntityResolutionServiceException = EntityResolutionServiceException$1;
+exports.ExceedsLimitException = ExceedsLimitException$1;
 exports.GenerateMatchIdCommand = GenerateMatchIdCommand;
-exports.GenerateMatchIdInputFilterSensitiveLog = GenerateMatchIdInputFilterSensitiveLog;
 exports.GetIdMappingJobCommand = GetIdMappingJobCommand;
 exports.GetIdMappingWorkflowCommand = GetIdMappingWorkflowCommand;
 exports.GetIdNamespaceCommand = GetIdNamespaceCommand;
 exports.GetMatchIdCommand = GetMatchIdCommand;
-exports.GetMatchIdInputFilterSensitiveLog = GetMatchIdInputFilterSensitiveLog;
 exports.GetMatchingJobCommand = GetMatchingJobCommand;
 exports.GetMatchingWorkflowCommand = GetMatchingWorkflowCommand;
 exports.GetPolicyCommand = GetPolicyCommand;
@@ -2544,7 +2539,7 @@ exports.IdMappingType = IdMappingType;
 exports.IdMappingWorkflowRuleDefinitionType = IdMappingWorkflowRuleDefinitionType;
 exports.IdNamespaceType = IdNamespaceType;
 exports.IncrementalRunType = IncrementalRunType;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.JobStatus = JobStatus;
 exports.JobType = JobType;
 exports.ListIdMappingJobsCommand = ListIdMappingJobsCommand;
@@ -2560,21 +2555,20 @@ exports.ProcessingType = ProcessingType;
 exports.PutPolicyCommand = PutPolicyCommand;
 exports.RecordMatchingModel = RecordMatchingModel;
 exports.ResolutionType = ResolutionType;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.SchemaAttributeType = SchemaAttributeType;
 exports.ServiceType = ServiceType;
 exports.StartIdMappingJobCommand = StartIdMappingJobCommand;
 exports.StartMatchingJobCommand = StartMatchingJobCommand;
 exports.StatementEffect = StatementEffect;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateIdMappingWorkflowCommand = UpdateIdMappingWorkflowCommand;
 exports.UpdateIdNamespaceCommand = UpdateIdNamespaceCommand;
 exports.UpdateMatchingWorkflowCommand = UpdateMatchingWorkflowCommand;
 exports.UpdateSchemaMappingCommand = UpdateSchemaMappingCommand;
-exports.ValidationException = ValidationException;
-exports._RecordFilterSensitiveLog = _RecordFilterSensitiveLog;
+exports.ValidationException = ValidationException$1;
 exports.paginateListIdMappingJobs = paginateListIdMappingJobs;
 exports.paginateListIdMappingWorkflows = paginateListIdMappingWorkflows;
 exports.paginateListIdNamespaces = paginateListIdNamespaces;