@aws-sdk/client-resiliencehubv2 3.1068.0 → 3.1070.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 Resiliencehubv2ServiceException = require('./models/Resiliencehubv2ServiceException');
+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, createWaiter, checkExceptions, WaiterState, 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, defaultResiliencehubv2HttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { CreateAssertion$, CreateInputSource$, CreatePolicy$, CreateReport$, CreateService$, CreateServiceFunction$, CreateServiceFunctionResources$, CreateSystem$, CreateUserJourney$, DeleteAssertion$, DeleteInputSource$, DeletePolicy$, DeleteService$, DeleteServiceFunction$, DeleteServiceFunctionResources$, DeleteSystem$, DeleteUserJourney$, GetFailureModeFinding$, GetPolicy$, GetService$, GetSystem$, GetUserJourney$, ImportApp$, ImportPolicy$, ListAssertions$, ListDependencies$, ListFailureModeAssessments$, ListFailureModeFindings$, ListInputSources$, ListPolicies$, ListReports$, ListResources$, ListServiceEvents$, ListServiceFunctions$, ListServices$, ListServiceTopologyEdges$, ListSystemEvents$, ListSystems$, ListTagsForResource$, ListUserJourneys$, StartFailureModeAssessment$, TagResource$, UntagResource$, UpdateAssertion$, UpdateDependency$, UpdateFailureModeFinding$, UpdatePolicy$, UpdateService$, UpdateServiceFunction$, UpdateSystem$, UpdateUserJourney$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { Resiliencehubv2ServiceException } = require("./models/Resiliencehubv2ServiceException");
+exports.Resiliencehubv2ServiceException = Resiliencehubv2ServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -68,692 +71,692 @@ 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 Resiliencehubv2Client extends client.Client {
+class Resiliencehubv2Client 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.defaultResiliencehubv2HttpAuthSchemeParametersProvider,
-            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: defaultResiliencehubv2HttpAuthSchemeParametersProvider,
+            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 CreateAssertionCommand extends client.Command
+class CreateAssertionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "CreateAssertion", {})
     .n("Resiliencehubv2Client", "CreateAssertionCommand")
-    .sc(schemas_0.CreateAssertion$)
+    .sc(CreateAssertion$)
     .build() {
 }
 
-class CreateInputSourceCommand extends client.Command
+class CreateInputSourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "CreateInputSource", {})
     .n("Resiliencehubv2Client", "CreateInputSourceCommand")
-    .sc(schemas_0.CreateInputSource$)
+    .sc(CreateInputSource$)
     .build() {
 }
 
-class CreatePolicyCommand extends client.Command
+class CreatePolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "CreatePolicy", {})
     .n("Resiliencehubv2Client", "CreatePolicyCommand")
-    .sc(schemas_0.CreatePolicy$)
+    .sc(CreatePolicy$)
     .build() {
 }
 
-class CreateReportCommand extends client.Command
+class CreateReportCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "CreateReport", {})
     .n("Resiliencehubv2Client", "CreateReportCommand")
-    .sc(schemas_0.CreateReport$)
+    .sc(CreateReport$)
     .build() {
 }
 
-class CreateServiceCommand extends client.Command
+class CreateServiceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "CreateService", {})
     .n("Resiliencehubv2Client", "CreateServiceCommand")
-    .sc(schemas_0.CreateService$)
+    .sc(CreateService$)
     .build() {
 }
 
-class CreateServiceFunctionCommand extends client.Command
+class CreateServiceFunctionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "CreateServiceFunction", {})
     .n("Resiliencehubv2Client", "CreateServiceFunctionCommand")
-    .sc(schemas_0.CreateServiceFunction$)
+    .sc(CreateServiceFunction$)
     .build() {
 }
 
-class CreateServiceFunctionResourcesCommand extends client.Command
+class CreateServiceFunctionResourcesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "CreateServiceFunctionResources", {})
     .n("Resiliencehubv2Client", "CreateServiceFunctionResourcesCommand")
-    .sc(schemas_0.CreateServiceFunctionResources$)
+    .sc(CreateServiceFunctionResources$)
     .build() {
 }
 
-class CreateSystemCommand extends client.Command
+class CreateSystemCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "CreateSystem", {})
     .n("Resiliencehubv2Client", "CreateSystemCommand")
-    .sc(schemas_0.CreateSystem$)
+    .sc(CreateSystem$)
     .build() {
 }
 
-class CreateUserJourneyCommand extends client.Command
+class CreateUserJourneyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "CreateUserJourney", {})
     .n("Resiliencehubv2Client", "CreateUserJourneyCommand")
-    .sc(schemas_0.CreateUserJourney$)
+    .sc(CreateUserJourney$)
     .build() {
 }
 
-class DeleteAssertionCommand extends client.Command
+class DeleteAssertionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "DeleteAssertion", {})
     .n("Resiliencehubv2Client", "DeleteAssertionCommand")
-    .sc(schemas_0.DeleteAssertion$)
+    .sc(DeleteAssertion$)
     .build() {
 }
 
-class DeleteInputSourceCommand extends client.Command
+class DeleteInputSourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "DeleteInputSource", {})
     .n("Resiliencehubv2Client", "DeleteInputSourceCommand")
-    .sc(schemas_0.DeleteInputSource$)
+    .sc(DeleteInputSource$)
     .build() {
 }
 
-class DeletePolicyCommand extends client.Command
+class DeletePolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "DeletePolicy", {})
     .n("Resiliencehubv2Client", "DeletePolicyCommand")
-    .sc(schemas_0.DeletePolicy$)
+    .sc(DeletePolicy$)
     .build() {
 }
 
-class DeleteServiceCommand extends client.Command
+class DeleteServiceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "DeleteService", {})
     .n("Resiliencehubv2Client", "DeleteServiceCommand")
-    .sc(schemas_0.DeleteService$)
+    .sc(DeleteService$)
     .build() {
 }
 
-class DeleteServiceFunctionCommand extends client.Command
+class DeleteServiceFunctionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "DeleteServiceFunction", {})
     .n("Resiliencehubv2Client", "DeleteServiceFunctionCommand")
-    .sc(schemas_0.DeleteServiceFunction$)
+    .sc(DeleteServiceFunction$)
     .build() {
 }
 
-class DeleteServiceFunctionResourcesCommand extends client.Command
+class DeleteServiceFunctionResourcesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "DeleteServiceFunctionResources", {})
     .n("Resiliencehubv2Client", "DeleteServiceFunctionResourcesCommand")
-    .sc(schemas_0.DeleteServiceFunctionResources$)
+    .sc(DeleteServiceFunctionResources$)
     .build() {
 }
 
-class DeleteSystemCommand extends client.Command
+class DeleteSystemCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "DeleteSystem", {})
     .n("Resiliencehubv2Client", "DeleteSystemCommand")
-    .sc(schemas_0.DeleteSystem$)
+    .sc(DeleteSystem$)
     .build() {
 }
 
-class DeleteUserJourneyCommand extends client.Command
+class DeleteUserJourneyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "DeleteUserJourney", {})
     .n("Resiliencehubv2Client", "DeleteUserJourneyCommand")
-    .sc(schemas_0.DeleteUserJourney$)
+    .sc(DeleteUserJourney$)
     .build() {
 }
 
-class GetFailureModeFindingCommand extends client.Command
+class GetFailureModeFindingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "GetFailureModeFinding", {})
     .n("Resiliencehubv2Client", "GetFailureModeFindingCommand")
-    .sc(schemas_0.GetFailureModeFinding$)
+    .sc(GetFailureModeFinding$)
     .build() {
 }
 
-class GetPolicyCommand extends client.Command
+class GetPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "GetPolicy", {})
     .n("Resiliencehubv2Client", "GetPolicyCommand")
-    .sc(schemas_0.GetPolicy$)
+    .sc(GetPolicy$)
     .build() {
 }
 
-class GetServiceCommand extends client.Command
+class GetServiceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "GetService", {})
     .n("Resiliencehubv2Client", "GetServiceCommand")
-    .sc(schemas_0.GetService$)
+    .sc(GetService$)
     .build() {
 }
 
-class GetSystemCommand extends client.Command
+class GetSystemCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "GetSystem", {})
     .n("Resiliencehubv2Client", "GetSystemCommand")
-    .sc(schemas_0.GetSystem$)
+    .sc(GetSystem$)
     .build() {
 }
 
-class GetUserJourneyCommand extends client.Command
+class GetUserJourneyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "GetUserJourney", {})
     .n("Resiliencehubv2Client", "GetUserJourneyCommand")
-    .sc(schemas_0.GetUserJourney$)
+    .sc(GetUserJourney$)
     .build() {
 }
 
-class ImportAppCommand extends client.Command
+class ImportAppCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ImportApp", {})
     .n("Resiliencehubv2Client", "ImportAppCommand")
-    .sc(schemas_0.ImportApp$)
+    .sc(ImportApp$)
     .build() {
 }
 
-class ImportPolicyCommand extends client.Command
+class ImportPolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ImportPolicy", {})
     .n("Resiliencehubv2Client", "ImportPolicyCommand")
-    .sc(schemas_0.ImportPolicy$)
+    .sc(ImportPolicy$)
     .build() {
 }
 
-class ListAssertionsCommand extends client.Command
+class ListAssertionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListAssertions", {})
     .n("Resiliencehubv2Client", "ListAssertionsCommand")
-    .sc(schemas_0.ListAssertions$)
+    .sc(ListAssertions$)
     .build() {
 }
 
-class ListDependenciesCommand extends client.Command
+class ListDependenciesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListDependencies", {})
     .n("Resiliencehubv2Client", "ListDependenciesCommand")
-    .sc(schemas_0.ListDependencies$)
+    .sc(ListDependencies$)
     .build() {
 }
 
-class ListFailureModeAssessmentsCommand extends client.Command
+class ListFailureModeAssessmentsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListFailureModeAssessments", {})
     .n("Resiliencehubv2Client", "ListFailureModeAssessmentsCommand")
-    .sc(schemas_0.ListFailureModeAssessments$)
+    .sc(ListFailureModeAssessments$)
     .build() {
 }
 
-class ListFailureModeFindingsCommand extends client.Command
+class ListFailureModeFindingsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListFailureModeFindings", {})
     .n("Resiliencehubv2Client", "ListFailureModeFindingsCommand")
-    .sc(schemas_0.ListFailureModeFindings$)
+    .sc(ListFailureModeFindings$)
     .build() {
 }
 
-class ListInputSourcesCommand extends client.Command
+class ListInputSourcesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListInputSources", {})
     .n("Resiliencehubv2Client", "ListInputSourcesCommand")
-    .sc(schemas_0.ListInputSources$)
+    .sc(ListInputSources$)
     .build() {
 }
 
-class ListPoliciesCommand extends client.Command
+class ListPoliciesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListPolicies", {})
     .n("Resiliencehubv2Client", "ListPoliciesCommand")
-    .sc(schemas_0.ListPolicies$)
+    .sc(ListPolicies$)
     .build() {
 }
 
-class ListReportsCommand extends client.Command
+class ListReportsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListReports", {})
     .n("Resiliencehubv2Client", "ListReportsCommand")
-    .sc(schemas_0.ListReports$)
+    .sc(ListReports$)
     .build() {
 }
 
-class ListResourcesCommand extends client.Command
+class ListResourcesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListResources", {})
     .n("Resiliencehubv2Client", "ListResourcesCommand")
-    .sc(schemas_0.ListResources$)
+    .sc(ListResources$)
     .build() {
 }
 
-class ListServiceEventsCommand extends client.Command
+class ListServiceEventsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListServiceEvents", {})
     .n("Resiliencehubv2Client", "ListServiceEventsCommand")
-    .sc(schemas_0.ListServiceEvents$)
+    .sc(ListServiceEvents$)
     .build() {
 }
 
-class ListServiceFunctionsCommand extends client.Command
+class ListServiceFunctionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListServiceFunctions", {})
     .n("Resiliencehubv2Client", "ListServiceFunctionsCommand")
-    .sc(schemas_0.ListServiceFunctions$)
+    .sc(ListServiceFunctions$)
     .build() {
 }
 
-class ListServicesCommand extends client.Command
+class ListServicesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListServices", {})
     .n("Resiliencehubv2Client", "ListServicesCommand")
-    .sc(schemas_0.ListServices$)
+    .sc(ListServices$)
     .build() {
 }
 
-class ListServiceTopologyEdgesCommand extends client.Command
+class ListServiceTopologyEdgesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListServiceTopologyEdges", {})
     .n("Resiliencehubv2Client", "ListServiceTopologyEdgesCommand")
-    .sc(schemas_0.ListServiceTopologyEdges$)
+    .sc(ListServiceTopologyEdges$)
     .build() {
 }
 
-class ListSystemEventsCommand extends client.Command
+class ListSystemEventsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListSystemEvents", {})
     .n("Resiliencehubv2Client", "ListSystemEventsCommand")
-    .sc(schemas_0.ListSystemEvents$)
+    .sc(ListSystemEvents$)
     .build() {
 }
 
-class ListSystemsCommand extends client.Command
+class ListSystemsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListSystems", {})
     .n("Resiliencehubv2Client", "ListSystemsCommand")
-    .sc(schemas_0.ListSystems$)
+    .sc(ListSystems$)
     .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("NGRHServiceCore", "ListTagsForResource", {})
     .n("Resiliencehubv2Client", "ListTagsForResourceCommand")
-    .sc(schemas_0.ListTagsForResource$)
+    .sc(ListTagsForResource$)
     .build() {
 }
 
-class ListUserJourneysCommand extends client.Command
+class ListUserJourneysCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "ListUserJourneys", {})
     .n("Resiliencehubv2Client", "ListUserJourneysCommand")
-    .sc(schemas_0.ListUserJourneys$)
+    .sc(ListUserJourneys$)
     .build() {
 }
 
-class StartFailureModeAssessmentCommand extends client.Command
+class StartFailureModeAssessmentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "StartFailureModeAssessment", {})
     .n("Resiliencehubv2Client", "StartFailureModeAssessmentCommand")
-    .sc(schemas_0.StartFailureModeAssessment$)
+    .sc(StartFailureModeAssessment$)
     .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("NGRHServiceCore", "TagResource", {})
     .n("Resiliencehubv2Client", "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("NGRHServiceCore", "UntagResource", {})
     .n("Resiliencehubv2Client", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateAssertionCommand extends client.Command
+class UpdateAssertionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "UpdateAssertion", {})
     .n("Resiliencehubv2Client", "UpdateAssertionCommand")
-    .sc(schemas_0.UpdateAssertion$)
+    .sc(UpdateAssertion$)
     .build() {
 }
 
-class UpdateDependencyCommand extends client.Command
+class UpdateDependencyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "UpdateDependency", {})
     .n("Resiliencehubv2Client", "UpdateDependencyCommand")
-    .sc(schemas_0.UpdateDependency$)
+    .sc(UpdateDependency$)
     .build() {
 }
 
-class UpdateFailureModeFindingCommand extends client.Command
+class UpdateFailureModeFindingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "UpdateFailureModeFinding", {})
     .n("Resiliencehubv2Client", "UpdateFailureModeFindingCommand")
-    .sc(schemas_0.UpdateFailureModeFinding$)
+    .sc(UpdateFailureModeFinding$)
     .build() {
 }
 
-class UpdatePolicyCommand extends client.Command
+class UpdatePolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "UpdatePolicy", {})
     .n("Resiliencehubv2Client", "UpdatePolicyCommand")
-    .sc(schemas_0.UpdatePolicy$)
+    .sc(UpdatePolicy$)
     .build() {
 }
 
-class UpdateServiceCommand extends client.Command
+class UpdateServiceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "UpdateService", {})
     .n("Resiliencehubv2Client", "UpdateServiceCommand")
-    .sc(schemas_0.UpdateService$)
+    .sc(UpdateService$)
     .build() {
 }
 
-class UpdateServiceFunctionCommand extends client.Command
+class UpdateServiceFunctionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "UpdateServiceFunction", {})
     .n("Resiliencehubv2Client", "UpdateServiceFunctionCommand")
-    .sc(schemas_0.UpdateServiceFunction$)
+    .sc(UpdateServiceFunction$)
     .build() {
 }
 
-class UpdateSystemCommand extends client.Command
+class UpdateSystemCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "UpdateSystem", {})
     .n("Resiliencehubv2Client", "UpdateSystemCommand")
-    .sc(schemas_0.UpdateSystem$)
+    .sc(UpdateSystem$)
     .build() {
 }
 
-class UpdateUserJourneyCommand extends client.Command
+class UpdateUserJourneyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("NGRHServiceCore", "UpdateUserJourney", {})
     .n("Resiliencehubv2Client", "UpdateUserJourneyCommand")
-    .sc(schemas_0.UpdateUserJourney$)
+    .sc(UpdateUserJourney$)
     .build() {
 }
 
-const paginateListAssertions = core.createPaginator(Resiliencehubv2Client, ListAssertionsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListAssertions = createPaginator(Resiliencehubv2Client, ListAssertionsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListDependencies = core.createPaginator(Resiliencehubv2Client, ListDependenciesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListDependencies = createPaginator(Resiliencehubv2Client, ListDependenciesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListFailureModeAssessments = core.createPaginator(Resiliencehubv2Client, ListFailureModeAssessmentsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListFailureModeAssessments = createPaginator(Resiliencehubv2Client, ListFailureModeAssessmentsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListFailureModeFindings = core.createPaginator(Resiliencehubv2Client, ListFailureModeFindingsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListFailureModeFindings = createPaginator(Resiliencehubv2Client, ListFailureModeFindingsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListInputSources = core.createPaginator(Resiliencehubv2Client, ListInputSourcesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListInputSources = createPaginator(Resiliencehubv2Client, ListInputSourcesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListPolicies = core.createPaginator(Resiliencehubv2Client, ListPoliciesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListPolicies = createPaginator(Resiliencehubv2Client, ListPoliciesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListReports = core.createPaginator(Resiliencehubv2Client, ListReportsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListReports = createPaginator(Resiliencehubv2Client, ListReportsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListResources = core.createPaginator(Resiliencehubv2Client, ListResourcesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListResources = createPaginator(Resiliencehubv2Client, ListResourcesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListServiceEvents = core.createPaginator(Resiliencehubv2Client, ListServiceEventsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListServiceEvents = createPaginator(Resiliencehubv2Client, ListServiceEventsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListServiceFunctions = core.createPaginator(Resiliencehubv2Client, ListServiceFunctionsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListServiceFunctions = createPaginator(Resiliencehubv2Client, ListServiceFunctionsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListServices = core.createPaginator(Resiliencehubv2Client, ListServicesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListServices = createPaginator(Resiliencehubv2Client, ListServicesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListServiceTopologyEdges = core.createPaginator(Resiliencehubv2Client, ListServiceTopologyEdgesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListServiceTopologyEdges = createPaginator(Resiliencehubv2Client, ListServiceTopologyEdgesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListSystemEvents = core.createPaginator(Resiliencehubv2Client, ListSystemEventsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListSystemEvents = createPaginator(Resiliencehubv2Client, ListSystemEventsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListSystems = core.createPaginator(Resiliencehubv2Client, ListSystemsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListSystems = createPaginator(Resiliencehubv2Client, ListSystemsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListUserJourneys = core.createPaginator(Resiliencehubv2Client, ListUserJourneysCommand, "nextToken", "nextToken", "maxResults");
+const paginateListUserJourneys = createPaginator(Resiliencehubv2Client, ListUserJourneysCommand, "nextToken", "nextToken", "maxResults");
 
-const checkState$3 = async (client$1, input) => {
+const checkState$3 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new ListFailureModeAssessmentsCommand(input));
+        let result = await client.send(new ListFailureModeAssessmentsCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -761,7 +764,7 @@ const checkState$3 = async (client$1, input) => {
                 return (flat_1.length == 0);
             };
             if (returnComparator() == true) {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -778,7 +781,7 @@ const checkState$3 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "SUCCESS");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -792,7 +795,7 @@ const checkState$3 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -801,22 +804,22 @@ const checkState$3 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForFailureModeAssessmentSuccess = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
 };
 const waitUntilFailureModeAssessmentSuccess = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return checkExceptions(result);
 };
 
-const checkState$2 = async (client$1, input) => {
+const checkState$2 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new ListReportsCommand(input));
+        let result = await client.send(new ListReportsCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -824,7 +827,7 @@ const checkState$2 = async (client$1, input) => {
                 return (flat_1.length == 0);
             };
             if (returnComparator() == true) {
-                return { state: client.WaiterState.RETRY, reason };
+                return { state: WaiterState.RETRY, reason };
             }
         }
         catch (e) { }
@@ -841,7 +844,7 @@ const checkState$2 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "SUCCEEDED");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -855,7 +858,7 @@ const checkState$2 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "FAILED") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -864,29 +867,29 @@ const checkState$2 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForReportSucceeded = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
 const waitUntilReportSucceeded = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return checkExceptions(result);
 };
 
-const checkState$1 = async (client$1, input) => {
+const checkState$1 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetServiceCommand(input));
+        let result = await client.send(new GetServiceCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.service.assessmentStatus;
             };
             if (returnComparator() === "SUCCESS") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -895,7 +898,7 @@ const checkState$1 = async (client$1, input) => {
                 return result.service.assessmentStatus;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -903,29 +906,29 @@ const checkState$1 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForServiceAssessmentCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
 const waitUntilServiceAssessmentCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return checkExceptions(result);
 };
 
-const checkState = async (client$1, input) => {
+const checkState = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new GetServiceCommand(input));
+        let result = await client.send(new GetServiceCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.service.resourceDiscovery.status;
             };
             if (returnComparator() === "SUCCEEDED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -934,7 +937,7 @@ const checkState = async (client$1, input) => {
                 return result.service.resourceDiscovery.status;
             };
             if (returnComparator() === "COMPLETED_WITH_FAILURES") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -943,7 +946,7 @@ const checkState = async (client$1, input) => {
                 return result.service.resourceDiscovery.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -951,16 +954,16 @@ const checkState = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForServiceResourceDiscoveryCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
 const waitUntilServiceResourceDiscoveryCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
 };
 
 const commands = {
@@ -1041,7 +1044,7 @@ const waiters = {
 };
 class Resiliencehubv2 extends Resiliencehubv2Client {
 }
-client.createAggregatedClient(commands, Resiliencehubv2, { paginators, waiters });
+createAggregatedClient(commands, Resiliencehubv2, { paginators, waiters });
 
 const AchievabilityStatus = {
     ACHIEVABLE: "ACHIEVABLE",
@@ -1226,9 +1229,6 @@ const SystemEventType = {
     SYSTEM_USER_JOURNEY_UPDATED: "SYSTEM_USER_JOURNEY_UPDATED",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.Resiliencehubv2ServiceException = Resiliencehubv2ServiceException.Resiliencehubv2ServiceException;
 exports.AchievabilityStatus = AchievabilityStatus;
 exports.ActorType = ActorType;
 exports.AssertionSource = AssertionSource;
@@ -1335,23 +1335,3 @@ exports.waitUntilFailureModeAssessmentSuccess = waitUntilFailureModeAssessmentSu
 exports.waitUntilReportSucceeded = waitUntilReportSucceeded;
 exports.waitUntilServiceAssessmentCompleted = waitUntilServiceAssessmentCompleted;
 exports.waitUntilServiceResourceDiscoveryCompleted = waitUntilServiceResourceDiscoveryCompleted;
-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];
-});