@aws-sdk/client-neptune-graph 3.478.0 → 3.481.0

package/dist-cjs/waiters/waitForPrivateGraphEndpointAvailable.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilPrivateGraphEndpointAvailable = exports.waitForPrivateGraphEndpointAvailable = void 0;
+const util_waiter_1 = require("@smithy/util-waiter");
+const GetPrivateGraphEndpointCommand_1 = require("../commands/GetPrivateGraphEndpointCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetPrivateGraphEndpointCommand_1.GetPrivateGraphEndpointCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "DELETING") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "AVAILABLE") {
+                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+const waitForPrivateGraphEndpointAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForPrivateGraphEndpointAvailable = waitForPrivateGraphEndpointAvailable;
+const waitUntilPrivateGraphEndpointAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+    return (0, util_waiter_1.checkExceptions)(result);
+};
+exports.waitUntilPrivateGraphEndpointAvailable = waitUntilPrivateGraphEndpointAvailable;

package/dist-cjs/waiters/waitForPrivateGraphEndpointDeleted.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilPrivateGraphEndpointDeleted = exports.waitForPrivateGraphEndpointDeleted = void 0;
+const util_waiter_1 = require("@smithy/util-waiter");
+const GetPrivateGraphEndpointCommand_1 = require("../commands/GetPrivateGraphEndpointCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetPrivateGraphEndpointCommand_1.GetPrivateGraphEndpointCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status != "DELETING";
+            };
+            if (returnComparator() == true) {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "ResourceNotFoundException") {
+            return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+const waitForPrivateGraphEndpointDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForPrivateGraphEndpointDeleted = waitForPrivateGraphEndpointDeleted;
+const waitUntilPrivateGraphEndpointDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+    return (0, util_waiter_1.checkExceptions)(result);
+};
+exports.waitUntilPrivateGraphEndpointDeleted = waitUntilPrivateGraphEndpointDeleted;

package/dist-es/commands/CancelImportTaskCommand.js

@@ -1,48 +1,25 @@
 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 { commonParams } from "../endpoint/EndpointParameters";
 import { de_CancelImportTaskCommand, se_CancelImportTaskCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CancelImportTaskCommand 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, CancelImportTaskCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "NeptuneGraphClient";
-        const commandName = "CancelImportTaskCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "CancelImportTask",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CancelImportTaskCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CancelImportTaskCommand(output, context);
-    }
+export class CancelImportTaskCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "CancelImportTask", {})
+    .n("NeptuneGraphClient", "CancelImportTaskCommand")
+    .f(void 0, void 0)
+    .ser(se_CancelImportTaskCommand)
+    .de(de_CancelImportTaskCommand)
+    .build() {
 }

package/dist-es/commands/CreateGraphCommand.js

@@ -1,48 +1,25 @@
 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 { commonParams } from "../endpoint/EndpointParameters";
 import { de_CreateGraphCommand, se_CreateGraphCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateGraphCommand 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, CreateGraphCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "NeptuneGraphClient";
-        const commandName = "CreateGraphCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "CreateGraph",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CreateGraphCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CreateGraphCommand(output, context);
-    }
+export class CreateGraphCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "CreateGraph", {})
+    .n("NeptuneGraphClient", "CreateGraphCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateGraphCommand)
+    .de(de_CreateGraphCommand)
+    .build() {
 }

package/dist-es/commands/CreateGraphSnapshotCommand.js

@@ -1,48 +1,25 @@
 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 { commonParams } from "../endpoint/EndpointParameters";
 import { de_CreateGraphSnapshotCommand, se_CreateGraphSnapshotCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateGraphSnapshotCommand 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, CreateGraphSnapshotCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "NeptuneGraphClient";
-        const commandName = "CreateGraphSnapshotCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "CreateGraphSnapshot",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CreateGraphSnapshotCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CreateGraphSnapshotCommand(output, context);
-    }
+export class CreateGraphSnapshotCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "CreateGraphSnapshot", {})
+    .n("NeptuneGraphClient", "CreateGraphSnapshotCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateGraphSnapshotCommand)
+    .de(de_CreateGraphSnapshotCommand)
+    .build() {
 }

package/dist-es/commands/CreateGraphUsingImportTaskCommand.js

@@ -1,48 +1,25 @@
 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 { commonParams } from "../endpoint/EndpointParameters";
 import { de_CreateGraphUsingImportTaskCommand, se_CreateGraphUsingImportTaskCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateGraphUsingImportTaskCommand 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, CreateGraphUsingImportTaskCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "NeptuneGraphClient";
-        const commandName = "CreateGraphUsingImportTaskCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "CreateGraphUsingImportTask",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CreateGraphUsingImportTaskCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CreateGraphUsingImportTaskCommand(output, context);
-    }
+export class CreateGraphUsingImportTaskCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "CreateGraphUsingImportTask", {})
+    .n("NeptuneGraphClient", "CreateGraphUsingImportTaskCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateGraphUsingImportTaskCommand)
+    .de(de_CreateGraphUsingImportTaskCommand)
+    .build() {
 }

package/dist-es/commands/CreatePrivateGraphEndpointCommand.js

@@ -1,48 +1,25 @@
 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 { commonParams } from "../endpoint/EndpointParameters";
 import { de_CreatePrivateGraphEndpointCommand, se_CreatePrivateGraphEndpointCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreatePrivateGraphEndpointCommand 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, CreatePrivateGraphEndpointCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "NeptuneGraphClient";
-        const commandName = "CreatePrivateGraphEndpointCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "CreatePrivateGraphEndpoint",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CreatePrivateGraphEndpointCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CreatePrivateGraphEndpointCommand(output, context);
-    }
+export class CreatePrivateGraphEndpointCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "CreatePrivateGraphEndpoint", {})
+    .n("NeptuneGraphClient", "CreatePrivateGraphEndpointCommand")
+    .f(void 0, void 0)
+    .ser(se_CreatePrivateGraphEndpointCommand)
+    .de(de_CreatePrivateGraphEndpointCommand)
+    .build() {
 }

package/dist-es/commands/DeleteGraphCommand.js

@@ -1,48 +1,25 @@
 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 { commonParams } from "../endpoint/EndpointParameters";
 import { de_DeleteGraphCommand, se_DeleteGraphCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class DeleteGraphCommand 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, DeleteGraphCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "NeptuneGraphClient";
-        const commandName = "DeleteGraphCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "DeleteGraph",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_DeleteGraphCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_DeleteGraphCommand(output, context);
-    }
+export class DeleteGraphCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "DeleteGraph", {})
+    .n("NeptuneGraphClient", "DeleteGraphCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteGraphCommand)
+    .de(de_DeleteGraphCommand)
+    .build() {
 }

package/dist-es/commands/DeleteGraphSnapshotCommand.js

@@ -1,48 +1,25 @@
 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 { commonParams } from "../endpoint/EndpointParameters";
 import { de_DeleteGraphSnapshotCommand, se_DeleteGraphSnapshotCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class DeleteGraphSnapshotCommand 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, DeleteGraphSnapshotCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "NeptuneGraphClient";
-        const commandName = "DeleteGraphSnapshotCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "DeleteGraphSnapshot",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_DeleteGraphSnapshotCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_DeleteGraphSnapshotCommand(output, context);
-    }
+export class DeleteGraphSnapshotCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "DeleteGraphSnapshot", {})
+    .n("NeptuneGraphClient", "DeleteGraphSnapshotCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteGraphSnapshotCommand)
+    .de(de_DeleteGraphSnapshotCommand)
+    .build() {
 }

package/dist-es/commands/DeletePrivateGraphEndpointCommand.js

@@ -1,48 +1,25 @@
 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 { commonParams } from "../endpoint/EndpointParameters";
 import { de_DeletePrivateGraphEndpointCommand, se_DeletePrivateGraphEndpointCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class DeletePrivateGraphEndpointCommand 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, DeletePrivateGraphEndpointCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "NeptuneGraphClient";
-        const commandName = "DeletePrivateGraphEndpointCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "DeletePrivateGraphEndpoint",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_DeletePrivateGraphEndpointCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_DeletePrivateGraphEndpointCommand(output, context);
-    }
+export class DeletePrivateGraphEndpointCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "DeletePrivateGraphEndpoint", {})
+    .n("NeptuneGraphClient", "DeletePrivateGraphEndpointCommand")
+    .f(void 0, void 0)
+    .ser(se_DeletePrivateGraphEndpointCommand)
+    .de(de_DeletePrivateGraphEndpointCommand)
+    .build() {
 }