@aws-sdk/client-neptune-graph 3.504.0 → 3.505.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,7 +1,8 @@
 import { awsExpectUnion as __expectUnion } from "@aws-sdk/core";
 import { requestBuilder as rb } from "@smithy/core";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, take, withBaseException, } from "@smithy/smithy-client";
-import { ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { isValidHostname as __isValidHostname, } from "@smithy/protocol-http";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map, parseEpochTimestamp as __parseEpochTimestamp, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, take, withBaseException, } from "@smithy/smithy-client";
+import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, UnprocessableException, ValidationException, } from "../models/models_0";
 import { NeptuneGraphServiceException as __BaseException } from "../models/NeptuneGraphServiceException";
 export const se_CancelImportTaskCommand = async (input, context) => {
     const b = rb(input, context);
@@ -12,6 +13,29 @@ export const se_CancelImportTaskCommand = async (input, context) => {
     b.m("DELETE").h(headers).b(body);
     return b.build();
 };
+export const se_CancelQueryCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        [_g]: input[_gI],
+    });
+    b.bp("/queries/{queryId}");
+    b.p("queryId", () => input.queryId, "{queryId}", false);
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "{graphIdentifier}." + resolvedHostname;
+        if (input.graphIdentifier === undefined) {
+            throw new Error("Empty value provided for input host prefix: graphIdentifier.");
+        }
+        resolvedHostname = resolvedHostname.replace("{graphIdentifier}", input.graphIdentifier);
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
+};
 export const se_CreateGraphCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -120,6 +144,36 @@ export const se_DeletePrivateGraphEndpointCommand = async (input, context) => {
     b.m("DELETE").h(headers).b(body);
     return b.build();
 };
+export const se_ExecuteQueryCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_g]: input[_gI],
+    });
+    b.bp("/queries");
+    let body;
+    body = JSON.stringify(take(input, {
+        explain: [, , `explainMode`],
+        language: [],
+        planCache: [],
+        query: [, , `queryString`],
+        queryTimeoutMilliseconds: [],
+    }));
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "{graphIdentifier}." + resolvedHostname;
+        if (input.graphIdentifier === undefined) {
+            throw new Error("Empty value provided for input host prefix: graphIdentifier.");
+        }
+        resolvedHostname = resolvedHostname.replace("{graphIdentifier}", input.graphIdentifier);
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_GetGraphCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -138,6 +192,31 @@ export const se_GetGraphSnapshotCommand = async (input, context) => {
     b.m("GET").h(headers).b(body);
     return b.build();
 };
+export const se_GetGraphSummaryCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        [_g]: input[_gI],
+    });
+    b.bp("/summary");
+    const query = map({
+        [_m]: [, input[_m]],
+    });
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "{graphIdentifier}." + resolvedHostname;
+        if (input.graphIdentifier === undefined) {
+            throw new Error("Empty value provided for input host prefix: graphIdentifier.");
+        }
+        resolvedHostname = resolvedHostname.replace("{graphIdentifier}", input.graphIdentifier);
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
+};
 export const se_GetImportTaskCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -157,6 +236,29 @@ export const se_GetPrivateGraphEndpointCommand = async (input, context) => {
     b.m("GET").h(headers).b(body);
     return b.build();
 };
+export const se_GetQueryCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        [_g]: input[_gI],
+    });
+    b.bp("/queries/{queryId}");
+    b.p("queryId", () => input.queryId, "{queryId}", false);
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "{graphIdentifier}." + resolvedHostname;
+        if (input.graphIdentifier === undefined) {
+            throw new Error("Empty value provided for input host prefix: graphIdentifier.");
+        }
+        resolvedHostname = resolvedHostname.replace("{graphIdentifier}", input.graphIdentifier);
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
+};
 export const se_ListGraphsCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -207,6 +309,32 @@ export const se_ListPrivateGraphEndpointsCommand = async (input, context) => {
     b.m("GET").h(headers).q(query).b(body);
     return b.build();
 };
+export const se_ListQueriesCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        [_g]: input[_gI],
+    });
+    b.bp("/queries");
+    const query = map({
+        [_mR]: [__expectNonNull(input.maxResults, `maxResults`) != null, () => input[_mR].toString()],
+        [_s]: [, input[_s]],
+    });
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "{graphIdentifier}." + resolvedHostname;
+        if (input.graphIdentifier === undefined) {
+            throw new Error("Empty value provided for input host prefix: graphIdentifier.");
+        }
+        resolvedHostname = resolvedHostname.replace("{graphIdentifier}", input.graphIdentifier);
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
+};
 export const se_ListTagsForResourceCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -344,6 +472,47 @@ const de_CancelImportTaskCommandError = async (output, context) => {
             });
     }
 };
+export const de_CancelQueryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CancelQueryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_CancelQueryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunegraph#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.neptunegraph#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.neptunegraph#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.neptunegraph#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.neptunegraph#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_CreateGraphCommand = async (output, context) => {
     if (output.statusCode !== 201 && output.statusCode >= 300) {
         return de_CreateGraphCommandError(output, context);
@@ -717,6 +886,52 @@ const de_DeletePrivateGraphEndpointCommandError = async (output, context) => {
             });
     }
 };
+export const de_ExecuteQueryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ExecuteQueryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = output.body;
+    context.sdkStreamMixin(data);
+    contents.payload = data;
+    return contents;
+};
+const de_ExecuteQueryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunegraph#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.neptunegraph#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.neptunegraph#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.neptunegraph#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "UnprocessableException":
+        case "com.amazonaws.neptunegraph#UnprocessableException":
+            throw await de_UnprocessableExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.neptunegraph#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_GetGraphCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_GetGraphCommandError(output, context);
@@ -821,6 +1036,53 @@ const de_GetGraphSnapshotCommandError = async (output, context) => {
             });
     }
 };
+export const de_GetGraphSummaryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetGraphSummaryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        graphSummary: _json,
+        lastStatisticsComputationTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        version: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetGraphSummaryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunegraph#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.neptunegraph#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.neptunegraph#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.neptunegraph#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.neptunegraph#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_GetImportTaskCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_GetImportTaskCommandError(output, context);
@@ -917,6 +1179,55 @@ const de_GetPrivateGraphEndpointCommandError = async (output, context) => {
             });
     }
 };
+export const de_GetQueryCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetQueryCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        elapsed: __expectInt32,
+        id: __expectString,
+        queryString: __expectString,
+        state: __expectString,
+        waited: __expectInt32,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetQueryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunegraph#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.neptunegraph#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.neptunegraph#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.neptunegraph#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.neptunegraph#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListGraphsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListGraphsCommandError(output, context);
@@ -1086,6 +1397,48 @@ const de_ListPrivateGraphEndpointsCommandError = async (output, context) => {
             });
     }
 };
+export const de_ListQueriesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListQueriesCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        queries: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListQueriesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.neptunegraph#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.neptunegraph#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.neptunegraph#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.neptunegraph#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListTagsForResourceCommandError(output, context);
@@ -1385,6 +1738,19 @@ const de_UpdateGraphCommandError = async (output, context) => {
     }
 };
 const throwDefaultError = withBaseException(__BaseException);
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new AccessDeniedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_ConflictExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -1455,6 +1821,20 @@ const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_UnprocessableExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+        reason: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new UnprocessableException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_ValidationExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -1512,9 +1892,12 @@ const isSerializableHeaderValue = (value) => value !== undefined &&
     value !== "" &&
     (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
     (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const _g = "graphidentifier";
 const _gI = "graphIdentifier";
+const _m = "mode";
 const _mR = "maxResults";
 const _nT = "nextToken";
+const _s = "state";
 const _sS = "skipSnapshot";
 const _tK = "tagKeys";
 const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {

package/dist-es/runtimeConfig.shared.js

@@ -1,6 +1,7 @@
 import { NoOpLogger } from "@smithy/smithy-client";
 import { parseUrl } from "@smithy/url-parser";
 import { fromBase64, toBase64 } from "@smithy/util-base64";
+import { sdkStreamMixin } from "@smithy/util-stream";
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
 import { defaultEndpointResolver } from "./endpoint/endpointResolver";
 export const getRuntimeConfig = (config) => {
@@ -12,6 +13,7 @@ export const getRuntimeConfig = (config) => {
         endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
         extensions: config?.extensions ?? [],
         logger: config?.logger ?? new NoOpLogger(),
+        sdkStreamMixin: config?.sdkStreamMixin ?? sdkStreamMixin,
         serviceId: config?.serviceId ?? "Neptune Graph",
         urlParser: config?.urlParser ?? parseUrl,
         utf8Decoder: config?.utf8Decoder ?? fromUtf8,

package/dist-types/NeptuneGraph.d.ts

@@ -1,5 +1,6 @@
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
 import { CancelImportTaskCommandInput, CancelImportTaskCommandOutput } from "./commands/CancelImportTaskCommand";
+import { CancelQueryCommandInput, CancelQueryCommandOutput } from "./commands/CancelQueryCommand";
 import { CreateGraphCommandInput, CreateGraphCommandOutput } from "./commands/CreateGraphCommand";
 import { CreateGraphSnapshotCommandInput, CreateGraphSnapshotCommandOutput } from "./commands/CreateGraphSnapshotCommand";
 import { CreateGraphUsingImportTaskCommandInput, CreateGraphUsingImportTaskCommandOutput } from "./commands/CreateGraphUsingImportTaskCommand";
@@ -7,14 +8,18 @@ import { CreatePrivateGraphEndpointCommandInput, CreatePrivateGraphEndpointComma
 import { DeleteGraphCommandInput, DeleteGraphCommandOutput } from "./commands/DeleteGraphCommand";
 import { DeleteGraphSnapshotCommandInput, DeleteGraphSnapshotCommandOutput } from "./commands/DeleteGraphSnapshotCommand";
 import { DeletePrivateGraphEndpointCommandInput, DeletePrivateGraphEndpointCommandOutput } from "./commands/DeletePrivateGraphEndpointCommand";
+import { ExecuteQueryCommandInput, ExecuteQueryCommandOutput } from "./commands/ExecuteQueryCommand";
 import { GetGraphCommandInput, GetGraphCommandOutput } from "./commands/GetGraphCommand";
 import { GetGraphSnapshotCommandInput, GetGraphSnapshotCommandOutput } from "./commands/GetGraphSnapshotCommand";
+import { GetGraphSummaryCommandInput, GetGraphSummaryCommandOutput } from "./commands/GetGraphSummaryCommand";
 import { GetImportTaskCommandInput, GetImportTaskCommandOutput } from "./commands/GetImportTaskCommand";
 import { GetPrivateGraphEndpointCommandInput, GetPrivateGraphEndpointCommandOutput } from "./commands/GetPrivateGraphEndpointCommand";
+import { GetQueryCommandInput, GetQueryCommandOutput } from "./commands/GetQueryCommand";
 import { ListGraphsCommandInput, ListGraphsCommandOutput } from "./commands/ListGraphsCommand";
 import { ListGraphSnapshotsCommandInput, ListGraphSnapshotsCommandOutput } from "./commands/ListGraphSnapshotsCommand";
 import { ListImportTasksCommandInput, ListImportTasksCommandOutput } from "./commands/ListImportTasksCommand";
 import { ListPrivateGraphEndpointsCommandInput, ListPrivateGraphEndpointsCommandOutput } from "./commands/ListPrivateGraphEndpointsCommand";
+import { ListQueriesCommandInput, ListQueriesCommandOutput } from "./commands/ListQueriesCommand";
 import { ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput } from "./commands/ListTagsForResourceCommand";
 import { ResetGraphCommandInput, ResetGraphCommandOutput } from "./commands/ResetGraphCommand";
 import { RestoreGraphFromSnapshotCommandInput, RestoreGraphFromSnapshotCommandOutput } from "./commands/RestoreGraphFromSnapshotCommand";
@@ -29,6 +34,12 @@ export interface NeptuneGraph {
     cancelImportTask(args: CancelImportTaskCommandInput, options?: __HttpHandlerOptions): Promise<CancelImportTaskCommandOutput>;
     cancelImportTask(args: CancelImportTaskCommandInput, cb: (err: any, data?: CancelImportTaskCommandOutput) => void): void;
     cancelImportTask(args: CancelImportTaskCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CancelImportTaskCommandOutput) => void): void;
+    /**
+     * @see {@link CancelQueryCommand}
+     */
+    cancelQuery(args: CancelQueryCommandInput, options?: __HttpHandlerOptions): Promise<CancelQueryCommandOutput>;
+    cancelQuery(args: CancelQueryCommandInput, cb: (err: any, data?: CancelQueryCommandOutput) => void): void;
+    cancelQuery(args: CancelQueryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CancelQueryCommandOutput) => void): void;
     /**
      * @see {@link CreateGraphCommand}
      */
@@ -71,6 +82,12 @@ export interface NeptuneGraph {
     deletePrivateGraphEndpoint(args: DeletePrivateGraphEndpointCommandInput, options?: __HttpHandlerOptions): Promise<DeletePrivateGraphEndpointCommandOutput>;
     deletePrivateGraphEndpoint(args: DeletePrivateGraphEndpointCommandInput, cb: (err: any, data?: DeletePrivateGraphEndpointCommandOutput) => void): void;
     deletePrivateGraphEndpoint(args: DeletePrivateGraphEndpointCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeletePrivateGraphEndpointCommandOutput) => void): void;
+    /**
+     * @see {@link ExecuteQueryCommand}
+     */
+    executeQuery(args: ExecuteQueryCommandInput, options?: __HttpHandlerOptions): Promise<ExecuteQueryCommandOutput>;
+    executeQuery(args: ExecuteQueryCommandInput, cb: (err: any, data?: ExecuteQueryCommandOutput) => void): void;
+    executeQuery(args: ExecuteQueryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ExecuteQueryCommandOutput) => void): void;
     /**
      * @see {@link GetGraphCommand}
      */
@@ -83,6 +100,12 @@ export interface NeptuneGraph {
     getGraphSnapshot(args: GetGraphSnapshotCommandInput, options?: __HttpHandlerOptions): Promise<GetGraphSnapshotCommandOutput>;
     getGraphSnapshot(args: GetGraphSnapshotCommandInput, cb: (err: any, data?: GetGraphSnapshotCommandOutput) => void): void;
     getGraphSnapshot(args: GetGraphSnapshotCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetGraphSnapshotCommandOutput) => void): void;
+    /**
+     * @see {@link GetGraphSummaryCommand}
+     */
+    getGraphSummary(args: GetGraphSummaryCommandInput, options?: __HttpHandlerOptions): Promise<GetGraphSummaryCommandOutput>;
+    getGraphSummary(args: GetGraphSummaryCommandInput, cb: (err: any, data?: GetGraphSummaryCommandOutput) => void): void;
+    getGraphSummary(args: GetGraphSummaryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetGraphSummaryCommandOutput) => void): void;
     /**
      * @see {@link GetImportTaskCommand}
      */
@@ -95,6 +118,12 @@ export interface NeptuneGraph {
     getPrivateGraphEndpoint(args: GetPrivateGraphEndpointCommandInput, options?: __HttpHandlerOptions): Promise<GetPrivateGraphEndpointCommandOutput>;
     getPrivateGraphEndpoint(args: GetPrivateGraphEndpointCommandInput, cb: (err: any, data?: GetPrivateGraphEndpointCommandOutput) => void): void;
     getPrivateGraphEndpoint(args: GetPrivateGraphEndpointCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetPrivateGraphEndpointCommandOutput) => void): void;
+    /**
+     * @see {@link GetQueryCommand}
+     */
+    getQuery(args: GetQueryCommandInput, options?: __HttpHandlerOptions): Promise<GetQueryCommandOutput>;
+    getQuery(args: GetQueryCommandInput, cb: (err: any, data?: GetQueryCommandOutput) => void): void;
+    getQuery(args: GetQueryCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetQueryCommandOutput) => void): void;
     /**
      * @see {@link ListGraphsCommand}
      */
@@ -119,6 +148,12 @@ export interface NeptuneGraph {
     listPrivateGraphEndpoints(args: ListPrivateGraphEndpointsCommandInput, options?: __HttpHandlerOptions): Promise<ListPrivateGraphEndpointsCommandOutput>;
     listPrivateGraphEndpoints(args: ListPrivateGraphEndpointsCommandInput, cb: (err: any, data?: ListPrivateGraphEndpointsCommandOutput) => void): void;
     listPrivateGraphEndpoints(args: ListPrivateGraphEndpointsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListPrivateGraphEndpointsCommandOutput) => void): void;
+    /**
+     * @see {@link ListQueriesCommand}
+     */
+    listQueries(args: ListQueriesCommandInput, options?: __HttpHandlerOptions): Promise<ListQueriesCommandOutput>;
+    listQueries(args: ListQueriesCommandInput, cb: (err: any, data?: ListQueriesCommandOutput) => void): void;
+    listQueries(args: ListQueriesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListQueriesCommandOutput) => void): void;
     /**
      * @see {@link ListTagsForResourceCommand}
      */
@@ -158,9 +193,9 @@ export interface NeptuneGraph {
 }
 /**
  * @public
- * <p>Neptune Analytics is a serverless in-memory graph database service for analytics
- *         that delivers high-performance analytics and real-time queries for any graph type. It
- *         complements the Amazon Neptune Database, an industry-leading managed graph database.</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>
  */
 export declare class NeptuneGraph extends NeptuneGraphClient implements NeptuneGraph {
 }