@aws-sdk/client-customer-profiles 3.183.0 → 3.186.0

package/dist-es/commands/DeleteProfileObjectTypeCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteProfileObjectTypeRequestFilterSensitiveLog, DeleteProfileObjectTypeResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeleteProfileObjectTypeCommand, serializeAws_restJson1DeleteProfileObjectTypeCommand, } from "../protocols/Aws_restJson1";
-export class DeleteProfileObjectTypeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteProfileObjectTypeCommand = (function (_super) {
+    __extends(DeleteProfileObjectTypeCommand, _super);
+    function DeleteProfileObjectTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteProfileObjectTypeCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CustomerProfilesClient";
-        const commandName = "DeleteProfileObjectTypeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CustomerProfilesClient";
+        var commandName = "DeleteProfileObjectTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteProfileObjectTypeRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteProfileObjectTypeResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteProfileObjectTypeCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteProfileObjectTypeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteProfileObjectTypeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteProfileObjectTypeCommand(output, context);
-    }
-}
+    };
+    return DeleteProfileObjectTypeCommand;
+}($Command));
+export { DeleteProfileObjectTypeCommand };

package/dist-es/commands/DeleteWorkflowCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteWorkflowRequestFilterSensitiveLog, DeleteWorkflowResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeleteWorkflowCommand, serializeAws_restJson1DeleteWorkflowCommand, } from "../protocols/Aws_restJson1";
-export class DeleteWorkflowCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteWorkflowCommand = (function (_super) {
+    __extends(DeleteWorkflowCommand, _super);
+    function DeleteWorkflowCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteWorkflowCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CustomerProfilesClient";
-        const commandName = "DeleteWorkflowCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CustomerProfilesClient";
+        var commandName = "DeleteWorkflowCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteWorkflowRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteWorkflowResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteWorkflowCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteWorkflowCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteWorkflowCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteWorkflowCommand(output, context);
-    }
-}
+    };
+    return DeleteWorkflowCommand;
+}($Command));
+export { DeleteWorkflowCommand };

package/dist-es/commands/GetAutoMergingPreviewCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetAutoMergingPreviewRequestFilterSensitiveLog, GetAutoMergingPreviewResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetAutoMergingPreviewCommand, serializeAws_restJson1GetAutoMergingPreviewCommand, } from "../protocols/Aws_restJson1";
-export class GetAutoMergingPreviewCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetAutoMergingPreviewCommand = (function (_super) {
+    __extends(GetAutoMergingPreviewCommand, _super);
+    function GetAutoMergingPreviewCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetAutoMergingPreviewCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CustomerProfilesClient";
-        const commandName = "GetAutoMergingPreviewCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CustomerProfilesClient";
+        var commandName = "GetAutoMergingPreviewCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetAutoMergingPreviewRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetAutoMergingPreviewResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetAutoMergingPreviewCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetAutoMergingPreviewCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetAutoMergingPreviewCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetAutoMergingPreviewCommand(output, context);
-    }
-}
+    };
+    return GetAutoMergingPreviewCommand;
+}($Command));
+export { GetAutoMergingPreviewCommand };

package/dist-es/commands/GetDomainCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetDomainRequestFilterSensitiveLog, GetDomainResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetDomainCommand, serializeAws_restJson1GetDomainCommand, } from "../protocols/Aws_restJson1";
-export class GetDomainCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetDomainCommand = (function (_super) {
+    __extends(GetDomainCommand, _super);
+    function GetDomainCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetDomainCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CustomerProfilesClient";
-        const commandName = "GetDomainCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CustomerProfilesClient";
+        var commandName = "GetDomainCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetDomainRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetDomainResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetDomainCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetDomainCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetDomainCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetDomainCommand(output, context);
-    }
-}
+    };
+    return GetDomainCommand;
+}($Command));
+export { GetDomainCommand };

package/dist-es/commands/GetIdentityResolutionJobCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetIdentityResolutionJobRequestFilterSensitiveLog, GetIdentityResolutionJobResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetIdentityResolutionJobCommand, serializeAws_restJson1GetIdentityResolutionJobCommand, } from "../protocols/Aws_restJson1";
-export class GetIdentityResolutionJobCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetIdentityResolutionJobCommand = (function (_super) {
+    __extends(GetIdentityResolutionJobCommand, _super);
+    function GetIdentityResolutionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetIdentityResolutionJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CustomerProfilesClient";
-        const commandName = "GetIdentityResolutionJobCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CustomerProfilesClient";
+        var commandName = "GetIdentityResolutionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetIdentityResolutionJobRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetIdentityResolutionJobResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetIdentityResolutionJobCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetIdentityResolutionJobCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetIdentityResolutionJobCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetIdentityResolutionJobCommand(output, context);
-    }
-}
+    };
+    return GetIdentityResolutionJobCommand;
+}($Command));
+export { GetIdentityResolutionJobCommand };

package/dist-es/commands/GetIntegrationCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetIntegrationRequestFilterSensitiveLog, GetIntegrationResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetIntegrationCommand, serializeAws_restJson1GetIntegrationCommand, } from "../protocols/Aws_restJson1";
-export class GetIntegrationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetIntegrationCommand = (function (_super) {
+    __extends(GetIntegrationCommand, _super);
+    function GetIntegrationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetIntegrationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CustomerProfilesClient";
-        const commandName = "GetIntegrationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CustomerProfilesClient";
+        var commandName = "GetIntegrationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetIntegrationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetIntegrationResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetIntegrationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetIntegrationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetIntegrationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetIntegrationCommand(output, context);
-    }
-}
+    };
+    return GetIntegrationCommand;
+}($Command));
+export { GetIntegrationCommand };

package/dist-es/commands/GetMatchesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetMatchesRequestFilterSensitiveLog, GetMatchesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetMatchesCommand, serializeAws_restJson1GetMatchesCommand, } from "../protocols/Aws_restJson1";
-export class GetMatchesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetMatchesCommand = (function (_super) {
+    __extends(GetMatchesCommand, _super);
+    function GetMatchesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetMatchesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CustomerProfilesClient";
-        const commandName = "GetMatchesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CustomerProfilesClient";
+        var commandName = "GetMatchesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetMatchesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetMatchesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetMatchesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetMatchesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetMatchesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetMatchesCommand(output, context);
-    }
-}
+    };
+    return GetMatchesCommand;
+}($Command));
+export { GetMatchesCommand };

package/dist-es/commands/GetProfileObjectTypeCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetProfileObjectTypeRequestFilterSensitiveLog, GetProfileObjectTypeResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetProfileObjectTypeCommand, serializeAws_restJson1GetProfileObjectTypeCommand, } from "../protocols/Aws_restJson1";
-export class GetProfileObjectTypeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetProfileObjectTypeCommand = (function (_super) {
+    __extends(GetProfileObjectTypeCommand, _super);
+    function GetProfileObjectTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetProfileObjectTypeCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CustomerProfilesClient";
-        const commandName = "GetProfileObjectTypeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CustomerProfilesClient";
+        var commandName = "GetProfileObjectTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetProfileObjectTypeRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetProfileObjectTypeResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetProfileObjectTypeCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetProfileObjectTypeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetProfileObjectTypeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetProfileObjectTypeCommand(output, context);
-    }
-}
+    };
+    return GetProfileObjectTypeCommand;
+}($Command));
+export { GetProfileObjectTypeCommand };

package/dist-es/commands/GetProfileObjectTypeTemplateCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetProfileObjectTypeTemplateRequestFilterSensitiveLog, GetProfileObjectTypeTemplateResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetProfileObjectTypeTemplateCommand, serializeAws_restJson1GetProfileObjectTypeTemplateCommand, } from "../protocols/Aws_restJson1";
-export class GetProfileObjectTypeTemplateCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetProfileObjectTypeTemplateCommand = (function (_super) {
+    __extends(GetProfileObjectTypeTemplateCommand, _super);
+    function GetProfileObjectTypeTemplateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetProfileObjectTypeTemplateCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CustomerProfilesClient";
-        const commandName = "GetProfileObjectTypeTemplateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CustomerProfilesClient";
+        var commandName = "GetProfileObjectTypeTemplateCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetProfileObjectTypeTemplateRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetProfileObjectTypeTemplateResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetProfileObjectTypeTemplateCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetProfileObjectTypeTemplateCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetProfileObjectTypeTemplateCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetProfileObjectTypeTemplateCommand(output, context);
-    }
-}
+    };
+    return GetProfileObjectTypeTemplateCommand;
+}($Command));
+export { GetProfileObjectTypeTemplateCommand };

package/dist-es/commands/GetWorkflowCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetWorkflowRequestFilterSensitiveLog, GetWorkflowResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetWorkflowCommand, serializeAws_restJson1GetWorkflowCommand, } from "../protocols/Aws_restJson1";
-export class GetWorkflowCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetWorkflowCommand = (function (_super) {
+    __extends(GetWorkflowCommand, _super);
+    function GetWorkflowCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetWorkflowCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CustomerProfilesClient";
-        const commandName = "GetWorkflowCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "CustomerProfilesClient";
+        var commandName = "GetWorkflowCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetWorkflowRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetWorkflowResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetWorkflowCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetWorkflowCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetWorkflowCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetWorkflowCommand(output, context);
-    }
-}
+    };
+    return GetWorkflowCommand;
+}($Command));
+export { GetWorkflowCommand };