@aws-sdk/client-entityresolution 3.428.0 → 3.429.0

package/dist-es/EntityResolution.js

@@ -1,38 +1,60 @@
 import { createAggregatedClient } from "@smithy/smithy-client";
+import { CreateIdMappingWorkflowCommand, } from "./commands/CreateIdMappingWorkflowCommand";
 import { CreateMatchingWorkflowCommand, } from "./commands/CreateMatchingWorkflowCommand";
 import { CreateSchemaMappingCommand, } from "./commands/CreateSchemaMappingCommand";
+import { DeleteIdMappingWorkflowCommand, } from "./commands/DeleteIdMappingWorkflowCommand";
 import { DeleteMatchingWorkflowCommand, } from "./commands/DeleteMatchingWorkflowCommand";
 import { DeleteSchemaMappingCommand, } from "./commands/DeleteSchemaMappingCommand";
+import { GetIdMappingJobCommand, } from "./commands/GetIdMappingJobCommand";
+import { GetIdMappingWorkflowCommand, } from "./commands/GetIdMappingWorkflowCommand";
 import { GetMatchIdCommand } from "./commands/GetMatchIdCommand";
 import { GetMatchingJobCommand, } from "./commands/GetMatchingJobCommand";
 import { GetMatchingWorkflowCommand, } from "./commands/GetMatchingWorkflowCommand";
+import { GetProviderServiceCommand, } from "./commands/GetProviderServiceCommand";
 import { GetSchemaMappingCommand, } from "./commands/GetSchemaMappingCommand";
+import { ListIdMappingJobsCommand, } from "./commands/ListIdMappingJobsCommand";
+import { ListIdMappingWorkflowsCommand, } from "./commands/ListIdMappingWorkflowsCommand";
 import { ListMatchingJobsCommand, } from "./commands/ListMatchingJobsCommand";
 import { ListMatchingWorkflowsCommand, } from "./commands/ListMatchingWorkflowsCommand";
+import { ListProviderServicesCommand, } from "./commands/ListProviderServicesCommand";
 import { ListSchemaMappingsCommand, } from "./commands/ListSchemaMappingsCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
+import { StartIdMappingJobCommand, } from "./commands/StartIdMappingJobCommand";
 import { StartMatchingJobCommand, } from "./commands/StartMatchingJobCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
+import { UpdateIdMappingWorkflowCommand, } from "./commands/UpdateIdMappingWorkflowCommand";
 import { UpdateMatchingWorkflowCommand, } from "./commands/UpdateMatchingWorkflowCommand";
+import { UpdateSchemaMappingCommand, } from "./commands/UpdateSchemaMappingCommand";
 import { EntityResolutionClient } from "./EntityResolutionClient";
 const commands = {
+    CreateIdMappingWorkflowCommand,
     CreateMatchingWorkflowCommand,
     CreateSchemaMappingCommand,
+    DeleteIdMappingWorkflowCommand,
     DeleteMatchingWorkflowCommand,
     DeleteSchemaMappingCommand,
+    GetIdMappingJobCommand,
+    GetIdMappingWorkflowCommand,
     GetMatchIdCommand,
     GetMatchingJobCommand,
     GetMatchingWorkflowCommand,
+    GetProviderServiceCommand,
     GetSchemaMappingCommand,
+    ListIdMappingJobsCommand,
+    ListIdMappingWorkflowsCommand,
     ListMatchingJobsCommand,
     ListMatchingWorkflowsCommand,
+    ListProviderServicesCommand,
     ListSchemaMappingsCommand,
     ListTagsForResourceCommand,
+    StartIdMappingJobCommand,
     StartMatchingJobCommand,
     TagResourceCommand,
     UntagResourceCommand,
+    UpdateIdMappingWorkflowCommand,
     UpdateMatchingWorkflowCommand,
+    UpdateSchemaMappingCommand,
 };
 export class EntityResolution extends EntityResolutionClient {
 }

package/dist-es/commands/CreateIdMappingWorkflowCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_CreateIdMappingWorkflowCommand, se_CreateIdMappingWorkflowCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateIdMappingWorkflowCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateIdMappingWorkflowCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "EntityResolutionClient";
+        const commandName = "CreateIdMappingWorkflowCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSVeniceService",
+                operation: "CreateIdMappingWorkflow",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateIdMappingWorkflowCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateIdMappingWorkflowCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteIdMappingWorkflowCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteIdMappingWorkflowCommand, se_DeleteIdMappingWorkflowCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteIdMappingWorkflowCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteIdMappingWorkflowCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "EntityResolutionClient";
+        const commandName = "DeleteIdMappingWorkflowCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSVeniceService",
+                operation: "DeleteIdMappingWorkflow",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteIdMappingWorkflowCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteIdMappingWorkflowCommand(output, context);
+    }
+}

package/dist-es/commands/GetIdMappingJobCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetIdMappingJobCommand, se_GetIdMappingJobCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetIdMappingJobCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetIdMappingJobCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "EntityResolutionClient";
+        const commandName = "GetIdMappingJobCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSVeniceService",
+                operation: "GetIdMappingJob",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetIdMappingJobCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetIdMappingJobCommand(output, context);
+    }
+}

package/dist-es/commands/GetIdMappingWorkflowCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetIdMappingWorkflowCommand, se_GetIdMappingWorkflowCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetIdMappingWorkflowCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetIdMappingWorkflowCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "EntityResolutionClient";
+        const commandName = "GetIdMappingWorkflowCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSVeniceService",
+                operation: "GetIdMappingWorkflow",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetIdMappingWorkflowCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetIdMappingWorkflowCommand(output, context);
+    }
+}

package/dist-es/commands/GetProviderServiceCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_GetProviderServiceCommand, se_GetProviderServiceCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetProviderServiceCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetProviderServiceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "EntityResolutionClient";
+        const commandName = "GetProviderServiceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSVeniceService",
+                operation: "GetProviderService",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetProviderServiceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetProviderServiceCommand(output, context);
+    }
+}

package/dist-es/commands/ListIdMappingJobsCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListIdMappingJobsCommand, se_ListIdMappingJobsCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListIdMappingJobsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListIdMappingJobsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "EntityResolutionClient";
+        const commandName = "ListIdMappingJobsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSVeniceService",
+                operation: "ListIdMappingJobs",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListIdMappingJobsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListIdMappingJobsCommand(output, context);
+    }
+}

package/dist-es/commands/ListIdMappingWorkflowsCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListIdMappingWorkflowsCommand, se_ListIdMappingWorkflowsCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListIdMappingWorkflowsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListIdMappingWorkflowsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "EntityResolutionClient";
+        const commandName = "ListIdMappingWorkflowsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSVeniceService",
+                operation: "ListIdMappingWorkflows",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListIdMappingWorkflowsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListIdMappingWorkflowsCommand(output, context);
+    }
+}

package/dist-es/commands/ListProviderServicesCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_ListProviderServicesCommand, se_ListProviderServicesCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListProviderServicesCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListProviderServicesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "EntityResolutionClient";
+        const commandName = "ListProviderServicesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSVeniceService",
+                operation: "ListProviderServices",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListProviderServicesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListProviderServicesCommand(output, context);
+    }
+}

package/dist-es/commands/StartIdMappingJobCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_StartIdMappingJobCommand, se_StartIdMappingJobCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class StartIdMappingJobCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, StartIdMappingJobCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "EntityResolutionClient";
+        const commandName = "StartIdMappingJobCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSVeniceService",
+                operation: "StartIdMappingJob",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_StartIdMappingJobCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_StartIdMappingJobCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateIdMappingWorkflowCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_UpdateIdMappingWorkflowCommand, se_UpdateIdMappingWorkflowCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateIdMappingWorkflowCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateIdMappingWorkflowCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "EntityResolutionClient";
+        const commandName = "UpdateIdMappingWorkflowCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSVeniceService",
+                operation: "UpdateIdMappingWorkflow",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateIdMappingWorkflowCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateIdMappingWorkflowCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateSchemaMappingCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_UpdateSchemaMappingCommand, se_UpdateSchemaMappingCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateSchemaMappingCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateSchemaMappingCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "EntityResolutionClient";
+        const commandName = "UpdateSchemaMappingCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AWSVeniceService",
+                operation: "UpdateSchemaMapping",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateSchemaMappingCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateSchemaMappingCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -1,16 +1,27 @@
+export * from "./CreateIdMappingWorkflowCommand";
 export * from "./CreateMatchingWorkflowCommand";
 export * from "./CreateSchemaMappingCommand";
+export * from "./DeleteIdMappingWorkflowCommand";
 export * from "./DeleteMatchingWorkflowCommand";
 export * from "./DeleteSchemaMappingCommand";
+export * from "./GetIdMappingJobCommand";
+export * from "./GetIdMappingWorkflowCommand";
 export * from "./GetMatchIdCommand";
 export * from "./GetMatchingJobCommand";
 export * from "./GetMatchingWorkflowCommand";
+export * from "./GetProviderServiceCommand";
 export * from "./GetSchemaMappingCommand";
+export * from "./ListIdMappingJobsCommand";
+export * from "./ListIdMappingWorkflowsCommand";
 export * from "./ListMatchingJobsCommand";
 export * from "./ListMatchingWorkflowsCommand";
+export * from "./ListProviderServicesCommand";
 export * from "./ListSchemaMappingsCommand";
 export * from "./ListTagsForResourceCommand";
+export * from "./StartIdMappingJobCommand";
 export * from "./StartMatchingJobCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";
+export * from "./UpdateIdMappingWorkflowCommand";
 export * from "./UpdateMatchingWorkflowCommand";
+export * from "./UpdateSchemaMappingCommand";

package/dist-es/endpoint/ruleset.js

@@ -1,4 +1,4 @@
-const q = "required", r = "fn", s = "argv", t = "ref";
-const a = "isSet", b = "tree", c = "error", d = "endpoint", e = "PartitionResult", f = { [q]: false, "type": "String" }, g = { [q]: true, "default": false, "type": "Boolean" }, h = { [t]: "Endpoint" }, i = { [r]: "booleanEquals", [s]: [{ [t]: "UseFIPS" }, true] }, j = { [r]: "booleanEquals", [s]: [{ [t]: "UseDualStack" }, true] }, k = {}, l = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsFIPS"] }] }, m = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsDualStack"] }] }, n = [i], o = [j], p = [{ [t]: "Region" }];
-const _data = { version: "1.0", parameters: { Region: f, UseDualStack: g, UseFIPS: g, Endpoint: f }, rules: [{ conditions: [{ [r]: a, [s]: [h] }], type: b, rules: [{ conditions: n, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: o, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: h, properties: k, headers: k }, type: d }] }] }, { type: b, rules: [{ conditions: [{ [r]: a, [s]: p }], type: b, rules: [{ conditions: [{ [r]: "aws.partition", [s]: p, assign: e }], type: b, rules: [{ conditions: [i, j], type: b, rules: [{ conditions: [l, m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://entityresolution-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: n, type: b, rules: [{ conditions: [l], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://entityresolution-fips.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: o, type: b, rules: [{ conditions: [m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://entityresolution.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { type: b, rules: [{ endpoint: { url: "https://entityresolution.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }] }, { error: "Invalid Configuration: Missing Region", type: c }] }] };
+const s = "required", t = "fn", u = "argv", v = "ref";
+const a = true, b = "isSet", c = "booleanEquals", d = "error", e = "endpoint", f = "tree", g = "PartitionResult", h = { [s]: false, "type": "String" }, i = { [s]: true, "default": false, "type": "Boolean" }, j = { [v]: "Endpoint" }, k = { [t]: c, [u]: [{ [v]: "UseFIPS" }, true] }, l = { [t]: c, [u]: [{ [v]: "UseDualStack" }, true] }, m = {}, n = { [t]: "getAttr", [u]: [{ [v]: g }, "supportsFIPS"] }, o = { [t]: c, [u]: [true, { [t]: "getAttr", [u]: [{ [v]: g }, "supportsDualStack"] }] }, p = [k], q = [l], r = [{ [v]: "Region" }];
+const _data = { version: "1.0", parameters: { Region: h, UseDualStack: i, UseFIPS: i, Endpoint: h }, rules: [{ conditions: [{ [t]: b, [u]: [j] }], rules: [{ conditions: p, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d }, { rules: [{ conditions: q, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d }, { endpoint: { url: j, properties: m, headers: m }, type: e }], type: f }], type: f }, { rules: [{ conditions: [{ [t]: b, [u]: r }], rules: [{ conditions: [{ [t]: "aws.partition", [u]: r, assign: g }], rules: [{ conditions: [k, l], rules: [{ conditions: [{ [t]: c, [u]: [a, n] }, o], rules: [{ rules: [{ endpoint: { url: "https://entityresolution-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d }], type: f }, { conditions: p, rules: [{ conditions: [{ [t]: c, [u]: [n, a] }], rules: [{ rules: [{ endpoint: { url: "https://entityresolution-fips.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }, { error: "FIPS is enabled but this partition does not support FIPS", type: d }], type: f }, { conditions: q, rules: [{ conditions: [o], rules: [{ rules: [{ endpoint: { url: "https://entityresolution.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }, { error: "DualStack is enabled but this partition does not support DualStack", type: d }], type: f }, { rules: [{ endpoint: { url: "https://entityresolution.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }], type: f }, { error: "Invalid Configuration: Missing Region", type: d }], type: f }] };
 export const ruleSet = _data;