@aws-sdk/client-greengrass 3.1068.0 → 3.1069.0

package/dist-cjs/index.js

@@ -1,18 +1,21 @@
-'use strict';
-
-var client$1 = require('@aws-sdk/core/client');
-var core = require('@smithy/core');
-var client = require('@smithy/core/client');
-var config = require('@smithy/core/config');
-var endpoints = require('@smithy/core/endpoints');
-var protocols = require('@smithy/core/protocols');
-var retry = require('@smithy/core/retry');
-var schema = require('@smithy/core/schema');
-var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var runtimeConfig = require('./runtimeConfig');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var GreengrassServiceException = require('./models/GreengrassServiceException');
+var __exportStar = (m, e) => { Object.assign(e, m); };
+const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin } = require("@smithy/core");
+const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
+exports.$Command = Command;
+exports.__Client = Client;
+const { resolveRegionConfig } = require("@smithy/core/config");
+const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveHttpAuthSchemeConfig, defaultGreengrassHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { AssociateRoleToGroup$, AssociateServiceRoleToAccount$, CreateConnectorDefinition$, CreateConnectorDefinitionVersion$, CreateCoreDefinition$, CreateCoreDefinitionVersion$, CreateDeployment$, CreateDeviceDefinition$, CreateDeviceDefinitionVersion$, CreateFunctionDefinition$, CreateFunctionDefinitionVersion$, CreateGroupCertificateAuthority$, CreateGroup$, CreateGroupVersion$, CreateLoggerDefinition$, CreateLoggerDefinitionVersion$, CreateResourceDefinition$, CreateResourceDefinitionVersion$, CreateSoftwareUpdateJob$, CreateSubscriptionDefinition$, CreateSubscriptionDefinitionVersion$, DeleteConnectorDefinition$, DeleteCoreDefinition$, DeleteDeviceDefinition$, DeleteFunctionDefinition$, DeleteGroup$, DeleteLoggerDefinition$, DeleteResourceDefinition$, DeleteSubscriptionDefinition$, DisassociateRoleFromGroup$, DisassociateServiceRoleFromAccount$, GetAssociatedRole$, GetBulkDeploymentStatus$, GetConnectivityInfo$, GetConnectorDefinition$, GetConnectorDefinitionVersion$, GetCoreDefinition$, GetCoreDefinitionVersion$, GetDeploymentStatus$, GetDeviceDefinition$, GetDeviceDefinitionVersion$, GetFunctionDefinition$, GetFunctionDefinitionVersion$, GetGroupCertificateAuthority$, GetGroupCertificateConfiguration$, GetGroup$, GetGroupVersion$, GetLoggerDefinition$, GetLoggerDefinitionVersion$, GetResourceDefinition$, GetResourceDefinitionVersion$, GetServiceRoleForAccount$, GetSubscriptionDefinition$, GetSubscriptionDefinitionVersion$, GetThingRuntimeConfiguration$, ListBulkDeploymentDetailedReports$, ListBulkDeployments$, ListConnectorDefinitions$, ListConnectorDefinitionVersions$, ListCoreDefinitions$, ListCoreDefinitionVersions$, ListDeployments$, ListDeviceDefinitions$, ListDeviceDefinitionVersions$, ListFunctionDefinitions$, ListFunctionDefinitionVersions$, ListGroupCertificateAuthorities$, ListGroups$, ListGroupVersions$, ListLoggerDefinitions$, ListLoggerDefinitionVersions$, ListResourceDefinitions$, ListResourceDefinitionVersions$, ListSubscriptionDefinitions$, ListSubscriptionDefinitionVersions$, ListTagsForResource$, ResetDeployments$, StartBulkDeployment$, StopBulkDeployment$, TagResource$, UntagResource$, UpdateConnectivityInfo$, UpdateConnectorDefinition$, UpdateCoreDefinition$, UpdateDeviceDefinition$, UpdateFunctionDefinition$, UpdateGroupCertificateConfiguration$, UpdateGroup$, UpdateLoggerDefinition$, UpdateResourceDefinition$, UpdateSubscriptionDefinition$, UpdateThingRuntimeConfiguration$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { GreengrassServiceException } = require("./models/GreengrassServiceException");
+exports.GreengrassServiceException = GreengrassServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -68,1147 +71,1147 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class GreengrassClient extends client.Client {
+class GreengrassClient extends Client {
     config;
     constructor(...[configuration]) {
-        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        const _config_0 = getRuntimeConfig(configuration || {});
         super(_config_0);
         this.initConfig = _config_0;
         const _config_1 = resolveClientEndpointParameters(_config_0);
-        const _config_2 = client$1.resolveUserAgentConfig(_config_1);
-        const _config_3 = retry.resolveRetryConfig(_config_2);
-        const _config_4 = config.resolveRegionConfig(_config_3);
-        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);
-        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
-        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_2 = resolveUserAgentConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveRegionConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveEndpointConfig(_config_5);
+        const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
-        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
-        this.middlewareStack.use(client$1.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(retry.getRetryPlugin(this.config));
-        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
-        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));
-        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
-            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultGreengrassHttpAuthSchemeParametersProvider,
-            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: defaultGreengrassHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
                 "aws.auth#sigv4": config.credentials,
             }),
         }));
-        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
     }
     destroy() {
         super.destroy();
     }
 }
 
-class AssociateRoleToGroupCommand extends client.Command
+class AssociateRoleToGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "AssociateRoleToGroup", {})
     .n("GreengrassClient", "AssociateRoleToGroupCommand")
-    .sc(schemas_0.AssociateRoleToGroup$)
+    .sc(AssociateRoleToGroup$)
     .build() {
 }
 
-class AssociateServiceRoleToAccountCommand extends client.Command
+class AssociateServiceRoleToAccountCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "AssociateServiceRoleToAccount", {})
     .n("GreengrassClient", "AssociateServiceRoleToAccountCommand")
-    .sc(schemas_0.AssociateServiceRoleToAccount$)
+    .sc(AssociateServiceRoleToAccount$)
     .build() {
 }
 
-class CreateConnectorDefinitionCommand extends client.Command
+class CreateConnectorDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateConnectorDefinition", {})
     .n("GreengrassClient", "CreateConnectorDefinitionCommand")
-    .sc(schemas_0.CreateConnectorDefinition$)
+    .sc(CreateConnectorDefinition$)
     .build() {
 }
 
-class CreateConnectorDefinitionVersionCommand extends client.Command
+class CreateConnectorDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateConnectorDefinitionVersion", {})
     .n("GreengrassClient", "CreateConnectorDefinitionVersionCommand")
-    .sc(schemas_0.CreateConnectorDefinitionVersion$)
+    .sc(CreateConnectorDefinitionVersion$)
     .build() {
 }
 
-class CreateCoreDefinitionCommand extends client.Command
+class CreateCoreDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateCoreDefinition", {})
     .n("GreengrassClient", "CreateCoreDefinitionCommand")
-    .sc(schemas_0.CreateCoreDefinition$)
+    .sc(CreateCoreDefinition$)
     .build() {
 }
 
-class CreateCoreDefinitionVersionCommand extends client.Command
+class CreateCoreDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateCoreDefinitionVersion", {})
     .n("GreengrassClient", "CreateCoreDefinitionVersionCommand")
-    .sc(schemas_0.CreateCoreDefinitionVersion$)
+    .sc(CreateCoreDefinitionVersion$)
     .build() {
 }
 
-class CreateDeploymentCommand extends client.Command
+class CreateDeploymentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateDeployment", {})
     .n("GreengrassClient", "CreateDeploymentCommand")
-    .sc(schemas_0.CreateDeployment$)
+    .sc(CreateDeployment$)
     .build() {
 }
 
-class CreateDeviceDefinitionCommand extends client.Command
+class CreateDeviceDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateDeviceDefinition", {})
     .n("GreengrassClient", "CreateDeviceDefinitionCommand")
-    .sc(schemas_0.CreateDeviceDefinition$)
+    .sc(CreateDeviceDefinition$)
     .build() {
 }
 
-class CreateDeviceDefinitionVersionCommand extends client.Command
+class CreateDeviceDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateDeviceDefinitionVersion", {})
     .n("GreengrassClient", "CreateDeviceDefinitionVersionCommand")
-    .sc(schemas_0.CreateDeviceDefinitionVersion$)
+    .sc(CreateDeviceDefinitionVersion$)
     .build() {
 }
 
-class CreateFunctionDefinitionCommand extends client.Command
+class CreateFunctionDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateFunctionDefinition", {})
     .n("GreengrassClient", "CreateFunctionDefinitionCommand")
-    .sc(schemas_0.CreateFunctionDefinition$)
+    .sc(CreateFunctionDefinition$)
     .build() {
 }
 
-class CreateFunctionDefinitionVersionCommand extends client.Command
+class CreateFunctionDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateFunctionDefinitionVersion", {})
     .n("GreengrassClient", "CreateFunctionDefinitionVersionCommand")
-    .sc(schemas_0.CreateFunctionDefinitionVersion$)
+    .sc(CreateFunctionDefinitionVersion$)
     .build() {
 }
 
-class CreateGroupCertificateAuthorityCommand extends client.Command
+class CreateGroupCertificateAuthorityCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateGroupCertificateAuthority", {})
     .n("GreengrassClient", "CreateGroupCertificateAuthorityCommand")
-    .sc(schemas_0.CreateGroupCertificateAuthority$)
+    .sc(CreateGroupCertificateAuthority$)
     .build() {
 }
 
-class CreateGroupCommand extends client.Command
+class CreateGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateGroup", {})
     .n("GreengrassClient", "CreateGroupCommand")
-    .sc(schemas_0.CreateGroup$)
+    .sc(CreateGroup$)
     .build() {
 }
 
-class CreateGroupVersionCommand extends client.Command
+class CreateGroupVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateGroupVersion", {})
     .n("GreengrassClient", "CreateGroupVersionCommand")
-    .sc(schemas_0.CreateGroupVersion$)
+    .sc(CreateGroupVersion$)
     .build() {
 }
 
-class CreateLoggerDefinitionCommand extends client.Command
+class CreateLoggerDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateLoggerDefinition", {})
     .n("GreengrassClient", "CreateLoggerDefinitionCommand")
-    .sc(schemas_0.CreateLoggerDefinition$)
+    .sc(CreateLoggerDefinition$)
     .build() {
 }
 
-class CreateLoggerDefinitionVersionCommand extends client.Command
+class CreateLoggerDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateLoggerDefinitionVersion", {})
     .n("GreengrassClient", "CreateLoggerDefinitionVersionCommand")
-    .sc(schemas_0.CreateLoggerDefinitionVersion$)
+    .sc(CreateLoggerDefinitionVersion$)
     .build() {
 }
 
-class CreateResourceDefinitionCommand extends client.Command
+class CreateResourceDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateResourceDefinition", {})
     .n("GreengrassClient", "CreateResourceDefinitionCommand")
-    .sc(schemas_0.CreateResourceDefinition$)
+    .sc(CreateResourceDefinition$)
     .build() {
 }
 
-class CreateResourceDefinitionVersionCommand extends client.Command
+class CreateResourceDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateResourceDefinitionVersion", {})
     .n("GreengrassClient", "CreateResourceDefinitionVersionCommand")
-    .sc(schemas_0.CreateResourceDefinitionVersion$)
+    .sc(CreateResourceDefinitionVersion$)
     .build() {
 }
 
-class CreateSoftwareUpdateJobCommand extends client.Command
+class CreateSoftwareUpdateJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateSoftwareUpdateJob", {})
     .n("GreengrassClient", "CreateSoftwareUpdateJobCommand")
-    .sc(schemas_0.CreateSoftwareUpdateJob$)
+    .sc(CreateSoftwareUpdateJob$)
     .build() {
 }
 
-class CreateSubscriptionDefinitionCommand extends client.Command
+class CreateSubscriptionDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateSubscriptionDefinition", {})
     .n("GreengrassClient", "CreateSubscriptionDefinitionCommand")
-    .sc(schemas_0.CreateSubscriptionDefinition$)
+    .sc(CreateSubscriptionDefinition$)
     .build() {
 }
 
-class CreateSubscriptionDefinitionVersionCommand extends client.Command
+class CreateSubscriptionDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "CreateSubscriptionDefinitionVersion", {})
     .n("GreengrassClient", "CreateSubscriptionDefinitionVersionCommand")
-    .sc(schemas_0.CreateSubscriptionDefinitionVersion$)
+    .sc(CreateSubscriptionDefinitionVersion$)
     .build() {
 }
 
-class DeleteConnectorDefinitionCommand extends client.Command
+class DeleteConnectorDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "DeleteConnectorDefinition", {})
     .n("GreengrassClient", "DeleteConnectorDefinitionCommand")
-    .sc(schemas_0.DeleteConnectorDefinition$)
+    .sc(DeleteConnectorDefinition$)
     .build() {
 }
 
-class DeleteCoreDefinitionCommand extends client.Command
+class DeleteCoreDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "DeleteCoreDefinition", {})
     .n("GreengrassClient", "DeleteCoreDefinitionCommand")
-    .sc(schemas_0.DeleteCoreDefinition$)
+    .sc(DeleteCoreDefinition$)
     .build() {
 }
 
-class DeleteDeviceDefinitionCommand extends client.Command
+class DeleteDeviceDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "DeleteDeviceDefinition", {})
     .n("GreengrassClient", "DeleteDeviceDefinitionCommand")
-    .sc(schemas_0.DeleteDeviceDefinition$)
+    .sc(DeleteDeviceDefinition$)
     .build() {
 }
 
-class DeleteFunctionDefinitionCommand extends client.Command
+class DeleteFunctionDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "DeleteFunctionDefinition", {})
     .n("GreengrassClient", "DeleteFunctionDefinitionCommand")
-    .sc(schemas_0.DeleteFunctionDefinition$)
+    .sc(DeleteFunctionDefinition$)
     .build() {
 }
 
-class DeleteGroupCommand extends client.Command
+class DeleteGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "DeleteGroup", {})
     .n("GreengrassClient", "DeleteGroupCommand")
-    .sc(schemas_0.DeleteGroup$)
+    .sc(DeleteGroup$)
     .build() {
 }
 
-class DeleteLoggerDefinitionCommand extends client.Command
+class DeleteLoggerDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "DeleteLoggerDefinition", {})
     .n("GreengrassClient", "DeleteLoggerDefinitionCommand")
-    .sc(schemas_0.DeleteLoggerDefinition$)
+    .sc(DeleteLoggerDefinition$)
     .build() {
 }
 
-class DeleteResourceDefinitionCommand extends client.Command
+class DeleteResourceDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "DeleteResourceDefinition", {})
     .n("GreengrassClient", "DeleteResourceDefinitionCommand")
-    .sc(schemas_0.DeleteResourceDefinition$)
+    .sc(DeleteResourceDefinition$)
     .build() {
 }
 
-class DeleteSubscriptionDefinitionCommand extends client.Command
+class DeleteSubscriptionDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "DeleteSubscriptionDefinition", {})
     .n("GreengrassClient", "DeleteSubscriptionDefinitionCommand")
-    .sc(schemas_0.DeleteSubscriptionDefinition$)
+    .sc(DeleteSubscriptionDefinition$)
     .build() {
 }
 
-class DisassociateRoleFromGroupCommand extends client.Command
+class DisassociateRoleFromGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "DisassociateRoleFromGroup", {})
     .n("GreengrassClient", "DisassociateRoleFromGroupCommand")
-    .sc(schemas_0.DisassociateRoleFromGroup$)
+    .sc(DisassociateRoleFromGroup$)
     .build() {
 }
 
-class DisassociateServiceRoleFromAccountCommand extends client.Command
+class DisassociateServiceRoleFromAccountCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "DisassociateServiceRoleFromAccount", {})
     .n("GreengrassClient", "DisassociateServiceRoleFromAccountCommand")
-    .sc(schemas_0.DisassociateServiceRoleFromAccount$)
+    .sc(DisassociateServiceRoleFromAccount$)
     .build() {
 }
 
-class GetAssociatedRoleCommand extends client.Command
+class GetAssociatedRoleCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetAssociatedRole", {})
     .n("GreengrassClient", "GetAssociatedRoleCommand")
-    .sc(schemas_0.GetAssociatedRole$)
+    .sc(GetAssociatedRole$)
     .build() {
 }
 
-class GetBulkDeploymentStatusCommand extends client.Command
+class GetBulkDeploymentStatusCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetBulkDeploymentStatus", {})
     .n("GreengrassClient", "GetBulkDeploymentStatusCommand")
-    .sc(schemas_0.GetBulkDeploymentStatus$)
+    .sc(GetBulkDeploymentStatus$)
     .build() {
 }
 
-class GetConnectivityInfoCommand extends client.Command
+class GetConnectivityInfoCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetConnectivityInfo", {})
     .n("GreengrassClient", "GetConnectivityInfoCommand")
-    .sc(schemas_0.GetConnectivityInfo$)
+    .sc(GetConnectivityInfo$)
     .build() {
 }
 
-class GetConnectorDefinitionCommand extends client.Command
+class GetConnectorDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetConnectorDefinition", {})
     .n("GreengrassClient", "GetConnectorDefinitionCommand")
-    .sc(schemas_0.GetConnectorDefinition$)
+    .sc(GetConnectorDefinition$)
     .build() {
 }
 
-class GetConnectorDefinitionVersionCommand extends client.Command
+class GetConnectorDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetConnectorDefinitionVersion", {})
     .n("GreengrassClient", "GetConnectorDefinitionVersionCommand")
-    .sc(schemas_0.GetConnectorDefinitionVersion$)
+    .sc(GetConnectorDefinitionVersion$)
     .build() {
 }
 
-class GetCoreDefinitionCommand extends client.Command
+class GetCoreDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetCoreDefinition", {})
     .n("GreengrassClient", "GetCoreDefinitionCommand")
-    .sc(schemas_0.GetCoreDefinition$)
+    .sc(GetCoreDefinition$)
     .build() {
 }
 
-class GetCoreDefinitionVersionCommand extends client.Command
+class GetCoreDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetCoreDefinitionVersion", {})
     .n("GreengrassClient", "GetCoreDefinitionVersionCommand")
-    .sc(schemas_0.GetCoreDefinitionVersion$)
+    .sc(GetCoreDefinitionVersion$)
     .build() {
 }
 
-class GetDeploymentStatusCommand extends client.Command
+class GetDeploymentStatusCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetDeploymentStatus", {})
     .n("GreengrassClient", "GetDeploymentStatusCommand")
-    .sc(schemas_0.GetDeploymentStatus$)
+    .sc(GetDeploymentStatus$)
     .build() {
 }
 
-class GetDeviceDefinitionCommand extends client.Command
+class GetDeviceDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetDeviceDefinition", {})
     .n("GreengrassClient", "GetDeviceDefinitionCommand")
-    .sc(schemas_0.GetDeviceDefinition$)
+    .sc(GetDeviceDefinition$)
     .build() {
 }
 
-class GetDeviceDefinitionVersionCommand extends client.Command
+class GetDeviceDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetDeviceDefinitionVersion", {})
     .n("GreengrassClient", "GetDeviceDefinitionVersionCommand")
-    .sc(schemas_0.GetDeviceDefinitionVersion$)
+    .sc(GetDeviceDefinitionVersion$)
     .build() {
 }
 
-class GetFunctionDefinitionCommand extends client.Command
+class GetFunctionDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetFunctionDefinition", {})
     .n("GreengrassClient", "GetFunctionDefinitionCommand")
-    .sc(schemas_0.GetFunctionDefinition$)
+    .sc(GetFunctionDefinition$)
     .build() {
 }
 
-class GetFunctionDefinitionVersionCommand extends client.Command
+class GetFunctionDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetFunctionDefinitionVersion", {})
     .n("GreengrassClient", "GetFunctionDefinitionVersionCommand")
-    .sc(schemas_0.GetFunctionDefinitionVersion$)
+    .sc(GetFunctionDefinitionVersion$)
     .build() {
 }
 
-class GetGroupCertificateAuthorityCommand extends client.Command
+class GetGroupCertificateAuthorityCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetGroupCertificateAuthority", {})
     .n("GreengrassClient", "GetGroupCertificateAuthorityCommand")
-    .sc(schemas_0.GetGroupCertificateAuthority$)
+    .sc(GetGroupCertificateAuthority$)
     .build() {
 }
 
-class GetGroupCertificateConfigurationCommand extends client.Command
+class GetGroupCertificateConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetGroupCertificateConfiguration", {})
     .n("GreengrassClient", "GetGroupCertificateConfigurationCommand")
-    .sc(schemas_0.GetGroupCertificateConfiguration$)
+    .sc(GetGroupCertificateConfiguration$)
     .build() {
 }
 
-class GetGroupCommand extends client.Command
+class GetGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetGroup", {})
     .n("GreengrassClient", "GetGroupCommand")
-    .sc(schemas_0.GetGroup$)
+    .sc(GetGroup$)
     .build() {
 }
 
-class GetGroupVersionCommand extends client.Command
+class GetGroupVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetGroupVersion", {})
     .n("GreengrassClient", "GetGroupVersionCommand")
-    .sc(schemas_0.GetGroupVersion$)
+    .sc(GetGroupVersion$)
     .build() {
 }
 
-class GetLoggerDefinitionCommand extends client.Command
+class GetLoggerDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetLoggerDefinition", {})
     .n("GreengrassClient", "GetLoggerDefinitionCommand")
-    .sc(schemas_0.GetLoggerDefinition$)
+    .sc(GetLoggerDefinition$)
     .build() {
 }
 
-class GetLoggerDefinitionVersionCommand extends client.Command
+class GetLoggerDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetLoggerDefinitionVersion", {})
     .n("GreengrassClient", "GetLoggerDefinitionVersionCommand")
-    .sc(schemas_0.GetLoggerDefinitionVersion$)
+    .sc(GetLoggerDefinitionVersion$)
     .build() {
 }
 
-class GetResourceDefinitionCommand extends client.Command
+class GetResourceDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetResourceDefinition", {})
     .n("GreengrassClient", "GetResourceDefinitionCommand")
-    .sc(schemas_0.GetResourceDefinition$)
+    .sc(GetResourceDefinition$)
     .build() {
 }
 
-class GetResourceDefinitionVersionCommand extends client.Command
+class GetResourceDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetResourceDefinitionVersion", {})
     .n("GreengrassClient", "GetResourceDefinitionVersionCommand")
-    .sc(schemas_0.GetResourceDefinitionVersion$)
+    .sc(GetResourceDefinitionVersion$)
     .build() {
 }
 
-class GetServiceRoleForAccountCommand extends client.Command
+class GetServiceRoleForAccountCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetServiceRoleForAccount", {})
     .n("GreengrassClient", "GetServiceRoleForAccountCommand")
-    .sc(schemas_0.GetServiceRoleForAccount$)
+    .sc(GetServiceRoleForAccount$)
     .build() {
 }
 
-class GetSubscriptionDefinitionCommand extends client.Command
+class GetSubscriptionDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetSubscriptionDefinition", {})
     .n("GreengrassClient", "GetSubscriptionDefinitionCommand")
-    .sc(schemas_0.GetSubscriptionDefinition$)
+    .sc(GetSubscriptionDefinition$)
     .build() {
 }
 
-class GetSubscriptionDefinitionVersionCommand extends client.Command
+class GetSubscriptionDefinitionVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetSubscriptionDefinitionVersion", {})
     .n("GreengrassClient", "GetSubscriptionDefinitionVersionCommand")
-    .sc(schemas_0.GetSubscriptionDefinitionVersion$)
+    .sc(GetSubscriptionDefinitionVersion$)
     .build() {
 }
 
-class GetThingRuntimeConfigurationCommand extends client.Command
+class GetThingRuntimeConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "GetThingRuntimeConfiguration", {})
     .n("GreengrassClient", "GetThingRuntimeConfigurationCommand")
-    .sc(schemas_0.GetThingRuntimeConfiguration$)
+    .sc(GetThingRuntimeConfiguration$)
     .build() {
 }
 
-class ListBulkDeploymentDetailedReportsCommand extends client.Command
+class ListBulkDeploymentDetailedReportsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListBulkDeploymentDetailedReports", {})
     .n("GreengrassClient", "ListBulkDeploymentDetailedReportsCommand")
-    .sc(schemas_0.ListBulkDeploymentDetailedReports$)
+    .sc(ListBulkDeploymentDetailedReports$)
     .build() {
 }
 
-class ListBulkDeploymentsCommand extends client.Command
+class ListBulkDeploymentsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListBulkDeployments", {})
     .n("GreengrassClient", "ListBulkDeploymentsCommand")
-    .sc(schemas_0.ListBulkDeployments$)
+    .sc(ListBulkDeployments$)
     .build() {
 }
 
-class ListConnectorDefinitionsCommand extends client.Command
+class ListConnectorDefinitionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListConnectorDefinitions", {})
     .n("GreengrassClient", "ListConnectorDefinitionsCommand")
-    .sc(schemas_0.ListConnectorDefinitions$)
+    .sc(ListConnectorDefinitions$)
     .build() {
 }
 
-class ListConnectorDefinitionVersionsCommand extends client.Command
+class ListConnectorDefinitionVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListConnectorDefinitionVersions", {})
     .n("GreengrassClient", "ListConnectorDefinitionVersionsCommand")
-    .sc(schemas_0.ListConnectorDefinitionVersions$)
+    .sc(ListConnectorDefinitionVersions$)
     .build() {
 }
 
-class ListCoreDefinitionsCommand extends client.Command
+class ListCoreDefinitionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListCoreDefinitions", {})
     .n("GreengrassClient", "ListCoreDefinitionsCommand")
-    .sc(schemas_0.ListCoreDefinitions$)
+    .sc(ListCoreDefinitions$)
     .build() {
 }
 
-class ListCoreDefinitionVersionsCommand extends client.Command
+class ListCoreDefinitionVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListCoreDefinitionVersions", {})
     .n("GreengrassClient", "ListCoreDefinitionVersionsCommand")
-    .sc(schemas_0.ListCoreDefinitionVersions$)
+    .sc(ListCoreDefinitionVersions$)
     .build() {
 }
 
-class ListDeploymentsCommand extends client.Command
+class ListDeploymentsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListDeployments", {})
     .n("GreengrassClient", "ListDeploymentsCommand")
-    .sc(schemas_0.ListDeployments$)
+    .sc(ListDeployments$)
     .build() {
 }
 
-class ListDeviceDefinitionsCommand extends client.Command
+class ListDeviceDefinitionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListDeviceDefinitions", {})
     .n("GreengrassClient", "ListDeviceDefinitionsCommand")
-    .sc(schemas_0.ListDeviceDefinitions$)
+    .sc(ListDeviceDefinitions$)
     .build() {
 }
 
-class ListDeviceDefinitionVersionsCommand extends client.Command
+class ListDeviceDefinitionVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListDeviceDefinitionVersions", {})
     .n("GreengrassClient", "ListDeviceDefinitionVersionsCommand")
-    .sc(schemas_0.ListDeviceDefinitionVersions$)
+    .sc(ListDeviceDefinitionVersions$)
     .build() {
 }
 
-class ListFunctionDefinitionsCommand extends client.Command
+class ListFunctionDefinitionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListFunctionDefinitions", {})
     .n("GreengrassClient", "ListFunctionDefinitionsCommand")
-    .sc(schemas_0.ListFunctionDefinitions$)
+    .sc(ListFunctionDefinitions$)
     .build() {
 }
 
-class ListFunctionDefinitionVersionsCommand extends client.Command
+class ListFunctionDefinitionVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListFunctionDefinitionVersions", {})
     .n("GreengrassClient", "ListFunctionDefinitionVersionsCommand")
-    .sc(schemas_0.ListFunctionDefinitionVersions$)
+    .sc(ListFunctionDefinitionVersions$)
     .build() {
 }
 
-class ListGroupCertificateAuthoritiesCommand extends client.Command
+class ListGroupCertificateAuthoritiesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListGroupCertificateAuthorities", {})
     .n("GreengrassClient", "ListGroupCertificateAuthoritiesCommand")
-    .sc(schemas_0.ListGroupCertificateAuthorities$)
+    .sc(ListGroupCertificateAuthorities$)
     .build() {
 }
 
-class ListGroupsCommand extends client.Command
+class ListGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListGroups", {})
     .n("GreengrassClient", "ListGroupsCommand")
-    .sc(schemas_0.ListGroups$)
+    .sc(ListGroups$)
     .build() {
 }
 
-class ListGroupVersionsCommand extends client.Command
+class ListGroupVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListGroupVersions", {})
     .n("GreengrassClient", "ListGroupVersionsCommand")
-    .sc(schemas_0.ListGroupVersions$)
+    .sc(ListGroupVersions$)
     .build() {
 }
 
-class ListLoggerDefinitionsCommand extends client.Command
+class ListLoggerDefinitionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListLoggerDefinitions", {})
     .n("GreengrassClient", "ListLoggerDefinitionsCommand")
-    .sc(schemas_0.ListLoggerDefinitions$)
+    .sc(ListLoggerDefinitions$)
     .build() {
 }
 
-class ListLoggerDefinitionVersionsCommand extends client.Command
+class ListLoggerDefinitionVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListLoggerDefinitionVersions", {})
     .n("GreengrassClient", "ListLoggerDefinitionVersionsCommand")
-    .sc(schemas_0.ListLoggerDefinitionVersions$)
+    .sc(ListLoggerDefinitionVersions$)
     .build() {
 }
 
-class ListResourceDefinitionsCommand extends client.Command
+class ListResourceDefinitionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListResourceDefinitions", {})
     .n("GreengrassClient", "ListResourceDefinitionsCommand")
-    .sc(schemas_0.ListResourceDefinitions$)
+    .sc(ListResourceDefinitions$)
     .build() {
 }
 
-class ListResourceDefinitionVersionsCommand extends client.Command
+class ListResourceDefinitionVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListResourceDefinitionVersions", {})
     .n("GreengrassClient", "ListResourceDefinitionVersionsCommand")
-    .sc(schemas_0.ListResourceDefinitionVersions$)
+    .sc(ListResourceDefinitionVersions$)
     .build() {
 }
 
-class ListSubscriptionDefinitionsCommand extends client.Command
+class ListSubscriptionDefinitionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListSubscriptionDefinitions", {})
     .n("GreengrassClient", "ListSubscriptionDefinitionsCommand")
-    .sc(schemas_0.ListSubscriptionDefinitions$)
+    .sc(ListSubscriptionDefinitions$)
     .build() {
 }
 
-class ListSubscriptionDefinitionVersionsCommand extends client.Command
+class ListSubscriptionDefinitionVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListSubscriptionDefinitionVersions", {})
     .n("GreengrassClient", "ListSubscriptionDefinitionVersionsCommand")
-    .sc(schemas_0.ListSubscriptionDefinitionVersions$)
+    .sc(ListSubscriptionDefinitionVersions$)
     .build() {
 }
 
-class ListTagsForResourceCommand extends client.Command
+class ListTagsForResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ListTagsForResource", {})
     .n("GreengrassClient", "ListTagsForResourceCommand")
-    .sc(schemas_0.ListTagsForResource$)
+    .sc(ListTagsForResource$)
     .build() {
 }
 
-class ResetDeploymentsCommand extends client.Command
+class ResetDeploymentsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "ResetDeployments", {})
     .n("GreengrassClient", "ResetDeploymentsCommand")
-    .sc(schemas_0.ResetDeployments$)
+    .sc(ResetDeployments$)
     .build() {
 }
 
-class StartBulkDeploymentCommand extends client.Command
+class StartBulkDeploymentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "StartBulkDeployment", {})
     .n("GreengrassClient", "StartBulkDeploymentCommand")
-    .sc(schemas_0.StartBulkDeployment$)
+    .sc(StartBulkDeployment$)
     .build() {
 }
 
-class StopBulkDeploymentCommand extends client.Command
+class StopBulkDeploymentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "StopBulkDeployment", {})
     .n("GreengrassClient", "StopBulkDeploymentCommand")
-    .sc(schemas_0.StopBulkDeployment$)
+    .sc(StopBulkDeployment$)
     .build() {
 }
 
-class TagResourceCommand extends client.Command
+class TagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "TagResource", {})
     .n("GreengrassClient", "TagResourceCommand")
-    .sc(schemas_0.TagResource$)
+    .sc(TagResource$)
     .build() {
 }
 
-class UntagResourceCommand extends client.Command
+class UntagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "UntagResource", {})
     .n("GreengrassClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateConnectivityInfoCommand extends client.Command
+class UpdateConnectivityInfoCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "UpdateConnectivityInfo", {})
     .n("GreengrassClient", "UpdateConnectivityInfoCommand")
-    .sc(schemas_0.UpdateConnectivityInfo$)
+    .sc(UpdateConnectivityInfo$)
     .build() {
 }
 
-class UpdateConnectorDefinitionCommand extends client.Command
+class UpdateConnectorDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "UpdateConnectorDefinition", {})
     .n("GreengrassClient", "UpdateConnectorDefinitionCommand")
-    .sc(schemas_0.UpdateConnectorDefinition$)
+    .sc(UpdateConnectorDefinition$)
     .build() {
 }
 
-class UpdateCoreDefinitionCommand extends client.Command
+class UpdateCoreDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "UpdateCoreDefinition", {})
     .n("GreengrassClient", "UpdateCoreDefinitionCommand")
-    .sc(schemas_0.UpdateCoreDefinition$)
+    .sc(UpdateCoreDefinition$)
     .build() {
 }
 
-class UpdateDeviceDefinitionCommand extends client.Command
+class UpdateDeviceDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "UpdateDeviceDefinition", {})
     .n("GreengrassClient", "UpdateDeviceDefinitionCommand")
-    .sc(schemas_0.UpdateDeviceDefinition$)
+    .sc(UpdateDeviceDefinition$)
     .build() {
 }
 
-class UpdateFunctionDefinitionCommand extends client.Command
+class UpdateFunctionDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "UpdateFunctionDefinition", {})
     .n("GreengrassClient", "UpdateFunctionDefinitionCommand")
-    .sc(schemas_0.UpdateFunctionDefinition$)
+    .sc(UpdateFunctionDefinition$)
     .build() {
 }
 
-class UpdateGroupCertificateConfigurationCommand extends client.Command
+class UpdateGroupCertificateConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "UpdateGroupCertificateConfiguration", {})
     .n("GreengrassClient", "UpdateGroupCertificateConfigurationCommand")
-    .sc(schemas_0.UpdateGroupCertificateConfiguration$)
+    .sc(UpdateGroupCertificateConfiguration$)
     .build() {
 }
 
-class UpdateGroupCommand extends client.Command
+class UpdateGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "UpdateGroup", {})
     .n("GreengrassClient", "UpdateGroupCommand")
-    .sc(schemas_0.UpdateGroup$)
+    .sc(UpdateGroup$)
     .build() {
 }
 
-class UpdateLoggerDefinitionCommand extends client.Command
+class UpdateLoggerDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "UpdateLoggerDefinition", {})
     .n("GreengrassClient", "UpdateLoggerDefinitionCommand")
-    .sc(schemas_0.UpdateLoggerDefinition$)
+    .sc(UpdateLoggerDefinition$)
     .build() {
 }
 
-class UpdateResourceDefinitionCommand extends client.Command
+class UpdateResourceDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "UpdateResourceDefinition", {})
     .n("GreengrassClient", "UpdateResourceDefinitionCommand")
-    .sc(schemas_0.UpdateResourceDefinition$)
+    .sc(UpdateResourceDefinition$)
     .build() {
 }
 
-class UpdateSubscriptionDefinitionCommand extends client.Command
+class UpdateSubscriptionDefinitionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "UpdateSubscriptionDefinition", {})
     .n("GreengrassClient", "UpdateSubscriptionDefinitionCommand")
-    .sc(schemas_0.UpdateSubscriptionDefinition$)
+    .sc(UpdateSubscriptionDefinition$)
     .build() {
 }
 
-class UpdateThingRuntimeConfigurationCommand extends client.Command
+class UpdateThingRuntimeConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Greengrass", "UpdateThingRuntimeConfiguration", {})
     .n("GreengrassClient", "UpdateThingRuntimeConfigurationCommand")
-    .sc(schemas_0.UpdateThingRuntimeConfiguration$)
+    .sc(UpdateThingRuntimeConfiguration$)
     .build() {
 }
 
@@ -1308,7 +1311,7 @@ const commands = {
 };
 class Greengrass extends GreengrassClient {
 }
-client.createAggregatedClient(commands, Greengrass);
+createAggregatedClient(commands, Greengrass);
 
 const EncodingType = {
     binary: "binary",
@@ -1386,9 +1389,6 @@ const Telemetry = {
     On: "On",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.GreengrassServiceException = GreengrassServiceException.GreengrassServiceException;
 exports.AssociateRoleToGroupCommand = AssociateRoleToGroupCommand;
 exports.AssociateServiceRoleToAccountCommand = AssociateServiceRoleToAccountCommand;
 exports.BulkDeploymentStatus = BulkDeploymentStatus;
@@ -1497,23 +1497,3 @@ exports.UpdateSubscriptionDefinitionCommand = UpdateSubscriptionDefinitionComman
 exports.UpdateTargetsArchitecture = UpdateTargetsArchitecture;
 exports.UpdateTargetsOperatingSystem = UpdateTargetsOperatingSystem;
 exports.UpdateThingRuntimeConfigurationCommand = UpdateThingRuntimeConfigurationCommand;
-Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: schemas_0['__proto__']
-    });
-
-Object.keys(schemas_0).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
-});
-Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: errors['__proto__']
-    });
-
-Object.keys(errors).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
-});