@aws-sdk/client-pinpoint 3.183.0 → 3.185.0

package/dist-es/Pinpoint.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { CreateAppCommand } from "./commands/CreateAppCommand";
 import { CreateCampaignCommand, } from "./commands/CreateCampaignCommand";
 import { CreateEmailTemplateCommand, } from "./commands/CreateEmailTemplateCommand";
@@ -118,1671 +119,1677 @@ import { UpdateVoiceChannelCommand, } from "./commands/UpdateVoiceChannelCommand
 import { UpdateVoiceTemplateCommand, } from "./commands/UpdateVoiceTemplateCommand";
 import { VerifyOTPMessageCommand, } from "./commands/VerifyOTPMessageCommand";
 import { PinpointClient } from "./PinpointClient";
-export class Pinpoint extends PinpointClient {
-    createApp(args, optionsOrCb, cb) {
-        const command = new CreateAppCommand(args);
+var Pinpoint = (function (_super) {
+    __extends(Pinpoint, _super);
+    function Pinpoint() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Pinpoint.prototype.createApp = function (args, optionsOrCb, cb) {
+        var command = new CreateAppCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createCampaign(args, optionsOrCb, cb) {
-        const command = new CreateCampaignCommand(args);
+    };
+    Pinpoint.prototype.createCampaign = function (args, optionsOrCb, cb) {
+        var command = new CreateCampaignCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createEmailTemplate(args, optionsOrCb, cb) {
-        const command = new CreateEmailTemplateCommand(args);
+    };
+    Pinpoint.prototype.createEmailTemplate = function (args, optionsOrCb, cb) {
+        var command = new CreateEmailTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createExportJob(args, optionsOrCb, cb) {
-        const command = new CreateExportJobCommand(args);
+    };
+    Pinpoint.prototype.createExportJob = function (args, optionsOrCb, cb) {
+        var command = new CreateExportJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createImportJob(args, optionsOrCb, cb) {
-        const command = new CreateImportJobCommand(args);
+    };
+    Pinpoint.prototype.createImportJob = function (args, optionsOrCb, cb) {
+        var command = new CreateImportJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createInAppTemplate(args, optionsOrCb, cb) {
-        const command = new CreateInAppTemplateCommand(args);
+    };
+    Pinpoint.prototype.createInAppTemplate = function (args, optionsOrCb, cb) {
+        var command = new CreateInAppTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createJourney(args, optionsOrCb, cb) {
-        const command = new CreateJourneyCommand(args);
+    };
+    Pinpoint.prototype.createJourney = function (args, optionsOrCb, cb) {
+        var command = new CreateJourneyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createPushTemplate(args, optionsOrCb, cb) {
-        const command = new CreatePushTemplateCommand(args);
+    };
+    Pinpoint.prototype.createPushTemplate = function (args, optionsOrCb, cb) {
+        var command = new CreatePushTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createRecommenderConfiguration(args, optionsOrCb, cb) {
-        const command = new CreateRecommenderConfigurationCommand(args);
+    };
+    Pinpoint.prototype.createRecommenderConfiguration = function (args, optionsOrCb, cb) {
+        var command = new CreateRecommenderConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createSegment(args, optionsOrCb, cb) {
-        const command = new CreateSegmentCommand(args);
+    };
+    Pinpoint.prototype.createSegment = function (args, optionsOrCb, cb) {
+        var command = new CreateSegmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createSmsTemplate(args, optionsOrCb, cb) {
-        const command = new CreateSmsTemplateCommand(args);
+    };
+    Pinpoint.prototype.createSmsTemplate = function (args, optionsOrCb, cb) {
+        var command = new CreateSmsTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createVoiceTemplate(args, optionsOrCb, cb) {
-        const command = new CreateVoiceTemplateCommand(args);
+    };
+    Pinpoint.prototype.createVoiceTemplate = function (args, optionsOrCb, cb) {
+        var command = new CreateVoiceTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteAdmChannel(args, optionsOrCb, cb) {
-        const command = new DeleteAdmChannelCommand(args);
+    };
+    Pinpoint.prototype.deleteAdmChannel = function (args, optionsOrCb, cb) {
+        var command = new DeleteAdmChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteApnsChannel(args, optionsOrCb, cb) {
-        const command = new DeleteApnsChannelCommand(args);
+    };
+    Pinpoint.prototype.deleteApnsChannel = function (args, optionsOrCb, cb) {
+        var command = new DeleteApnsChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteApnsSandboxChannel(args, optionsOrCb, cb) {
-        const command = new DeleteApnsSandboxChannelCommand(args);
+    };
+    Pinpoint.prototype.deleteApnsSandboxChannel = function (args, optionsOrCb, cb) {
+        var command = new DeleteApnsSandboxChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteApnsVoipChannel(args, optionsOrCb, cb) {
-        const command = new DeleteApnsVoipChannelCommand(args);
+    };
+    Pinpoint.prototype.deleteApnsVoipChannel = function (args, optionsOrCb, cb) {
+        var command = new DeleteApnsVoipChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteApnsVoipSandboxChannel(args, optionsOrCb, cb) {
-        const command = new DeleteApnsVoipSandboxChannelCommand(args);
+    };
+    Pinpoint.prototype.deleteApnsVoipSandboxChannel = function (args, optionsOrCb, cb) {
+        var command = new DeleteApnsVoipSandboxChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteApp(args, optionsOrCb, cb) {
-        const command = new DeleteAppCommand(args);
+    };
+    Pinpoint.prototype.deleteApp = function (args, optionsOrCb, cb) {
+        var command = new DeleteAppCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteBaiduChannel(args, optionsOrCb, cb) {
-        const command = new DeleteBaiduChannelCommand(args);
+    };
+    Pinpoint.prototype.deleteBaiduChannel = function (args, optionsOrCb, cb) {
+        var command = new DeleteBaiduChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteCampaign(args, optionsOrCb, cb) {
-        const command = new DeleteCampaignCommand(args);
+    };
+    Pinpoint.prototype.deleteCampaign = function (args, optionsOrCb, cb) {
+        var command = new DeleteCampaignCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteEmailChannel(args, optionsOrCb, cb) {
-        const command = new DeleteEmailChannelCommand(args);
+    };
+    Pinpoint.prototype.deleteEmailChannel = function (args, optionsOrCb, cb) {
+        var command = new DeleteEmailChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteEmailTemplate(args, optionsOrCb, cb) {
-        const command = new DeleteEmailTemplateCommand(args);
+    };
+    Pinpoint.prototype.deleteEmailTemplate = function (args, optionsOrCb, cb) {
+        var command = new DeleteEmailTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteEndpoint(args, optionsOrCb, cb) {
-        const command = new DeleteEndpointCommand(args);
+    };
+    Pinpoint.prototype.deleteEndpoint = function (args, optionsOrCb, cb) {
+        var command = new DeleteEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteEventStream(args, optionsOrCb, cb) {
-        const command = new DeleteEventStreamCommand(args);
+    };
+    Pinpoint.prototype.deleteEventStream = function (args, optionsOrCb, cb) {
+        var command = new DeleteEventStreamCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteGcmChannel(args, optionsOrCb, cb) {
-        const command = new DeleteGcmChannelCommand(args);
+    };
+    Pinpoint.prototype.deleteGcmChannel = function (args, optionsOrCb, cb) {
+        var command = new DeleteGcmChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteInAppTemplate(args, optionsOrCb, cb) {
-        const command = new DeleteInAppTemplateCommand(args);
+    };
+    Pinpoint.prototype.deleteInAppTemplate = function (args, optionsOrCb, cb) {
+        var command = new DeleteInAppTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteJourney(args, optionsOrCb, cb) {
-        const command = new DeleteJourneyCommand(args);
+    };
+    Pinpoint.prototype.deleteJourney = function (args, optionsOrCb, cb) {
+        var command = new DeleteJourneyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deletePushTemplate(args, optionsOrCb, cb) {
-        const command = new DeletePushTemplateCommand(args);
+    };
+    Pinpoint.prototype.deletePushTemplate = function (args, optionsOrCb, cb) {
+        var command = new DeletePushTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteRecommenderConfiguration(args, optionsOrCb, cb) {
-        const command = new DeleteRecommenderConfigurationCommand(args);
+    };
+    Pinpoint.prototype.deleteRecommenderConfiguration = function (args, optionsOrCb, cb) {
+        var command = new DeleteRecommenderConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteSegment(args, optionsOrCb, cb) {
-        const command = new DeleteSegmentCommand(args);
+    };
+    Pinpoint.prototype.deleteSegment = function (args, optionsOrCb, cb) {
+        var command = new DeleteSegmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteSmsChannel(args, optionsOrCb, cb) {
-        const command = new DeleteSmsChannelCommand(args);
+    };
+    Pinpoint.prototype.deleteSmsChannel = function (args, optionsOrCb, cb) {
+        var command = new DeleteSmsChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteSmsTemplate(args, optionsOrCb, cb) {
-        const command = new DeleteSmsTemplateCommand(args);
+    };
+    Pinpoint.prototype.deleteSmsTemplate = function (args, optionsOrCb, cb) {
+        var command = new DeleteSmsTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteUserEndpoints(args, optionsOrCb, cb) {
-        const command = new DeleteUserEndpointsCommand(args);
+    };
+    Pinpoint.prototype.deleteUserEndpoints = function (args, optionsOrCb, cb) {
+        var command = new DeleteUserEndpointsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteVoiceChannel(args, optionsOrCb, cb) {
-        const command = new DeleteVoiceChannelCommand(args);
+    };
+    Pinpoint.prototype.deleteVoiceChannel = function (args, optionsOrCb, cb) {
+        var command = new DeleteVoiceChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteVoiceTemplate(args, optionsOrCb, cb) {
-        const command = new DeleteVoiceTemplateCommand(args);
+    };
+    Pinpoint.prototype.deleteVoiceTemplate = function (args, optionsOrCb, cb) {
+        var command = new DeleteVoiceTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getAdmChannel(args, optionsOrCb, cb) {
-        const command = new GetAdmChannelCommand(args);
+    };
+    Pinpoint.prototype.getAdmChannel = function (args, optionsOrCb, cb) {
+        var command = new GetAdmChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getApnsChannel(args, optionsOrCb, cb) {
-        const command = new GetApnsChannelCommand(args);
+    };
+    Pinpoint.prototype.getApnsChannel = function (args, optionsOrCb, cb) {
+        var command = new GetApnsChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getApnsSandboxChannel(args, optionsOrCb, cb) {
-        const command = new GetApnsSandboxChannelCommand(args);
+    };
+    Pinpoint.prototype.getApnsSandboxChannel = function (args, optionsOrCb, cb) {
+        var command = new GetApnsSandboxChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getApnsVoipChannel(args, optionsOrCb, cb) {
-        const command = new GetApnsVoipChannelCommand(args);
+    };
+    Pinpoint.prototype.getApnsVoipChannel = function (args, optionsOrCb, cb) {
+        var command = new GetApnsVoipChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getApnsVoipSandboxChannel(args, optionsOrCb, cb) {
-        const command = new GetApnsVoipSandboxChannelCommand(args);
+    };
+    Pinpoint.prototype.getApnsVoipSandboxChannel = function (args, optionsOrCb, cb) {
+        var command = new GetApnsVoipSandboxChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getApp(args, optionsOrCb, cb) {
-        const command = new GetAppCommand(args);
+    };
+    Pinpoint.prototype.getApp = function (args, optionsOrCb, cb) {
+        var command = new GetAppCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getApplicationDateRangeKpi(args, optionsOrCb, cb) {
-        const command = new GetApplicationDateRangeKpiCommand(args);
+    };
+    Pinpoint.prototype.getApplicationDateRangeKpi = function (args, optionsOrCb, cb) {
+        var command = new GetApplicationDateRangeKpiCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getApplicationSettings(args, optionsOrCb, cb) {
-        const command = new GetApplicationSettingsCommand(args);
+    };
+    Pinpoint.prototype.getApplicationSettings = function (args, optionsOrCb, cb) {
+        var command = new GetApplicationSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getApps(args, optionsOrCb, cb) {
-        const command = new GetAppsCommand(args);
+    };
+    Pinpoint.prototype.getApps = function (args, optionsOrCb, cb) {
+        var command = new GetAppsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBaiduChannel(args, optionsOrCb, cb) {
-        const command = new GetBaiduChannelCommand(args);
+    };
+    Pinpoint.prototype.getBaiduChannel = function (args, optionsOrCb, cb) {
+        var command = new GetBaiduChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCampaign(args, optionsOrCb, cb) {
-        const command = new GetCampaignCommand(args);
+    };
+    Pinpoint.prototype.getCampaign = function (args, optionsOrCb, cb) {
+        var command = new GetCampaignCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCampaignActivities(args, optionsOrCb, cb) {
-        const command = new GetCampaignActivitiesCommand(args);
+    };
+    Pinpoint.prototype.getCampaignActivities = function (args, optionsOrCb, cb) {
+        var command = new GetCampaignActivitiesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCampaignDateRangeKpi(args, optionsOrCb, cb) {
-        const command = new GetCampaignDateRangeKpiCommand(args);
+    };
+    Pinpoint.prototype.getCampaignDateRangeKpi = function (args, optionsOrCb, cb) {
+        var command = new GetCampaignDateRangeKpiCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCampaigns(args, optionsOrCb, cb) {
-        const command = new GetCampaignsCommand(args);
+    };
+    Pinpoint.prototype.getCampaigns = function (args, optionsOrCb, cb) {
+        var command = new GetCampaignsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCampaignVersion(args, optionsOrCb, cb) {
-        const command = new GetCampaignVersionCommand(args);
+    };
+    Pinpoint.prototype.getCampaignVersion = function (args, optionsOrCb, cb) {
+        var command = new GetCampaignVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCampaignVersions(args, optionsOrCb, cb) {
-        const command = new GetCampaignVersionsCommand(args);
+    };
+    Pinpoint.prototype.getCampaignVersions = function (args, optionsOrCb, cb) {
+        var command = new GetCampaignVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getChannels(args, optionsOrCb, cb) {
-        const command = new GetChannelsCommand(args);
+    };
+    Pinpoint.prototype.getChannels = function (args, optionsOrCb, cb) {
+        var command = new GetChannelsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getEmailChannel(args, optionsOrCb, cb) {
-        const command = new GetEmailChannelCommand(args);
+    };
+    Pinpoint.prototype.getEmailChannel = function (args, optionsOrCb, cb) {
+        var command = new GetEmailChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getEmailTemplate(args, optionsOrCb, cb) {
-        const command = new GetEmailTemplateCommand(args);
+    };
+    Pinpoint.prototype.getEmailTemplate = function (args, optionsOrCb, cb) {
+        var command = new GetEmailTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getEndpoint(args, optionsOrCb, cb) {
-        const command = new GetEndpointCommand(args);
+    };
+    Pinpoint.prototype.getEndpoint = function (args, optionsOrCb, cb) {
+        var command = new GetEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getEventStream(args, optionsOrCb, cb) {
-        const command = new GetEventStreamCommand(args);
+    };
+    Pinpoint.prototype.getEventStream = function (args, optionsOrCb, cb) {
+        var command = new GetEventStreamCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getExportJob(args, optionsOrCb, cb) {
-        const command = new GetExportJobCommand(args);
+    };
+    Pinpoint.prototype.getExportJob = function (args, optionsOrCb, cb) {
+        var command = new GetExportJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getExportJobs(args, optionsOrCb, cb) {
-        const command = new GetExportJobsCommand(args);
+    };
+    Pinpoint.prototype.getExportJobs = function (args, optionsOrCb, cb) {
+        var command = new GetExportJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getGcmChannel(args, optionsOrCb, cb) {
-        const command = new GetGcmChannelCommand(args);
+    };
+    Pinpoint.prototype.getGcmChannel = function (args, optionsOrCb, cb) {
+        var command = new GetGcmChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getImportJob(args, optionsOrCb, cb) {
-        const command = new GetImportJobCommand(args);
+    };
+    Pinpoint.prototype.getImportJob = function (args, optionsOrCb, cb) {
+        var command = new GetImportJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getImportJobs(args, optionsOrCb, cb) {
-        const command = new GetImportJobsCommand(args);
+    };
+    Pinpoint.prototype.getImportJobs = function (args, optionsOrCb, cb) {
+        var command = new GetImportJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getInAppMessages(args, optionsOrCb, cb) {
-        const command = new GetInAppMessagesCommand(args);
+    };
+    Pinpoint.prototype.getInAppMessages = function (args, optionsOrCb, cb) {
+        var command = new GetInAppMessagesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getInAppTemplate(args, optionsOrCb, cb) {
-        const command = new GetInAppTemplateCommand(args);
+    };
+    Pinpoint.prototype.getInAppTemplate = function (args, optionsOrCb, cb) {
+        var command = new GetInAppTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getJourney(args, optionsOrCb, cb) {
-        const command = new GetJourneyCommand(args);
+    };
+    Pinpoint.prototype.getJourney = function (args, optionsOrCb, cb) {
+        var command = new GetJourneyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getJourneyDateRangeKpi(args, optionsOrCb, cb) {
-        const command = new GetJourneyDateRangeKpiCommand(args);
+    };
+    Pinpoint.prototype.getJourneyDateRangeKpi = function (args, optionsOrCb, cb) {
+        var command = new GetJourneyDateRangeKpiCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getJourneyExecutionActivityMetrics(args, optionsOrCb, cb) {
-        const command = new GetJourneyExecutionActivityMetricsCommand(args);
+    };
+    Pinpoint.prototype.getJourneyExecutionActivityMetrics = function (args, optionsOrCb, cb) {
+        var command = new GetJourneyExecutionActivityMetricsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getJourneyExecutionMetrics(args, optionsOrCb, cb) {
-        const command = new GetJourneyExecutionMetricsCommand(args);
+    };
+    Pinpoint.prototype.getJourneyExecutionMetrics = function (args, optionsOrCb, cb) {
+        var command = new GetJourneyExecutionMetricsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getPushTemplate(args, optionsOrCb, cb) {
-        const command = new GetPushTemplateCommand(args);
+    };
+    Pinpoint.prototype.getPushTemplate = function (args, optionsOrCb, cb) {
+        var command = new GetPushTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRecommenderConfiguration(args, optionsOrCb, cb) {
-        const command = new GetRecommenderConfigurationCommand(args);
+    };
+    Pinpoint.prototype.getRecommenderConfiguration = function (args, optionsOrCb, cb) {
+        var command = new GetRecommenderConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRecommenderConfigurations(args, optionsOrCb, cb) {
-        const command = new GetRecommenderConfigurationsCommand(args);
+    };
+    Pinpoint.prototype.getRecommenderConfigurations = function (args, optionsOrCb, cb) {
+        var command = new GetRecommenderConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSegment(args, optionsOrCb, cb) {
-        const command = new GetSegmentCommand(args);
+    };
+    Pinpoint.prototype.getSegment = function (args, optionsOrCb, cb) {
+        var command = new GetSegmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSegmentExportJobs(args, optionsOrCb, cb) {
-        const command = new GetSegmentExportJobsCommand(args);
+    };
+    Pinpoint.prototype.getSegmentExportJobs = function (args, optionsOrCb, cb) {
+        var command = new GetSegmentExportJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSegmentImportJobs(args, optionsOrCb, cb) {
-        const command = new GetSegmentImportJobsCommand(args);
+    };
+    Pinpoint.prototype.getSegmentImportJobs = function (args, optionsOrCb, cb) {
+        var command = new GetSegmentImportJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSegments(args, optionsOrCb, cb) {
-        const command = new GetSegmentsCommand(args);
+    };
+    Pinpoint.prototype.getSegments = function (args, optionsOrCb, cb) {
+        var command = new GetSegmentsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSegmentVersion(args, optionsOrCb, cb) {
-        const command = new GetSegmentVersionCommand(args);
+    };
+    Pinpoint.prototype.getSegmentVersion = function (args, optionsOrCb, cb) {
+        var command = new GetSegmentVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSegmentVersions(args, optionsOrCb, cb) {
-        const command = new GetSegmentVersionsCommand(args);
+    };
+    Pinpoint.prototype.getSegmentVersions = function (args, optionsOrCb, cb) {
+        var command = new GetSegmentVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSmsChannel(args, optionsOrCb, cb) {
-        const command = new GetSmsChannelCommand(args);
+    };
+    Pinpoint.prototype.getSmsChannel = function (args, optionsOrCb, cb) {
+        var command = new GetSmsChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSmsTemplate(args, optionsOrCb, cb) {
-        const command = new GetSmsTemplateCommand(args);
+    };
+    Pinpoint.prototype.getSmsTemplate = function (args, optionsOrCb, cb) {
+        var command = new GetSmsTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getUserEndpoints(args, optionsOrCb, cb) {
-        const command = new GetUserEndpointsCommand(args);
+    };
+    Pinpoint.prototype.getUserEndpoints = function (args, optionsOrCb, cb) {
+        var command = new GetUserEndpointsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getVoiceChannel(args, optionsOrCb, cb) {
-        const command = new GetVoiceChannelCommand(args);
+    };
+    Pinpoint.prototype.getVoiceChannel = function (args, optionsOrCb, cb) {
+        var command = new GetVoiceChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getVoiceTemplate(args, optionsOrCb, cb) {
-        const command = new GetVoiceTemplateCommand(args);
+    };
+    Pinpoint.prototype.getVoiceTemplate = function (args, optionsOrCb, cb) {
+        var command = new GetVoiceTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listJourneys(args, optionsOrCb, cb) {
-        const command = new ListJourneysCommand(args);
+    };
+    Pinpoint.prototype.listJourneys = function (args, optionsOrCb, cb) {
+        var command = new ListJourneysCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTagsForResource(args, optionsOrCb, cb) {
-        const command = new ListTagsForResourceCommand(args);
+    };
+    Pinpoint.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
+        var command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTemplates(args, optionsOrCb, cb) {
-        const command = new ListTemplatesCommand(args);
+    };
+    Pinpoint.prototype.listTemplates = function (args, optionsOrCb, cb) {
+        var command = new ListTemplatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTemplateVersions(args, optionsOrCb, cb) {
-        const command = new ListTemplateVersionsCommand(args);
+    };
+    Pinpoint.prototype.listTemplateVersions = function (args, optionsOrCb, cb) {
+        var command = new ListTemplateVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    phoneNumberValidate(args, optionsOrCb, cb) {
-        const command = new PhoneNumberValidateCommand(args);
+    };
+    Pinpoint.prototype.phoneNumberValidate = function (args, optionsOrCb, cb) {
+        var command = new PhoneNumberValidateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putEvents(args, optionsOrCb, cb) {
-        const command = new PutEventsCommand(args);
+    };
+    Pinpoint.prototype.putEvents = function (args, optionsOrCb, cb) {
+        var command = new PutEventsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putEventStream(args, optionsOrCb, cb) {
-        const command = new PutEventStreamCommand(args);
+    };
+    Pinpoint.prototype.putEventStream = function (args, optionsOrCb, cb) {
+        var command = new PutEventStreamCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    removeAttributes(args, optionsOrCb, cb) {
-        const command = new RemoveAttributesCommand(args);
+    };
+    Pinpoint.prototype.removeAttributes = function (args, optionsOrCb, cb) {
+        var command = new RemoveAttributesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    sendMessages(args, optionsOrCb, cb) {
-        const command = new SendMessagesCommand(args);
+    };
+    Pinpoint.prototype.sendMessages = function (args, optionsOrCb, cb) {
+        var command = new SendMessagesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    sendOTPMessage(args, optionsOrCb, cb) {
-        const command = new SendOTPMessageCommand(args);
+    };
+    Pinpoint.prototype.sendOTPMessage = function (args, optionsOrCb, cb) {
+        var command = new SendOTPMessageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    sendUsersMessages(args, optionsOrCb, cb) {
-        const command = new SendUsersMessagesCommand(args);
+    };
+    Pinpoint.prototype.sendUsersMessages = function (args, optionsOrCb, cb) {
+        var command = new SendUsersMessagesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    tagResource(args, optionsOrCb, cb) {
-        const command = new TagResourceCommand(args);
+    };
+    Pinpoint.prototype.tagResource = function (args, optionsOrCb, cb) {
+        var command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    untagResource(args, optionsOrCb, cb) {
-        const command = new UntagResourceCommand(args);
+    };
+    Pinpoint.prototype.untagResource = function (args, optionsOrCb, cb) {
+        var command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateAdmChannel(args, optionsOrCb, cb) {
-        const command = new UpdateAdmChannelCommand(args);
+    };
+    Pinpoint.prototype.updateAdmChannel = function (args, optionsOrCb, cb) {
+        var command = new UpdateAdmChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateApnsChannel(args, optionsOrCb, cb) {
-        const command = new UpdateApnsChannelCommand(args);
+    };
+    Pinpoint.prototype.updateApnsChannel = function (args, optionsOrCb, cb) {
+        var command = new UpdateApnsChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateApnsSandboxChannel(args, optionsOrCb, cb) {
-        const command = new UpdateApnsSandboxChannelCommand(args);
+    };
+    Pinpoint.prototype.updateApnsSandboxChannel = function (args, optionsOrCb, cb) {
+        var command = new UpdateApnsSandboxChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateApnsVoipChannel(args, optionsOrCb, cb) {
-        const command = new UpdateApnsVoipChannelCommand(args);
+    };
+    Pinpoint.prototype.updateApnsVoipChannel = function (args, optionsOrCb, cb) {
+        var command = new UpdateApnsVoipChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateApnsVoipSandboxChannel(args, optionsOrCb, cb) {
-        const command = new UpdateApnsVoipSandboxChannelCommand(args);
+    };
+    Pinpoint.prototype.updateApnsVoipSandboxChannel = function (args, optionsOrCb, cb) {
+        var command = new UpdateApnsVoipSandboxChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateApplicationSettings(args, optionsOrCb, cb) {
-        const command = new UpdateApplicationSettingsCommand(args);
+    };
+    Pinpoint.prototype.updateApplicationSettings = function (args, optionsOrCb, cb) {
+        var command = new UpdateApplicationSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateBaiduChannel(args, optionsOrCb, cb) {
-        const command = new UpdateBaiduChannelCommand(args);
+    };
+    Pinpoint.prototype.updateBaiduChannel = function (args, optionsOrCb, cb) {
+        var command = new UpdateBaiduChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateCampaign(args, optionsOrCb, cb) {
-        const command = new UpdateCampaignCommand(args);
+    };
+    Pinpoint.prototype.updateCampaign = function (args, optionsOrCb, cb) {
+        var command = new UpdateCampaignCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateEmailChannel(args, optionsOrCb, cb) {
-        const command = new UpdateEmailChannelCommand(args);
+    };
+    Pinpoint.prototype.updateEmailChannel = function (args, optionsOrCb, cb) {
+        var command = new UpdateEmailChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateEmailTemplate(args, optionsOrCb, cb) {
-        const command = new UpdateEmailTemplateCommand(args);
+    };
+    Pinpoint.prototype.updateEmailTemplate = function (args, optionsOrCb, cb) {
+        var command = new UpdateEmailTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateEndpoint(args, optionsOrCb, cb) {
-        const command = new UpdateEndpointCommand(args);
+    };
+    Pinpoint.prototype.updateEndpoint = function (args, optionsOrCb, cb) {
+        var command = new UpdateEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateEndpointsBatch(args, optionsOrCb, cb) {
-        const command = new UpdateEndpointsBatchCommand(args);
+    };
+    Pinpoint.prototype.updateEndpointsBatch = function (args, optionsOrCb, cb) {
+        var command = new UpdateEndpointsBatchCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateGcmChannel(args, optionsOrCb, cb) {
-        const command = new UpdateGcmChannelCommand(args);
+    };
+    Pinpoint.prototype.updateGcmChannel = function (args, optionsOrCb, cb) {
+        var command = new UpdateGcmChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateInAppTemplate(args, optionsOrCb, cb) {
-        const command = new UpdateInAppTemplateCommand(args);
+    };
+    Pinpoint.prototype.updateInAppTemplate = function (args, optionsOrCb, cb) {
+        var command = new UpdateInAppTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateJourney(args, optionsOrCb, cb) {
-        const command = new UpdateJourneyCommand(args);
+    };
+    Pinpoint.prototype.updateJourney = function (args, optionsOrCb, cb) {
+        var command = new UpdateJourneyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateJourneyState(args, optionsOrCb, cb) {
-        const command = new UpdateJourneyStateCommand(args);
+    };
+    Pinpoint.prototype.updateJourneyState = function (args, optionsOrCb, cb) {
+        var command = new UpdateJourneyStateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updatePushTemplate(args, optionsOrCb, cb) {
-        const command = new UpdatePushTemplateCommand(args);
+    };
+    Pinpoint.prototype.updatePushTemplate = function (args, optionsOrCb, cb) {
+        var command = new UpdatePushTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateRecommenderConfiguration(args, optionsOrCb, cb) {
-        const command = new UpdateRecommenderConfigurationCommand(args);
+    };
+    Pinpoint.prototype.updateRecommenderConfiguration = function (args, optionsOrCb, cb) {
+        var command = new UpdateRecommenderConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateSegment(args, optionsOrCb, cb) {
-        const command = new UpdateSegmentCommand(args);
+    };
+    Pinpoint.prototype.updateSegment = function (args, optionsOrCb, cb) {
+        var command = new UpdateSegmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateSmsChannel(args, optionsOrCb, cb) {
-        const command = new UpdateSmsChannelCommand(args);
+    };
+    Pinpoint.prototype.updateSmsChannel = function (args, optionsOrCb, cb) {
+        var command = new UpdateSmsChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateSmsTemplate(args, optionsOrCb, cb) {
-        const command = new UpdateSmsTemplateCommand(args);
+    };
+    Pinpoint.prototype.updateSmsTemplate = function (args, optionsOrCb, cb) {
+        var command = new UpdateSmsTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateTemplateActiveVersion(args, optionsOrCb, cb) {
-        const command = new UpdateTemplateActiveVersionCommand(args);
+    };
+    Pinpoint.prototype.updateTemplateActiveVersion = function (args, optionsOrCb, cb) {
+        var command = new UpdateTemplateActiveVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateVoiceChannel(args, optionsOrCb, cb) {
-        const command = new UpdateVoiceChannelCommand(args);
+    };
+    Pinpoint.prototype.updateVoiceChannel = function (args, optionsOrCb, cb) {
+        var command = new UpdateVoiceChannelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateVoiceTemplate(args, optionsOrCb, cb) {
-        const command = new UpdateVoiceTemplateCommand(args);
+    };
+    Pinpoint.prototype.updateVoiceTemplate = function (args, optionsOrCb, cb) {
+        var command = new UpdateVoiceTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    verifyOTPMessage(args, optionsOrCb, cb) {
-        const command = new VerifyOTPMessageCommand(args);
+    };
+    Pinpoint.prototype.verifyOTPMessage = function (args, optionsOrCb, cb) {
+        var command = new VerifyOTPMessageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-}
+    };
+    return Pinpoint;
+}(PinpointClient));
+export { Pinpoint };