@aws-sdk/client-neptune-graph 3.474.0

package/dist-types/commands/ListGraphsCommand.d.ts

@@ -0,0 +1,97 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { ListGraphsInput, ListGraphsOutput } from "../models/models_0";
+import { NeptuneGraphClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NeptuneGraphClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link ListGraphsCommand}.
+ */
+export interface ListGraphsCommandInput extends ListGraphsInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link ListGraphsCommand}.
+ */
+export interface ListGraphsCommandOutput extends ListGraphsOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Lists available Neptune Analytics graphs.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NeptuneGraphClient, ListGraphsCommand } from "@aws-sdk/client-neptune-graph"; // ES Modules import
+ * // const { NeptuneGraphClient, ListGraphsCommand } = require("@aws-sdk/client-neptune-graph"); // CommonJS import
+ * const client = new NeptuneGraphClient(config);
+ * const input = { // ListGraphsInput
+ *   nextToken: "STRING_VALUE",
+ *   maxResults: Number("int"),
+ * };
+ * const command = new ListGraphsCommand(input);
+ * const response = await client.send(command);
+ * // { // ListGraphsOutput
+ * //   graphs: [ // GraphSummaryList // required
+ * //     { // GraphSummary
+ * //       id: "STRING_VALUE", // required
+ * //       name: "STRING_VALUE", // required
+ * //       arn: "STRING_VALUE", // required
+ * //       status: "CREATING" || "AVAILABLE" || "DELETING" || "RESETTING" || "UPDATING" || "SNAPSHOTTING" || "FAILED",
+ * //       provisionedMemory: Number("int"),
+ * //       publicConnectivity: true || false,
+ * //       endpoint: "STRING_VALUE",
+ * //       replicaCount: Number("int"),
+ * //       kmsKeyIdentifier: "STRING_VALUE",
+ * //       deletionProtection: true || false,
+ * //     },
+ * //   ],
+ * //   nextToken: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param ListGraphsCommandInput - {@link ListGraphsCommandInput}
+ * @returns {@link ListGraphsCommandOutput}
+ * @see {@link ListGraphsCommandInput} for command's `input` shape.
+ * @see {@link ListGraphsCommandOutput} for command's `response` shape.
+ * @see {@link NeptuneGraphClientResolvedConfig | config} for NeptuneGraphClient's `config` shape.
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>A failure occurred on the server.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>A specified resource could not be located.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The exception was interrupted by throttling.</p>
+ *
+ * @throws {@link NeptuneGraphServiceException}
+ * <p>Base exception class for all service exceptions from NeptuneGraph service.</p>
+ *
+ */
+export declare class ListGraphsCommand extends $Command<ListGraphsCommandInput, ListGraphsCommandOutput, NeptuneGraphClientResolvedConfig> {
+    readonly input: ListGraphsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: ListGraphsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NeptuneGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListGraphsCommandInput, ListGraphsCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/commands/ListImportTasksCommand.d.ts

@@ -0,0 +1,96 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { ListImportTasksInput, ListImportTasksOutput } from "../models/models_0";
+import { NeptuneGraphClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NeptuneGraphClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link ListImportTasksCommand}.
+ */
+export interface ListImportTasksCommandInput extends ListImportTasksInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link ListImportTasksCommand}.
+ */
+export interface ListImportTasksCommandOutput extends ListImportTasksOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Lists import tasks.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NeptuneGraphClient, ListImportTasksCommand } from "@aws-sdk/client-neptune-graph"; // ES Modules import
+ * // const { NeptuneGraphClient, ListImportTasksCommand } = require("@aws-sdk/client-neptune-graph"); // CommonJS import
+ * const client = new NeptuneGraphClient(config);
+ * const input = { // ListImportTasksInput
+ *   nextToken: "STRING_VALUE",
+ *   maxResults: Number("int"),
+ * };
+ * const command = new ListImportTasksCommand(input);
+ * const response = await client.send(command);
+ * // { // ListImportTasksOutput
+ * //   tasks: [ // ImportTaskSummaryList // required
+ * //     { // ImportTaskSummary
+ * //       graphId: "STRING_VALUE",
+ * //       taskId: "STRING_VALUE", // required
+ * //       source: "STRING_VALUE", // required
+ * //       format: "CSV" || "OPEN_CYPHER",
+ * //       roleArn: "STRING_VALUE", // required
+ * //       status: "INITIALIZING" || "EXPORTING" || "ANALYZING_DATA" || "IMPORTING" || "REPROVISIONING" || "ROLLING_BACK" || "SUCCEEDED" || "FAILED" || "CANCELLING" || "CANCELLED", // required
+ * //     },
+ * //   ],
+ * //   nextToken: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param ListImportTasksCommandInput - {@link ListImportTasksCommandInput}
+ * @returns {@link ListImportTasksCommandOutput}
+ * @see {@link ListImportTasksCommandInput} for command's `input` shape.
+ * @see {@link ListImportTasksCommandOutput} for command's `response` shape.
+ * @see {@link NeptuneGraphClientResolvedConfig | config} for NeptuneGraphClient's `config` shape.
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>A failure occurred on the server.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>A specified resource could not be located.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The exception was interrupted by throttling.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>A resource could not be validated</p>
+ *
+ * @throws {@link NeptuneGraphServiceException}
+ * <p>Base exception class for all service exceptions from NeptuneGraph service.</p>
+ *
+ */
+export declare class ListImportTasksCommand extends $Command<ListImportTasksCommandInput, ListImportTasksCommandOutput, NeptuneGraphClientResolvedConfig> {
+    readonly input: ListImportTasksCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: ListImportTasksCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NeptuneGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListImportTasksCommandInput, ListImportTasksCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/commands/ListPrivateGraphEndpointsCommand.d.ts

@@ -0,0 +1,97 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { ListPrivateGraphEndpointsInput, ListPrivateGraphEndpointsOutput } from "../models/models_0";
+import { NeptuneGraphClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NeptuneGraphClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link ListPrivateGraphEndpointsCommand}.
+ */
+export interface ListPrivateGraphEndpointsCommandInput extends ListPrivateGraphEndpointsInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link ListPrivateGraphEndpointsCommand}.
+ */
+export interface ListPrivateGraphEndpointsCommandOutput extends ListPrivateGraphEndpointsOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Lists private endpoints for a specified Neptune Analytics graph.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NeptuneGraphClient, ListPrivateGraphEndpointsCommand } from "@aws-sdk/client-neptune-graph"; // ES Modules import
+ * // const { NeptuneGraphClient, ListPrivateGraphEndpointsCommand } = require("@aws-sdk/client-neptune-graph"); // CommonJS import
+ * const client = new NeptuneGraphClient(config);
+ * const input = { // ListPrivateGraphEndpointsInput
+ *   graphIdentifier: "STRING_VALUE", // required
+ *   nextToken: "STRING_VALUE",
+ *   maxResults: Number("int"),
+ * };
+ * const command = new ListPrivateGraphEndpointsCommand(input);
+ * const response = await client.send(command);
+ * // { // ListPrivateGraphEndpointsOutput
+ * //   privateGraphEndpoints: [ // PrivateGraphEndpointSummaryList // required
+ * //     { // PrivateGraphEndpointSummary
+ * //       vpcId: "STRING_VALUE", // required
+ * //       subnetIds: [ // SubnetIds // required
+ * //         "STRING_VALUE",
+ * //       ],
+ * //       status: "CREATING" || "AVAILABLE" || "DELETING" || "FAILED", // required
+ * //       vpcEndpointId: "STRING_VALUE",
+ * //     },
+ * //   ],
+ * //   nextToken: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param ListPrivateGraphEndpointsCommandInput - {@link ListPrivateGraphEndpointsCommandInput}
+ * @returns {@link ListPrivateGraphEndpointsCommandOutput}
+ * @see {@link ListPrivateGraphEndpointsCommandInput} for command's `input` shape.
+ * @see {@link ListPrivateGraphEndpointsCommandOutput} for command's `response` shape.
+ * @see {@link NeptuneGraphClientResolvedConfig | config} for NeptuneGraphClient's `config` shape.
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>A failure occurred on the server.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>A specified resource could not be located.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The exception was interrupted by throttling.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>A resource could not be validated</p>
+ *
+ * @throws {@link NeptuneGraphServiceException}
+ * <p>Base exception class for all service exceptions from NeptuneGraph service.</p>
+ *
+ */
+export declare class ListPrivateGraphEndpointsCommand extends $Command<ListPrivateGraphEndpointsCommandInput, ListPrivateGraphEndpointsCommandOutput, NeptuneGraphClientResolvedConfig> {
+    readonly input: ListPrivateGraphEndpointsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: ListPrivateGraphEndpointsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NeptuneGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPrivateGraphEndpointsCommandInput, ListPrivateGraphEndpointsCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/commands/ListTagsForResourceCommand.d.ts

@@ -0,0 +1,87 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { ListTagsForResourceInput, ListTagsForResourceOutput } from "../models/models_0";
+import { NeptuneGraphClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NeptuneGraphClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link ListTagsForResourceCommand}.
+ */
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link ListTagsForResourceCommand}.
+ */
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Lists tags associated with a specified resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NeptuneGraphClient, ListTagsForResourceCommand } from "@aws-sdk/client-neptune-graph"; // ES Modules import
+ * // const { NeptuneGraphClient, ListTagsForResourceCommand } = require("@aws-sdk/client-neptune-graph"); // CommonJS import
+ * const client = new NeptuneGraphClient(config);
+ * const input = { // ListTagsForResourceInput
+ *   resourceArn: "STRING_VALUE", // required
+ * };
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * // { // ListTagsForResourceOutput
+ * //   tags: { // TagMap
+ * //     "<keys>": "STRING_VALUE",
+ * //   },
+ * // };
+ *
+ * ```
+ *
+ * @param ListTagsForResourceCommandInput - {@link ListTagsForResourceCommandInput}
+ * @returns {@link ListTagsForResourceCommandOutput}
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link NeptuneGraphClientResolvedConfig | config} for NeptuneGraphClient's `config` shape.
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>A failure occurred on the server.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>A specified resource could not be located.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The exception was interrupted by throttling.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>A resource could not be validated</p>
+ *
+ * @throws {@link NeptuneGraphServiceException}
+ * <p>Base exception class for all service exceptions from NeptuneGraph service.</p>
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, NeptuneGraphClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NeptuneGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/commands/ResetGraphCommand.d.ts

@@ -0,0 +1,105 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { ResetGraphInput, ResetGraphOutput } from "../models/models_0";
+import { NeptuneGraphClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NeptuneGraphClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link ResetGraphCommand}.
+ */
+export interface ResetGraphCommandInput extends ResetGraphInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link ResetGraphCommand}.
+ */
+export interface ResetGraphCommandOutput extends ResetGraphOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Empties the data from a specified Neptune Analytics graph.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NeptuneGraphClient, ResetGraphCommand } from "@aws-sdk/client-neptune-graph"; // ES Modules import
+ * // const { NeptuneGraphClient, ResetGraphCommand } = require("@aws-sdk/client-neptune-graph"); // CommonJS import
+ * const client = new NeptuneGraphClient(config);
+ * const input = { // ResetGraphInput
+ *   graphIdentifier: "STRING_VALUE", // required
+ *   skipSnapshot: true || false, // required
+ * };
+ * const command = new ResetGraphCommand(input);
+ * const response = await client.send(command);
+ * // { // ResetGraphOutput
+ * //   id: "STRING_VALUE", // required
+ * //   name: "STRING_VALUE", // required
+ * //   arn: "STRING_VALUE", // required
+ * //   status: "CREATING" || "AVAILABLE" || "DELETING" || "RESETTING" || "UPDATING" || "SNAPSHOTTING" || "FAILED",
+ * //   statusReason: "STRING_VALUE",
+ * //   createTime: new Date("TIMESTAMP"),
+ * //   provisionedMemory: Number("int"),
+ * //   endpoint: "STRING_VALUE",
+ * //   publicConnectivity: true || false,
+ * //   vectorSearchConfiguration: { // VectorSearchConfiguration
+ * //     dimension: Number("int"), // required
+ * //   },
+ * //   replicaCount: Number("int"),
+ * //   kmsKeyIdentifier: "STRING_VALUE",
+ * //   sourceSnapshotId: "STRING_VALUE",
+ * //   deletionProtection: true || false,
+ * //   buildNumber: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param ResetGraphCommandInput - {@link ResetGraphCommandInput}
+ * @returns {@link ResetGraphCommandOutput}
+ * @see {@link ResetGraphCommandInput} for command's `input` shape.
+ * @see {@link ResetGraphCommandOutput} for command's `response` shape.
+ * @see {@link NeptuneGraphClientResolvedConfig | config} for NeptuneGraphClient's `config` shape.
+ *
+ * @throws {@link ConflictException} (client fault)
+ *  <p>Raised when a conflict is encountered.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>A failure occurred on the server.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>A specified resource could not be located.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The exception was interrupted by throttling.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>A resource could not be validated</p>
+ *
+ * @throws {@link NeptuneGraphServiceException}
+ * <p>Base exception class for all service exceptions from NeptuneGraph service.</p>
+ *
+ */
+export declare class ResetGraphCommand extends $Command<ResetGraphCommandInput, ResetGraphCommandOutput, NeptuneGraphClientResolvedConfig> {
+    readonly input: ResetGraphCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: ResetGraphCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NeptuneGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetGraphCommandInput, ResetGraphCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

package/dist-types/commands/RestoreGraphFromSnapshotCommand.d.ts

@@ -0,0 +1,115 @@
+import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
+import { Command as $Command } from "@smithy/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { RestoreGraphFromSnapshotInput, RestoreGraphFromSnapshotOutput } from "../models/models_0";
+import { NeptuneGraphClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NeptuneGraphClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link RestoreGraphFromSnapshotCommand}.
+ */
+export interface RestoreGraphFromSnapshotCommandInput extends RestoreGraphFromSnapshotInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link RestoreGraphFromSnapshotCommand}.
+ */
+export interface RestoreGraphFromSnapshotCommandOutput extends RestoreGraphFromSnapshotOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Restores a graph from a snapshot.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NeptuneGraphClient, RestoreGraphFromSnapshotCommand } from "@aws-sdk/client-neptune-graph"; // ES Modules import
+ * // const { NeptuneGraphClient, RestoreGraphFromSnapshotCommand } = require("@aws-sdk/client-neptune-graph"); // CommonJS import
+ * const client = new NeptuneGraphClient(config);
+ * const input = { // RestoreGraphFromSnapshotInput
+ *   snapshotIdentifier: "STRING_VALUE", // required
+ *   graphName: "STRING_VALUE", // required
+ *   provisionedMemory: Number("int"),
+ *   deletionProtection: true || false,
+ *   tags: { // TagMap
+ *     "<keys>": "STRING_VALUE",
+ *   },
+ *   replicaCount: Number("int"),
+ *   publicConnectivity: true || false,
+ * };
+ * const command = new RestoreGraphFromSnapshotCommand(input);
+ * const response = await client.send(command);
+ * // { // RestoreGraphFromSnapshotOutput
+ * //   id: "STRING_VALUE", // required
+ * //   name: "STRING_VALUE", // required
+ * //   arn: "STRING_VALUE", // required
+ * //   status: "CREATING" || "AVAILABLE" || "DELETING" || "RESETTING" || "UPDATING" || "SNAPSHOTTING" || "FAILED",
+ * //   statusReason: "STRING_VALUE",
+ * //   createTime: new Date("TIMESTAMP"),
+ * //   provisionedMemory: Number("int"),
+ * //   endpoint: "STRING_VALUE",
+ * //   publicConnectivity: true || false,
+ * //   vectorSearchConfiguration: { // VectorSearchConfiguration
+ * //     dimension: Number("int"), // required
+ * //   },
+ * //   replicaCount: Number("int"),
+ * //   kmsKeyIdentifier: "STRING_VALUE",
+ * //   sourceSnapshotId: "STRING_VALUE",
+ * //   deletionProtection: true || false,
+ * //   buildNumber: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param RestoreGraphFromSnapshotCommandInput - {@link RestoreGraphFromSnapshotCommandInput}
+ * @returns {@link RestoreGraphFromSnapshotCommandOutput}
+ * @see {@link RestoreGraphFromSnapshotCommandInput} for command's `input` shape.
+ * @see {@link RestoreGraphFromSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link NeptuneGraphClientResolvedConfig | config} for NeptuneGraphClient's `config` shape.
+ *
+ * @throws {@link ConflictException} (client fault)
+ *  <p>Raised when a conflict is encountered.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>A failure occurred on the server.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>A specified resource could not be located.</p>
+ *
+ * @throws {@link ServiceQuotaExceededException} (client fault)
+ *  <p>A service quota was exceeded.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The exception was interrupted by throttling.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>A resource could not be validated</p>
+ *
+ * @throws {@link NeptuneGraphServiceException}
+ * <p>Base exception class for all service exceptions from NeptuneGraph service.</p>
+ *
+ */
+export declare class RestoreGraphFromSnapshotCommand extends $Command<RestoreGraphFromSnapshotCommandInput, RestoreGraphFromSnapshotCommandOutput, NeptuneGraphClientResolvedConfig> {
+    readonly input: RestoreGraphFromSnapshotCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: RestoreGraphFromSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NeptuneGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestoreGraphFromSnapshotCommandInput, RestoreGraphFromSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}