@aws-sdk/client-iotfleetwise 3.179.0

package/dist-es/commands/DisassociateVehicleFleetCommand.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 { DisassociateVehicleFleetRequestFilterSensitiveLog, DisassociateVehicleFleetResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0DisassociateVehicleFleetCommand, serializeAws_json1_0DisassociateVehicleFleetCommand, } from "../protocols/Aws_json1_0";
+var DisassociateVehicleFleetCommand = (function (_super) {
+    __extends(DisassociateVehicleFleetCommand, _super);
+    function DisassociateVehicleFleetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DisassociateVehicleFleetCommand.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 = "DisassociateVehicleFleetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DisassociateVehicleFleetRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DisassociateVehicleFleetResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DisassociateVehicleFleetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DisassociateVehicleFleetCommand(input, context);
+    };
+    DisassociateVehicleFleetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DisassociateVehicleFleetCommand(output, context);
+    };
+    return DisassociateVehicleFleetCommand;
+}($Command));
+export { DisassociateVehicleFleetCommand };

package/dist-es/commands/GetCampaignCommand.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 { GetCampaignRequestFilterSensitiveLog, GetCampaignResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetCampaignCommand, serializeAws_json1_0GetCampaignCommand, } from "../protocols/Aws_json1_0";
+var GetCampaignCommand = (function (_super) {
+    __extends(GetCampaignCommand, _super);
+    function GetCampaignCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetCampaignCommand.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 = "GetCampaignCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetCampaignRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetCampaignResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetCampaignCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0GetCampaignCommand(input, context);
+    };
+    GetCampaignCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0GetCampaignCommand(output, context);
+    };
+    return GetCampaignCommand;
+}($Command));
+export { GetCampaignCommand };

package/dist-es/commands/GetDecoderManifestCommand.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 { GetDecoderManifestRequestFilterSensitiveLog, GetDecoderManifestResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetDecoderManifestCommand, serializeAws_json1_0GetDecoderManifestCommand, } from "../protocols/Aws_json1_0";
+var GetDecoderManifestCommand = (function (_super) {
+    __extends(GetDecoderManifestCommand, _super);
+    function GetDecoderManifestCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetDecoderManifestCommand.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 = "GetDecoderManifestCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetDecoderManifestRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetDecoderManifestResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetDecoderManifestCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0GetDecoderManifestCommand(input, context);
+    };
+    GetDecoderManifestCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0GetDecoderManifestCommand(output, context);
+    };
+    return GetDecoderManifestCommand;
+}($Command));
+export { GetDecoderManifestCommand };

package/dist-es/commands/GetFleetCommand.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 { GetFleetRequestFilterSensitiveLog, GetFleetResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetFleetCommand, serializeAws_json1_0GetFleetCommand } from "../protocols/Aws_json1_0";
+var GetFleetCommand = (function (_super) {
+    __extends(GetFleetCommand, _super);
+    function GetFleetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFleetCommand.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 = "GetFleetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFleetRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetFleetResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFleetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0GetFleetCommand(input, context);
+    };
+    GetFleetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0GetFleetCommand(output, context);
+    };
+    return GetFleetCommand;
+}($Command));
+export { GetFleetCommand };

package/dist-es/commands/GetLoggingOptionsCommand.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 { GetLoggingOptionsRequestFilterSensitiveLog, GetLoggingOptionsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetLoggingOptionsCommand, serializeAws_json1_0GetLoggingOptionsCommand, } from "../protocols/Aws_json1_0";
+var GetLoggingOptionsCommand = (function (_super) {
+    __extends(GetLoggingOptionsCommand, _super);
+    function GetLoggingOptionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetLoggingOptionsCommand.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 = "GetLoggingOptionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetLoggingOptionsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetLoggingOptionsResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetLoggingOptionsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0GetLoggingOptionsCommand(input, context);
+    };
+    GetLoggingOptionsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0GetLoggingOptionsCommand(output, context);
+    };
+    return GetLoggingOptionsCommand;
+}($Command));
+export { GetLoggingOptionsCommand };

package/dist-es/commands/GetModelManifestCommand.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 { GetModelManifestRequestFilterSensitiveLog, GetModelManifestResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetModelManifestCommand, serializeAws_json1_0GetModelManifestCommand, } from "../protocols/Aws_json1_0";
+var GetModelManifestCommand = (function (_super) {
+    __extends(GetModelManifestCommand, _super);
+    function GetModelManifestCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetModelManifestCommand.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 = "GetModelManifestCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetModelManifestRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetModelManifestResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetModelManifestCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0GetModelManifestCommand(input, context);
+    };
+    GetModelManifestCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0GetModelManifestCommand(output, context);
+    };
+    return GetModelManifestCommand;
+}($Command));
+export { GetModelManifestCommand };

package/dist-es/commands/GetRegisterAccountStatusCommand.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 { GetRegisterAccountStatusRequestFilterSensitiveLog, GetRegisterAccountStatusResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetRegisterAccountStatusCommand, serializeAws_json1_0GetRegisterAccountStatusCommand, } from "../protocols/Aws_json1_0";
+var GetRegisterAccountStatusCommand = (function (_super) {
+    __extends(GetRegisterAccountStatusCommand, _super);
+    function GetRegisterAccountStatusCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetRegisterAccountStatusCommand.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 = "GetRegisterAccountStatusCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetRegisterAccountStatusRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetRegisterAccountStatusResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRegisterAccountStatusCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0GetRegisterAccountStatusCommand(input, context);
+    };
+    GetRegisterAccountStatusCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0GetRegisterAccountStatusCommand(output, context);
+    };
+    return GetRegisterAccountStatusCommand;
+}($Command));
+export { GetRegisterAccountStatusCommand };

package/dist-es/commands/GetSignalCatalogCommand.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 { GetSignalCatalogRequestFilterSensitiveLog, GetSignalCatalogResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetSignalCatalogCommand, serializeAws_json1_0GetSignalCatalogCommand, } from "../protocols/Aws_json1_0";
+var GetSignalCatalogCommand = (function (_super) {
+    __extends(GetSignalCatalogCommand, _super);
+    function GetSignalCatalogCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetSignalCatalogCommand.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 = "GetSignalCatalogCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetSignalCatalogRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetSignalCatalogResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetSignalCatalogCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0GetSignalCatalogCommand(input, context);
+    };
+    GetSignalCatalogCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0GetSignalCatalogCommand(output, context);
+    };
+    return GetSignalCatalogCommand;
+}($Command));
+export { GetSignalCatalogCommand };

package/dist-es/commands/GetVehicleCommand.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 { GetVehicleRequestFilterSensitiveLog, GetVehicleResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetVehicleCommand, serializeAws_json1_0GetVehicleCommand, } from "../protocols/Aws_json1_0";
+var GetVehicleCommand = (function (_super) {
+    __extends(GetVehicleCommand, _super);
+    function GetVehicleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetVehicleCommand.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 = "GetVehicleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetVehicleRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetVehicleResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetVehicleCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0GetVehicleCommand(input, context);
+    };
+    GetVehicleCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0GetVehicleCommand(output, context);
+    };
+    return GetVehicleCommand;
+}($Command));
+export { GetVehicleCommand };

package/dist-es/commands/GetVehicleStatusCommand.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 { GetVehicleStatusRequestFilterSensitiveLog, GetVehicleStatusResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetVehicleStatusCommand, serializeAws_json1_0GetVehicleStatusCommand, } from "../protocols/Aws_json1_0";
+var GetVehicleStatusCommand = (function (_super) {
+    __extends(GetVehicleStatusCommand, _super);
+    function GetVehicleStatusCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetVehicleStatusCommand.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 = "GetVehicleStatusCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetVehicleStatusRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetVehicleStatusResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetVehicleStatusCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0GetVehicleStatusCommand(input, context);
+    };
+    GetVehicleStatusCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0GetVehicleStatusCommand(output, context);
+    };
+    return GetVehicleStatusCommand;
+}($Command));
+export { GetVehicleStatusCommand };

package/dist-es/commands/ImportDecoderManifestCommand.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 { ImportDecoderManifestRequestFilterSensitiveLog, ImportDecoderManifestResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0ImportDecoderManifestCommand, serializeAws_json1_0ImportDecoderManifestCommand, } from "../protocols/Aws_json1_0";
+var ImportDecoderManifestCommand = (function (_super) {
+    __extends(ImportDecoderManifestCommand, _super);
+    function ImportDecoderManifestCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ImportDecoderManifestCommand.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 = "ImportDecoderManifestCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ImportDecoderManifestRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ImportDecoderManifestResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ImportDecoderManifestCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0ImportDecoderManifestCommand(input, context);
+    };
+    ImportDecoderManifestCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ImportDecoderManifestCommand(output, context);
+    };
+    return ImportDecoderManifestCommand;
+}($Command));
+export { ImportDecoderManifestCommand };

package/dist-es/commands/ImportSignalCatalogCommand.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 { ImportSignalCatalogRequestFilterSensitiveLog, ImportSignalCatalogResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0ImportSignalCatalogCommand, serializeAws_json1_0ImportSignalCatalogCommand, } from "../protocols/Aws_json1_0";
+var ImportSignalCatalogCommand = (function (_super) {
+    __extends(ImportSignalCatalogCommand, _super);
+    function ImportSignalCatalogCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ImportSignalCatalogCommand.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 = "ImportSignalCatalogCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ImportSignalCatalogRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ImportSignalCatalogResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ImportSignalCatalogCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0ImportSignalCatalogCommand(input, context);
+    };
+    ImportSignalCatalogCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ImportSignalCatalogCommand(output, context);
+    };
+    return ImportSignalCatalogCommand;
+}($Command));
+export { ImportSignalCatalogCommand };

package/dist-es/commands/ListCampaignsCommand.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 { ListCampaignsRequestFilterSensitiveLog, ListCampaignsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0ListCampaignsCommand, serializeAws_json1_0ListCampaignsCommand, } from "../protocols/Aws_json1_0";
+var ListCampaignsCommand = (function (_super) {
+    __extends(ListCampaignsCommand, _super);
+    function ListCampaignsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListCampaignsCommand.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 = "ListCampaignsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListCampaignsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListCampaignsResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListCampaignsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0ListCampaignsCommand(input, context);
+    };
+    ListCampaignsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListCampaignsCommand(output, context);
+    };
+    return ListCampaignsCommand;
+}($Command));
+export { ListCampaignsCommand };

package/dist-es/commands/ListDecoderManifestNetworkInterfacesCommand.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 { ListDecoderManifestNetworkInterfacesRequestFilterSensitiveLog, ListDecoderManifestNetworkInterfacesResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0ListDecoderManifestNetworkInterfacesCommand, serializeAws_json1_0ListDecoderManifestNetworkInterfacesCommand, } from "../protocols/Aws_json1_0";
+var ListDecoderManifestNetworkInterfacesCommand = (function (_super) {
+    __extends(ListDecoderManifestNetworkInterfacesCommand, _super);
+    function ListDecoderManifestNetworkInterfacesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListDecoderManifestNetworkInterfacesCommand.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 = "ListDecoderManifestNetworkInterfacesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListDecoderManifestNetworkInterfacesRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListDecoderManifestNetworkInterfacesResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListDecoderManifestNetworkInterfacesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0ListDecoderManifestNetworkInterfacesCommand(input, context);
+    };
+    ListDecoderManifestNetworkInterfacesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListDecoderManifestNetworkInterfacesCommand(output, context);
+    };
+    return ListDecoderManifestNetworkInterfacesCommand;
+}($Command));
+export { ListDecoderManifestNetworkInterfacesCommand };

package/dist-es/commands/ListDecoderManifestSignalsCommand.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 { ListDecoderManifestSignalsRequestFilterSensitiveLog, ListDecoderManifestSignalsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0ListDecoderManifestSignalsCommand, serializeAws_json1_0ListDecoderManifestSignalsCommand, } from "../protocols/Aws_json1_0";
+var ListDecoderManifestSignalsCommand = (function (_super) {
+    __extends(ListDecoderManifestSignalsCommand, _super);
+    function ListDecoderManifestSignalsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListDecoderManifestSignalsCommand.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 = "ListDecoderManifestSignalsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListDecoderManifestSignalsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListDecoderManifestSignalsResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListDecoderManifestSignalsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0ListDecoderManifestSignalsCommand(input, context);
+    };
+    ListDecoderManifestSignalsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListDecoderManifestSignalsCommand(output, context);
+    };
+    return ListDecoderManifestSignalsCommand;
+}($Command));
+export { ListDecoderManifestSignalsCommand };

package/dist-es/commands/ListDecoderManifestsCommand.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 { ListDecoderManifestsRequestFilterSensitiveLog, ListDecoderManifestsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0ListDecoderManifestsCommand, serializeAws_json1_0ListDecoderManifestsCommand, } from "../protocols/Aws_json1_0";
+var ListDecoderManifestsCommand = (function (_super) {
+    __extends(ListDecoderManifestsCommand, _super);
+    function ListDecoderManifestsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListDecoderManifestsCommand.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 = "ListDecoderManifestsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListDecoderManifestsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListDecoderManifestsResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListDecoderManifestsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0ListDecoderManifestsCommand(input, context);
+    };
+    ListDecoderManifestsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListDecoderManifestsCommand(output, context);
+    };
+    return ListDecoderManifestsCommand;
+}($Command));
+export { ListDecoderManifestsCommand };