@aws-sdk/client-networkmanager 3.43.0 → 3.47.1

package/dist-es/commands/GetCoreNetworkChangeSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetCoreNetworkChangeSetRequest, GetCoreNetworkChangeSetResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetCoreNetworkChangeSetCommand, serializeAws_restJson1GetCoreNetworkChangeSetCommand, } from "../protocols/Aws_restJson1";
+var GetCoreNetworkChangeSetCommand = (function (_super) {
+    __extends(GetCoreNetworkChangeSetCommand, _super);
+    function GetCoreNetworkChangeSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetCoreNetworkChangeSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "GetCoreNetworkChangeSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetCoreNetworkChangeSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetCoreNetworkChangeSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetCoreNetworkChangeSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetCoreNetworkChangeSetCommand(input, context);
+    };
+    GetCoreNetworkChangeSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetCoreNetworkChangeSetCommand(output, context);
+    };
+    return GetCoreNetworkChangeSetCommand;
+}($Command));
+export { GetCoreNetworkChangeSetCommand };

package/dist-es/commands/GetCoreNetworkCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetCoreNetworkRequest, GetCoreNetworkResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetCoreNetworkCommand, serializeAws_restJson1GetCoreNetworkCommand, } from "../protocols/Aws_restJson1";
+var GetCoreNetworkCommand = (function (_super) {
+    __extends(GetCoreNetworkCommand, _super);
+    function GetCoreNetworkCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetCoreNetworkCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "GetCoreNetworkCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetCoreNetworkRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetCoreNetworkResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetCoreNetworkCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetCoreNetworkCommand(input, context);
+    };
+    GetCoreNetworkCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetCoreNetworkCommand(output, context);
+    };
+    return GetCoreNetworkCommand;
+}($Command));
+export { GetCoreNetworkCommand };

package/dist-es/commands/GetCoreNetworkPolicyCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetCoreNetworkPolicyRequest, GetCoreNetworkPolicyResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetCoreNetworkPolicyCommand, serializeAws_restJson1GetCoreNetworkPolicyCommand, } from "../protocols/Aws_restJson1";
+var GetCoreNetworkPolicyCommand = (function (_super) {
+    __extends(GetCoreNetworkPolicyCommand, _super);
+    function GetCoreNetworkPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetCoreNetworkPolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "GetCoreNetworkPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetCoreNetworkPolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetCoreNetworkPolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetCoreNetworkPolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetCoreNetworkPolicyCommand(input, context);
+    };
+    GetCoreNetworkPolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetCoreNetworkPolicyCommand(output, context);
+    };
+    return GetCoreNetworkPolicyCommand;
+}($Command));
+export { GetCoreNetworkPolicyCommand };

package/dist-es/commands/GetResourcePolicyCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetResourcePolicyRequest, GetResourcePolicyResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetResourcePolicyCommand, serializeAws_restJson1GetResourcePolicyCommand, } from "../protocols/Aws_restJson1";
+var GetResourcePolicyCommand = (function (_super) {
+    __extends(GetResourcePolicyCommand, _super);
+    function GetResourcePolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResourcePolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "GetResourcePolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResourcePolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetResourcePolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResourcePolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetResourcePolicyCommand(input, context);
+    };
+    GetResourcePolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetResourcePolicyCommand(output, context);
+    };
+    return GetResourcePolicyCommand;
+}($Command));
+export { GetResourcePolicyCommand };

package/dist-es/commands/GetSiteToSiteVpnAttachmentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetSiteToSiteVpnAttachmentRequest, GetSiteToSiteVpnAttachmentResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetSiteToSiteVpnAttachmentCommand, serializeAws_restJson1GetSiteToSiteVpnAttachmentCommand, } from "../protocols/Aws_restJson1";
+var GetSiteToSiteVpnAttachmentCommand = (function (_super) {
+    __extends(GetSiteToSiteVpnAttachmentCommand, _super);
+    function GetSiteToSiteVpnAttachmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetSiteToSiteVpnAttachmentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "GetSiteToSiteVpnAttachmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetSiteToSiteVpnAttachmentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetSiteToSiteVpnAttachmentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetSiteToSiteVpnAttachmentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetSiteToSiteVpnAttachmentCommand(input, context);
+    };
+    GetSiteToSiteVpnAttachmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetSiteToSiteVpnAttachmentCommand(output, context);
+    };
+    return GetSiteToSiteVpnAttachmentCommand;
+}($Command));
+export { GetSiteToSiteVpnAttachmentCommand };

package/dist-es/commands/GetVpcAttachmentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetVpcAttachmentRequest, GetVpcAttachmentResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetVpcAttachmentCommand, serializeAws_restJson1GetVpcAttachmentCommand, } from "../protocols/Aws_restJson1";
+var GetVpcAttachmentCommand = (function (_super) {
+    __extends(GetVpcAttachmentCommand, _super);
+    function GetVpcAttachmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetVpcAttachmentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "GetVpcAttachmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetVpcAttachmentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetVpcAttachmentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetVpcAttachmentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetVpcAttachmentCommand(input, context);
+    };
+    GetVpcAttachmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetVpcAttachmentCommand(output, context);
+    };
+    return GetVpcAttachmentCommand;
+}($Command));
+export { GetVpcAttachmentCommand };

package/dist-es/commands/ListAttachmentsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListAttachmentsRequest, ListAttachmentsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListAttachmentsCommand, serializeAws_restJson1ListAttachmentsCommand, } from "../protocols/Aws_restJson1";
+var ListAttachmentsCommand = (function (_super) {
+    __extends(ListAttachmentsCommand, _super);
+    function ListAttachmentsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListAttachmentsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "ListAttachmentsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListAttachmentsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListAttachmentsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListAttachmentsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListAttachmentsCommand(input, context);
+    };
+    ListAttachmentsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListAttachmentsCommand(output, context);
+    };
+    return ListAttachmentsCommand;
+}($Command));
+export { ListAttachmentsCommand };

package/dist-es/commands/ListConnectPeersCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListConnectPeersRequest, ListConnectPeersResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListConnectPeersCommand, serializeAws_restJson1ListConnectPeersCommand, } from "../protocols/Aws_restJson1";
+var ListConnectPeersCommand = (function (_super) {
+    __extends(ListConnectPeersCommand, _super);
+    function ListConnectPeersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListConnectPeersCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "ListConnectPeersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListConnectPeersRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListConnectPeersResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListConnectPeersCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListConnectPeersCommand(input, context);
+    };
+    ListConnectPeersCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListConnectPeersCommand(output, context);
+    };
+    return ListConnectPeersCommand;
+}($Command));
+export { ListConnectPeersCommand };

package/dist-es/commands/ListCoreNetworkPolicyVersionsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListCoreNetworkPolicyVersionsRequest, ListCoreNetworkPolicyVersionsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListCoreNetworkPolicyVersionsCommand, serializeAws_restJson1ListCoreNetworkPolicyVersionsCommand, } from "../protocols/Aws_restJson1";
+var ListCoreNetworkPolicyVersionsCommand = (function (_super) {
+    __extends(ListCoreNetworkPolicyVersionsCommand, _super);
+    function ListCoreNetworkPolicyVersionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListCoreNetworkPolicyVersionsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "ListCoreNetworkPolicyVersionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListCoreNetworkPolicyVersionsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListCoreNetworkPolicyVersionsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListCoreNetworkPolicyVersionsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListCoreNetworkPolicyVersionsCommand(input, context);
+    };
+    ListCoreNetworkPolicyVersionsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListCoreNetworkPolicyVersionsCommand(output, context);
+    };
+    return ListCoreNetworkPolicyVersionsCommand;
+}($Command));
+export { ListCoreNetworkPolicyVersionsCommand };

package/dist-es/commands/ListCoreNetworksCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListCoreNetworksRequest, ListCoreNetworksResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListCoreNetworksCommand, serializeAws_restJson1ListCoreNetworksCommand, } from "../protocols/Aws_restJson1";
+var ListCoreNetworksCommand = (function (_super) {
+    __extends(ListCoreNetworksCommand, _super);
+    function ListCoreNetworksCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListCoreNetworksCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "ListCoreNetworksCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListCoreNetworksRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListCoreNetworksResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListCoreNetworksCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListCoreNetworksCommand(input, context);
+    };
+    ListCoreNetworksCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListCoreNetworksCommand(output, context);
+    };
+    return ListCoreNetworksCommand;
+}($Command));
+export { ListCoreNetworksCommand };

package/dist-es/commands/PutCoreNetworkPolicyCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PutCoreNetworkPolicyRequest, PutCoreNetworkPolicyResponse } from "../models/models_0";
+import { deserializeAws_restJson1PutCoreNetworkPolicyCommand, serializeAws_restJson1PutCoreNetworkPolicyCommand, } from "../protocols/Aws_restJson1";
+var PutCoreNetworkPolicyCommand = (function (_super) {
+    __extends(PutCoreNetworkPolicyCommand, _super);
+    function PutCoreNetworkPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutCoreNetworkPolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "PutCoreNetworkPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutCoreNetworkPolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: PutCoreNetworkPolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutCoreNetworkPolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1PutCoreNetworkPolicyCommand(input, context);
+    };
+    PutCoreNetworkPolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1PutCoreNetworkPolicyCommand(output, context);
+    };
+    return PutCoreNetworkPolicyCommand;
+}($Command));
+export { PutCoreNetworkPolicyCommand };

package/dist-es/commands/PutResourcePolicyCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PutResourcePolicyRequest, PutResourcePolicyResponse } from "../models/models_0";
+import { deserializeAws_restJson1PutResourcePolicyCommand, serializeAws_restJson1PutResourcePolicyCommand, } from "../protocols/Aws_restJson1";
+var PutResourcePolicyCommand = (function (_super) {
+    __extends(PutResourcePolicyCommand, _super);
+    function PutResourcePolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutResourcePolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "PutResourcePolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutResourcePolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: PutResourcePolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutResourcePolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1PutResourcePolicyCommand(input, context);
+    };
+    PutResourcePolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1PutResourcePolicyCommand(output, context);
+    };
+    return PutResourcePolicyCommand;
+}($Command));
+export { PutResourcePolicyCommand };

package/dist-es/commands/RejectAttachmentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { RejectAttachmentRequest, RejectAttachmentResponse } from "../models/models_0";
+import { deserializeAws_restJson1RejectAttachmentCommand, serializeAws_restJson1RejectAttachmentCommand, } from "../protocols/Aws_restJson1";
+var RejectAttachmentCommand = (function (_super) {
+    __extends(RejectAttachmentCommand, _super);
+    function RejectAttachmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RejectAttachmentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "RejectAttachmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RejectAttachmentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: RejectAttachmentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    RejectAttachmentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1RejectAttachmentCommand(input, context);
+    };
+    RejectAttachmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1RejectAttachmentCommand(output, context);
+    };
+    return RejectAttachmentCommand;
+}($Command));
+export { RejectAttachmentCommand };

package/dist-es/commands/RestoreCoreNetworkPolicyVersionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { RestoreCoreNetworkPolicyVersionRequest, RestoreCoreNetworkPolicyVersionResponse } from "../models/models_0";
+import { deserializeAws_restJson1RestoreCoreNetworkPolicyVersionCommand, serializeAws_restJson1RestoreCoreNetworkPolicyVersionCommand, } from "../protocols/Aws_restJson1";
+var RestoreCoreNetworkPolicyVersionCommand = (function (_super) {
+    __extends(RestoreCoreNetworkPolicyVersionCommand, _super);
+    function RestoreCoreNetworkPolicyVersionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RestoreCoreNetworkPolicyVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "RestoreCoreNetworkPolicyVersionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RestoreCoreNetworkPolicyVersionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: RestoreCoreNetworkPolicyVersionResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    RestoreCoreNetworkPolicyVersionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1RestoreCoreNetworkPolicyVersionCommand(input, context);
+    };
+    RestoreCoreNetworkPolicyVersionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1RestoreCoreNetworkPolicyVersionCommand(output, context);
+    };
+    return RestoreCoreNetworkPolicyVersionCommand;
+}($Command));
+export { RestoreCoreNetworkPolicyVersionCommand };

package/dist-es/commands/UpdateCoreNetworkCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateCoreNetworkRequest, UpdateCoreNetworkResponse } from "../models/models_0";
+import { deserializeAws_restJson1UpdateCoreNetworkCommand, serializeAws_restJson1UpdateCoreNetworkCommand, } from "../protocols/Aws_restJson1";
+var UpdateCoreNetworkCommand = (function (_super) {
+    __extends(UpdateCoreNetworkCommand, _super);
+    function UpdateCoreNetworkCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateCoreNetworkCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "UpdateCoreNetworkCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateCoreNetworkRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateCoreNetworkResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateCoreNetworkCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateCoreNetworkCommand(input, context);
+    };
+    UpdateCoreNetworkCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateCoreNetworkCommand(output, context);
+    };
+    return UpdateCoreNetworkCommand;
+}($Command));
+export { UpdateCoreNetworkCommand };

package/dist-es/commands/UpdateVpcAttachmentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateVpcAttachmentRequest, UpdateVpcAttachmentResponse } from "../models/models_0";
+import { deserializeAws_restJson1UpdateVpcAttachmentCommand, serializeAws_restJson1UpdateVpcAttachmentCommand, } from "../protocols/Aws_restJson1";
+var UpdateVpcAttachmentCommand = (function (_super) {
+    __extends(UpdateVpcAttachmentCommand, _super);
+    function UpdateVpcAttachmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateVpcAttachmentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "NetworkManagerClient";
+        var commandName = "UpdateVpcAttachmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateVpcAttachmentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateVpcAttachmentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateVpcAttachmentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateVpcAttachmentCommand(input, context);
+    };
+    UpdateVpcAttachmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateVpcAttachmentCommand(output, context);
+    };
+    return UpdateVpcAttachmentCommand;
+}($Command));
+export { UpdateVpcAttachmentCommand };