@aws-sdk/client-greengrass 3.33.0 → 3.36.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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