@aws-sdk/client-location 3.478.0 → 3.481.0

package/dist-es/commands/BatchPutGeofenceCommand.js

@@ -1,48 +1,25 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { BatchPutGeofenceRequestFilterSensitiveLog, } from "../models/models_0";
 import { de_BatchPutGeofenceCommand, se_BatchPutGeofenceCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class BatchPutGeofenceCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, BatchPutGeofenceCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LocationClient";
-        const commandName = "BatchPutGeofenceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: BatchPutGeofenceRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "LocationService",
-                operation: "BatchPutGeofence",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_BatchPutGeofenceCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_BatchPutGeofenceCommand(output, context);
-    }
+export class BatchPutGeofenceCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("LocationService", "BatchPutGeofence", {})
+    .n("LocationClient", "BatchPutGeofenceCommand")
+    .f(BatchPutGeofenceRequestFilterSensitiveLog, void 0)
+    .ser(se_BatchPutGeofenceCommand)
+    .de(de_BatchPutGeofenceCommand)
+    .build() {
 }

package/dist-es/commands/BatchUpdateDevicePositionCommand.js

@@ -1,48 +1,25 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { BatchUpdateDevicePositionRequestFilterSensitiveLog, } from "../models/models_0";
 import { de_BatchUpdateDevicePositionCommand, se_BatchUpdateDevicePositionCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class BatchUpdateDevicePositionCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, BatchUpdateDevicePositionCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LocationClient";
-        const commandName = "BatchUpdateDevicePositionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: BatchUpdateDevicePositionRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "LocationService",
-                operation: "BatchUpdateDevicePosition",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_BatchUpdateDevicePositionCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_BatchUpdateDevicePositionCommand(output, context);
-    }
+export class BatchUpdateDevicePositionCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("LocationService", "BatchUpdateDevicePosition", {})
+    .n("LocationClient", "BatchUpdateDevicePositionCommand")
+    .f(BatchUpdateDevicePositionRequestFilterSensitiveLog, void 0)
+    .ser(se_BatchUpdateDevicePositionCommand)
+    .de(de_BatchUpdateDevicePositionCommand)
+    .build() {
 }

package/dist-es/commands/CalculateRouteCommand.js

@@ -1,48 +1,25 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { CalculateRouteRequestFilterSensitiveLog, CalculateRouteResponseFilterSensitiveLog, } from "../models/models_0";
 import { de_CalculateRouteCommand, se_CalculateRouteCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CalculateRouteCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, CalculateRouteCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LocationClient";
-        const commandName = "CalculateRouteCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: CalculateRouteRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: CalculateRouteResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "LocationService",
-                operation: "CalculateRoute",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CalculateRouteCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CalculateRouteCommand(output, context);
-    }
+export class CalculateRouteCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("LocationService", "CalculateRoute", {})
+    .n("LocationClient", "CalculateRouteCommand")
+    .f(CalculateRouteRequestFilterSensitiveLog, CalculateRouteResponseFilterSensitiveLog)
+    .ser(se_CalculateRouteCommand)
+    .de(de_CalculateRouteCommand)
+    .build() {
 }

package/dist-es/commands/CalculateRouteMatrixCommand.js

@@ -1,48 +1,25 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { CalculateRouteMatrixRequestFilterSensitiveLog, CalculateRouteMatrixResponseFilterSensitiveLog, } from "../models/models_0";
 import { de_CalculateRouteMatrixCommand, se_CalculateRouteMatrixCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CalculateRouteMatrixCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, CalculateRouteMatrixCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LocationClient";
-        const commandName = "CalculateRouteMatrixCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: CalculateRouteMatrixRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: CalculateRouteMatrixResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "LocationService",
-                operation: "CalculateRouteMatrix",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CalculateRouteMatrixCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CalculateRouteMatrixCommand(output, context);
-    }
+export class CalculateRouteMatrixCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("LocationService", "CalculateRouteMatrix", {})
+    .n("LocationClient", "CalculateRouteMatrixCommand")
+    .f(CalculateRouteMatrixRequestFilterSensitiveLog, CalculateRouteMatrixResponseFilterSensitiveLog)
+    .ser(se_CalculateRouteMatrixCommand)
+    .de(de_CalculateRouteMatrixCommand)
+    .build() {
 }

package/dist-es/commands/CreateGeofenceCollectionCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_CreateGeofenceCollectionCommand, se_CreateGeofenceCollectionCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateGeofenceCollectionCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, CreateGeofenceCollectionCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LocationClient";
-        const commandName = "CreateGeofenceCollectionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "LocationService",
-                operation: "CreateGeofenceCollection",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CreateGeofenceCollectionCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CreateGeofenceCollectionCommand(output, context);
-    }
+export class CreateGeofenceCollectionCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("LocationService", "CreateGeofenceCollection", {})
+    .n("LocationClient", "CreateGeofenceCollectionCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateGeofenceCollectionCommand)
+    .de(de_CreateGeofenceCollectionCommand)
+    .build() {
 }

package/dist-es/commands/CreateKeyCommand.js

@@ -1,48 +1,25 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { CreateKeyResponseFilterSensitiveLog } from "../models/models_0";
 import { de_CreateKeyCommand, se_CreateKeyCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateKeyCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, CreateKeyCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LocationClient";
-        const commandName = "CreateKeyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: CreateKeyResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "LocationService",
-                operation: "CreateKey",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CreateKeyCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CreateKeyCommand(output, context);
-    }
+export class CreateKeyCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("LocationService", "CreateKey", {})
+    .n("LocationClient", "CreateKeyCommand")
+    .f(void 0, CreateKeyResponseFilterSensitiveLog)
+    .ser(se_CreateKeyCommand)
+    .de(de_CreateKeyCommand)
+    .build() {
 }

package/dist-es/commands/CreateMapCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_CreateMapCommand, se_CreateMapCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateMapCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, CreateMapCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LocationClient";
-        const commandName = "CreateMapCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "LocationService",
-                operation: "CreateMap",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CreateMapCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CreateMapCommand(output, context);
-    }
+export class CreateMapCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("LocationService", "CreateMap", {})
+    .n("LocationClient", "CreateMapCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateMapCommand)
+    .de(de_CreateMapCommand)
+    .build() {
 }

package/dist-es/commands/CreatePlaceIndexCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_CreatePlaceIndexCommand, se_CreatePlaceIndexCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreatePlaceIndexCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, CreatePlaceIndexCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LocationClient";
-        const commandName = "CreatePlaceIndexCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "LocationService",
-                operation: "CreatePlaceIndex",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CreatePlaceIndexCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CreatePlaceIndexCommand(output, context);
-    }
+export class CreatePlaceIndexCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("LocationService", "CreatePlaceIndex", {})
+    .n("LocationClient", "CreatePlaceIndexCommand")
+    .f(void 0, void 0)
+    .ser(se_CreatePlaceIndexCommand)
+    .de(de_CreatePlaceIndexCommand)
+    .build() {
 }

package/dist-es/commands/CreateRouteCalculatorCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_CreateRouteCalculatorCommand, se_CreateRouteCalculatorCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateRouteCalculatorCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, CreateRouteCalculatorCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LocationClient";
-        const commandName = "CreateRouteCalculatorCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "LocationService",
-                operation: "CreateRouteCalculator",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CreateRouteCalculatorCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CreateRouteCalculatorCommand(output, context);
-    }
+export class CreateRouteCalculatorCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("LocationService", "CreateRouteCalculator", {})
+    .n("LocationClient", "CreateRouteCalculatorCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateRouteCalculatorCommand)
+    .de(de_CreateRouteCalculatorCommand)
+    .build() {
 }