@aws-sdk/client-neptune-graph 3.474.0

package/dist-es/commands/UpdateGraphCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_UpdateGraphCommand, se_UpdateGraphCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateGraphCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            ApiType: { type: "staticContextParams", value: `ControlPlane` },
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateGraphCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "NeptuneGraphClient";
+        const commandName = "UpdateGraphCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "AmazonNeptuneGraph",
+                operation: "UpdateGraph",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateGraphCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateGraphCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -0,0 +1,22 @@
+export * from "./CancelImportTaskCommand";
+export * from "./CreateGraphCommand";
+export * from "./CreateGraphSnapshotCommand";
+export * from "./CreateGraphUsingImportTaskCommand";
+export * from "./CreatePrivateGraphEndpointCommand";
+export * from "./DeleteGraphCommand";
+export * from "./DeleteGraphSnapshotCommand";
+export * from "./DeletePrivateGraphEndpointCommand";
+export * from "./GetGraphCommand";
+export * from "./GetGraphSnapshotCommand";
+export * from "./GetImportTaskCommand";
+export * from "./GetPrivateGraphEndpointCommand";
+export * from "./ListGraphSnapshotsCommand";
+export * from "./ListGraphsCommand";
+export * from "./ListImportTasksCommand";
+export * from "./ListPrivateGraphEndpointsCommand";
+export * from "./ListTagsForResourceCommand";
+export * from "./ResetGraphCommand";
+export * from "./RestoreGraphFromSnapshotCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateGraphCommand";

package/dist-es/endpoint/EndpointParameters.js

@@ -0,0 +1,8 @@
+export const resolveClientEndpointParameters = (options) => {
+    return {
+        ...options,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        defaultSigningName: "neptune-graph",
+    };
+};

package/dist-es/endpoint/endpointResolver.js

@@ -0,0 +1,8 @@
+import { resolveEndpoint } from "@smithy/util-endpoints";
+import { ruleSet } from "./ruleset";
+export const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return resolveEndpoint(ruleSet, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    });
+};

package/dist-es/endpoint/ruleset.js

@@ -0,0 +1,4 @@
+const w = "required", x = "type", y = "fn", z = "argv", A = "ref";
+const a = true, b = "String", c = "isSet", d = "error", e = "endpoint", f = "tree", g = "PartitionResult", h = { [w]: false, [x]: b }, i = { [w]: true, "default": false, [x]: "Boolean" }, j = { [A]: "Endpoint" }, k = { [y]: "booleanEquals", [z]: [{ [A]: "UseFIPS" }, true] }, l = { [y]: "booleanEquals", [z]: [{ [A]: "UseDualStack" }, true] }, m = {}, n = { [y]: "booleanEquals", [z]: [true, { [y]: "getAttr", [z]: [{ [A]: g }, "supportsFIPS"] }] }, o = { [y]: "booleanEquals", [z]: [true, { [y]: "getAttr", [z]: [{ [A]: g }, "supportsDualStack"] }] }, p = { "conditions": [{ [y]: "stringEquals", [z]: [{ [A]: "ApiType" }, "DataPlane"] }], [d]: "Invalid Configuration: fips endpoint is not supported for this API", [x]: d }, q = { [d]: "Invalid Configuration: Unknown ApiType", [x]: d }, r = [k], s = [l], t = [{ [A]: "Region" }], u = [{ [y]: "stringEquals", [z]: [{ [A]: "ApiType" }, "ControlPlane"] }], v = [{ [y]: "stringEquals", [z]: [{ [A]: "ApiType" }, "DataPlane"] }];
+const _data = { version: "1.0", parameters: { Region: h, UseFIPS: i, UseDualStack: i, Endpoint: h, ApiType: { [w]: a, [x]: b } }, rules: [{ conditions: [{ [y]: c, [z]: [j] }], rules: [{ conditions: r, error: "Invalid Configuration: FIPS and custom endpoint are not supported", [x]: d }, { conditions: s, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", [x]: d }, { endpoint: { url: j, properties: m, headers: m }, [x]: e }], [x]: f }, { conditions: [{ [y]: c, [z]: t }], rules: [{ conditions: [{ [y]: "aws.partition", [z]: t, assign: g }], rules: [{ conditions: [k, l], rules: [{ conditions: [n, o], rules: [{ conditions: u, endpoint: { url: "https://neptune-graph-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, [x]: e }, p, q], [x]: f }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", [x]: d }], [x]: f }, { conditions: r, rules: [{ conditions: [n], rules: [{ conditions: u, endpoint: { url: "https://neptune-graph-fips.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, [x]: e }, p, q], [x]: f }, { error: "FIPS is enabled but this partition does not support FIPS", [x]: d }], [x]: f }, { conditions: s, rules: [{ conditions: [o], rules: [{ conditions: u, endpoint: { url: "https://neptune-graph.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, [x]: e }, { conditions: v, endpoint: { url: "https://neptune-graph.{Region}.on.aws", properties: m, headers: m }, [x]: e }, q], [x]: f }, { error: "DualStack is enabled but this partition does not support DualStack", [x]: d }], [x]: f }, { conditions: u, endpoint: { url: "https://neptune-graph.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, [x]: e }, { conditions: v, endpoint: { url: "https://{Region}.neptune-graph.{PartitionResult#dnsSuffix}", properties: m, headers: m }, [x]: e }, q], [x]: f }], [x]: f }, { error: "Invalid Configuration: Missing Region", [x]: d }] };
+export const ruleSet = _data;

package/dist-es/extensionConfiguration.js

@@ -0,0 +1 @@
+export {};

package/dist-es/index.js

@@ -0,0 +1,7 @@
+export * from "./NeptuneGraphClient";
+export * from "./NeptuneGraph";
+export * from "./commands";
+export * from "./pagination";
+export * from "./models";
+import "@aws-sdk/util-endpoints";
+export { NeptuneGraphServiceException } from "./models/NeptuneGraphServiceException";

package/dist-es/models/NeptuneGraphServiceException.js

@@ -0,0 +1,8 @@
+import { ServiceException as __ServiceException, } from "@smithy/smithy-client";
+export { __ServiceException };
+export class NeptuneGraphServiceException extends __ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, NeptuneGraphServiceException.prototype);
+    }
+}

package/dist-es/models/index.js

@@ -0,0 +1 @@
+export * from "./models_0";

package/dist-es/models/models_0.js

@@ -0,0 +1,140 @@
+import { NeptuneGraphServiceException as __BaseException } from "./NeptuneGraphServiceException";
+export const ConflictExceptionReason = {
+    CONCURRENT_MODIFICATION: "CONCURRENT_MODIFICATION",
+};
+export class ConflictException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConflictException.prototype);
+        this.reason = opts.reason;
+    }
+}
+export const GraphStatus = {
+    AVAILABLE: "AVAILABLE",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+    RESETTING: "RESETTING",
+    SNAPSHOTTING: "SNAPSHOTTING",
+    UPDATING: "UPDATING",
+};
+export class InternalServerException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalServerException";
+        this.$fault = "server";
+        this.$retryable = {};
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+    }
+}
+export class ServiceQuotaExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceQuotaExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+        this.resourceId = opts.resourceId;
+        this.resourceType = opts.resourceType;
+        this.serviceCode = opts.serviceCode;
+        this.quotaCode = opts.quotaCode;
+    }
+}
+export class ThrottlingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        this.$retryable = {
+            throttling: true,
+        };
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+    }
+}
+export const ValidationExceptionReason = {
+    BAD_REQUEST: "BAD_REQUEST",
+    CONSTRAINT_VIOLATION: "CONSTRAINT_VIOLATION",
+    ILLEGAL_ARGUMENT: "ILLEGAL_ARGUMENT",
+    MALFORMED_QUERY: "MALFORMED_QUERY",
+    QUERY_CANCELLED: "QUERY_CANCELLED",
+    QUERY_TOO_LARGE: "QUERY_TOO_LARGE",
+    UNSUPPORTED_OPERATION: "UNSUPPORTED_OPERATION",
+};
+export class ValidationException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ValidationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.reason = opts.reason;
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+    }
+}
+export const PrivateGraphEndpointStatus = {
+    AVAILABLE: "AVAILABLE",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+};
+export const SnapshotStatus = {
+    AVAILABLE: "AVAILABLE",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+};
+export const Format = {
+    CSV: "CSV",
+    OPEN_CYPHER: "OPEN_CYPHER",
+};
+export const ImportTaskStatus = {
+    ANALYZING_DATA: "ANALYZING_DATA",
+    CANCELLED: "CANCELLED",
+    CANCELLING: "CANCELLING",
+    EXPORTING: "EXPORTING",
+    FAILED: "FAILED",
+    IMPORTING: "IMPORTING",
+    INITIALIZING: "INITIALIZING",
+    REPROVISIONING: "REPROVISIONING",
+    ROLLING_BACK: "ROLLING_BACK",
+    SUCCEEDED: "SUCCEEDED",
+};
+export var ImportOptions;
+(function (ImportOptions) {
+    ImportOptions.visit = (value, visitor) => {
+        if (value.neptune !== undefined)
+            return visitor.neptune(value.neptune);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ImportOptions || (ImportOptions = {}));

package/dist-es/pagination/Interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist-es/pagination/ListGraphSnapshotsPaginator.js

@@ -0,0 +1,25 @@
+import { ListGraphSnapshotsCommand, } from "../commands/ListGraphSnapshotsCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListGraphSnapshotsCommand(input), ...args);
+};
+export async function* paginateListGraphSnapshots(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof NeptuneGraphClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected NeptuneGraph | NeptuneGraphClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListGraphsPaginator.js

@@ -0,0 +1,25 @@
+import { ListGraphsCommand } from "../commands/ListGraphsCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListGraphsCommand(input), ...args);
+};
+export async function* paginateListGraphs(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof NeptuneGraphClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected NeptuneGraph | NeptuneGraphClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListImportTasksPaginator.js

@@ -0,0 +1,25 @@
+import { ListImportTasksCommand, } from "../commands/ListImportTasksCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListImportTasksCommand(input), ...args);
+};
+export async function* paginateListImportTasks(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof NeptuneGraphClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected NeptuneGraph | NeptuneGraphClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListPrivateGraphEndpointsPaginator.js

@@ -0,0 +1,25 @@
+import { ListPrivateGraphEndpointsCommand, } from "../commands/ListPrivateGraphEndpointsCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListPrivateGraphEndpointsCommand(input), ...args);
+};
+export async function* paginateListPrivateGraphEndpoints(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof NeptuneGraphClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected NeptuneGraph | NeptuneGraphClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -0,0 +1,5 @@
+export * from "./Interfaces";
+export * from "./ListGraphSnapshotsPaginator";
+export * from "./ListGraphsPaginator";
+export * from "./ListImportTasksPaginator";
+export * from "./ListPrivateGraphEndpointsPaginator";