@aws-sdk/client-neptune-graph 3.876.0 → 3.879.0

package/README.md

@@ -6,9 +6,7 @@
 
 AWS SDK for JavaScript NeptuneGraph Client for Node.js, Browser and React Native.
 
-<p>Neptune Analytics is a new analytics database engine for Amazon Neptune that helps customers get to
-insights faster by quickly processing large amounts of graph data, invoking popular graph analytic
-algorithms in low-latency queries, and getting analytics results in seconds.</p>
+<p>Neptune Analytics is a new analytics database engine for Amazon Neptune that helps customers get to insights faster by quickly processing large amounts of graph data, invoking popular graph analytic algorithms in low-latency queries, and getting analytics results in seconds.</p>
 
 ## Installing
 
@@ -428,6 +426,14 @@ StartExportTask
 
 [Command API Reference](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/neptune-graph/command/StartExportTaskCommand/) / [Input](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-neptune-graph/Interface/StartExportTaskCommandInput/) / [Output](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-neptune-graph/Interface/StartExportTaskCommandOutput/)
 
+</details>
+<details>
+<summary>
+StartGraph
+</summary>
+
+[Command API Reference](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/neptune-graph/command/StartGraphCommand/) / [Input](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-neptune-graph/Interface/StartGraphCommandInput/) / [Output](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-neptune-graph/Interface/StartGraphCommandOutput/)
+
 </details>
 <details>
 <summary>
@@ -436,6 +442,14 @@ StartImportTask
 
 [Command API Reference](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/neptune-graph/command/StartImportTaskCommand/) / [Input](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-neptune-graph/Interface/StartImportTaskCommandInput/) / [Output](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-neptune-graph/Interface/StartImportTaskCommandOutput/)
 
+</details>
+<details>
+<summary>
+StopGraph
+</summary>
+
+[Command API Reference](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/neptune-graph/command/StopGraphCommand/) / [Input](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-neptune-graph/Interface/StopGraphCommandInput/) / [Output](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-neptune-graph/Interface/StopGraphCommandOutput/)
+
 </details>
 <details>
 <summary>

package/dist-cjs/index.js

@@ -76,7 +76,9 @@ __export(index_exports, {
   ServiceQuotaExceededException: () => ServiceQuotaExceededException,
   SnapshotStatus: () => SnapshotStatus,
   StartExportTaskCommand: () => StartExportTaskCommand,
+  StartGraphCommand: () => StartGraphCommand,
   StartImportTaskCommand: () => StartImportTaskCommand,
+  StopGraphCommand: () => StopGraphCommand,
   TagResourceCommand: () => TagResourceCommand,
   ThrottlingException: () => ThrottlingException,
   UnprocessableException: () => UnprocessableException,
@@ -97,6 +99,7 @@ __export(index_exports, {
   waitForGraphDeleted: () => waitForGraphDeleted,
   waitForGraphSnapshotAvailable: () => waitForGraphSnapshotAvailable,
   waitForGraphSnapshotDeleted: () => waitForGraphSnapshotDeleted,
+  waitForGraphStopped: () => waitForGraphStopped,
   waitForImportTaskCancelled: () => waitForImportTaskCancelled,
   waitForImportTaskSuccessful: () => waitForImportTaskSuccessful,
   waitForPrivateGraphEndpointAvailable: () => waitForPrivateGraphEndpointAvailable,
@@ -107,6 +110,7 @@ __export(index_exports, {
   waitUntilGraphDeleted: () => waitUntilGraphDeleted,
   waitUntilGraphSnapshotAvailable: () => waitUntilGraphSnapshotAvailable,
   waitUntilGraphSnapshotDeleted: () => waitUntilGraphSnapshotDeleted,
+  waitUntilGraphStopped: () => waitUntilGraphStopped,
   waitUntilImportTaskCancelled: () => waitUntilImportTaskCancelled,
   waitUntilImportTaskSuccessful: () => waitUntilImportTaskSuccessful,
   waitUntilPrivateGraphEndpointAvailable: () => waitUntilPrivateGraphEndpointAvailable,
@@ -481,6 +485,9 @@ var GraphStatus = {
   IMPORTING: "IMPORTING",
   RESETTING: "RESETTING",
   SNAPSHOTTING: "SNAPSHOTTING",
+  STARTING: "STARTING",
+  STOPPED: "STOPPED",
+  STOPPING: "STOPPING",
   UPDATING: "UPDATING"
 };
 var ServiceQuotaExceededException = class _ServiceQuotaExceededException extends NeptuneGraphServiceException {
@@ -1040,6 +1047,15 @@ var se_StartExportTaskCommand = /* @__PURE__ */ __name(async (input, context) =>
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_StartExportTaskCommand");
+var se_StartGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/graphs/{graphIdentifier}/start");
+  b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartGraphCommand");
 var se_StartImportTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
@@ -1062,6 +1078,15 @@ var se_StartImportTaskCommand = /* @__PURE__ */ __name(async (input, context) =>
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_StartImportTaskCommand");
+var se_StopGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/graphs/{graphIdentifier}/stop");
+  b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
+  let body;
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StopGraphCommand");
 var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
@@ -1652,6 +1677,34 @@ var de_StartExportTaskCommand = /* @__PURE__ */ __name(async (output, context) =
   Object.assign(contents, doc);
   return contents;
 }, "de_StartExportTaskCommand");
+var de_StartGraphCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    buildNumber: import_smithy_client.expectString,
+    createTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createTime"),
+    deletionProtection: import_smithy_client.expectBoolean,
+    endpoint: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    provisionedMemory: import_smithy_client.expectInt32,
+    publicConnectivity: import_smithy_client.expectBoolean,
+    replicaCount: import_smithy_client.expectInt32,
+    sourceSnapshotId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client.expectString,
+    vectorSearchConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartGraphCommand");
 var de_StartImportTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 201 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1673,6 +1726,34 @@ var de_StartImportTaskCommand = /* @__PURE__ */ __name(async (output, context) =
   Object.assign(contents, doc);
   return contents;
 }, "de_StartImportTaskCommand");
+var de_StopGraphCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    buildNumber: import_smithy_client.expectString,
+    createTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createTime"),
+    deletionProtection: import_smithy_client.expectBoolean,
+    endpoint: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    provisionedMemory: import_smithy_client.expectInt32,
+    publicConnectivity: import_smithy_client.expectBoolean,
+    replicaCount: import_smithy_client.expectInt32,
+    sourceSnapshotId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client.expectString,
+    vectorSearchConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StopGraphCommand");
 var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -2439,6 +2520,24 @@ var StartExportTaskCommand = class extends import_smithy_client.Command.classBui
   }
 };
 
+// src/commands/StartGraphCommand.ts
+
+
+
+var StartGraphCommand = class extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  ApiType: { type: "staticContextParams", value: `ControlPlane` }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonNeptuneGraph", "StartGraph", {}).n("NeptuneGraphClient", "StartGraphCommand").f(void 0, void 0).ser(se_StartGraphCommand).de(de_StartGraphCommand).build() {
+  static {
+    __name(this, "StartGraphCommand");
+  }
+};
+
 // src/commands/StartImportTaskCommand.ts
 
 
@@ -2457,6 +2556,24 @@ var StartImportTaskCommand = class extends import_smithy_client.Command.classBui
   }
 };
 
+// src/commands/StopGraphCommand.ts
+
+
+
+var StopGraphCommand = class extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  ApiType: { type: "staticContextParams", value: `ControlPlane` }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonNeptuneGraph", "StopGraph", {}).n("NeptuneGraphClient", "StopGraphCommand").f(void 0, void 0).ser(se_StopGraphCommand).de(de_StopGraphCommand).build() {
+  static {
+    __name(this, "StopGraphCommand");
+  }
+};
+
 // src/commands/TagResourceCommand.ts
 
 
@@ -2541,7 +2658,9 @@ var commands = {
   ResetGraphCommand,
   RestoreGraphFromSnapshotCommand,
   StartExportTaskCommand,
+  StartGraphCommand,
   StartImportTaskCommand,
+  StopGraphCommand,
   TagResourceCommand,
   UntagResourceCommand,
   UpdateGraphCommand
@@ -2837,9 +2956,49 @@ var waitUntilGraphSnapshotDeleted = /* @__PURE__ */ __name(async (params, input)
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilGraphSnapshotDeleted");
 
-// src/waiters/waitForImportTaskCancelled.ts
+// src/waiters/waitForGraphStopped.ts
 
 var checkState7 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetGraphCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "STOPPED") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status != "STOPPING";
+      }, "returnComparator");
+      if (returnComparator() == true) {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForGraphStopped = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 20, maxDelay: 1800 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState7);
+}, "waitForGraphStopped");
+var waitUntilGraphStopped = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 20, maxDelay: 1800 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState7);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilGraphStopped");
+
+// src/waiters/waitForImportTaskCancelled.ts
+
+var checkState8 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new GetImportTaskCommand(input));
@@ -2869,17 +3028,17 @@ var checkState7 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForImportTaskCancelled = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState7);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState8);
 }, "waitForImportTaskCancelled");
 var waitUntilImportTaskCancelled = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState7);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState8);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilImportTaskCancelled");
 
 // src/waiters/waitForImportTaskSuccessful.ts
 
-var checkState8 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState9 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new GetImportTaskCommand(input));
@@ -2936,17 +3095,17 @@ var checkState8 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForImportTaskSuccessful = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState8);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState9);
 }, "waitForImportTaskSuccessful");
 var waitUntilImportTaskSuccessful = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState8);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState9);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilImportTaskSuccessful");
 
 // src/waiters/waitForPrivateGraphEndpointAvailable.ts
 
-var checkState9 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState10 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new GetPrivateGraphEndpointCommand(input));
@@ -2985,17 +3144,17 @@ var checkState9 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForPrivateGraphEndpointAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState9);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState10);
 }, "waitForPrivateGraphEndpointAvailable");
 var waitUntilPrivateGraphEndpointAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState9);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState10);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilPrivateGraphEndpointAvailable");
 
 // src/waiters/waitForPrivateGraphEndpointDeleted.ts
 
-var checkState10 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState11 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new GetPrivateGraphEndpointCommand(input));
@@ -3019,11 +3178,11 @@ var checkState10 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForPrivateGraphEndpointDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState10);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState11);
 }, "waitForPrivateGraphEndpointDeleted");
 var waitUntilPrivateGraphEndpointDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState10);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState11);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilPrivateGraphEndpointDeleted");
 // Annotate the CommonJS export names for ESM import in node:
@@ -3062,7 +3221,9 @@ var waitUntilPrivateGraphEndpointDeleted = /* @__PURE__ */ __name(async (params,
   ResetGraphCommand,
   RestoreGraphFromSnapshotCommand,
   StartExportTaskCommand,
+  StartGraphCommand,
   StartImportTaskCommand,
+  StopGraphCommand,
   TagResourceCommand,
   UntagResourceCommand,
   UpdateGraphCommand,
@@ -3083,6 +3244,8 @@ var waitUntilPrivateGraphEndpointDeleted = /* @__PURE__ */ __name(async (params,
   waitUntilGraphSnapshotAvailable,
   waitForGraphSnapshotDeleted,
   waitUntilGraphSnapshotDeleted,
+  waitForGraphStopped,
+  waitUntilGraphStopped,
   waitForImportTaskCancelled,
   waitUntilImportTaskCancelled,
   waitForImportTaskSuccessful,

package/dist-es/NeptuneGraph.js

@@ -27,7 +27,9 @@ import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceComma
 import { ResetGraphCommand } from "./commands/ResetGraphCommand";
 import { RestoreGraphFromSnapshotCommand, } from "./commands/RestoreGraphFromSnapshotCommand";
 import { StartExportTaskCommand, } from "./commands/StartExportTaskCommand";
+import { StartGraphCommand } from "./commands/StartGraphCommand";
 import { StartImportTaskCommand, } from "./commands/StartImportTaskCommand";
+import { StopGraphCommand } from "./commands/StopGraphCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateGraphCommand } from "./commands/UpdateGraphCommand";
@@ -61,7 +63,9 @@ const commands = {
     ResetGraphCommand,
     RestoreGraphFromSnapshotCommand,
     StartExportTaskCommand,
+    StartGraphCommand,
     StartImportTaskCommand,
+    StopGraphCommand,
     TagResourceCommand,
     UntagResourceCommand,
     UpdateGraphCommand,

package/dist-es/commands/StartGraphCommand.js

@@ -0,0 +1,25 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_StartGraphCommand, se_StartGraphCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class StartGraphCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "StartGraph", {})
+    .n("NeptuneGraphClient", "StartGraphCommand")
+    .f(void 0, void 0)
+    .ser(se_StartGraphCommand)
+    .de(de_StartGraphCommand)
+    .build() {
+}

package/dist-es/commands/StopGraphCommand.js

@@ -0,0 +1,25 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_StopGraphCommand, se_StopGraphCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class StopGraphCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "StopGraph", {})
+    .n("NeptuneGraphClient", "StopGraphCommand")
+    .f(void 0, void 0)
+    .ser(se_StopGraphCommand)
+    .de(de_StopGraphCommand)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -26,7 +26,9 @@ export * from "./ListTagsForResourceCommand";
 export * from "./ResetGraphCommand";
 export * from "./RestoreGraphFromSnapshotCommand";
 export * from "./StartExportTaskCommand";
+export * from "./StartGraphCommand";
 export * from "./StartImportTaskCommand";
+export * from "./StopGraphCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";
 export * from "./UpdateGraphCommand";

package/dist-es/models/models_0.js

@@ -141,6 +141,9 @@ export const GraphStatus = {
     IMPORTING: "IMPORTING",
     RESETTING: "RESETTING",
     SNAPSHOTTING: "SNAPSHOTTING",
+    STARTING: "STARTING",
+    STOPPED: "STOPPED",
+    STOPPING: "STOPPING",
     UPDATING: "UPDATING",
 };
 export class ServiceQuotaExceededException extends __BaseException {

package/dist-es/protocols/Aws_restJson1.js

@@ -431,6 +431,15 @@ export const se_StartExportTaskCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_StartGraphCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/graphs/{graphIdentifier}/start");
+    b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
+    let body;
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_StartImportTaskCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -451,6 +460,15 @@ export const se_StartImportTaskCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_StopGraphCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/graphs/{graphIdentifier}/stop");
+    b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
+    let body;
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_TagResourceCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -1037,6 +1055,34 @@ export const de_StartExportTaskCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_StartGraphCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        arn: __expectString,
+        buildNumber: __expectString,
+        createTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        deletionProtection: __expectBoolean,
+        endpoint: __expectString,
+        id: __expectString,
+        kmsKeyIdentifier: __expectString,
+        name: __expectString,
+        provisionedMemory: __expectInt32,
+        publicConnectivity: __expectBoolean,
+        replicaCount: __expectInt32,
+        sourceSnapshotId: __expectString,
+        status: __expectString,
+        statusReason: __expectString,
+        vectorSearchConfiguration: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_StartImportTaskCommand = async (output, context) => {
     if (output.statusCode !== 201 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -1058,6 +1104,34 @@ export const de_StartImportTaskCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_StopGraphCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        arn: __expectString,
+        buildNumber: __expectString,
+        createTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        deletionProtection: __expectBoolean,
+        endpoint: __expectString,
+        id: __expectString,
+        kmsKeyIdentifier: __expectString,
+        name: __expectString,
+        provisionedMemory: __expectInt32,
+        publicConnectivity: __expectBoolean,
+        replicaCount: __expectInt32,
+        sourceSnapshotId: __expectString,
+        status: __expectString,
+        statusReason: __expectString,
+        vectorSearchConfiguration: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);

package/dist-es/waiters/index.js

@@ -4,6 +4,7 @@ export * from "./waitForGraphAvailable";
 export * from "./waitForGraphDeleted";
 export * from "./waitForGraphSnapshotAvailable";
 export * from "./waitForGraphSnapshotDeleted";
+export * from "./waitForGraphStopped";
 export * from "./waitForImportTaskCancelled";
 export * from "./waitForImportTaskSuccessful";
 export * from "./waitForPrivateGraphEndpointAvailable";

package/dist-es/waiters/waitForGraphStopped.js

@@ -0,0 +1,40 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetGraphCommand } from "../commands/GetGraphCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetGraphCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "STOPPED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status != "STOPPING";
+            };
+            if (returnComparator() == true) {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForGraphStopped = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 1800 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilGraphStopped = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 1800 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};