@aws-sdk/client-neptune-graph 3.474.0

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

@@ -0,0 +1,94 @@
+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 { DeletePrivateGraphEndpointInput, DeletePrivateGraphEndpointOutput } from "../models/models_0";
+import { NeptuneGraphClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NeptuneGraphClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link DeletePrivateGraphEndpointCommand}.
+ */
+export interface DeletePrivateGraphEndpointCommandInput extends DeletePrivateGraphEndpointInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link DeletePrivateGraphEndpointCommand}.
+ */
+export interface DeletePrivateGraphEndpointCommandOutput extends DeletePrivateGraphEndpointOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Deletes a private graph endpoint.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NeptuneGraphClient, DeletePrivateGraphEndpointCommand } from "@aws-sdk/client-neptune-graph"; // ES Modules import
+ * // const { NeptuneGraphClient, DeletePrivateGraphEndpointCommand } = require("@aws-sdk/client-neptune-graph"); // CommonJS import
+ * const client = new NeptuneGraphClient(config);
+ * const input = { // DeletePrivateGraphEndpointInput
+ *   graphIdentifier: "STRING_VALUE", // required
+ *   vpcId: "STRING_VALUE", // required
+ * };
+ * const command = new DeletePrivateGraphEndpointCommand(input);
+ * const response = await client.send(command);
+ * // { // DeletePrivateGraphEndpointOutput
+ * //   vpcId: "STRING_VALUE", // required
+ * //   subnetIds: [ // SubnetIds // required
+ * //     "STRING_VALUE",
+ * //   ],
+ * //   status: "CREATING" || "AVAILABLE" || "DELETING" || "FAILED", // required
+ * //   vpcEndpointId: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param DeletePrivateGraphEndpointCommandInput - {@link DeletePrivateGraphEndpointCommandInput}
+ * @returns {@link DeletePrivateGraphEndpointCommandOutput}
+ * @see {@link DeletePrivateGraphEndpointCommandInput} for command's `input` shape.
+ * @see {@link DeletePrivateGraphEndpointCommandOutput} 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 DeletePrivateGraphEndpointCommand extends $Command<DeletePrivateGraphEndpointCommandInput, DeletePrivateGraphEndpointCommandOutput, NeptuneGraphClientResolvedConfig> {
+    readonly input: DeletePrivateGraphEndpointCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: DeletePrivateGraphEndpointCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NeptuneGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePrivateGraphEndpointCommandInput, DeletePrivateGraphEndpointCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -0,0 +1,101 @@
+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 { GetGraphInput, GetGraphOutput } from "../models/models_0";
+import { NeptuneGraphClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NeptuneGraphClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link GetGraphCommand}.
+ */
+export interface GetGraphCommandInput extends GetGraphInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link GetGraphCommand}.
+ */
+export interface GetGraphCommandOutput extends GetGraphOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Gets information about a specified graph.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NeptuneGraphClient, GetGraphCommand } from "@aws-sdk/client-neptune-graph"; // ES Modules import
+ * // const { NeptuneGraphClient, GetGraphCommand } = require("@aws-sdk/client-neptune-graph"); // CommonJS import
+ * const client = new NeptuneGraphClient(config);
+ * const input = { // GetGraphInput
+ *   graphIdentifier: "STRING_VALUE", // required
+ * };
+ * const command = new GetGraphCommand(input);
+ * const response = await client.send(command);
+ * // { // GetGraphOutput
+ * //   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 GetGraphCommandInput - {@link GetGraphCommandInput}
+ * @returns {@link GetGraphCommandOutput}
+ * @see {@link GetGraphCommandInput} for command's `input` shape.
+ * @see {@link GetGraphCommandOutput} 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 GetGraphCommand extends $Command<GetGraphCommandInput, GetGraphCommandOutput, NeptuneGraphClientResolvedConfig> {
+    readonly input: GetGraphCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: GetGraphCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NeptuneGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGraphCommandInput, GetGraphCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -0,0 +1,91 @@
+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 { GetGraphSnapshotInput, GetGraphSnapshotOutput } from "../models/models_0";
+import { NeptuneGraphClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NeptuneGraphClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link GetGraphSnapshotCommand}.
+ */
+export interface GetGraphSnapshotCommandInput extends GetGraphSnapshotInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link GetGraphSnapshotCommand}.
+ */
+export interface GetGraphSnapshotCommandOutput extends GetGraphSnapshotOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Retrieves a specified graph snapshot.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NeptuneGraphClient, GetGraphSnapshotCommand } from "@aws-sdk/client-neptune-graph"; // ES Modules import
+ * // const { NeptuneGraphClient, GetGraphSnapshotCommand } = require("@aws-sdk/client-neptune-graph"); // CommonJS import
+ * const client = new NeptuneGraphClient(config);
+ * const input = { // GetGraphSnapshotInput
+ *   snapshotIdentifier: "STRING_VALUE", // required
+ * };
+ * const command = new GetGraphSnapshotCommand(input);
+ * const response = await client.send(command);
+ * // { // GetGraphSnapshotOutput
+ * //   id: "STRING_VALUE", // required
+ * //   name: "STRING_VALUE", // required
+ * //   arn: "STRING_VALUE", // required
+ * //   sourceGraphId: "STRING_VALUE",
+ * //   snapshotCreateTime: new Date("TIMESTAMP"),
+ * //   status: "CREATING" || "AVAILABLE" || "DELETING" || "FAILED",
+ * //   kmsKeyIdentifier: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param GetGraphSnapshotCommandInput - {@link GetGraphSnapshotCommandInput}
+ * @returns {@link GetGraphSnapshotCommandOutput}
+ * @see {@link GetGraphSnapshotCommandInput} for command's `input` shape.
+ * @see {@link GetGraphSnapshotCommandOutput} 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 GetGraphSnapshotCommand extends $Command<GetGraphSnapshotCommandInput, GetGraphSnapshotCommandOutput, NeptuneGraphClientResolvedConfig> {
+    readonly input: GetGraphSnapshotCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: GetGraphSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NeptuneGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGraphSnapshotCommandInput, GetGraphSnapshotCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -0,0 +1,110 @@
+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 { GetImportTaskInput, GetImportTaskOutput } from "../models/models_0";
+import { NeptuneGraphClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NeptuneGraphClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link GetImportTaskCommand}.
+ */
+export interface GetImportTaskCommandInput extends GetImportTaskInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link GetImportTaskCommand}.
+ */
+export interface GetImportTaskCommandOutput extends GetImportTaskOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Retrieves a specified import task.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NeptuneGraphClient, GetImportTaskCommand } from "@aws-sdk/client-neptune-graph"; // ES Modules import
+ * // const { NeptuneGraphClient, GetImportTaskCommand } = require("@aws-sdk/client-neptune-graph"); // CommonJS import
+ * const client = new NeptuneGraphClient(config);
+ * const input = { // GetImportTaskInput
+ *   taskIdentifier: "STRING_VALUE", // required
+ * };
+ * const command = new GetImportTaskCommand(input);
+ * const response = await client.send(command);
+ * // { // GetImportTaskOutput
+ * //   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
+ * //   importOptions: { // ImportOptions Union: only one key present
+ * //     neptune: { // NeptuneImportOptions
+ * //       s3ExportPath: "STRING_VALUE", // required
+ * //       s3ExportKmsKeyId: "STRING_VALUE", // required
+ * //       preserveDefaultVertexLabels: true || false,
+ * //       preserveEdgeIds: true || false,
+ * //     },
+ * //   },
+ * //   importTaskDetails: { // ImportTaskDetails
+ * //     status: "STRING_VALUE", // required
+ * //     startTime: new Date("TIMESTAMP"), // required
+ * //     timeElapsedSeconds: Number("long"), // required
+ * //     progressPercentage: Number("int"), // required
+ * //     errorCount: Number("int"), // required
+ * //     errorDetails: "STRING_VALUE",
+ * //     statementCount: Number("long"), // required
+ * //     dictionaryEntryCount: Number("long"), // required
+ * //   },
+ * //   attemptNumber: Number("int"),
+ * //   statusReason: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param GetImportTaskCommandInput - {@link GetImportTaskCommandInput}
+ * @returns {@link GetImportTaskCommandOutput}
+ * @see {@link GetImportTaskCommandInput} for command's `input` shape.
+ * @see {@link GetImportTaskCommandOutput} 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 GetImportTaskCommand extends $Command<GetImportTaskCommandInput, GetImportTaskCommandOutput, NeptuneGraphClientResolvedConfig> {
+    readonly input: GetImportTaskCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: GetImportTaskCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NeptuneGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetImportTaskCommandInput, GetImportTaskCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -0,0 +1,91 @@
+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 { GetPrivateGraphEndpointInput, GetPrivateGraphEndpointOutput } from "../models/models_0";
+import { NeptuneGraphClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NeptuneGraphClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link GetPrivateGraphEndpointCommand}.
+ */
+export interface GetPrivateGraphEndpointCommandInput extends GetPrivateGraphEndpointInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link GetPrivateGraphEndpointCommand}.
+ */
+export interface GetPrivateGraphEndpointCommandOutput extends GetPrivateGraphEndpointOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Retrieves information about a specified private endpoint.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { NeptuneGraphClient, GetPrivateGraphEndpointCommand } from "@aws-sdk/client-neptune-graph"; // ES Modules import
+ * // const { NeptuneGraphClient, GetPrivateGraphEndpointCommand } = require("@aws-sdk/client-neptune-graph"); // CommonJS import
+ * const client = new NeptuneGraphClient(config);
+ * const input = { // GetPrivateGraphEndpointInput
+ *   graphIdentifier: "STRING_VALUE", // required
+ *   vpcId: "STRING_VALUE", // required
+ * };
+ * const command = new GetPrivateGraphEndpointCommand(input);
+ * const response = await client.send(command);
+ * // { // GetPrivateGraphEndpointOutput
+ * //   vpcId: "STRING_VALUE", // required
+ * //   subnetIds: [ // SubnetIds // required
+ * //     "STRING_VALUE",
+ * //   ],
+ * //   status: "CREATING" || "AVAILABLE" || "DELETING" || "FAILED", // required
+ * //   vpcEndpointId: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param GetPrivateGraphEndpointCommandInput - {@link GetPrivateGraphEndpointCommandInput}
+ * @returns {@link GetPrivateGraphEndpointCommandOutput}
+ * @see {@link GetPrivateGraphEndpointCommandInput} for command's `input` shape.
+ * @see {@link GetPrivateGraphEndpointCommandOutput} 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 GetPrivateGraphEndpointCommand extends $Command<GetPrivateGraphEndpointCommandInput, GetPrivateGraphEndpointCommandOutput, NeptuneGraphClientResolvedConfig> {
+    readonly input: GetPrivateGraphEndpointCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: GetPrivateGraphEndpointCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NeptuneGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetPrivateGraphEndpointCommandInput, GetPrivateGraphEndpointCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -0,0 +1,98 @@
+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 { ListGraphSnapshotsInput, ListGraphSnapshotsOutput } from "../models/models_0";
+import { NeptuneGraphClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NeptuneGraphClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link ListGraphSnapshotsCommand}.
+ */
+export interface ListGraphSnapshotsCommandInput extends ListGraphSnapshotsInput {
+}
+/**
+ * @public
+ *
+ * The output of {@link ListGraphSnapshotsCommand}.
+ */
+export interface ListGraphSnapshotsCommandOutput extends ListGraphSnapshotsOutput, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Lists available snapshots of 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, ListGraphSnapshotsCommand } from "@aws-sdk/client-neptune-graph"; // ES Modules import
+ * // const { NeptuneGraphClient, ListGraphSnapshotsCommand } = require("@aws-sdk/client-neptune-graph"); // CommonJS import
+ * const client = new NeptuneGraphClient(config);
+ * const input = { // ListGraphSnapshotsInput
+ *   graphIdentifier: "STRING_VALUE",
+ *   nextToken: "STRING_VALUE",
+ *   maxResults: Number("int"),
+ * };
+ * const command = new ListGraphSnapshotsCommand(input);
+ * const response = await client.send(command);
+ * // { // ListGraphSnapshotsOutput
+ * //   graphSnapshots: [ // GraphSnapshotSummaryList // required
+ * //     { // GraphSnapshotSummary
+ * //       id: "STRING_VALUE", // required
+ * //       name: "STRING_VALUE", // required
+ * //       arn: "STRING_VALUE", // required
+ * //       sourceGraphId: "STRING_VALUE",
+ * //       snapshotCreateTime: new Date("TIMESTAMP"),
+ * //       status: "CREATING" || "AVAILABLE" || "DELETING" || "FAILED",
+ * //       kmsKeyIdentifier: "STRING_VALUE",
+ * //     },
+ * //   ],
+ * //   nextToken: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param ListGraphSnapshotsCommandInput - {@link ListGraphSnapshotsCommandInput}
+ * @returns {@link ListGraphSnapshotsCommandOutput}
+ * @see {@link ListGraphSnapshotsCommandInput} for command's `input` shape.
+ * @see {@link ListGraphSnapshotsCommandOutput} 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 ListGraphSnapshotsCommand extends $Command<ListGraphSnapshotsCommandInput, ListGraphSnapshotsCommandOutput, NeptuneGraphClientResolvedConfig> {
+    readonly input: ListGraphSnapshotsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: ListGraphSnapshotsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NeptuneGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListGraphSnapshotsCommandInput, ListGraphSnapshotsCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}