@aws-sdk/client-greengrass 3.33.0 → 3.36.1

package/dist-es/GreengrassClient.js

@@ -0,0 +1,37 @@
+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 { 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 GreengrassClient = (function (_super) {
+    __extends(GreengrassClient, _super);
+    function GreengrassClient(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(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
+    }
+    GreengrassClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return GreengrassClient;
+}(__Client));
+export { GreengrassClient };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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