@aws-sdk/client-iot-managed-integrations 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 IoTManagedIntegrationsServiceException = require('./models/IoTManagedIntegrationsServiceException');
+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, createPaginator } = 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, defaultIoTManagedIntegrationsHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { CreateAccountAssociation$, CreateCloudConnector$, CreateConnectorDestination$, CreateCredentialLocker$, CreateDestination$, CreateEventLogConfiguration$, CreateManagedThing$, CreateNotificationConfiguration$, CreateOtaTask$, CreateOtaTaskConfiguration$, CreateProvisioningProfile$, DeleteAccountAssociation$, DeleteCloudConnector$, DeleteConnectorDestination$, DeleteCredentialLocker$, DeleteDestination$, DeleteEventLogConfiguration$, DeleteManagedThing$, DeleteNotificationConfiguration$, DeleteOtaTask$, DeleteOtaTaskConfiguration$, DeleteProvisioningProfile$, DeregisterAccountAssociation$, GetAccountAssociation$, GetCloudConnector$, GetConnectorDestination$, GetCredentialLocker$, GetCustomEndpoint$, GetDefaultEncryptionConfiguration$, GetDestination$, GetDeviceDiscovery$, GetEventLogConfiguration$, GetHubConfiguration$, GetManagedThingCapabilities$, GetManagedThingCertificate$, GetManagedThing$, GetManagedThingConnectivityData$, GetManagedThingMetaData$, GetManagedThingState$, GetNotificationConfiguration$, GetOtaTask$, GetOtaTaskConfiguration$, GetProvisioningProfile$, GetRuntimeLogConfiguration$, GetSchemaVersion$, ListAccountAssociations$, ListCloudConnectors$, ListConnectorDestinations$, ListCredentialLockers$, ListDestinations$, ListDeviceDiscoveries$, ListDiscoveredDevices$, ListEventLogConfigurations$, ListManagedThingAccountAssociations$, ListManagedThingSchemas$, ListManagedThings$, ListNotificationConfigurations$, ListOtaTaskConfigurations$, ListOtaTaskExecutions$, ListOtaTasks$, ListProvisioningProfiles$, ListSchemaVersions$, ListTagsForResource$, PutDefaultEncryptionConfiguration$, PutHubConfiguration$, PutRuntimeLogConfiguration$, RegisterAccountAssociation$, RegisterCustomEndpoint$, ResetRuntimeLogConfiguration$, SendConnectorEvent$, SendManagedThingCommand$, StartAccountAssociationRefresh$, StartDeviceDiscovery$, TagResource$, UntagResource$, UpdateAccountAssociation$, UpdateCloudConnector$, UpdateConnectorDestination$, UpdateDestination$, UpdateEventLogConfiguration$, UpdateManagedThing$, UpdateNotificationConfiguration$, UpdateOtaTask$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { IoTManagedIntegrationsServiceException } = require("./models/IoTManagedIntegrationsServiceException");
+exports.IoTManagedIntegrationsServiceException = IoTManagedIntegrationsServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -66,1075 +69,1075 @@ 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 IoTManagedIntegrationsClient extends client.Client {
+class IoTManagedIntegrationsClient 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.defaultIoTManagedIntegrationsHttpAuthSchemeParametersProvider,
-            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: defaultIoTManagedIntegrationsHttpAuthSchemeParametersProvider,
+            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 CreateAccountAssociationCommand extends client.Command
+class CreateAccountAssociationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "CreateAccountAssociation", {})
     .n("IoTManagedIntegrationsClient", "CreateAccountAssociationCommand")
-    .sc(schemas_0.CreateAccountAssociation$)
+    .sc(CreateAccountAssociation$)
     .build() {
 }
 
-class CreateCloudConnectorCommand extends client.Command
+class CreateCloudConnectorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "CreateCloudConnector", {})
     .n("IoTManagedIntegrationsClient", "CreateCloudConnectorCommand")
-    .sc(schemas_0.CreateCloudConnector$)
+    .sc(CreateCloudConnector$)
     .build() {
 }
 
-class CreateConnectorDestinationCommand extends client.Command
+class CreateConnectorDestinationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "CreateConnectorDestination", {})
     .n("IoTManagedIntegrationsClient", "CreateConnectorDestinationCommand")
-    .sc(schemas_0.CreateConnectorDestination$)
+    .sc(CreateConnectorDestination$)
     .build() {
 }
 
-class CreateCredentialLockerCommand extends client.Command
+class CreateCredentialLockerCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "CreateCredentialLocker", {})
     .n("IoTManagedIntegrationsClient", "CreateCredentialLockerCommand")
-    .sc(schemas_0.CreateCredentialLocker$)
+    .sc(CreateCredentialLocker$)
     .build() {
 }
 
-class CreateDestinationCommand extends client.Command
+class CreateDestinationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "CreateDestination", {})
     .n("IoTManagedIntegrationsClient", "CreateDestinationCommand")
-    .sc(schemas_0.CreateDestination$)
+    .sc(CreateDestination$)
     .build() {
 }
 
-class CreateEventLogConfigurationCommand extends client.Command
+class CreateEventLogConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "CreateEventLogConfiguration", {})
     .n("IoTManagedIntegrationsClient", "CreateEventLogConfigurationCommand")
-    .sc(schemas_0.CreateEventLogConfiguration$)
+    .sc(CreateEventLogConfiguration$)
     .build() {
 }
 
-class CreateManagedThingCommand extends client.Command
+class CreateManagedThingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "CreateManagedThing", {})
     .n("IoTManagedIntegrationsClient", "CreateManagedThingCommand")
-    .sc(schemas_0.CreateManagedThing$)
+    .sc(CreateManagedThing$)
     .build() {
 }
 
-class CreateNotificationConfigurationCommand extends client.Command
+class CreateNotificationConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "CreateNotificationConfiguration", {})
     .n("IoTManagedIntegrationsClient", "CreateNotificationConfigurationCommand")
-    .sc(schemas_0.CreateNotificationConfiguration$)
+    .sc(CreateNotificationConfiguration$)
     .build() {
 }
 
-class CreateOtaTaskCommand extends client.Command
+class CreateOtaTaskCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "CreateOtaTask", {})
     .n("IoTManagedIntegrationsClient", "CreateOtaTaskCommand")
-    .sc(schemas_0.CreateOtaTask$)
+    .sc(CreateOtaTask$)
     .build() {
 }
 
-class CreateOtaTaskConfigurationCommand extends client.Command
+class CreateOtaTaskConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "CreateOtaTaskConfiguration", {})
     .n("IoTManagedIntegrationsClient", "CreateOtaTaskConfigurationCommand")
-    .sc(schemas_0.CreateOtaTaskConfiguration$)
+    .sc(CreateOtaTaskConfiguration$)
     .build() {
 }
 
-class CreateProvisioningProfileCommand extends client.Command
+class CreateProvisioningProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "CreateProvisioningProfile", {})
     .n("IoTManagedIntegrationsClient", "CreateProvisioningProfileCommand")
-    .sc(schemas_0.CreateProvisioningProfile$)
+    .sc(CreateProvisioningProfile$)
     .build() {
 }
 
-class DeleteAccountAssociationCommand extends client.Command
+class DeleteAccountAssociationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "DeleteAccountAssociation", {})
     .n("IoTManagedIntegrationsClient", "DeleteAccountAssociationCommand")
-    .sc(schemas_0.DeleteAccountAssociation$)
+    .sc(DeleteAccountAssociation$)
     .build() {
 }
 
-class DeleteCloudConnectorCommand extends client.Command
+class DeleteCloudConnectorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "DeleteCloudConnector", {})
     .n("IoTManagedIntegrationsClient", "DeleteCloudConnectorCommand")
-    .sc(schemas_0.DeleteCloudConnector$)
+    .sc(DeleteCloudConnector$)
     .build() {
 }
 
-class DeleteConnectorDestinationCommand extends client.Command
+class DeleteConnectorDestinationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "DeleteConnectorDestination", {})
     .n("IoTManagedIntegrationsClient", "DeleteConnectorDestinationCommand")
-    .sc(schemas_0.DeleteConnectorDestination$)
+    .sc(DeleteConnectorDestination$)
     .build() {
 }
 
-class DeleteCredentialLockerCommand extends client.Command
+class DeleteCredentialLockerCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "DeleteCredentialLocker", {})
     .n("IoTManagedIntegrationsClient", "DeleteCredentialLockerCommand")
-    .sc(schemas_0.DeleteCredentialLocker$)
+    .sc(DeleteCredentialLocker$)
     .build() {
 }
 
-class DeleteDestinationCommand extends client.Command
+class DeleteDestinationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "DeleteDestination", {})
     .n("IoTManagedIntegrationsClient", "DeleteDestinationCommand")
-    .sc(schemas_0.DeleteDestination$)
+    .sc(DeleteDestination$)
     .build() {
 }
 
-class DeleteEventLogConfigurationCommand extends client.Command
+class DeleteEventLogConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "DeleteEventLogConfiguration", {})
     .n("IoTManagedIntegrationsClient", "DeleteEventLogConfigurationCommand")
-    .sc(schemas_0.DeleteEventLogConfiguration$)
+    .sc(DeleteEventLogConfiguration$)
     .build() {
 }
 
-class DeleteManagedThingCommand extends client.Command
+class DeleteManagedThingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "DeleteManagedThing", {})
     .n("IoTManagedIntegrationsClient", "DeleteManagedThingCommand")
-    .sc(schemas_0.DeleteManagedThing$)
+    .sc(DeleteManagedThing$)
     .build() {
 }
 
-class DeleteNotificationConfigurationCommand extends client.Command
+class DeleteNotificationConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "DeleteNotificationConfiguration", {})
     .n("IoTManagedIntegrationsClient", "DeleteNotificationConfigurationCommand")
-    .sc(schemas_0.DeleteNotificationConfiguration$)
+    .sc(DeleteNotificationConfiguration$)
     .build() {
 }
 
-class DeleteOtaTaskCommand extends client.Command
+class DeleteOtaTaskCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "DeleteOtaTask", {})
     .n("IoTManagedIntegrationsClient", "DeleteOtaTaskCommand")
-    .sc(schemas_0.DeleteOtaTask$)
+    .sc(DeleteOtaTask$)
     .build() {
 }
 
-class DeleteOtaTaskConfigurationCommand extends client.Command
+class DeleteOtaTaskConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "DeleteOtaTaskConfiguration", {})
     .n("IoTManagedIntegrationsClient", "DeleteOtaTaskConfigurationCommand")
-    .sc(schemas_0.DeleteOtaTaskConfiguration$)
+    .sc(DeleteOtaTaskConfiguration$)
     .build() {
 }
 
-class DeleteProvisioningProfileCommand extends client.Command
+class DeleteProvisioningProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "DeleteProvisioningProfile", {})
     .n("IoTManagedIntegrationsClient", "DeleteProvisioningProfileCommand")
-    .sc(schemas_0.DeleteProvisioningProfile$)
+    .sc(DeleteProvisioningProfile$)
     .build() {
 }
 
-class DeregisterAccountAssociationCommand extends client.Command
+class DeregisterAccountAssociationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "DeregisterAccountAssociation", {})
     .n("IoTManagedIntegrationsClient", "DeregisterAccountAssociationCommand")
-    .sc(schemas_0.DeregisterAccountAssociation$)
+    .sc(DeregisterAccountAssociation$)
     .build() {
 }
 
-class GetAccountAssociationCommand extends client.Command
+class GetAccountAssociationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetAccountAssociation", {})
     .n("IoTManagedIntegrationsClient", "GetAccountAssociationCommand")
-    .sc(schemas_0.GetAccountAssociation$)
+    .sc(GetAccountAssociation$)
     .build() {
 }
 
-class GetCloudConnectorCommand extends client.Command
+class GetCloudConnectorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetCloudConnector", {})
     .n("IoTManagedIntegrationsClient", "GetCloudConnectorCommand")
-    .sc(schemas_0.GetCloudConnector$)
+    .sc(GetCloudConnector$)
     .build() {
 }
 
-class GetConnectorDestinationCommand extends client.Command
+class GetConnectorDestinationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetConnectorDestination", {})
     .n("IoTManagedIntegrationsClient", "GetConnectorDestinationCommand")
-    .sc(schemas_0.GetConnectorDestination$)
+    .sc(GetConnectorDestination$)
     .build() {
 }
 
-class GetCredentialLockerCommand extends client.Command
+class GetCredentialLockerCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetCredentialLocker", {})
     .n("IoTManagedIntegrationsClient", "GetCredentialLockerCommand")
-    .sc(schemas_0.GetCredentialLocker$)
+    .sc(GetCredentialLocker$)
     .build() {
 }
 
-class GetCustomEndpointCommand extends client.Command
+class GetCustomEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetCustomEndpoint", {})
     .n("IoTManagedIntegrationsClient", "GetCustomEndpointCommand")
-    .sc(schemas_0.GetCustomEndpoint$)
+    .sc(GetCustomEndpoint$)
     .build() {
 }
 
-class GetDefaultEncryptionConfigurationCommand extends client.Command
+class GetDefaultEncryptionConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetDefaultEncryptionConfiguration", {})
     .n("IoTManagedIntegrationsClient", "GetDefaultEncryptionConfigurationCommand")
-    .sc(schemas_0.GetDefaultEncryptionConfiguration$)
+    .sc(GetDefaultEncryptionConfiguration$)
     .build() {
 }
 
-class GetDestinationCommand extends client.Command
+class GetDestinationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetDestination", {})
     .n("IoTManagedIntegrationsClient", "GetDestinationCommand")
-    .sc(schemas_0.GetDestination$)
+    .sc(GetDestination$)
     .build() {
 }
 
-class GetDeviceDiscoveryCommand extends client.Command
+class GetDeviceDiscoveryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetDeviceDiscovery", {})
     .n("IoTManagedIntegrationsClient", "GetDeviceDiscoveryCommand")
-    .sc(schemas_0.GetDeviceDiscovery$)
+    .sc(GetDeviceDiscovery$)
     .build() {
 }
 
-class GetEventLogConfigurationCommand extends client.Command
+class GetEventLogConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetEventLogConfiguration", {})
     .n("IoTManagedIntegrationsClient", "GetEventLogConfigurationCommand")
-    .sc(schemas_0.GetEventLogConfiguration$)
+    .sc(GetEventLogConfiguration$)
     .build() {
 }
 
-class GetHubConfigurationCommand extends client.Command
+class GetHubConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetHubConfiguration", {})
     .n("IoTManagedIntegrationsClient", "GetHubConfigurationCommand")
-    .sc(schemas_0.GetHubConfiguration$)
+    .sc(GetHubConfiguration$)
     .build() {
 }
 
-class GetManagedThingCapabilitiesCommand extends client.Command
+class GetManagedThingCapabilitiesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetManagedThingCapabilities", {})
     .n("IoTManagedIntegrationsClient", "GetManagedThingCapabilitiesCommand")
-    .sc(schemas_0.GetManagedThingCapabilities$)
+    .sc(GetManagedThingCapabilities$)
     .build() {
 }
 
-class GetManagedThingCertificateCommand extends client.Command
+class GetManagedThingCertificateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetManagedThingCertificate", {})
     .n("IoTManagedIntegrationsClient", "GetManagedThingCertificateCommand")
-    .sc(schemas_0.GetManagedThingCertificate$)
+    .sc(GetManagedThingCertificate$)
     .build() {
 }
 
-class GetManagedThingCommand extends client.Command
+class GetManagedThingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetManagedThing", {})
     .n("IoTManagedIntegrationsClient", "GetManagedThingCommand")
-    .sc(schemas_0.GetManagedThing$)
+    .sc(GetManagedThing$)
     .build() {
 }
 
-class GetManagedThingConnectivityDataCommand extends client.Command
+class GetManagedThingConnectivityDataCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetManagedThingConnectivityData", {})
     .n("IoTManagedIntegrationsClient", "GetManagedThingConnectivityDataCommand")
-    .sc(schemas_0.GetManagedThingConnectivityData$)
+    .sc(GetManagedThingConnectivityData$)
     .build() {
 }
 
-class GetManagedThingMetaDataCommand extends client.Command
+class GetManagedThingMetaDataCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetManagedThingMetaData", {})
     .n("IoTManagedIntegrationsClient", "GetManagedThingMetaDataCommand")
-    .sc(schemas_0.GetManagedThingMetaData$)
+    .sc(GetManagedThingMetaData$)
     .build() {
 }
 
-class GetManagedThingStateCommand extends client.Command
+class GetManagedThingStateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetManagedThingState", {})
     .n("IoTManagedIntegrationsClient", "GetManagedThingStateCommand")
-    .sc(schemas_0.GetManagedThingState$)
+    .sc(GetManagedThingState$)
     .build() {
 }
 
-class GetNotificationConfigurationCommand extends client.Command
+class GetNotificationConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetNotificationConfiguration", {})
     .n("IoTManagedIntegrationsClient", "GetNotificationConfigurationCommand")
-    .sc(schemas_0.GetNotificationConfiguration$)
+    .sc(GetNotificationConfiguration$)
     .build() {
 }
 
-class GetOtaTaskCommand extends client.Command
+class GetOtaTaskCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetOtaTask", {})
     .n("IoTManagedIntegrationsClient", "GetOtaTaskCommand")
-    .sc(schemas_0.GetOtaTask$)
+    .sc(GetOtaTask$)
     .build() {
 }
 
-class GetOtaTaskConfigurationCommand extends client.Command
+class GetOtaTaskConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetOtaTaskConfiguration", {})
     .n("IoTManagedIntegrationsClient", "GetOtaTaskConfigurationCommand")
-    .sc(schemas_0.GetOtaTaskConfiguration$)
+    .sc(GetOtaTaskConfiguration$)
     .build() {
 }
 
-class GetProvisioningProfileCommand extends client.Command
+class GetProvisioningProfileCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetProvisioningProfile", {})
     .n("IoTManagedIntegrationsClient", "GetProvisioningProfileCommand")
-    .sc(schemas_0.GetProvisioningProfile$)
+    .sc(GetProvisioningProfile$)
     .build() {
 }
 
-class GetRuntimeLogConfigurationCommand extends client.Command
+class GetRuntimeLogConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetRuntimeLogConfiguration", {})
     .n("IoTManagedIntegrationsClient", "GetRuntimeLogConfigurationCommand")
-    .sc(schemas_0.GetRuntimeLogConfiguration$)
+    .sc(GetRuntimeLogConfiguration$)
     .build() {
 }
 
-class GetSchemaVersionCommand extends client.Command
+class GetSchemaVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "GetSchemaVersion", {})
     .n("IoTManagedIntegrationsClient", "GetSchemaVersionCommand")
-    .sc(schemas_0.GetSchemaVersion$)
+    .sc(GetSchemaVersion$)
     .build() {
 }
 
-class ListAccountAssociationsCommand extends client.Command
+class ListAccountAssociationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListAccountAssociations", {})
     .n("IoTManagedIntegrationsClient", "ListAccountAssociationsCommand")
-    .sc(schemas_0.ListAccountAssociations$)
+    .sc(ListAccountAssociations$)
     .build() {
 }
 
-class ListCloudConnectorsCommand extends client.Command
+class ListCloudConnectorsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListCloudConnectors", {})
     .n("IoTManagedIntegrationsClient", "ListCloudConnectorsCommand")
-    .sc(schemas_0.ListCloudConnectors$)
+    .sc(ListCloudConnectors$)
     .build() {
 }
 
-class ListConnectorDestinationsCommand extends client.Command
+class ListConnectorDestinationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListConnectorDestinations", {})
     .n("IoTManagedIntegrationsClient", "ListConnectorDestinationsCommand")
-    .sc(schemas_0.ListConnectorDestinations$)
+    .sc(ListConnectorDestinations$)
     .build() {
 }
 
-class ListCredentialLockersCommand extends client.Command
+class ListCredentialLockersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListCredentialLockers", {})
     .n("IoTManagedIntegrationsClient", "ListCredentialLockersCommand")
-    .sc(schemas_0.ListCredentialLockers$)
+    .sc(ListCredentialLockers$)
     .build() {
 }
 
-class ListDestinationsCommand extends client.Command
+class ListDestinationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListDestinations", {})
     .n("IoTManagedIntegrationsClient", "ListDestinationsCommand")
-    .sc(schemas_0.ListDestinations$)
+    .sc(ListDestinations$)
     .build() {
 }
 
-class ListDeviceDiscoveriesCommand extends client.Command
+class ListDeviceDiscoveriesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListDeviceDiscoveries", {})
     .n("IoTManagedIntegrationsClient", "ListDeviceDiscoveriesCommand")
-    .sc(schemas_0.ListDeviceDiscoveries$)
+    .sc(ListDeviceDiscoveries$)
     .build() {
 }
 
-class ListDiscoveredDevicesCommand extends client.Command
+class ListDiscoveredDevicesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListDiscoveredDevices", {})
     .n("IoTManagedIntegrationsClient", "ListDiscoveredDevicesCommand")
-    .sc(schemas_0.ListDiscoveredDevices$)
+    .sc(ListDiscoveredDevices$)
     .build() {
 }
 
-class ListEventLogConfigurationsCommand extends client.Command
+class ListEventLogConfigurationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListEventLogConfigurations", {})
     .n("IoTManagedIntegrationsClient", "ListEventLogConfigurationsCommand")
-    .sc(schemas_0.ListEventLogConfigurations$)
+    .sc(ListEventLogConfigurations$)
     .build() {
 }
 
-class ListManagedThingAccountAssociationsCommand extends client.Command
+class ListManagedThingAccountAssociationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListManagedThingAccountAssociations", {})
     .n("IoTManagedIntegrationsClient", "ListManagedThingAccountAssociationsCommand")
-    .sc(schemas_0.ListManagedThingAccountAssociations$)
+    .sc(ListManagedThingAccountAssociations$)
     .build() {
 }
 
-class ListManagedThingSchemasCommand extends client.Command
+class ListManagedThingSchemasCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListManagedThingSchemas", {})
     .n("IoTManagedIntegrationsClient", "ListManagedThingSchemasCommand")
-    .sc(schemas_0.ListManagedThingSchemas$)
+    .sc(ListManagedThingSchemas$)
     .build() {
 }
 
-class ListManagedThingsCommand extends client.Command
+class ListManagedThingsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListManagedThings", {})
     .n("IoTManagedIntegrationsClient", "ListManagedThingsCommand")
-    .sc(schemas_0.ListManagedThings$)
+    .sc(ListManagedThings$)
     .build() {
 }
 
-class ListNotificationConfigurationsCommand extends client.Command
+class ListNotificationConfigurationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListNotificationConfigurations", {})
     .n("IoTManagedIntegrationsClient", "ListNotificationConfigurationsCommand")
-    .sc(schemas_0.ListNotificationConfigurations$)
+    .sc(ListNotificationConfigurations$)
     .build() {
 }
 
-class ListOtaTaskConfigurationsCommand extends client.Command
+class ListOtaTaskConfigurationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListOtaTaskConfigurations", {})
     .n("IoTManagedIntegrationsClient", "ListOtaTaskConfigurationsCommand")
-    .sc(schemas_0.ListOtaTaskConfigurations$)
+    .sc(ListOtaTaskConfigurations$)
     .build() {
 }
 
-class ListOtaTaskExecutionsCommand extends client.Command
+class ListOtaTaskExecutionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListOtaTaskExecutions", {})
     .n("IoTManagedIntegrationsClient", "ListOtaTaskExecutionsCommand")
-    .sc(schemas_0.ListOtaTaskExecutions$)
+    .sc(ListOtaTaskExecutions$)
     .build() {
 }
 
-class ListOtaTasksCommand extends client.Command
+class ListOtaTasksCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListOtaTasks", {})
     .n("IoTManagedIntegrationsClient", "ListOtaTasksCommand")
-    .sc(schemas_0.ListOtaTasks$)
+    .sc(ListOtaTasks$)
     .build() {
 }
 
-class ListProvisioningProfilesCommand extends client.Command
+class ListProvisioningProfilesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListProvisioningProfiles", {})
     .n("IoTManagedIntegrationsClient", "ListProvisioningProfilesCommand")
-    .sc(schemas_0.ListProvisioningProfiles$)
+    .sc(ListProvisioningProfiles$)
     .build() {
 }
 
-class ListSchemaVersionsCommand extends client.Command
+class ListSchemaVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ListSchemaVersions", {})
     .n("IoTManagedIntegrationsClient", "ListSchemaVersionsCommand")
-    .sc(schemas_0.ListSchemaVersions$)
+    .sc(ListSchemaVersions$)
     .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("IotManagedIntegrations", "ListTagsForResource", {})
     .n("IoTManagedIntegrationsClient", "ListTagsForResourceCommand")
-    .sc(schemas_0.ListTagsForResource$)
+    .sc(ListTagsForResource$)
     .build() {
 }
 
-class PutDefaultEncryptionConfigurationCommand extends client.Command
+class PutDefaultEncryptionConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "PutDefaultEncryptionConfiguration", {})
     .n("IoTManagedIntegrationsClient", "PutDefaultEncryptionConfigurationCommand")
-    .sc(schemas_0.PutDefaultEncryptionConfiguration$)
+    .sc(PutDefaultEncryptionConfiguration$)
     .build() {
 }
 
-class PutHubConfigurationCommand extends client.Command
+class PutHubConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "PutHubConfiguration", {})
     .n("IoTManagedIntegrationsClient", "PutHubConfigurationCommand")
-    .sc(schemas_0.PutHubConfiguration$)
+    .sc(PutHubConfiguration$)
     .build() {
 }
 
-class PutRuntimeLogConfigurationCommand extends client.Command
+class PutRuntimeLogConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "PutRuntimeLogConfiguration", {})
     .n("IoTManagedIntegrationsClient", "PutRuntimeLogConfigurationCommand")
-    .sc(schemas_0.PutRuntimeLogConfiguration$)
+    .sc(PutRuntimeLogConfiguration$)
     .build() {
 }
 
-class RegisterAccountAssociationCommand extends client.Command
+class RegisterAccountAssociationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "RegisterAccountAssociation", {})
     .n("IoTManagedIntegrationsClient", "RegisterAccountAssociationCommand")
-    .sc(schemas_0.RegisterAccountAssociation$)
+    .sc(RegisterAccountAssociation$)
     .build() {
 }
 
-class RegisterCustomEndpointCommand extends client.Command
+class RegisterCustomEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "RegisterCustomEndpoint", {})
     .n("IoTManagedIntegrationsClient", "RegisterCustomEndpointCommand")
-    .sc(schemas_0.RegisterCustomEndpoint$)
+    .sc(RegisterCustomEndpoint$)
     .build() {
 }
 
-class ResetRuntimeLogConfigurationCommand extends client.Command
+class ResetRuntimeLogConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "ResetRuntimeLogConfiguration", {})
     .n("IoTManagedIntegrationsClient", "ResetRuntimeLogConfigurationCommand")
-    .sc(schemas_0.ResetRuntimeLogConfiguration$)
+    .sc(ResetRuntimeLogConfiguration$)
     .build() {
 }
 
-class SendConnectorEventCommand extends client.Command
+class SendConnectorEventCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "SendConnectorEvent", {})
     .n("IoTManagedIntegrationsClient", "SendConnectorEventCommand")
-    .sc(schemas_0.SendConnectorEvent$)
+    .sc(SendConnectorEvent$)
     .build() {
 }
 
-class SendManagedThingCommandCommand extends client.Command
+class SendManagedThingCommandCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "SendManagedThingCommand", {})
     .n("IoTManagedIntegrationsClient", "SendManagedThingCommandCommand")
-    .sc(schemas_0.SendManagedThingCommand$)
+    .sc(SendManagedThingCommand$)
     .build() {
 }
 
-class StartAccountAssociationRefreshCommand extends client.Command
+class StartAccountAssociationRefreshCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "StartAccountAssociationRefresh", {})
     .n("IoTManagedIntegrationsClient", "StartAccountAssociationRefreshCommand")
-    .sc(schemas_0.StartAccountAssociationRefresh$)
+    .sc(StartAccountAssociationRefresh$)
     .build() {
 }
 
-class StartDeviceDiscoveryCommand extends client.Command
+class StartDeviceDiscoveryCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "StartDeviceDiscovery", {})
     .n("IoTManagedIntegrationsClient", "StartDeviceDiscoveryCommand")
-    .sc(schemas_0.StartDeviceDiscovery$)
+    .sc(StartDeviceDiscovery$)
     .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("IotManagedIntegrations", "TagResource", {})
     .n("IoTManagedIntegrationsClient", "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("IotManagedIntegrations", "UntagResource", {})
     .n("IoTManagedIntegrationsClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateAccountAssociationCommand extends client.Command
+class UpdateAccountAssociationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "UpdateAccountAssociation", {})
     .n("IoTManagedIntegrationsClient", "UpdateAccountAssociationCommand")
-    .sc(schemas_0.UpdateAccountAssociation$)
+    .sc(UpdateAccountAssociation$)
     .build() {
 }
 
-class UpdateCloudConnectorCommand extends client.Command
+class UpdateCloudConnectorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "UpdateCloudConnector", {})
     .n("IoTManagedIntegrationsClient", "UpdateCloudConnectorCommand")
-    .sc(schemas_0.UpdateCloudConnector$)
+    .sc(UpdateCloudConnector$)
     .build() {
 }
 
-class UpdateConnectorDestinationCommand extends client.Command
+class UpdateConnectorDestinationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "UpdateConnectorDestination", {})
     .n("IoTManagedIntegrationsClient", "UpdateConnectorDestinationCommand")
-    .sc(schemas_0.UpdateConnectorDestination$)
+    .sc(UpdateConnectorDestination$)
     .build() {
 }
 
-class UpdateDestinationCommand extends client.Command
+class UpdateDestinationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "UpdateDestination", {})
     .n("IoTManagedIntegrationsClient", "UpdateDestinationCommand")
-    .sc(schemas_0.UpdateDestination$)
+    .sc(UpdateDestination$)
     .build() {
 }
 
-class UpdateEventLogConfigurationCommand extends client.Command
+class UpdateEventLogConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "UpdateEventLogConfiguration", {})
     .n("IoTManagedIntegrationsClient", "UpdateEventLogConfigurationCommand")
-    .sc(schemas_0.UpdateEventLogConfiguration$)
+    .sc(UpdateEventLogConfiguration$)
     .build() {
 }
 
-class UpdateManagedThingCommand extends client.Command
+class UpdateManagedThingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "UpdateManagedThing", {})
     .n("IoTManagedIntegrationsClient", "UpdateManagedThingCommand")
-    .sc(schemas_0.UpdateManagedThing$)
+    .sc(UpdateManagedThing$)
     .build() {
 }
 
-class UpdateNotificationConfigurationCommand extends client.Command
+class UpdateNotificationConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "UpdateNotificationConfiguration", {})
     .n("IoTManagedIntegrationsClient", "UpdateNotificationConfigurationCommand")
-    .sc(schemas_0.UpdateNotificationConfiguration$)
+    .sc(UpdateNotificationConfiguration$)
     .build() {
 }
 
-class UpdateOtaTaskCommand extends client.Command
+class UpdateOtaTaskCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("IotManagedIntegrations", "UpdateOtaTask", {})
     .n("IoTManagedIntegrationsClient", "UpdateOtaTaskCommand")
-    .sc(schemas_0.UpdateOtaTask$)
+    .sc(UpdateOtaTask$)
     .build() {
 }
 
-const paginateListAccountAssociations = core.createPaginator(IoTManagedIntegrationsClient, ListAccountAssociationsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListAccountAssociations = createPaginator(IoTManagedIntegrationsClient, ListAccountAssociationsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListCloudConnectors = core.createPaginator(IoTManagedIntegrationsClient, ListCloudConnectorsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListCloudConnectors = createPaginator(IoTManagedIntegrationsClient, ListCloudConnectorsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListConnectorDestinations = core.createPaginator(IoTManagedIntegrationsClient, ListConnectorDestinationsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListConnectorDestinations = createPaginator(IoTManagedIntegrationsClient, ListConnectorDestinationsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListCredentialLockers = core.createPaginator(IoTManagedIntegrationsClient, ListCredentialLockersCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListCredentialLockers = createPaginator(IoTManagedIntegrationsClient, ListCredentialLockersCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListDestinations = core.createPaginator(IoTManagedIntegrationsClient, ListDestinationsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListDestinations = createPaginator(IoTManagedIntegrationsClient, ListDestinationsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListDeviceDiscoveries = core.createPaginator(IoTManagedIntegrationsClient, ListDeviceDiscoveriesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListDeviceDiscoveries = createPaginator(IoTManagedIntegrationsClient, ListDeviceDiscoveriesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListDiscoveredDevices = core.createPaginator(IoTManagedIntegrationsClient, ListDiscoveredDevicesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListDiscoveredDevices = createPaginator(IoTManagedIntegrationsClient, ListDiscoveredDevicesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListEventLogConfigurations = core.createPaginator(IoTManagedIntegrationsClient, ListEventLogConfigurationsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListEventLogConfigurations = createPaginator(IoTManagedIntegrationsClient, ListEventLogConfigurationsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListManagedThingAccountAssociations = core.createPaginator(IoTManagedIntegrationsClient, ListManagedThingAccountAssociationsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListManagedThingAccountAssociations = createPaginator(IoTManagedIntegrationsClient, ListManagedThingAccountAssociationsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListManagedThingSchemas = core.createPaginator(IoTManagedIntegrationsClient, ListManagedThingSchemasCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListManagedThingSchemas = createPaginator(IoTManagedIntegrationsClient, ListManagedThingSchemasCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListManagedThings = core.createPaginator(IoTManagedIntegrationsClient, ListManagedThingsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListManagedThings = createPaginator(IoTManagedIntegrationsClient, ListManagedThingsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListNotificationConfigurations = core.createPaginator(IoTManagedIntegrationsClient, ListNotificationConfigurationsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListNotificationConfigurations = createPaginator(IoTManagedIntegrationsClient, ListNotificationConfigurationsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListOtaTaskConfigurations = core.createPaginator(IoTManagedIntegrationsClient, ListOtaTaskConfigurationsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListOtaTaskConfigurations = createPaginator(IoTManagedIntegrationsClient, ListOtaTaskConfigurationsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListOtaTaskExecutions = core.createPaginator(IoTManagedIntegrationsClient, ListOtaTaskExecutionsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListOtaTaskExecutions = createPaginator(IoTManagedIntegrationsClient, ListOtaTaskExecutionsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListOtaTasks = core.createPaginator(IoTManagedIntegrationsClient, ListOtaTasksCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListOtaTasks = createPaginator(IoTManagedIntegrationsClient, ListOtaTasksCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListProvisioningProfiles = core.createPaginator(IoTManagedIntegrationsClient, ListProvisioningProfilesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListProvisioningProfiles = createPaginator(IoTManagedIntegrationsClient, ListProvisioningProfilesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListSchemaVersions = core.createPaginator(IoTManagedIntegrationsClient, ListSchemaVersionsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListSchemaVersions = createPaginator(IoTManagedIntegrationsClient, ListSchemaVersionsCommand, "NextToken", "NextToken", "MaxResults");
 
 const commands = {
     CreateAccountAssociationCommand,
@@ -1242,7 +1245,7 @@ const paginators = {
 };
 class IoTManagedIntegrations extends IoTManagedIntegrationsClient {
 }
-client.createAggregatedClient(commands, IoTManagedIntegrations, { paginators });
+createAggregatedClient(commands, IoTManagedIntegrations, { paginators });
 
 const AbortCriteriaAction = {
     CANCEL: "CANCEL",
@@ -1445,9 +1448,6 @@ const OtaTaskExecutionStatus = {
     TIMED_OUT: "TIMED_OUT",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.IoTManagedIntegrationsServiceException = IoTManagedIntegrationsServiceException.IoTManagedIntegrationsServiceException;
 exports.AbortCriteriaAction = AbortCriteriaAction;
 exports.AbortCriteriaFailureType = AbortCriteriaFailureType;
 exports.AssociationState = AssociationState;
@@ -1586,23 +1586,3 @@ exports.paginateListOtaTaskExecutions = paginateListOtaTaskExecutions;
 exports.paginateListOtaTasks = paginateListOtaTasks;
 exports.paginateListProvisioningProfiles = paginateListProvisioningProfiles;
 exports.paginateListSchemaVersions = paginateListSchemaVersions;
-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];
-});