@aws-sdk/client-location 3.183.0 → 3.185.0

package/dist-es/commands/CreateGeofenceCollectionCommand.js

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

package/dist-es/commands/CreateMapCommand.js

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

package/dist-es/commands/CreatePlaceIndexCommand.js

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

package/dist-es/commands/CreateRouteCalculatorCommand.js

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

package/dist-es/commands/CreateTrackerCommand.js

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

package/dist-es/commands/DeleteGeofenceCollectionCommand.js

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

package/dist-es/commands/DeleteMapCommand.js

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

package/dist-es/commands/DeletePlaceIndexCommand.js

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

package/dist-es/commands/DeleteRouteCalculatorCommand.js

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

package/dist-es/commands/DeleteTrackerCommand.js

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