@aws-sdk/client-neptune-graph 3.1045.0 → 3.1047.0

package/dist-cjs/index.js

@@ -4,19 +4,17 @@ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
 var middlewareLogger = require('@aws-sdk/middleware-logger');
 var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
-var configResolver = require('@smithy/config-resolver');
 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 middlewareContentLength = require('@smithy/middleware-content-length');
-var middlewareEndpoint = require('@smithy/middleware-endpoint');
-var middlewareRetry = require('@smithy/middleware-retry');
-var smithyClient = require('@smithy/smithy-client');
 var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
-var protocolHttp = require('@smithy/protocol-http');
 var schemas_0 = require('./schemas/schemas_0');
-var utilWaiter = require('@smithy/util-waiter');
 var errors = require('./models/errors');
 var NeptuneGraphServiceException = require('./models/NeptuneGraphServiceException');
 
@@ -74,12 +72,12 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class NeptuneGraphClient extends smithyClient.Client {
+class NeptuneGraphClient extends client.Client {
     config;
     constructor(...[configuration]) {
         const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
@@ -87,17 +85,17 @@ class NeptuneGraphClient extends smithyClient.Client {
         this.initConfig = _config_0;
         const _config_1 = resolveClientEndpointParameters(_config_0);
         const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
-        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
-        const _config_4 = configResolver.resolveRegionConfig(_config_3);
+        const _config_3 = retry.resolveRetryConfig(_config_2);
+        const _config_4 = config.resolveRegionConfig(_config_3);
         const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
-        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
+        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
         const _config_7 = httpAuthSchemeProvider.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(middlewareUserAgent.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
-        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(retry.getRetryPlugin(this.config));
+        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
         this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
         this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
         this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
@@ -114,14 +112,14 @@ class NeptuneGraphClient extends smithyClient.Client {
     }
 }
 
-class CancelExportTaskCommand extends smithyClient.Command
+class CancelExportTaskCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "CancelExportTask", {})
     .n("NeptuneGraphClient", "CancelExportTaskCommand")
@@ -129,14 +127,14 @@ class CancelExportTaskCommand extends smithyClient.Command
     .build() {
 }
 
-class CancelImportTaskCommand extends smithyClient.Command
+class CancelImportTaskCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "CancelImportTask", {})
     .n("NeptuneGraphClient", "CancelImportTaskCommand")
@@ -144,14 +142,14 @@ class CancelImportTaskCommand extends smithyClient.Command
     .build() {
 }
 
-class CancelQueryCommand extends smithyClient.Command
+class CancelQueryCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `DataPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "CancelQuery", {})
     .n("NeptuneGraphClient", "CancelQueryCommand")
@@ -159,14 +157,14 @@ class CancelQueryCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateGraphCommand extends smithyClient.Command
+class CreateGraphCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "CreateGraph", {})
     .n("NeptuneGraphClient", "CreateGraphCommand")
@@ -174,14 +172,14 @@ class CreateGraphCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateGraphSnapshotCommand extends smithyClient.Command
+class CreateGraphSnapshotCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "CreateGraphSnapshot", {})
     .n("NeptuneGraphClient", "CreateGraphSnapshotCommand")
@@ -189,14 +187,14 @@ class CreateGraphSnapshotCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateGraphUsingImportTaskCommand extends smithyClient.Command
+class CreateGraphUsingImportTaskCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "CreateGraphUsingImportTask", {})
     .n("NeptuneGraphClient", "CreateGraphUsingImportTaskCommand")
@@ -204,14 +202,14 @@ class CreateGraphUsingImportTaskCommand extends smithyClient.Command
     .build() {
 }
 
-class CreatePrivateGraphEndpointCommand extends smithyClient.Command
+class CreatePrivateGraphEndpointCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "CreatePrivateGraphEndpoint", {})
     .n("NeptuneGraphClient", "CreatePrivateGraphEndpointCommand")
@@ -219,14 +217,14 @@ class CreatePrivateGraphEndpointCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteGraphCommand extends smithyClient.Command
+class DeleteGraphCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "DeleteGraph", {})
     .n("NeptuneGraphClient", "DeleteGraphCommand")
@@ -234,14 +232,14 @@ class DeleteGraphCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteGraphSnapshotCommand extends smithyClient.Command
+class DeleteGraphSnapshotCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "DeleteGraphSnapshot", {})
     .n("NeptuneGraphClient", "DeleteGraphSnapshotCommand")
@@ -249,14 +247,14 @@ class DeleteGraphSnapshotCommand extends smithyClient.Command
     .build() {
 }
 
-class DeletePrivateGraphEndpointCommand extends smithyClient.Command
+class DeletePrivateGraphEndpointCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "DeletePrivateGraphEndpoint", {})
     .n("NeptuneGraphClient", "DeletePrivateGraphEndpointCommand")
@@ -264,14 +262,14 @@ class DeletePrivateGraphEndpointCommand extends smithyClient.Command
     .build() {
 }
 
-class ExecuteQueryCommand extends smithyClient.Command
+class ExecuteQueryCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `DataPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "ExecuteQuery", {})
     .n("NeptuneGraphClient", "ExecuteQueryCommand")
@@ -279,14 +277,14 @@ class ExecuteQueryCommand extends smithyClient.Command
     .build() {
 }
 
-class GetExportTaskCommand extends smithyClient.Command
+class GetExportTaskCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "GetExportTask", {})
     .n("NeptuneGraphClient", "GetExportTaskCommand")
@@ -294,14 +292,14 @@ class GetExportTaskCommand extends smithyClient.Command
     .build() {
 }
 
-class GetGraphCommand extends smithyClient.Command
+class GetGraphCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "GetGraph", {})
     .n("NeptuneGraphClient", "GetGraphCommand")
@@ -309,14 +307,14 @@ class GetGraphCommand extends smithyClient.Command
     .build() {
 }
 
-class GetGraphSnapshotCommand extends smithyClient.Command
+class GetGraphSnapshotCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "GetGraphSnapshot", {})
     .n("NeptuneGraphClient", "GetGraphSnapshotCommand")
@@ -324,14 +322,14 @@ class GetGraphSnapshotCommand extends smithyClient.Command
     .build() {
 }
 
-class GetGraphSummaryCommand extends smithyClient.Command
+class GetGraphSummaryCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `DataPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "GetGraphSummary", {})
     .n("NeptuneGraphClient", "GetGraphSummaryCommand")
@@ -339,14 +337,14 @@ class GetGraphSummaryCommand extends smithyClient.Command
     .build() {
 }
 
-class GetImportTaskCommand extends smithyClient.Command
+class GetImportTaskCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "GetImportTask", {})
     .n("NeptuneGraphClient", "GetImportTaskCommand")
@@ -354,14 +352,14 @@ class GetImportTaskCommand extends smithyClient.Command
     .build() {
 }
 
-class GetPrivateGraphEndpointCommand extends smithyClient.Command
+class GetPrivateGraphEndpointCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "GetPrivateGraphEndpoint", {})
     .n("NeptuneGraphClient", "GetPrivateGraphEndpointCommand")
@@ -369,14 +367,14 @@ class GetPrivateGraphEndpointCommand extends smithyClient.Command
     .build() {
 }
 
-class GetQueryCommand extends smithyClient.Command
+class GetQueryCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `DataPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "GetQuery", {})
     .n("NeptuneGraphClient", "GetQueryCommand")
@@ -384,14 +382,14 @@ class GetQueryCommand extends smithyClient.Command
     .build() {
 }
 
-class ListExportTasksCommand extends smithyClient.Command
+class ListExportTasksCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "ListExportTasks", {})
     .n("NeptuneGraphClient", "ListExportTasksCommand")
@@ -399,14 +397,14 @@ class ListExportTasksCommand extends smithyClient.Command
     .build() {
 }
 
-class ListGraphsCommand extends smithyClient.Command
+class ListGraphsCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "ListGraphs", {})
     .n("NeptuneGraphClient", "ListGraphsCommand")
@@ -414,14 +412,14 @@ class ListGraphsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListGraphSnapshotsCommand extends smithyClient.Command
+class ListGraphSnapshotsCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "ListGraphSnapshots", {})
     .n("NeptuneGraphClient", "ListGraphSnapshotsCommand")
@@ -429,14 +427,14 @@ class ListGraphSnapshotsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListImportTasksCommand extends smithyClient.Command
+class ListImportTasksCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "ListImportTasks", {})
     .n("NeptuneGraphClient", "ListImportTasksCommand")
@@ -444,14 +442,14 @@ class ListImportTasksCommand extends smithyClient.Command
     .build() {
 }
 
-class ListPrivateGraphEndpointsCommand extends smithyClient.Command
+class ListPrivateGraphEndpointsCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "ListPrivateGraphEndpoints", {})
     .n("NeptuneGraphClient", "ListPrivateGraphEndpointsCommand")
@@ -459,14 +457,14 @@ class ListPrivateGraphEndpointsCommand extends smithyClient.Command
     .build() {
 }
 
-class ListQueriesCommand extends smithyClient.Command
+class ListQueriesCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `DataPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "ListQueries", {})
     .n("NeptuneGraphClient", "ListQueriesCommand")
@@ -474,14 +472,14 @@ class ListQueriesCommand extends smithyClient.Command
     .build() {
 }
 
-class ListTagsForResourceCommand extends smithyClient.Command
+class ListTagsForResourceCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "ListTagsForResource", {})
     .n("NeptuneGraphClient", "ListTagsForResourceCommand")
@@ -489,14 +487,14 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .build() {
 }
 
-class ResetGraphCommand extends smithyClient.Command
+class ResetGraphCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "ResetGraph", {})
     .n("NeptuneGraphClient", "ResetGraphCommand")
@@ -504,14 +502,14 @@ class ResetGraphCommand extends smithyClient.Command
     .build() {
 }
 
-class RestoreGraphFromSnapshotCommand extends smithyClient.Command
+class RestoreGraphFromSnapshotCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "RestoreGraphFromSnapshot", {})
     .n("NeptuneGraphClient", "RestoreGraphFromSnapshotCommand")
@@ -519,14 +517,14 @@ class RestoreGraphFromSnapshotCommand extends smithyClient.Command
     .build() {
 }
 
-class StartExportTaskCommand extends smithyClient.Command
+class StartExportTaskCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "StartExportTask", {})
     .n("NeptuneGraphClient", "StartExportTaskCommand")
@@ -534,14 +532,14 @@ class StartExportTaskCommand extends smithyClient.Command
     .build() {
 }
 
-class StartGraphCommand extends smithyClient.Command
+class StartGraphCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "StartGraph", {})
     .n("NeptuneGraphClient", "StartGraphCommand")
@@ -549,14 +547,14 @@ class StartGraphCommand extends smithyClient.Command
     .build() {
 }
 
-class StartImportTaskCommand extends smithyClient.Command
+class StartImportTaskCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "StartImportTask", {})
     .n("NeptuneGraphClient", "StartImportTaskCommand")
@@ -564,14 +562,14 @@ class StartImportTaskCommand extends smithyClient.Command
     .build() {
 }
 
-class StopGraphCommand extends smithyClient.Command
+class StopGraphCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "StopGraph", {})
     .n("NeptuneGraphClient", "StopGraphCommand")
@@ -579,14 +577,14 @@ class StopGraphCommand extends smithyClient.Command
     .build() {
 }
 
-class TagResourceCommand extends smithyClient.Command
+class TagResourceCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "TagResource", {})
     .n("NeptuneGraphClient", "TagResourceCommand")
@@ -594,14 +592,14 @@ class TagResourceCommand extends smithyClient.Command
     .build() {
 }
 
-class UntagResourceCommand extends smithyClient.Command
+class UntagResourceCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "UntagResource", {})
     .n("NeptuneGraphClient", "UntagResourceCommand")
@@ -609,14 +607,14 @@ class UntagResourceCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateGraphCommand extends smithyClient.Command
+class UpdateGraphCommand extends client.Command
     .classBuilder()
     .ep({
     ...commonParams,
     ApiType: { type: "staticContextParams", value: `ControlPlane` },
 })
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonNeptuneGraph", "UpdateGraph", {})
     .n("NeptuneGraphClient", "UpdateGraphCommand")
@@ -634,17 +632,17 @@ const paginateListImportTasks = core.createPaginator(NeptuneGraphClient, ListImp
 
 const paginateListPrivateGraphEndpoints = core.createPaginator(NeptuneGraphClient, ListPrivateGraphEndpointsCommand, "nextToken", "nextToken", "maxResults");
 
-const checkState$a = async (client, input) => {
+const checkState$a = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetExportTaskCommand(input));
+        let result = await client$1.send(new GetExportTaskCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return ((result.status != "CANCELLING") && (result.status != "CANCELLED"));
             };
             if (returnComparator() == true) {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -653,7 +651,7 @@ const checkState$a = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -661,29 +659,29 @@ const checkState$a = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForExportTaskCancelled = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
 };
 const waitUntilExportTaskCancelled = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
+    return client.checkExceptions(result);
 };
 
-const checkState$9 = async (client, input) => {
+const checkState$9 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetExportTaskCommand(input));
+        let result = await client$1.send(new GetExportTaskCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLING") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -692,7 +690,7 @@ const checkState$9 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -701,7 +699,7 @@ const checkState$9 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -710,7 +708,7 @@ const checkState$9 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "SUCCEEDED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -718,29 +716,29 @@ const checkState$9 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForExportTaskSuccessful = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
 };
 const waitUntilExportTaskSuccessful = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+    return client.checkExceptions(result);
 };
 
-const checkState$8 = async (client, input) => {
+const checkState$8 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetGraphCommand(input));
+        let result = await client$1.send(new GetGraphCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETING") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -749,7 +747,7 @@ const checkState$8 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -758,7 +756,7 @@ const checkState$8 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "AVAILABLE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -766,29 +764,29 @@ const checkState$8 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForGraphAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
 };
 const waitUntilGraphAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return client.checkExceptions(result);
 };
 
-const checkState$7 = async (client, input) => {
+const checkState$7 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetGraphCommand(input));
+        let result = await client$1.send(new GetGraphCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return (result.status != "DELETING");
             };
             if (returnComparator() == true) {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -796,32 +794,32 @@ const checkState$7 = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            return { state: client.WaiterState.SUCCESS, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForGraphDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
 };
 const waitUntilGraphDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return client.checkExceptions(result);
 };
 
-const checkState$6 = async (client, input) => {
+const checkState$6 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetGraphSnapshotCommand(input));
+        let result = await client$1.send(new GetGraphSnapshotCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETING") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -830,7 +828,7 @@ const checkState$6 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -839,7 +837,7 @@ const checkState$6 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "AVAILABLE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -847,29 +845,29 @@ const checkState$6 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForGraphSnapshotAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 7200 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
 };
 const waitUntilGraphSnapshotAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 7200 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return client.checkExceptions(result);
 };
 
-const checkState$5 = async (client, input) => {
+const checkState$5 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetGraphSnapshotCommand(input));
+        let result = await client$1.send(new GetGraphSnapshotCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return (result.status != "DELETING");
             };
             if (returnComparator() == true) {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -877,32 +875,32 @@ const checkState$5 = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            return { state: client.WaiterState.SUCCESS, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForGraphSnapshotDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
 };
 const waitUntilGraphSnapshotDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return client.checkExceptions(result);
 };
 
-const checkState$4 = async (client, input) => {
+const checkState$4 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetGraphCommand(input));
+        let result = await client$1.send(new GetGraphCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "STOPPED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -911,7 +909,7 @@ const checkState$4 = async (client, input) => {
                 return (result.status != "STOPPING");
             };
             if (returnComparator() == true) {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -919,29 +917,29 @@ const checkState$4 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForGraphStopped = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 1800 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
 };
 const waitUntilGraphStopped = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 1800 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return client.checkExceptions(result);
 };
 
-const checkState$3 = async (client, input) => {
+const checkState$3 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetImportTaskCommand(input));
+        let result = await client$1.send(new GetImportTaskCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return ((result.status != "CANCELLING") && (result.status != "CANCELLED"));
             };
             if (returnComparator() == true) {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -950,7 +948,7 @@ const checkState$3 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -958,29 +956,29 @@ const checkState$3 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForImportTaskCancelled = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
 };
 const waitUntilImportTaskCancelled = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return client.checkExceptions(result);
 };
 
-const checkState$2 = async (client, input) => {
+const checkState$2 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetImportTaskCommand(input));
+        let result = await client$1.send(new GetImportTaskCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLING") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -989,7 +987,7 @@ const checkState$2 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -998,7 +996,7 @@ const checkState$2 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "ROLLING_BACK") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1007,7 +1005,7 @@ const checkState$2 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1016,7 +1014,7 @@ const checkState$2 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "SUCCEEDED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1024,29 +1022,29 @@ const checkState$2 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForImportTaskSuccessful = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
 const waitUntilImportTaskSuccessful = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return client.checkExceptions(result);
 };
 
-const checkState$1 = async (client, input) => {
+const checkState$1 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetPrivateGraphEndpointCommand(input));
+        let result = await client$1.send(new GetPrivateGraphEndpointCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETING") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1055,7 +1053,7 @@ const checkState$1 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1064,7 +1062,7 @@ const checkState$1 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "AVAILABLE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1072,29 +1070,29 @@ const checkState$1 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForPrivateGraphEndpointAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
 const waitUntilPrivateGraphEndpointAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return client.checkExceptions(result);
 };
 
-const checkState = async (client, input) => {
+const checkState = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetPrivateGraphEndpointCommand(input));
+        let result = await client$1.send(new GetPrivateGraphEndpointCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return (result.status != "DELETING");
             };
             if (returnComparator() == true) {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1102,19 +1100,19 @@ const checkState = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            return { state: client.WaiterState.SUCCESS, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForPrivateGraphEndpointDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
 const waitUntilPrivateGraphEndpointDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return client.checkExceptions(result);
 };
 
 const commands = {
@@ -1175,7 +1173,7 @@ const waiters = {
 };
 class NeptuneGraph extends NeptuneGraphClient {
 }
-smithyClient.createAggregatedClient(commands, NeptuneGraph, { paginators, waiters });
+client.createAggregatedClient(commands, NeptuneGraph, { paginators, waiters });
 
 const ValidationExceptionReason = {
     BAD_REQUEST: "BAD_REQUEST",
@@ -1291,8 +1289,8 @@ const MultiValueHandlingType = {
     TO_LIST: "TO_LIST",
 };
 
-exports.$Command = smithyClient.Command;
-exports.__Client = smithyClient.Client;
+exports.$Command = client.Command;
+exports.__Client = client.Client;
 exports.NeptuneGraphServiceException = NeptuneGraphServiceException.NeptuneGraphServiceException;
 exports.BlankNodeHandling = BlankNodeHandling;
 exports.CancelExportTaskCommand = CancelExportTaskCommand;