@aws-sdk/client-networkmanager 3.183.0 → 3.185.0

package/dist-es/NetworkManager.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { AcceptAttachmentCommand, } from "./commands/AcceptAttachmentCommand";
 import { AssociateConnectPeerCommand, } from "./commands/AssociateConnectPeerCommand";
 import { AssociateCustomerGatewayCommand, } from "./commands/AssociateCustomerGatewayCommand";
@@ -84,1195 +85,1201 @@ import { UpdateNetworkResourceMetadataCommand, } from "./commands/UpdateNetworkR
 import { UpdateSiteCommand } from "./commands/UpdateSiteCommand";
 import { UpdateVpcAttachmentCommand, } from "./commands/UpdateVpcAttachmentCommand";
 import { NetworkManagerClient } from "./NetworkManagerClient";
-export class NetworkManager extends NetworkManagerClient {
-    acceptAttachment(args, optionsOrCb, cb) {
-        const command = new AcceptAttachmentCommand(args);
+var NetworkManager = (function (_super) {
+    __extends(NetworkManager, _super);
+    function NetworkManager() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    NetworkManager.prototype.acceptAttachment = function (args, optionsOrCb, cb) {
+        var command = new AcceptAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    associateConnectPeer(args, optionsOrCb, cb) {
-        const command = new AssociateConnectPeerCommand(args);
+    };
+    NetworkManager.prototype.associateConnectPeer = function (args, optionsOrCb, cb) {
+        var command = new AssociateConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    associateCustomerGateway(args, optionsOrCb, cb) {
-        const command = new AssociateCustomerGatewayCommand(args);
+    };
+    NetworkManager.prototype.associateCustomerGateway = function (args, optionsOrCb, cb) {
+        var command = new AssociateCustomerGatewayCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    associateLink(args, optionsOrCb, cb) {
-        const command = new AssociateLinkCommand(args);
+    };
+    NetworkManager.prototype.associateLink = function (args, optionsOrCb, cb) {
+        var command = new AssociateLinkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    associateTransitGatewayConnectPeer(args, optionsOrCb, cb) {
-        const command = new AssociateTransitGatewayConnectPeerCommand(args);
+    };
+    NetworkManager.prototype.associateTransitGatewayConnectPeer = function (args, optionsOrCb, cb) {
+        var command = new AssociateTransitGatewayConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createConnectAttachment(args, optionsOrCb, cb) {
-        const command = new CreateConnectAttachmentCommand(args);
+    };
+    NetworkManager.prototype.createConnectAttachment = function (args, optionsOrCb, cb) {
+        var command = new CreateConnectAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createConnection(args, optionsOrCb, cb) {
-        const command = new CreateConnectionCommand(args);
+    };
+    NetworkManager.prototype.createConnection = function (args, optionsOrCb, cb) {
+        var command = new CreateConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createConnectPeer(args, optionsOrCb, cb) {
-        const command = new CreateConnectPeerCommand(args);
+    };
+    NetworkManager.prototype.createConnectPeer = function (args, optionsOrCb, cb) {
+        var command = new CreateConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createCoreNetwork(args, optionsOrCb, cb) {
-        const command = new CreateCoreNetworkCommand(args);
+    };
+    NetworkManager.prototype.createCoreNetwork = function (args, optionsOrCb, cb) {
+        var command = new CreateCoreNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDevice(args, optionsOrCb, cb) {
-        const command = new CreateDeviceCommand(args);
+    };
+    NetworkManager.prototype.createDevice = function (args, optionsOrCb, cb) {
+        var command = new CreateDeviceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createGlobalNetwork(args, optionsOrCb, cb) {
-        const command = new CreateGlobalNetworkCommand(args);
+    };
+    NetworkManager.prototype.createGlobalNetwork = function (args, optionsOrCb, cb) {
+        var command = new CreateGlobalNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createLink(args, optionsOrCb, cb) {
-        const command = new CreateLinkCommand(args);
+    };
+    NetworkManager.prototype.createLink = function (args, optionsOrCb, cb) {
+        var command = new CreateLinkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createSite(args, optionsOrCb, cb) {
-        const command = new CreateSiteCommand(args);
+    };
+    NetworkManager.prototype.createSite = function (args, optionsOrCb, cb) {
+        var command = new CreateSiteCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createSiteToSiteVpnAttachment(args, optionsOrCb, cb) {
-        const command = new CreateSiteToSiteVpnAttachmentCommand(args);
+    };
+    NetworkManager.prototype.createSiteToSiteVpnAttachment = function (args, optionsOrCb, cb) {
+        var command = new CreateSiteToSiteVpnAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createTransitGatewayPeering(args, optionsOrCb, cb) {
-        const command = new CreateTransitGatewayPeeringCommand(args);
+    };
+    NetworkManager.prototype.createTransitGatewayPeering = function (args, optionsOrCb, cb) {
+        var command = new CreateTransitGatewayPeeringCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createTransitGatewayRouteTableAttachment(args, optionsOrCb, cb) {
-        const command = new CreateTransitGatewayRouteTableAttachmentCommand(args);
+    };
+    NetworkManager.prototype.createTransitGatewayRouteTableAttachment = function (args, optionsOrCb, cb) {
+        var command = new CreateTransitGatewayRouteTableAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createVpcAttachment(args, optionsOrCb, cb) {
-        const command = new CreateVpcAttachmentCommand(args);
+    };
+    NetworkManager.prototype.createVpcAttachment = function (args, optionsOrCb, cb) {
+        var command = new CreateVpcAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteAttachment(args, optionsOrCb, cb) {
-        const command = new DeleteAttachmentCommand(args);
+    };
+    NetworkManager.prototype.deleteAttachment = function (args, optionsOrCb, cb) {
+        var command = new DeleteAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteConnection(args, optionsOrCb, cb) {
-        const command = new DeleteConnectionCommand(args);
+    };
+    NetworkManager.prototype.deleteConnection = function (args, optionsOrCb, cb) {
+        var command = new DeleteConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteConnectPeer(args, optionsOrCb, cb) {
-        const command = new DeleteConnectPeerCommand(args);
+    };
+    NetworkManager.prototype.deleteConnectPeer = function (args, optionsOrCb, cb) {
+        var command = new DeleteConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteCoreNetwork(args, optionsOrCb, cb) {
-        const command = new DeleteCoreNetworkCommand(args);
+    };
+    NetworkManager.prototype.deleteCoreNetwork = function (args, optionsOrCb, cb) {
+        var command = new DeleteCoreNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteCoreNetworkPolicyVersion(args, optionsOrCb, cb) {
-        const command = new DeleteCoreNetworkPolicyVersionCommand(args);
+    };
+    NetworkManager.prototype.deleteCoreNetworkPolicyVersion = function (args, optionsOrCb, cb) {
+        var command = new DeleteCoreNetworkPolicyVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDevice(args, optionsOrCb, cb) {
-        const command = new DeleteDeviceCommand(args);
+    };
+    NetworkManager.prototype.deleteDevice = function (args, optionsOrCb, cb) {
+        var command = new DeleteDeviceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteGlobalNetwork(args, optionsOrCb, cb) {
-        const command = new DeleteGlobalNetworkCommand(args);
+    };
+    NetworkManager.prototype.deleteGlobalNetwork = function (args, optionsOrCb, cb) {
+        var command = new DeleteGlobalNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteLink(args, optionsOrCb, cb) {
-        const command = new DeleteLinkCommand(args);
+    };
+    NetworkManager.prototype.deleteLink = function (args, optionsOrCb, cb) {
+        var command = new DeleteLinkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deletePeering(args, optionsOrCb, cb) {
-        const command = new DeletePeeringCommand(args);
+    };
+    NetworkManager.prototype.deletePeering = function (args, optionsOrCb, cb) {
+        var command = new DeletePeeringCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteResourcePolicy(args, optionsOrCb, cb) {
-        const command = new DeleteResourcePolicyCommand(args);
+    };
+    NetworkManager.prototype.deleteResourcePolicy = function (args, optionsOrCb, cb) {
+        var command = new DeleteResourcePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteSite(args, optionsOrCb, cb) {
-        const command = new DeleteSiteCommand(args);
+    };
+    NetworkManager.prototype.deleteSite = function (args, optionsOrCb, cb) {
+        var command = new DeleteSiteCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deregisterTransitGateway(args, optionsOrCb, cb) {
-        const command = new DeregisterTransitGatewayCommand(args);
+    };
+    NetworkManager.prototype.deregisterTransitGateway = function (args, optionsOrCb, cb) {
+        var command = new DeregisterTransitGatewayCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeGlobalNetworks(args, optionsOrCb, cb) {
-        const command = new DescribeGlobalNetworksCommand(args);
+    };
+    NetworkManager.prototype.describeGlobalNetworks = function (args, optionsOrCb, cb) {
+        var command = new DescribeGlobalNetworksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    disassociateConnectPeer(args, optionsOrCb, cb) {
-        const command = new DisassociateConnectPeerCommand(args);
+    };
+    NetworkManager.prototype.disassociateConnectPeer = function (args, optionsOrCb, cb) {
+        var command = new DisassociateConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    disassociateCustomerGateway(args, optionsOrCb, cb) {
-        const command = new DisassociateCustomerGatewayCommand(args);
+    };
+    NetworkManager.prototype.disassociateCustomerGateway = function (args, optionsOrCb, cb) {
+        var command = new DisassociateCustomerGatewayCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    disassociateLink(args, optionsOrCb, cb) {
-        const command = new DisassociateLinkCommand(args);
+    };
+    NetworkManager.prototype.disassociateLink = function (args, optionsOrCb, cb) {
+        var command = new DisassociateLinkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    disassociateTransitGatewayConnectPeer(args, optionsOrCb, cb) {
-        const command = new DisassociateTransitGatewayConnectPeerCommand(args);
+    };
+    NetworkManager.prototype.disassociateTransitGatewayConnectPeer = function (args, optionsOrCb, cb) {
+        var command = new DisassociateTransitGatewayConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    executeCoreNetworkChangeSet(args, optionsOrCb, cb) {
-        const command = new ExecuteCoreNetworkChangeSetCommand(args);
+    };
+    NetworkManager.prototype.executeCoreNetworkChangeSet = function (args, optionsOrCb, cb) {
+        var command = new ExecuteCoreNetworkChangeSetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getConnectAttachment(args, optionsOrCb, cb) {
-        const command = new GetConnectAttachmentCommand(args);
+    };
+    NetworkManager.prototype.getConnectAttachment = function (args, optionsOrCb, cb) {
+        var command = new GetConnectAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getConnections(args, optionsOrCb, cb) {
-        const command = new GetConnectionsCommand(args);
+    };
+    NetworkManager.prototype.getConnections = function (args, optionsOrCb, cb) {
+        var command = new GetConnectionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getConnectPeer(args, optionsOrCb, cb) {
-        const command = new GetConnectPeerCommand(args);
+    };
+    NetworkManager.prototype.getConnectPeer = function (args, optionsOrCb, cb) {
+        var command = new GetConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getConnectPeerAssociations(args, optionsOrCb, cb) {
-        const command = new GetConnectPeerAssociationsCommand(args);
+    };
+    NetworkManager.prototype.getConnectPeerAssociations = function (args, optionsOrCb, cb) {
+        var command = new GetConnectPeerAssociationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCoreNetwork(args, optionsOrCb, cb) {
-        const command = new GetCoreNetworkCommand(args);
+    };
+    NetworkManager.prototype.getCoreNetwork = function (args, optionsOrCb, cb) {
+        var command = new GetCoreNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCoreNetworkChangeEvents(args, optionsOrCb, cb) {
-        const command = new GetCoreNetworkChangeEventsCommand(args);
+    };
+    NetworkManager.prototype.getCoreNetworkChangeEvents = function (args, optionsOrCb, cb) {
+        var command = new GetCoreNetworkChangeEventsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCoreNetworkChangeSet(args, optionsOrCb, cb) {
-        const command = new GetCoreNetworkChangeSetCommand(args);
+    };
+    NetworkManager.prototype.getCoreNetworkChangeSet = function (args, optionsOrCb, cb) {
+        var command = new GetCoreNetworkChangeSetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCoreNetworkPolicy(args, optionsOrCb, cb) {
-        const command = new GetCoreNetworkPolicyCommand(args);
+    };
+    NetworkManager.prototype.getCoreNetworkPolicy = function (args, optionsOrCb, cb) {
+        var command = new GetCoreNetworkPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCustomerGatewayAssociations(args, optionsOrCb, cb) {
-        const command = new GetCustomerGatewayAssociationsCommand(args);
+    };
+    NetworkManager.prototype.getCustomerGatewayAssociations = function (args, optionsOrCb, cb) {
+        var command = new GetCustomerGatewayAssociationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDevices(args, optionsOrCb, cb) {
-        const command = new GetDevicesCommand(args);
+    };
+    NetworkManager.prototype.getDevices = function (args, optionsOrCb, cb) {
+        var command = new GetDevicesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getLinkAssociations(args, optionsOrCb, cb) {
-        const command = new GetLinkAssociationsCommand(args);
+    };
+    NetworkManager.prototype.getLinkAssociations = function (args, optionsOrCb, cb) {
+        var command = new GetLinkAssociationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getLinks(args, optionsOrCb, cb) {
-        const command = new GetLinksCommand(args);
+    };
+    NetworkManager.prototype.getLinks = function (args, optionsOrCb, cb) {
+        var command = new GetLinksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getNetworkResourceCounts(args, optionsOrCb, cb) {
-        const command = new GetNetworkResourceCountsCommand(args);
+    };
+    NetworkManager.prototype.getNetworkResourceCounts = function (args, optionsOrCb, cb) {
+        var command = new GetNetworkResourceCountsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getNetworkResourceRelationships(args, optionsOrCb, cb) {
-        const command = new GetNetworkResourceRelationshipsCommand(args);
+    };
+    NetworkManager.prototype.getNetworkResourceRelationships = function (args, optionsOrCb, cb) {
+        var command = new GetNetworkResourceRelationshipsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getNetworkResources(args, optionsOrCb, cb) {
-        const command = new GetNetworkResourcesCommand(args);
+    };
+    NetworkManager.prototype.getNetworkResources = function (args, optionsOrCb, cb) {
+        var command = new GetNetworkResourcesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getNetworkRoutes(args, optionsOrCb, cb) {
-        const command = new GetNetworkRoutesCommand(args);
+    };
+    NetworkManager.prototype.getNetworkRoutes = function (args, optionsOrCb, cb) {
+        var command = new GetNetworkRoutesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getNetworkTelemetry(args, optionsOrCb, cb) {
-        const command = new GetNetworkTelemetryCommand(args);
+    };
+    NetworkManager.prototype.getNetworkTelemetry = function (args, optionsOrCb, cb) {
+        var command = new GetNetworkTelemetryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getResourcePolicy(args, optionsOrCb, cb) {
-        const command = new GetResourcePolicyCommand(args);
+    };
+    NetworkManager.prototype.getResourcePolicy = function (args, optionsOrCb, cb) {
+        var command = new GetResourcePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRouteAnalysis(args, optionsOrCb, cb) {
-        const command = new GetRouteAnalysisCommand(args);
+    };
+    NetworkManager.prototype.getRouteAnalysis = function (args, optionsOrCb, cb) {
+        var command = new GetRouteAnalysisCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSites(args, optionsOrCb, cb) {
-        const command = new GetSitesCommand(args);
+    };
+    NetworkManager.prototype.getSites = function (args, optionsOrCb, cb) {
+        var command = new GetSitesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSiteToSiteVpnAttachment(args, optionsOrCb, cb) {
-        const command = new GetSiteToSiteVpnAttachmentCommand(args);
+    };
+    NetworkManager.prototype.getSiteToSiteVpnAttachment = function (args, optionsOrCb, cb) {
+        var command = new GetSiteToSiteVpnAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getTransitGatewayConnectPeerAssociations(args, optionsOrCb, cb) {
-        const command = new GetTransitGatewayConnectPeerAssociationsCommand(args);
+    };
+    NetworkManager.prototype.getTransitGatewayConnectPeerAssociations = function (args, optionsOrCb, cb) {
+        var command = new GetTransitGatewayConnectPeerAssociationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getTransitGatewayPeering(args, optionsOrCb, cb) {
-        const command = new GetTransitGatewayPeeringCommand(args);
+    };
+    NetworkManager.prototype.getTransitGatewayPeering = function (args, optionsOrCb, cb) {
+        var command = new GetTransitGatewayPeeringCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getTransitGatewayRegistrations(args, optionsOrCb, cb) {
-        const command = new GetTransitGatewayRegistrationsCommand(args);
+    };
+    NetworkManager.prototype.getTransitGatewayRegistrations = function (args, optionsOrCb, cb) {
+        var command = new GetTransitGatewayRegistrationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getTransitGatewayRouteTableAttachment(args, optionsOrCb, cb) {
-        const command = new GetTransitGatewayRouteTableAttachmentCommand(args);
+    };
+    NetworkManager.prototype.getTransitGatewayRouteTableAttachment = function (args, optionsOrCb, cb) {
+        var command = new GetTransitGatewayRouteTableAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getVpcAttachment(args, optionsOrCb, cb) {
-        const command = new GetVpcAttachmentCommand(args);
+    };
+    NetworkManager.prototype.getVpcAttachment = function (args, optionsOrCb, cb) {
+        var command = new GetVpcAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listAttachments(args, optionsOrCb, cb) {
-        const command = new ListAttachmentsCommand(args);
+    };
+    NetworkManager.prototype.listAttachments = function (args, optionsOrCb, cb) {
+        var command = new ListAttachmentsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listConnectPeers(args, optionsOrCb, cb) {
-        const command = new ListConnectPeersCommand(args);
+    };
+    NetworkManager.prototype.listConnectPeers = function (args, optionsOrCb, cb) {
+        var command = new ListConnectPeersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listCoreNetworkPolicyVersions(args, optionsOrCb, cb) {
-        const command = new ListCoreNetworkPolicyVersionsCommand(args);
+    };
+    NetworkManager.prototype.listCoreNetworkPolicyVersions = function (args, optionsOrCb, cb) {
+        var command = new ListCoreNetworkPolicyVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listCoreNetworks(args, optionsOrCb, cb) {
-        const command = new ListCoreNetworksCommand(args);
+    };
+    NetworkManager.prototype.listCoreNetworks = function (args, optionsOrCb, cb) {
+        var command = new ListCoreNetworksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listOrganizationServiceAccessStatus(args, optionsOrCb, cb) {
-        const command = new ListOrganizationServiceAccessStatusCommand(args);
+    };
+    NetworkManager.prototype.listOrganizationServiceAccessStatus = function (args, optionsOrCb, cb) {
+        var command = new ListOrganizationServiceAccessStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listPeerings(args, optionsOrCb, cb) {
-        const command = new ListPeeringsCommand(args);
+    };
+    NetworkManager.prototype.listPeerings = function (args, optionsOrCb, cb) {
+        var command = new ListPeeringsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTagsForResource(args, optionsOrCb, cb) {
-        const command = new ListTagsForResourceCommand(args);
+    };
+    NetworkManager.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
+        var command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putCoreNetworkPolicy(args, optionsOrCb, cb) {
-        const command = new PutCoreNetworkPolicyCommand(args);
+    };
+    NetworkManager.prototype.putCoreNetworkPolicy = function (args, optionsOrCb, cb) {
+        var command = new PutCoreNetworkPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putResourcePolicy(args, optionsOrCb, cb) {
-        const command = new PutResourcePolicyCommand(args);
+    };
+    NetworkManager.prototype.putResourcePolicy = function (args, optionsOrCb, cb) {
+        var command = new PutResourcePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    registerTransitGateway(args, optionsOrCb, cb) {
-        const command = new RegisterTransitGatewayCommand(args);
+    };
+    NetworkManager.prototype.registerTransitGateway = function (args, optionsOrCb, cb) {
+        var command = new RegisterTransitGatewayCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    rejectAttachment(args, optionsOrCb, cb) {
-        const command = new RejectAttachmentCommand(args);
+    };
+    NetworkManager.prototype.rejectAttachment = function (args, optionsOrCb, cb) {
+        var command = new RejectAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    restoreCoreNetworkPolicyVersion(args, optionsOrCb, cb) {
-        const command = new RestoreCoreNetworkPolicyVersionCommand(args);
+    };
+    NetworkManager.prototype.restoreCoreNetworkPolicyVersion = function (args, optionsOrCb, cb) {
+        var command = new RestoreCoreNetworkPolicyVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startOrganizationServiceAccessUpdate(args, optionsOrCb, cb) {
-        const command = new StartOrganizationServiceAccessUpdateCommand(args);
+    };
+    NetworkManager.prototype.startOrganizationServiceAccessUpdate = function (args, optionsOrCb, cb) {
+        var command = new StartOrganizationServiceAccessUpdateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startRouteAnalysis(args, optionsOrCb, cb) {
-        const command = new StartRouteAnalysisCommand(args);
+    };
+    NetworkManager.prototype.startRouteAnalysis = function (args, optionsOrCb, cb) {
+        var command = new StartRouteAnalysisCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    tagResource(args, optionsOrCb, cb) {
-        const command = new TagResourceCommand(args);
+    };
+    NetworkManager.prototype.tagResource = function (args, optionsOrCb, cb) {
+        var command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    untagResource(args, optionsOrCb, cb) {
-        const command = new UntagResourceCommand(args);
+    };
+    NetworkManager.prototype.untagResource = function (args, optionsOrCb, cb) {
+        var command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateConnection(args, optionsOrCb, cb) {
-        const command = new UpdateConnectionCommand(args);
+    };
+    NetworkManager.prototype.updateConnection = function (args, optionsOrCb, cb) {
+        var command = new UpdateConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateCoreNetwork(args, optionsOrCb, cb) {
-        const command = new UpdateCoreNetworkCommand(args);
+    };
+    NetworkManager.prototype.updateCoreNetwork = function (args, optionsOrCb, cb) {
+        var command = new UpdateCoreNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDevice(args, optionsOrCb, cb) {
-        const command = new UpdateDeviceCommand(args);
+    };
+    NetworkManager.prototype.updateDevice = function (args, optionsOrCb, cb) {
+        var command = new UpdateDeviceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateGlobalNetwork(args, optionsOrCb, cb) {
-        const command = new UpdateGlobalNetworkCommand(args);
+    };
+    NetworkManager.prototype.updateGlobalNetwork = function (args, optionsOrCb, cb) {
+        var command = new UpdateGlobalNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateLink(args, optionsOrCb, cb) {
-        const command = new UpdateLinkCommand(args);
+    };
+    NetworkManager.prototype.updateLink = function (args, optionsOrCb, cb) {
+        var command = new UpdateLinkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateNetworkResourceMetadata(args, optionsOrCb, cb) {
-        const command = new UpdateNetworkResourceMetadataCommand(args);
+    };
+    NetworkManager.prototype.updateNetworkResourceMetadata = function (args, optionsOrCb, cb) {
+        var command = new UpdateNetworkResourceMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateSite(args, optionsOrCb, cb) {
-        const command = new UpdateSiteCommand(args);
+    };
+    NetworkManager.prototype.updateSite = function (args, optionsOrCb, cb) {
+        var command = new UpdateSiteCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateVpcAttachment(args, optionsOrCb, cb) {
-        const command = new UpdateVpcAttachmentCommand(args);
+    };
+    NetworkManager.prototype.updateVpcAttachment = function (args, optionsOrCb, cb) {
+        var command = new UpdateVpcAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-}
+    };
+    return NetworkManager;
+}(NetworkManagerClient));
+export { NetworkManager };