@aws-sdk/client-iotfleetwise 3.179.0

package/dist-es/IoTFleetWiseClient.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
+import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
+import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
+import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRecursionDetectionPlugin } from "@aws-sdk/middleware-recursion-detection";
+import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
+import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
+import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { Client as __Client, } from "@aws-sdk/smithy-client";
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+var IoTFleetWiseClient = (function (_super) {
+    __extends(IoTFleetWiseClient, _super);
+    function IoTFleetWiseClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getRecursionDetectionPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
+    }
+    IoTFleetWiseClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return IoTFleetWiseClient;
+}(__Client));
+export { IoTFleetWiseClient };

package/dist-es/commands/AssociateVehicleFleetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { AssociateVehicleFleetRequestFilterSensitiveLog, AssociateVehicleFleetResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0AssociateVehicleFleetCommand, serializeAws_json1_0AssociateVehicleFleetCommand, } from "../protocols/Aws_json1_0";
+var AssociateVehicleFleetCommand = (function (_super) {
+    __extends(AssociateVehicleFleetCommand, _super);
+    function AssociateVehicleFleetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssociateVehicleFleetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "AssociateVehicleFleetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssociateVehicleFleetRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: AssociateVehicleFleetResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateVehicleFleetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0AssociateVehicleFleetCommand(input, context);
+    };
+    AssociateVehicleFleetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0AssociateVehicleFleetCommand(output, context);
+    };
+    return AssociateVehicleFleetCommand;
+}($Command));
+export { AssociateVehicleFleetCommand };

package/dist-es/commands/BatchCreateVehicleCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { BatchCreateVehicleRequestFilterSensitiveLog, BatchCreateVehicleResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0BatchCreateVehicleCommand, serializeAws_json1_0BatchCreateVehicleCommand, } from "../protocols/Aws_json1_0";
+var BatchCreateVehicleCommand = (function (_super) {
+    __extends(BatchCreateVehicleCommand, _super);
+    function BatchCreateVehicleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    BatchCreateVehicleCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "BatchCreateVehicleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: BatchCreateVehicleRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: BatchCreateVehicleResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchCreateVehicleCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0BatchCreateVehicleCommand(input, context);
+    };
+    BatchCreateVehicleCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0BatchCreateVehicleCommand(output, context);
+    };
+    return BatchCreateVehicleCommand;
+}($Command));
+export { BatchCreateVehicleCommand };

package/dist-es/commands/BatchUpdateVehicleCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { BatchUpdateVehicleRequestFilterSensitiveLog, BatchUpdateVehicleResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0BatchUpdateVehicleCommand, serializeAws_json1_0BatchUpdateVehicleCommand, } from "../protocols/Aws_json1_0";
+var BatchUpdateVehicleCommand = (function (_super) {
+    __extends(BatchUpdateVehicleCommand, _super);
+    function BatchUpdateVehicleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    BatchUpdateVehicleCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "BatchUpdateVehicleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: BatchUpdateVehicleRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: BatchUpdateVehicleResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchUpdateVehicleCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0BatchUpdateVehicleCommand(input, context);
+    };
+    BatchUpdateVehicleCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0BatchUpdateVehicleCommand(output, context);
+    };
+    return BatchUpdateVehicleCommand;
+}($Command));
+export { BatchUpdateVehicleCommand };

package/dist-es/commands/CreateCampaignCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateCampaignRequestFilterSensitiveLog, CreateCampaignResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0CreateCampaignCommand, serializeAws_json1_0CreateCampaignCommand, } from "../protocols/Aws_json1_0";
+var CreateCampaignCommand = (function (_super) {
+    __extends(CreateCampaignCommand, _super);
+    function CreateCampaignCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateCampaignCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "CreateCampaignCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateCampaignRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateCampaignResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateCampaignCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0CreateCampaignCommand(input, context);
+    };
+    CreateCampaignCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0CreateCampaignCommand(output, context);
+    };
+    return CreateCampaignCommand;
+}($Command));
+export { CreateCampaignCommand };

package/dist-es/commands/CreateDecoderManifestCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDecoderManifestRequestFilterSensitiveLog, CreateDecoderManifestResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0CreateDecoderManifestCommand, serializeAws_json1_0CreateDecoderManifestCommand, } from "../protocols/Aws_json1_0";
+var CreateDecoderManifestCommand = (function (_super) {
+    __extends(CreateDecoderManifestCommand, _super);
+    function CreateDecoderManifestCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateDecoderManifestCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "CreateDecoderManifestCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateDecoderManifestRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateDecoderManifestResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDecoderManifestCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0CreateDecoderManifestCommand(input, context);
+    };
+    CreateDecoderManifestCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0CreateDecoderManifestCommand(output, context);
+    };
+    return CreateDecoderManifestCommand;
+}($Command));
+export { CreateDecoderManifestCommand };

package/dist-es/commands/CreateFleetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateFleetRequestFilterSensitiveLog, CreateFleetResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0CreateFleetCommand, serializeAws_json1_0CreateFleetCommand, } from "../protocols/Aws_json1_0";
+var CreateFleetCommand = (function (_super) {
+    __extends(CreateFleetCommand, _super);
+    function CreateFleetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateFleetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "CreateFleetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateFleetRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateFleetResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateFleetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0CreateFleetCommand(input, context);
+    };
+    CreateFleetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0CreateFleetCommand(output, context);
+    };
+    return CreateFleetCommand;
+}($Command));
+export { CreateFleetCommand };

package/dist-es/commands/CreateModelManifestCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateModelManifestRequestFilterSensitiveLog, CreateModelManifestResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0CreateModelManifestCommand, serializeAws_json1_0CreateModelManifestCommand, } from "../protocols/Aws_json1_0";
+var CreateModelManifestCommand = (function (_super) {
+    __extends(CreateModelManifestCommand, _super);
+    function CreateModelManifestCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateModelManifestCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "CreateModelManifestCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateModelManifestRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateModelManifestResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateModelManifestCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0CreateModelManifestCommand(input, context);
+    };
+    CreateModelManifestCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0CreateModelManifestCommand(output, context);
+    };
+    return CreateModelManifestCommand;
+}($Command));
+export { CreateModelManifestCommand };

package/dist-es/commands/CreateSignalCatalogCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateSignalCatalogRequestFilterSensitiveLog, CreateSignalCatalogResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0CreateSignalCatalogCommand, serializeAws_json1_0CreateSignalCatalogCommand, } from "../protocols/Aws_json1_0";
+var CreateSignalCatalogCommand = (function (_super) {
+    __extends(CreateSignalCatalogCommand, _super);
+    function CreateSignalCatalogCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateSignalCatalogCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "CreateSignalCatalogCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateSignalCatalogRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateSignalCatalogResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateSignalCatalogCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0CreateSignalCatalogCommand(input, context);
+    };
+    CreateSignalCatalogCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0CreateSignalCatalogCommand(output, context);
+    };
+    return CreateSignalCatalogCommand;
+}($Command));
+export { CreateSignalCatalogCommand };

package/dist-es/commands/CreateVehicleCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateVehicleRequestFilterSensitiveLog, CreateVehicleResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0CreateVehicleCommand, serializeAws_json1_0CreateVehicleCommand, } from "../protocols/Aws_json1_0";
+var CreateVehicleCommand = (function (_super) {
+    __extends(CreateVehicleCommand, _super);
+    function CreateVehicleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateVehicleCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "CreateVehicleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateVehicleRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateVehicleResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateVehicleCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0CreateVehicleCommand(input, context);
+    };
+    CreateVehicleCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0CreateVehicleCommand(output, context);
+    };
+    return CreateVehicleCommand;
+}($Command));
+export { CreateVehicleCommand };

package/dist-es/commands/DeleteCampaignCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteCampaignRequestFilterSensitiveLog, DeleteCampaignResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0DeleteCampaignCommand, serializeAws_json1_0DeleteCampaignCommand, } from "../protocols/Aws_json1_0";
+var DeleteCampaignCommand = (function (_super) {
+    __extends(DeleteCampaignCommand, _super);
+    function DeleteCampaignCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteCampaignCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "DeleteCampaignCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteCampaignRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteCampaignResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteCampaignCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DeleteCampaignCommand(input, context);
+    };
+    DeleteCampaignCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DeleteCampaignCommand(output, context);
+    };
+    return DeleteCampaignCommand;
+}($Command));
+export { DeleteCampaignCommand };

package/dist-es/commands/DeleteDecoderManifestCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteDecoderManifestRequestFilterSensitiveLog, DeleteDecoderManifestResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0DeleteDecoderManifestCommand, serializeAws_json1_0DeleteDecoderManifestCommand, } from "../protocols/Aws_json1_0";
+var DeleteDecoderManifestCommand = (function (_super) {
+    __extends(DeleteDecoderManifestCommand, _super);
+    function DeleteDecoderManifestCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteDecoderManifestCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "DeleteDecoderManifestCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteDecoderManifestRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteDecoderManifestResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteDecoderManifestCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DeleteDecoderManifestCommand(input, context);
+    };
+    DeleteDecoderManifestCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DeleteDecoderManifestCommand(output, context);
+    };
+    return DeleteDecoderManifestCommand;
+}($Command));
+export { DeleteDecoderManifestCommand };

package/dist-es/commands/DeleteFleetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteFleetRequestFilterSensitiveLog, DeleteFleetResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0DeleteFleetCommand, serializeAws_json1_0DeleteFleetCommand, } from "../protocols/Aws_json1_0";
+var DeleteFleetCommand = (function (_super) {
+    __extends(DeleteFleetCommand, _super);
+    function DeleteFleetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteFleetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "DeleteFleetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteFleetRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteFleetResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteFleetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DeleteFleetCommand(input, context);
+    };
+    DeleteFleetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DeleteFleetCommand(output, context);
+    };
+    return DeleteFleetCommand;
+}($Command));
+export { DeleteFleetCommand };

package/dist-es/commands/DeleteModelManifestCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteModelManifestRequestFilterSensitiveLog, DeleteModelManifestResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0DeleteModelManifestCommand, serializeAws_json1_0DeleteModelManifestCommand, } from "../protocols/Aws_json1_0";
+var DeleteModelManifestCommand = (function (_super) {
+    __extends(DeleteModelManifestCommand, _super);
+    function DeleteModelManifestCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteModelManifestCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "DeleteModelManifestCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteModelManifestRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteModelManifestResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteModelManifestCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DeleteModelManifestCommand(input, context);
+    };
+    DeleteModelManifestCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DeleteModelManifestCommand(output, context);
+    };
+    return DeleteModelManifestCommand;
+}($Command));
+export { DeleteModelManifestCommand };

package/dist-es/commands/DeleteSignalCatalogCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteSignalCatalogRequestFilterSensitiveLog, DeleteSignalCatalogResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0DeleteSignalCatalogCommand, serializeAws_json1_0DeleteSignalCatalogCommand, } from "../protocols/Aws_json1_0";
+var DeleteSignalCatalogCommand = (function (_super) {
+    __extends(DeleteSignalCatalogCommand, _super);
+    function DeleteSignalCatalogCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteSignalCatalogCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "DeleteSignalCatalogCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteSignalCatalogRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteSignalCatalogResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteSignalCatalogCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DeleteSignalCatalogCommand(input, context);
+    };
+    DeleteSignalCatalogCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DeleteSignalCatalogCommand(output, context);
+    };
+    return DeleteSignalCatalogCommand;
+}($Command));
+export { DeleteSignalCatalogCommand };

package/dist-es/commands/DeleteVehicleCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteVehicleRequestFilterSensitiveLog, DeleteVehicleResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0DeleteVehicleCommand, serializeAws_json1_0DeleteVehicleCommand, } from "../protocols/Aws_json1_0";
+var DeleteVehicleCommand = (function (_super) {
+    __extends(DeleteVehicleCommand, _super);
+    function DeleteVehicleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteVehicleCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTFleetWiseClient";
+        var commandName = "DeleteVehicleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteVehicleRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteVehicleResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteVehicleCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DeleteVehicleCommand(input, context);
+    };
+    DeleteVehicleCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DeleteVehicleCommand(output, context);
+    };
+    return DeleteVehicleCommand;
+}($Command));
+export { DeleteVehicleCommand };