@aws-sdk/client-networkmanager 3.43.0 → 3.47.1

package/dist-es/commands/AssociateConnectPeerCommand.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 { AssociateConnectPeerRequest, AssociateConnectPeerResponse } from "../models/models_0";
+import { deserializeAws_restJson1AssociateConnectPeerCommand, serializeAws_restJson1AssociateConnectPeerCommand, } from "../protocols/Aws_restJson1";
+var AssociateConnectPeerCommand = (function (_super) {
+    __extends(AssociateConnectPeerCommand, _super);
+    function AssociateConnectPeerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AssociateConnectPeerCommand.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 = "AssociateConnectPeerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AssociateConnectPeerRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: AssociateConnectPeerResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssociateConnectPeerCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1AssociateConnectPeerCommand(input, context);
+    };
+    AssociateConnectPeerCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1AssociateConnectPeerCommand(output, context);
+    };
+    return AssociateConnectPeerCommand;
+}($Command));
+export { AssociateConnectPeerCommand };

package/dist-es/commands/CreateConnectAttachmentCommand.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 { CreateConnectAttachmentRequest, CreateConnectAttachmentResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateConnectAttachmentCommand, serializeAws_restJson1CreateConnectAttachmentCommand, } from "../protocols/Aws_restJson1";
+var CreateConnectAttachmentCommand = (function (_super) {
+    __extends(CreateConnectAttachmentCommand, _super);
+    function CreateConnectAttachmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateConnectAttachmentCommand.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 = "CreateConnectAttachmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateConnectAttachmentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateConnectAttachmentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateConnectAttachmentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateConnectAttachmentCommand(input, context);
+    };
+    CreateConnectAttachmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateConnectAttachmentCommand(output, context);
+    };
+    return CreateConnectAttachmentCommand;
+}($Command));
+export { CreateConnectAttachmentCommand };

package/dist-es/commands/CreateConnectPeerCommand.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 { CreateConnectPeerRequest, CreateConnectPeerResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateConnectPeerCommand, serializeAws_restJson1CreateConnectPeerCommand, } from "../protocols/Aws_restJson1";
+var CreateConnectPeerCommand = (function (_super) {
+    __extends(CreateConnectPeerCommand, _super);
+    function CreateConnectPeerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateConnectPeerCommand.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 = "CreateConnectPeerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateConnectPeerRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateConnectPeerResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateConnectPeerCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateConnectPeerCommand(input, context);
+    };
+    CreateConnectPeerCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateConnectPeerCommand(output, context);
+    };
+    return CreateConnectPeerCommand;
+}($Command));
+export { CreateConnectPeerCommand };

package/dist-es/commands/CreateCoreNetworkCommand.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 { CreateCoreNetworkRequest, CreateCoreNetworkResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateCoreNetworkCommand, serializeAws_restJson1CreateCoreNetworkCommand, } from "../protocols/Aws_restJson1";
+var CreateCoreNetworkCommand = (function (_super) {
+    __extends(CreateCoreNetworkCommand, _super);
+    function CreateCoreNetworkCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateCoreNetworkCommand.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 = "CreateCoreNetworkCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateCoreNetworkRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateCoreNetworkResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateCoreNetworkCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateCoreNetworkCommand(input, context);
+    };
+    CreateCoreNetworkCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateCoreNetworkCommand(output, context);
+    };
+    return CreateCoreNetworkCommand;
+}($Command));
+export { CreateCoreNetworkCommand };

package/dist-es/commands/CreateSiteToSiteVpnAttachmentCommand.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 { CreateSiteToSiteVpnAttachmentRequest, CreateSiteToSiteVpnAttachmentResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateSiteToSiteVpnAttachmentCommand, serializeAws_restJson1CreateSiteToSiteVpnAttachmentCommand, } from "../protocols/Aws_restJson1";
+var CreateSiteToSiteVpnAttachmentCommand = (function (_super) {
+    __extends(CreateSiteToSiteVpnAttachmentCommand, _super);
+    function CreateSiteToSiteVpnAttachmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateSiteToSiteVpnAttachmentCommand.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 = "CreateSiteToSiteVpnAttachmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateSiteToSiteVpnAttachmentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateSiteToSiteVpnAttachmentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateSiteToSiteVpnAttachmentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateSiteToSiteVpnAttachmentCommand(input, context);
+    };
+    CreateSiteToSiteVpnAttachmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateSiteToSiteVpnAttachmentCommand(output, context);
+    };
+    return CreateSiteToSiteVpnAttachmentCommand;
+}($Command));
+export { CreateSiteToSiteVpnAttachmentCommand };

package/dist-es/commands/CreateVpcAttachmentCommand.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 { CreateVpcAttachmentRequest, CreateVpcAttachmentResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateVpcAttachmentCommand, serializeAws_restJson1CreateVpcAttachmentCommand, } from "../protocols/Aws_restJson1";
+var CreateVpcAttachmentCommand = (function (_super) {
+    __extends(CreateVpcAttachmentCommand, _super);
+    function CreateVpcAttachmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateVpcAttachmentCommand.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 = "CreateVpcAttachmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateVpcAttachmentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateVpcAttachmentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateVpcAttachmentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateVpcAttachmentCommand(input, context);
+    };
+    CreateVpcAttachmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateVpcAttachmentCommand(output, context);
+    };
+    return CreateVpcAttachmentCommand;
+}($Command));
+export { CreateVpcAttachmentCommand };

package/dist-es/commands/DeleteAttachmentCommand.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 { DeleteAttachmentRequest, DeleteAttachmentResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteAttachmentCommand, serializeAws_restJson1DeleteAttachmentCommand, } from "../protocols/Aws_restJson1";
+var DeleteAttachmentCommand = (function (_super) {
+    __extends(DeleteAttachmentCommand, _super);
+    function DeleteAttachmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteAttachmentCommand.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 = "DeleteAttachmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteAttachmentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteAttachmentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteAttachmentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteAttachmentCommand(input, context);
+    };
+    DeleteAttachmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteAttachmentCommand(output, context);
+    };
+    return DeleteAttachmentCommand;
+}($Command));
+export { DeleteAttachmentCommand };

package/dist-es/commands/DeleteConnectPeerCommand.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 { DeleteConnectPeerRequest, DeleteConnectPeerResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteConnectPeerCommand, serializeAws_restJson1DeleteConnectPeerCommand, } from "../protocols/Aws_restJson1";
+var DeleteConnectPeerCommand = (function (_super) {
+    __extends(DeleteConnectPeerCommand, _super);
+    function DeleteConnectPeerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteConnectPeerCommand.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 = "DeleteConnectPeerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteConnectPeerRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteConnectPeerResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteConnectPeerCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteConnectPeerCommand(input, context);
+    };
+    DeleteConnectPeerCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteConnectPeerCommand(output, context);
+    };
+    return DeleteConnectPeerCommand;
+}($Command));
+export { DeleteConnectPeerCommand };

package/dist-es/commands/DeleteCoreNetworkCommand.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 { DeleteCoreNetworkRequest, DeleteCoreNetworkResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteCoreNetworkCommand, serializeAws_restJson1DeleteCoreNetworkCommand, } from "../protocols/Aws_restJson1";
+var DeleteCoreNetworkCommand = (function (_super) {
+    __extends(DeleteCoreNetworkCommand, _super);
+    function DeleteCoreNetworkCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteCoreNetworkCommand.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 = "DeleteCoreNetworkCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteCoreNetworkRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteCoreNetworkResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteCoreNetworkCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteCoreNetworkCommand(input, context);
+    };
+    DeleteCoreNetworkCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteCoreNetworkCommand(output, context);
+    };
+    return DeleteCoreNetworkCommand;
+}($Command));
+export { DeleteCoreNetworkCommand };

package/dist-es/commands/DeleteCoreNetworkPolicyVersionCommand.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 { DeleteCoreNetworkPolicyVersionRequest, DeleteCoreNetworkPolicyVersionResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteCoreNetworkPolicyVersionCommand, serializeAws_restJson1DeleteCoreNetworkPolicyVersionCommand, } from "../protocols/Aws_restJson1";
+var DeleteCoreNetworkPolicyVersionCommand = (function (_super) {
+    __extends(DeleteCoreNetworkPolicyVersionCommand, _super);
+    function DeleteCoreNetworkPolicyVersionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteCoreNetworkPolicyVersionCommand.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 = "DeleteCoreNetworkPolicyVersionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteCoreNetworkPolicyVersionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteCoreNetworkPolicyVersionResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteCoreNetworkPolicyVersionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteCoreNetworkPolicyVersionCommand(input, context);
+    };
+    DeleteCoreNetworkPolicyVersionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteCoreNetworkPolicyVersionCommand(output, context);
+    };
+    return DeleteCoreNetworkPolicyVersionCommand;
+}($Command));
+export { DeleteCoreNetworkPolicyVersionCommand };

package/dist-es/commands/DeleteResourcePolicyCommand.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 { DeleteResourcePolicyRequest, DeleteResourcePolicyResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteResourcePolicyCommand, serializeAws_restJson1DeleteResourcePolicyCommand, } from "../protocols/Aws_restJson1";
+var DeleteResourcePolicyCommand = (function (_super) {
+    __extends(DeleteResourcePolicyCommand, _super);
+    function DeleteResourcePolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteResourcePolicyCommand.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 = "DeleteResourcePolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteResourcePolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteResourcePolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteResourcePolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteResourcePolicyCommand(input, context);
+    };
+    DeleteResourcePolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteResourcePolicyCommand(output, context);
+    };
+    return DeleteResourcePolicyCommand;
+}($Command));
+export { DeleteResourcePolicyCommand };

package/dist-es/commands/DisassociateConnectPeerCommand.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 { DisassociateConnectPeerRequest, DisassociateConnectPeerResponse } from "../models/models_0";
+import { deserializeAws_restJson1DisassociateConnectPeerCommand, serializeAws_restJson1DisassociateConnectPeerCommand, } from "../protocols/Aws_restJson1";
+var DisassociateConnectPeerCommand = (function (_super) {
+    __extends(DisassociateConnectPeerCommand, _super);
+    function DisassociateConnectPeerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DisassociateConnectPeerCommand.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 = "DisassociateConnectPeerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DisassociateConnectPeerRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DisassociateConnectPeerResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DisassociateConnectPeerCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DisassociateConnectPeerCommand(input, context);
+    };
+    DisassociateConnectPeerCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DisassociateConnectPeerCommand(output, context);
+    };
+    return DisassociateConnectPeerCommand;
+}($Command));
+export { DisassociateConnectPeerCommand };

package/dist-es/commands/ExecuteCoreNetworkChangeSetCommand.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 { ExecuteCoreNetworkChangeSetRequest, ExecuteCoreNetworkChangeSetResponse } from "../models/models_0";
+import { deserializeAws_restJson1ExecuteCoreNetworkChangeSetCommand, serializeAws_restJson1ExecuteCoreNetworkChangeSetCommand, } from "../protocols/Aws_restJson1";
+var ExecuteCoreNetworkChangeSetCommand = (function (_super) {
+    __extends(ExecuteCoreNetworkChangeSetCommand, _super);
+    function ExecuteCoreNetworkChangeSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ExecuteCoreNetworkChangeSetCommand.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 = "ExecuteCoreNetworkChangeSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ExecuteCoreNetworkChangeSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ExecuteCoreNetworkChangeSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ExecuteCoreNetworkChangeSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ExecuteCoreNetworkChangeSetCommand(input, context);
+    };
+    ExecuteCoreNetworkChangeSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ExecuteCoreNetworkChangeSetCommand(output, context);
+    };
+    return ExecuteCoreNetworkChangeSetCommand;
+}($Command));
+export { ExecuteCoreNetworkChangeSetCommand };

package/dist-es/commands/GetConnectAttachmentCommand.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 { GetConnectAttachmentRequest, GetConnectAttachmentResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetConnectAttachmentCommand, serializeAws_restJson1GetConnectAttachmentCommand, } from "../protocols/Aws_restJson1";
+var GetConnectAttachmentCommand = (function (_super) {
+    __extends(GetConnectAttachmentCommand, _super);
+    function GetConnectAttachmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetConnectAttachmentCommand.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 = "GetConnectAttachmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetConnectAttachmentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetConnectAttachmentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetConnectAttachmentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetConnectAttachmentCommand(input, context);
+    };
+    GetConnectAttachmentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetConnectAttachmentCommand(output, context);
+    };
+    return GetConnectAttachmentCommand;
+}($Command));
+export { GetConnectAttachmentCommand };

package/dist-es/commands/GetConnectPeerAssociationsCommand.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 { GetConnectPeerAssociationsRequest, GetConnectPeerAssociationsResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetConnectPeerAssociationsCommand, serializeAws_restJson1GetConnectPeerAssociationsCommand, } from "../protocols/Aws_restJson1";
+var GetConnectPeerAssociationsCommand = (function (_super) {
+    __extends(GetConnectPeerAssociationsCommand, _super);
+    function GetConnectPeerAssociationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetConnectPeerAssociationsCommand.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 = "GetConnectPeerAssociationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetConnectPeerAssociationsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetConnectPeerAssociationsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetConnectPeerAssociationsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetConnectPeerAssociationsCommand(input, context);
+    };
+    GetConnectPeerAssociationsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetConnectPeerAssociationsCommand(output, context);
+    };
+    return GetConnectPeerAssociationsCommand;
+}($Command));
+export { GetConnectPeerAssociationsCommand };

package/dist-es/commands/GetConnectPeerCommand.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 { GetConnectPeerRequest, GetConnectPeerResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetConnectPeerCommand, serializeAws_restJson1GetConnectPeerCommand, } from "../protocols/Aws_restJson1";
+var GetConnectPeerCommand = (function (_super) {
+    __extends(GetConnectPeerCommand, _super);
+    function GetConnectPeerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetConnectPeerCommand.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 = "GetConnectPeerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetConnectPeerRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetConnectPeerResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetConnectPeerCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetConnectPeerCommand(input, context);
+    };
+    GetConnectPeerCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetConnectPeerCommand(output, context);
+    };
+    return GetConnectPeerCommand;
+}($Command));
+export { GetConnectPeerCommand };