@aws-sdk/client-pinpoint 3.183.0 → 3.185.0

package/dist-es/commands/UpdateApplicationSettingsCommand.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 { UpdateApplicationSettingsRequestFilterSensitiveLog, UpdateApplicationSettingsResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1UpdateApplicationSettingsCommand, serializeAws_restJson1UpdateApplicationSettingsCommand, } from "../protocols/Aws_restJson1";
-export class UpdateApplicationSettingsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateApplicationSettingsCommand = (function (_super) {
+    __extends(UpdateApplicationSettingsCommand, _super);
+    function UpdateApplicationSettingsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateApplicationSettingsCommand.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 = "PinpointClient";
-        const commandName = "UpdateApplicationSettingsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "PinpointClient";
+        var commandName = "UpdateApplicationSettingsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateApplicationSettingsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateApplicationSettingsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateApplicationSettingsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateApplicationSettingsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateApplicationSettingsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateApplicationSettingsCommand(output, context);
-    }
-}
+    };
+    return UpdateApplicationSettingsCommand;
+}($Command));
+export { UpdateApplicationSettingsCommand };

package/dist-es/commands/UpdateBaiduChannelCommand.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 { UpdateBaiduChannelRequestFilterSensitiveLog, UpdateBaiduChannelResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1UpdateBaiduChannelCommand, serializeAws_restJson1UpdateBaiduChannelCommand, } from "../protocols/Aws_restJson1";
-export class UpdateBaiduChannelCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateBaiduChannelCommand = (function (_super) {
+    __extends(UpdateBaiduChannelCommand, _super);
+    function UpdateBaiduChannelCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateBaiduChannelCommand.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 = "PinpointClient";
-        const commandName = "UpdateBaiduChannelCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "PinpointClient";
+        var commandName = "UpdateBaiduChannelCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateBaiduChannelRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateBaiduChannelResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateBaiduChannelCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateBaiduChannelCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateBaiduChannelCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateBaiduChannelCommand(output, context);
-    }
-}
+    };
+    return UpdateBaiduChannelCommand;
+}($Command));
+export { UpdateBaiduChannelCommand };

package/dist-es/commands/UpdateCampaignCommand.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 { UpdateCampaignRequestFilterSensitiveLog, UpdateCampaignResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1UpdateCampaignCommand, serializeAws_restJson1UpdateCampaignCommand, } from "../protocols/Aws_restJson1";
-export class UpdateCampaignCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateCampaignCommand = (function (_super) {
+    __extends(UpdateCampaignCommand, _super);
+    function UpdateCampaignCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateCampaignCommand.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 = "PinpointClient";
-        const commandName = "UpdateCampaignCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "PinpointClient";
+        var commandName = "UpdateCampaignCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateCampaignRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateCampaignResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateCampaignCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateCampaignCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateCampaignCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateCampaignCommand(output, context);
-    }
-}
+    };
+    return UpdateCampaignCommand;
+}($Command));
+export { UpdateCampaignCommand };

package/dist-es/commands/UpdateEmailChannelCommand.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 { UpdateEmailChannelRequestFilterSensitiveLog, UpdateEmailChannelResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1UpdateEmailChannelCommand, serializeAws_restJson1UpdateEmailChannelCommand, } from "../protocols/Aws_restJson1";
-export class UpdateEmailChannelCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateEmailChannelCommand = (function (_super) {
+    __extends(UpdateEmailChannelCommand, _super);
+    function UpdateEmailChannelCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateEmailChannelCommand.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 = "PinpointClient";
-        const commandName = "UpdateEmailChannelCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "PinpointClient";
+        var commandName = "UpdateEmailChannelCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateEmailChannelRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateEmailChannelResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateEmailChannelCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateEmailChannelCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateEmailChannelCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateEmailChannelCommand(output, context);
-    }
-}
+    };
+    return UpdateEmailChannelCommand;
+}($Command));
+export { UpdateEmailChannelCommand };

package/dist-es/commands/UpdateEmailTemplateCommand.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 { UpdateEmailTemplateRequestFilterSensitiveLog, UpdateEmailTemplateResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1UpdateEmailTemplateCommand, serializeAws_restJson1UpdateEmailTemplateCommand, } from "../protocols/Aws_restJson1";
-export class UpdateEmailTemplateCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateEmailTemplateCommand = (function (_super) {
+    __extends(UpdateEmailTemplateCommand, _super);
+    function UpdateEmailTemplateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateEmailTemplateCommand.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 = "PinpointClient";
-        const commandName = "UpdateEmailTemplateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "PinpointClient";
+        var commandName = "UpdateEmailTemplateCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateEmailTemplateRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateEmailTemplateResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateEmailTemplateCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateEmailTemplateCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateEmailTemplateCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateEmailTemplateCommand(output, context);
-    }
-}
+    };
+    return UpdateEmailTemplateCommand;
+}($Command));
+export { UpdateEmailTemplateCommand };

package/dist-es/commands/UpdateEndpointCommand.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 { UpdateEndpointRequestFilterSensitiveLog, UpdateEndpointResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1UpdateEndpointCommand, serializeAws_restJson1UpdateEndpointCommand, } from "../protocols/Aws_restJson1";
-export class UpdateEndpointCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateEndpointCommand = (function (_super) {
+    __extends(UpdateEndpointCommand, _super);
+    function UpdateEndpointCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateEndpointCommand.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 = "PinpointClient";
-        const commandName = "UpdateEndpointCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "PinpointClient";
+        var commandName = "UpdateEndpointCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateEndpointRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateEndpointResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateEndpointCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateEndpointCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateEndpointCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateEndpointCommand(output, context);
-    }
-}
+    };
+    return UpdateEndpointCommand;
+}($Command));
+export { UpdateEndpointCommand };

package/dist-es/commands/UpdateEndpointsBatchCommand.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 { UpdateEndpointsBatchRequestFilterSensitiveLog, UpdateEndpointsBatchResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1UpdateEndpointsBatchCommand, serializeAws_restJson1UpdateEndpointsBatchCommand, } from "../protocols/Aws_restJson1";
-export class UpdateEndpointsBatchCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateEndpointsBatchCommand = (function (_super) {
+    __extends(UpdateEndpointsBatchCommand, _super);
+    function UpdateEndpointsBatchCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateEndpointsBatchCommand.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 = "PinpointClient";
-        const commandName = "UpdateEndpointsBatchCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "PinpointClient";
+        var commandName = "UpdateEndpointsBatchCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateEndpointsBatchRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateEndpointsBatchResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateEndpointsBatchCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateEndpointsBatchCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateEndpointsBatchCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateEndpointsBatchCommand(output, context);
-    }
-}
+    };
+    return UpdateEndpointsBatchCommand;
+}($Command));
+export { UpdateEndpointsBatchCommand };

package/dist-es/commands/UpdateGcmChannelCommand.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 { UpdateGcmChannelRequestFilterSensitiveLog, UpdateGcmChannelResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1UpdateGcmChannelCommand, serializeAws_restJson1UpdateGcmChannelCommand, } from "../protocols/Aws_restJson1";
-export class UpdateGcmChannelCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateGcmChannelCommand = (function (_super) {
+    __extends(UpdateGcmChannelCommand, _super);
+    function UpdateGcmChannelCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateGcmChannelCommand.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 = "PinpointClient";
-        const commandName = "UpdateGcmChannelCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "PinpointClient";
+        var commandName = "UpdateGcmChannelCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateGcmChannelRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateGcmChannelResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateGcmChannelCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateGcmChannelCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateGcmChannelCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateGcmChannelCommand(output, context);
-    }
-}
+    };
+    return UpdateGcmChannelCommand;
+}($Command));
+export { UpdateGcmChannelCommand };

package/dist-es/commands/UpdateInAppTemplateCommand.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 { UpdateInAppTemplateRequestFilterSensitiveLog, UpdateInAppTemplateResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1UpdateInAppTemplateCommand, serializeAws_restJson1UpdateInAppTemplateCommand, } from "../protocols/Aws_restJson1";
-export class UpdateInAppTemplateCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateInAppTemplateCommand = (function (_super) {
+    __extends(UpdateInAppTemplateCommand, _super);
+    function UpdateInAppTemplateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateInAppTemplateCommand.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 = "PinpointClient";
-        const commandName = "UpdateInAppTemplateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "PinpointClient";
+        var commandName = "UpdateInAppTemplateCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateInAppTemplateRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateInAppTemplateResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateInAppTemplateCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateInAppTemplateCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateInAppTemplateCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateInAppTemplateCommand(output, context);
-    }
-}
+    };
+    return UpdateInAppTemplateCommand;
+}($Command));
+export { UpdateInAppTemplateCommand };

package/dist-es/commands/UpdateJourneyCommand.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 { UpdateJourneyRequestFilterSensitiveLog, UpdateJourneyResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restJson1UpdateJourneyCommand, serializeAws_restJson1UpdateJourneyCommand, } from "../protocols/Aws_restJson1";
-export class UpdateJourneyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateJourneyCommand = (function (_super) {
+    __extends(UpdateJourneyCommand, _super);
+    function UpdateJourneyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateJourneyCommand.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 = "PinpointClient";
-        const commandName = "UpdateJourneyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "PinpointClient";
+        var commandName = "UpdateJourneyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: UpdateJourneyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateJourneyResponseFilterSensitiveLog,
         };
-        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);
+    };
+    UpdateJourneyCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1UpdateJourneyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    UpdateJourneyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateJourneyCommand(output, context);
-    }
-}
+    };
+    return UpdateJourneyCommand;
+}($Command));
+export { UpdateJourneyCommand };