@aws-sdk/client-rtbfabric 3.1045.0 → 3.1046.0

package/dist-cjs/index.js

@@ -4,19 +4,17 @@ var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
 var middlewareLogger = require('@aws-sdk/middleware-logger');
 var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
-var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var client = require('@smithy/core/client');
+var config = require('@smithy/core/config');
+var endpoints = require('@smithy/core/endpoints');
+var protocols = require('@smithy/core/protocols');
+var retry = require('@smithy/core/retry');
 var schema = require('@smithy/core/schema');
-var middlewareContentLength = require('@smithy/middleware-content-length');
-var middlewareEndpoint = require('@smithy/middleware-endpoint');
-var middlewareRetry = require('@smithy/middleware-retry');
-var smithyClient = require('@smithy/smithy-client');
 var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
-var protocolHttp = require('@smithy/protocol-http');
 var schemas_0 = require('./schemas/schemas_0');
-var utilWaiter = require('@smithy/util-waiter');
 var errors = require('./models/errors');
 var RTBFabricServiceException = require('./models/RTBFabricServiceException');
 
@@ -74,12 +72,12 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class RTBFabricClient extends smithyClient.Client {
+class RTBFabricClient extends client.Client {
     config;
     constructor(...[configuration]) {
         const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
@@ -87,17 +85,17 @@ class RTBFabricClient extends smithyClient.Client {
         this.initConfig = _config_0;
         const _config_1 = resolveClientEndpointParameters(_config_0);
         const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
-        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
-        const _config_4 = configResolver.resolveRegionConfig(_config_3);
+        const _config_3 = retry.resolveRetryConfig(_config_2);
+        const _config_4 = config.resolveRegionConfig(_config_3);
         const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
-        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
+        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
         this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
-        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(retry.getRetryPlugin(this.config));
+        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
         this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
         this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
         this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
@@ -114,11 +112,11 @@ class RTBFabricClient extends smithyClient.Client {
     }
 }
 
-class AcceptLinkCommand extends smithyClient.Command
+class AcceptLinkCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "AcceptLink", {})
     .n("RTBFabricClient", "AcceptLinkCommand")
@@ -126,11 +124,23 @@ class AcceptLinkCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateInboundExternalLinkCommand extends smithyClient.Command
+class AssociateCertificateCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("RTBFabric", "AssociateCertificate", {})
+    .n("RTBFabricClient", "AssociateCertificateCommand")
+    .sc(schemas_0.AssociateCertificate$)
+    .build() {
+}
+
+class CreateInboundExternalLinkCommand extends client.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "CreateInboundExternalLink", {})
     .n("RTBFabricClient", "CreateInboundExternalLinkCommand")
@@ -138,11 +148,11 @@ class CreateInboundExternalLinkCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateLinkCommand extends smithyClient.Command
+class CreateLinkCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "CreateLink", {})
     .n("RTBFabricClient", "CreateLinkCommand")
@@ -150,11 +160,23 @@ class CreateLinkCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateOutboundExternalLinkCommand extends smithyClient.Command
+class CreateLinkRoutingRuleCommand extends client.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("RTBFabric", "CreateLinkRoutingRule", {})
+    .n("RTBFabricClient", "CreateLinkRoutingRuleCommand")
+    .sc(schemas_0.CreateLinkRoutingRule$)
+    .build() {
+}
+
+class CreateOutboundExternalLinkCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "CreateOutboundExternalLink", {})
     .n("RTBFabricClient", "CreateOutboundExternalLinkCommand")
@@ -162,11 +184,11 @@ class CreateOutboundExternalLinkCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateRequesterGatewayCommand extends smithyClient.Command
+class CreateRequesterGatewayCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "CreateRequesterGateway", {})
     .n("RTBFabricClient", "CreateRequesterGatewayCommand")
@@ -174,11 +196,11 @@ class CreateRequesterGatewayCommand extends smithyClient.Command
     .build() {
 }
 
-class CreateResponderGatewayCommand extends smithyClient.Command
+class CreateResponderGatewayCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "CreateResponderGateway", {})
     .n("RTBFabricClient", "CreateResponderGatewayCommand")
@@ -186,11 +208,11 @@ class CreateResponderGatewayCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteInboundExternalLinkCommand extends smithyClient.Command
+class DeleteInboundExternalLinkCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "DeleteInboundExternalLink", {})
     .n("RTBFabricClient", "DeleteInboundExternalLinkCommand")
@@ -198,11 +220,11 @@ class DeleteInboundExternalLinkCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteLinkCommand extends smithyClient.Command
+class DeleteLinkCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "DeleteLink", {})
     .n("RTBFabricClient", "DeleteLinkCommand")
@@ -210,11 +232,23 @@ class DeleteLinkCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteOutboundExternalLinkCommand extends smithyClient.Command
+class DeleteLinkRoutingRuleCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("RTBFabric", "DeleteLinkRoutingRule", {})
+    .n("RTBFabricClient", "DeleteLinkRoutingRuleCommand")
+    .sc(schemas_0.DeleteLinkRoutingRule$)
+    .build() {
+}
+
+class DeleteOutboundExternalLinkCommand extends client.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "DeleteOutboundExternalLink", {})
     .n("RTBFabricClient", "DeleteOutboundExternalLinkCommand")
@@ -222,11 +256,11 @@ class DeleteOutboundExternalLinkCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteRequesterGatewayCommand extends smithyClient.Command
+class DeleteRequesterGatewayCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "DeleteRequesterGateway", {})
     .n("RTBFabricClient", "DeleteRequesterGatewayCommand")
@@ -234,11 +268,11 @@ class DeleteRequesterGatewayCommand extends smithyClient.Command
     .build() {
 }
 
-class DeleteResponderGatewayCommand extends smithyClient.Command
+class DeleteResponderGatewayCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "DeleteResponderGateway", {})
     .n("RTBFabricClient", "DeleteResponderGatewayCommand")
@@ -246,11 +280,35 @@ class DeleteResponderGatewayCommand extends smithyClient.Command
     .build() {
 }
 
-class GetInboundExternalLinkCommand extends smithyClient.Command
+class DisassociateCertificateCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("RTBFabric", "DisassociateCertificate", {})
+    .n("RTBFabricClient", "DisassociateCertificateCommand")
+    .sc(schemas_0.DisassociateCertificate$)
+    .build() {
+}
+
+class GetCertificateAssociationCommand extends client.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("RTBFabric", "GetCertificateAssociation", {})
+    .n("RTBFabricClient", "GetCertificateAssociationCommand")
+    .sc(schemas_0.GetCertificateAssociation$)
+    .build() {
+}
+
+class GetInboundExternalLinkCommand extends client.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "GetInboundExternalLink", {})
     .n("RTBFabricClient", "GetInboundExternalLinkCommand")
@@ -258,11 +316,11 @@ class GetInboundExternalLinkCommand extends smithyClient.Command
     .build() {
 }
 
-class GetLinkCommand extends smithyClient.Command
+class GetLinkCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "GetLink", {})
     .n("RTBFabricClient", "GetLinkCommand")
@@ -270,11 +328,23 @@ class GetLinkCommand extends smithyClient.Command
     .build() {
 }
 
-class GetOutboundExternalLinkCommand extends smithyClient.Command
+class GetLinkRoutingRuleCommand extends client.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("RTBFabric", "GetLinkRoutingRule", {})
+    .n("RTBFabricClient", "GetLinkRoutingRuleCommand")
+    .sc(schemas_0.GetLinkRoutingRule$)
+    .build() {
+}
+
+class GetOutboundExternalLinkCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "GetOutboundExternalLink", {})
     .n("RTBFabricClient", "GetOutboundExternalLinkCommand")
@@ -282,11 +352,11 @@ class GetOutboundExternalLinkCommand extends smithyClient.Command
     .build() {
 }
 
-class GetRequesterGatewayCommand extends smithyClient.Command
+class GetRequesterGatewayCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "GetRequesterGateway", {})
     .n("RTBFabricClient", "GetRequesterGatewayCommand")
@@ -294,11 +364,11 @@ class GetRequesterGatewayCommand extends smithyClient.Command
     .build() {
 }
 
-class GetResponderGatewayCommand extends smithyClient.Command
+class GetResponderGatewayCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "GetResponderGateway", {})
     .n("RTBFabricClient", "GetResponderGatewayCommand")
@@ -306,11 +376,35 @@ class GetResponderGatewayCommand extends smithyClient.Command
     .build() {
 }
 
-class ListLinksCommand extends smithyClient.Command
+class ListCertificateAssociationsCommand extends client.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("RTBFabric", "ListCertificateAssociations", {})
+    .n("RTBFabricClient", "ListCertificateAssociationsCommand")
+    .sc(schemas_0.ListCertificateAssociations$)
+    .build() {
+}
+
+class ListLinkRoutingRulesCommand extends client.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("RTBFabric", "ListLinkRoutingRules", {})
+    .n("RTBFabricClient", "ListLinkRoutingRulesCommand")
+    .sc(schemas_0.ListLinkRoutingRules$)
+    .build() {
+}
+
+class ListLinksCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "ListLinks", {})
     .n("RTBFabricClient", "ListLinksCommand")
@@ -318,11 +412,11 @@ class ListLinksCommand extends smithyClient.Command
     .build() {
 }
 
-class ListRequesterGatewaysCommand extends smithyClient.Command
+class ListRequesterGatewaysCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "ListRequesterGateways", {})
     .n("RTBFabricClient", "ListRequesterGatewaysCommand")
@@ -330,11 +424,11 @@ class ListRequesterGatewaysCommand extends smithyClient.Command
     .build() {
 }
 
-class ListResponderGatewaysCommand extends smithyClient.Command
+class ListResponderGatewaysCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "ListResponderGateways", {})
     .n("RTBFabricClient", "ListResponderGatewaysCommand")
@@ -342,11 +436,11 @@ class ListResponderGatewaysCommand extends smithyClient.Command
     .build() {
 }
 
-class ListTagsForResourceCommand extends smithyClient.Command
+class ListTagsForResourceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "ListTagsForResource", {})
     .n("RTBFabricClient", "ListTagsForResourceCommand")
@@ -354,11 +448,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .build() {
 }
 
-class RejectLinkCommand extends smithyClient.Command
+class RejectLinkCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "RejectLink", {})
     .n("RTBFabricClient", "RejectLinkCommand")
@@ -366,11 +460,11 @@ class RejectLinkCommand extends smithyClient.Command
     .build() {
 }
 
-class TagResourceCommand extends smithyClient.Command
+class TagResourceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "TagResource", {})
     .n("RTBFabricClient", "TagResourceCommand")
@@ -378,11 +472,11 @@ class TagResourceCommand extends smithyClient.Command
     .build() {
 }
 
-class UntagResourceCommand extends smithyClient.Command
+class UntagResourceCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "UntagResource", {})
     .n("RTBFabricClient", "UntagResourceCommand")
@@ -390,11 +484,11 @@ class UntagResourceCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateLinkCommand extends smithyClient.Command
+class UpdateLinkCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "UpdateLink", {})
     .n("RTBFabricClient", "UpdateLinkCommand")
@@ -402,11 +496,11 @@ class UpdateLinkCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateLinkModuleFlowCommand extends smithyClient.Command
+class UpdateLinkModuleFlowCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "UpdateLinkModuleFlow", {})
     .n("RTBFabricClient", "UpdateLinkModuleFlowCommand")
@@ -414,11 +508,23 @@ class UpdateLinkModuleFlowCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateRequesterGatewayCommand extends smithyClient.Command
+class UpdateLinkRoutingRuleCommand extends client.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("RTBFabric", "UpdateLinkRoutingRule", {})
+    .n("RTBFabricClient", "UpdateLinkRoutingRuleCommand")
+    .sc(schemas_0.UpdateLinkRoutingRule$)
+    .build() {
+}
+
+class UpdateRequesterGatewayCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "UpdateRequesterGateway", {})
     .n("RTBFabricClient", "UpdateRequesterGatewayCommand")
@@ -426,11 +532,11 @@ class UpdateRequesterGatewayCommand extends smithyClient.Command
     .build() {
 }
 
-class UpdateResponderGatewayCommand extends smithyClient.Command
+class UpdateResponderGatewayCommand extends client.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RTBFabric", "UpdateResponderGateway", {})
     .n("RTBFabricClient", "UpdateResponderGatewayCommand")
@@ -438,23 +544,138 @@ class UpdateResponderGatewayCommand extends smithyClient.Command
     .build() {
 }
 
+const paginateListCertificateAssociations = core.createPaginator(RTBFabricClient, ListCertificateAssociationsCommand, "nextToken", "nextToken", "maxResults");
+
+const paginateListLinkRoutingRules = core.createPaginator(RTBFabricClient, ListLinkRoutingRulesCommand, "nextToken", "nextToken", "maxResults");
+
 const paginateListLinks = core.createPaginator(RTBFabricClient, ListLinksCommand, "nextToken", "nextToken", "maxResults");
 
 const paginateListRequesterGateways = core.createPaginator(RTBFabricClient, ListRequesterGatewaysCommand, "nextToken", "nextToken", "maxResults");
 
 const paginateListResponderGateways = core.createPaginator(RTBFabricClient, ListResponderGatewaysCommand, "nextToken", "nextToken", "maxResults");
 
-const checkState$a = async (client, input) => {
+const checkState$e = async (client$1, input) => {
+    let reason;
+    try {
+        let result = await client$1.send(new GetCertificateAssociationCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "ASSOCIATED") {
+                return { state: client.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: client.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "DISASSOCIATED") {
+                return { state: client.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "PENDING_DISASSOCIATION") {
+                return { state: client.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name === "ResourceNotFoundException") {
+            return { state: client.WaiterState.FAILURE, reason };
+        }
+    }
+    return { state: client.WaiterState.RETRY, reason };
+};
+const waitForCertificateAssociated = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
+};
+const waitUntilCertificateAssociated = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
+    return client.checkExceptions(result);
+};
+
+const checkState$d = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetInboundExternalLinkCommand(input));
+        let result = await client$1.send(new GetCertificateAssociationCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "DISASSOCIATED") {
+                return { state: client.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: client.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "PENDING_ASSOCIATION") {
+                return { state: client.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name === "ResourceNotFoundException") {
+            return { state: client.WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: client.WaiterState.RETRY, reason };
+};
+const waitForCertificateDisassociated = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
+};
+const waitUntilCertificateDisassociated = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
+    return client.checkExceptions(result);
+};
+
+const checkState$c = async (client$1, input) => {
+    let reason;
+    try {
+        let result = await client$1.send(new GetInboundExternalLinkCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -463,7 +684,7 @@ const checkState$a = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "REJECTED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -472,7 +693,7 @@ const checkState$a = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -481,7 +702,7 @@ const checkState$a = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -490,7 +711,7 @@ const checkState$a = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "ISOLATED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -498,29 +719,29 @@ const checkState$a = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForInboundExternalLinkActive = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
 };
 const waitUntilInboundExternalLinkActive = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
+    return client.checkExceptions(result);
 };
 
-const checkState$9 = async (client, input) => {
+const checkState$b = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetInboundExternalLinkCommand(input));
+        let result = await client$1.send(new GetInboundExternalLinkCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -529,7 +750,7 @@ const checkState$9 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -538,7 +759,7 @@ const checkState$9 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "REJECTED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -546,29 +767,29 @@ const checkState$9 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForInboundExternalLinkDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
 };
 const waitUntilInboundExternalLinkDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
+    return client.checkExceptions(result);
 };
 
-const checkState$8 = async (client, input) => {
+const checkState$a = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetLinkCommand(input));
+        let result = await client$1.send(new GetLinkCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACCEPTED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -577,7 +798,7 @@ const checkState$8 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "REJECTED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -586,7 +807,7 @@ const checkState$8 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -595,7 +816,7 @@ const checkState$8 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -603,29 +824,29 @@ const checkState$8 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForLinkAccepted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
 };
 const waitUntilLinkAccepted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
+    return client.checkExceptions(result);
 };
 
-const checkState$7 = async (client, input) => {
+const checkState$9 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetLinkCommand(input));
+        let result = await client$1.send(new GetLinkCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -634,7 +855,7 @@ const checkState$7 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "REJECTED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -643,7 +864,7 @@ const checkState$7 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -652,7 +873,7 @@ const checkState$7 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -660,29 +881,29 @@ const checkState$7 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForLinkActive = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
 };
 const waitUntilLinkActive = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+    return client.checkExceptions(result);
 };
 
-const checkState$6 = async (client, input) => {
+const checkState$8 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetLinkCommand(input));
+        let result = await client$1.send(new GetLinkCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -691,7 +912,7 @@ const checkState$6 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -700,7 +921,7 @@ const checkState$6 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "REJECTED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -708,29 +929,119 @@ const checkState$6 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForLinkDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
 };
 const waitUntilLinkDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return client.checkExceptions(result);
+};
+
+const checkState$7 = async (client$1, input) => {
+    let reason;
+    try {
+        let result = await client$1.send(new GetLinkRoutingRuleCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "ACTIVE") {
+                return { state: client.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: client.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "DELETED") {
+                return { state: client.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: client.WaiterState.RETRY, reason };
+};
+const waitForLinkRoutingRuleActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+};
+const waitUntilLinkRoutingRuleActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return client.checkExceptions(result);
 };
 
-const checkState$5 = async (client, input) => {
+const checkState$6 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetOutboundExternalLinkCommand(input));
+        let result = await client$1.send(new GetLinkRoutingRuleCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "DELETED") {
+                return { state: client.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: client.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name === "ResourceNotFoundException") {
+            return { state: client.WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: client.WaiterState.RETRY, reason };
+};
+const waitForLinkRoutingRuleDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+};
+const waitUntilLinkRoutingRuleDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return client.checkExceptions(result);
+};
+
+const checkState$5 = async (client$1, input) => {
+    let reason;
+    try {
+        let result = await client$1.send(new GetOutboundExternalLinkCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -739,7 +1050,7 @@ const checkState$5 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "REJECTED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -748,7 +1059,7 @@ const checkState$5 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -757,7 +1068,7 @@ const checkState$5 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -766,7 +1077,7 @@ const checkState$5 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "ISOLATED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -774,29 +1085,29 @@ const checkState$5 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForOutboundExternalLinkActive = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
 };
 const waitUntilOutboundExternalLinkActive = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return client.checkExceptions(result);
 };
 
-const checkState$4 = async (client, input) => {
+const checkState$4 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetOutboundExternalLinkCommand(input));
+        let result = await client$1.send(new GetOutboundExternalLinkCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -805,7 +1116,7 @@ const checkState$4 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -814,7 +1125,7 @@ const checkState$4 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "REJECTED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -822,29 +1133,29 @@ const checkState$4 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForOutboundExternalLinkDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
 };
 const waitUntilOutboundExternalLinkDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return client.checkExceptions(result);
 };
 
-const checkState$3 = async (client, input) => {
+const checkState$3 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetRequesterGatewayCommand(input));
+        let result = await client$1.send(new GetRequesterGatewayCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -853,7 +1164,7 @@ const checkState$3 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -862,7 +1173,7 @@ const checkState$3 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "ERROR") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -870,29 +1181,29 @@ const checkState$3 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForRequesterGatewayActive = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
 };
 const waitUntilRequesterGatewayActive = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return client.checkExceptions(result);
 };
 
-const checkState$2 = async (client, input) => {
+const checkState$2 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetRequesterGatewayCommand(input));
+        let result = await client$1.send(new GetRequesterGatewayCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -901,7 +1212,7 @@ const checkState$2 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "ERROR") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -909,32 +1220,32 @@ const checkState$2 = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            return { state: client.WaiterState.SUCCESS, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForRequesterGatewayDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
 const waitUntilRequesterGatewayDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return client.checkExceptions(result);
 };
 
-const checkState$1 = async (client, input) => {
+const checkState$1 = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetResponderGatewayCommand(input));
+        let result = await client$1.send(new GetResponderGatewayCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -943,7 +1254,7 @@ const checkState$1 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -952,7 +1263,7 @@ const checkState$1 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "ERROR") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -960,29 +1271,29 @@ const checkState$1 = async (client, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForResponderGatewayActive = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
 const waitUntilResponderGatewayActive = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return client.checkExceptions(result);
 };
 
-const checkState = async (client, input) => {
+const checkState = async (client$1, input) => {
     let reason;
     try {
-        let result = await client.send(new GetResponderGatewayCommand(input));
+        let result = await client$1.send(new GetResponderGatewayCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
             if (returnComparator() === "DELETED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+                return { state: client.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -991,7 +1302,7 @@ const checkState = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "ERROR") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+                return { state: client.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -999,38 +1310,46 @@ const checkState = async (client, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            return { state: client.WaiterState.SUCCESS, reason };
         }
     }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
+    return { state: client.WaiterState.RETRY, reason };
 };
 const waitForResponderGatewayDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
 const waitUntilResponderGatewayDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return utilWaiter.checkExceptions(result);
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return client.checkExceptions(result);
 };
 
 const commands = {
     AcceptLinkCommand,
+    AssociateCertificateCommand,
     CreateInboundExternalLinkCommand,
     CreateLinkCommand,
+    CreateLinkRoutingRuleCommand,
     CreateOutboundExternalLinkCommand,
     CreateRequesterGatewayCommand,
     CreateResponderGatewayCommand,
     DeleteInboundExternalLinkCommand,
     DeleteLinkCommand,
+    DeleteLinkRoutingRuleCommand,
     DeleteOutboundExternalLinkCommand,
     DeleteRequesterGatewayCommand,
     DeleteResponderGatewayCommand,
+    DisassociateCertificateCommand,
+    GetCertificateAssociationCommand,
     GetInboundExternalLinkCommand,
     GetLinkCommand,
+    GetLinkRoutingRuleCommand,
     GetOutboundExternalLinkCommand,
     GetRequesterGatewayCommand,
     GetResponderGatewayCommand,
+    ListCertificateAssociationsCommand,
+    ListLinkRoutingRulesCommand,
     ListLinksCommand,
     ListRequesterGatewaysCommand,
     ListResponderGatewaysCommand,
@@ -1040,20 +1359,27 @@ const commands = {
     UntagResourceCommand,
     UpdateLinkCommand,
     UpdateLinkModuleFlowCommand,
+    UpdateLinkRoutingRuleCommand,
     UpdateRequesterGatewayCommand,
     UpdateResponderGatewayCommand,
 };
 const paginators = {
+    paginateListCertificateAssociations,
+    paginateListLinkRoutingRules,
     paginateListLinks,
     paginateListRequesterGateways,
     paginateListResponderGateways,
 };
 const waiters = {
+    waitUntilCertificateAssociated,
+    waitUntilCertificateDisassociated,
     waitUntilInboundExternalLinkActive,
     waitUntilInboundExternalLinkDeleted,
     waitUntilLinkAccepted,
     waitUntilLinkActive,
     waitUntilLinkDeleted,
+    waitUntilLinkRoutingRuleActive,
+    waitUntilLinkRoutingRuleDeleted,
     waitUntilOutboundExternalLinkActive,
     waitUntilOutboundExternalLinkDeleted,
     waitUntilRequesterGatewayActive,
@@ -1063,7 +1389,7 @@ const waiters = {
 };
 class RTBFabric extends RTBFabricClient {
 }
-smithyClient.createAggregatedClient(commands, RTBFabric, { paginators, waiters });
+client.createAggregatedClient(commands, RTBFabric, { paginators, waiters });
 
 const ResponderErrorMaskingAction = {
     NO_BID: "NO_BID",
@@ -1103,10 +1429,25 @@ const LinkStatus = {
     REJECTED: "REJECTED",
     REQUESTED: "REQUESTED",
 };
+const CertificateAssociationStatus = {
+    ASSOCIATED: "ASSOCIATED",
+    DISASSOCIATED: "DISASSOCIATED",
+    FAILED: "FAILED",
+    PENDING_ASSOCIATION: "PENDING_ASSOCIATION",
+    PENDING_DISASSOCIATION: "PENDING_DISASSOCIATION",
+};
 const Protocol = {
     HTTP: "HTTP",
     HTTPS: "HTTPS",
 };
+const RuleStatus = {
+    ACTIVE: "ACTIVE",
+    CREATION_IN_PROGRESS: "CREATION_IN_PROGRESS",
+    DELETED: "DELETED",
+    DELETION_IN_PROGRESS: "DELETION_IN_PROGRESS",
+    FAILED: "FAILED",
+    UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
+};
 const RequesterGatewayStatus = {
     ACTIVE: "ACTIVE",
     DELETED: "DELETED",
@@ -1134,30 +1475,39 @@ const ResponderGatewayStatus = {
     PENDING_UPDATE: "PENDING_UPDATE",
 };
 
-exports.$Command = smithyClient.Command;
-exports.__Client = smithyClient.Client;
+exports.$Command = client.Command;
+exports.__Client = client.Client;
 exports.RTBFabricServiceException = RTBFabricServiceException.RTBFabricServiceException;
 exports.AcceptLinkCommand = AcceptLinkCommand;
+exports.AssociateCertificateCommand = AssociateCertificateCommand;
+exports.CertificateAssociationStatus = CertificateAssociationStatus;
 exports.ConnectivityType = ConnectivityType;
 exports.CreateInboundExternalLinkCommand = CreateInboundExternalLinkCommand;
 exports.CreateLinkCommand = CreateLinkCommand;
+exports.CreateLinkRoutingRuleCommand = CreateLinkRoutingRuleCommand;
 exports.CreateOutboundExternalLinkCommand = CreateOutboundExternalLinkCommand;
 exports.CreateRequesterGatewayCommand = CreateRequesterGatewayCommand;
 exports.CreateResponderGatewayCommand = CreateResponderGatewayCommand;
 exports.DeleteInboundExternalLinkCommand = DeleteInboundExternalLinkCommand;
 exports.DeleteLinkCommand = DeleteLinkCommand;
+exports.DeleteLinkRoutingRuleCommand = DeleteLinkRoutingRuleCommand;
 exports.DeleteOutboundExternalLinkCommand = DeleteOutboundExternalLinkCommand;
 exports.DeleteRequesterGatewayCommand = DeleteRequesterGatewayCommand;
 exports.DeleteResponderGatewayCommand = DeleteResponderGatewayCommand;
+exports.DisassociateCertificateCommand = DisassociateCertificateCommand;
 exports.FilterType = FilterType;
 exports.GatewayType = GatewayType;
+exports.GetCertificateAssociationCommand = GetCertificateAssociationCommand;
 exports.GetInboundExternalLinkCommand = GetInboundExternalLinkCommand;
 exports.GetLinkCommand = GetLinkCommand;
+exports.GetLinkRoutingRuleCommand = GetLinkRoutingRuleCommand;
 exports.GetOutboundExternalLinkCommand = GetOutboundExternalLinkCommand;
 exports.GetRequesterGatewayCommand = GetRequesterGatewayCommand;
 exports.GetResponderGatewayCommand = GetResponderGatewayCommand;
 exports.LinkDirection = LinkDirection;
 exports.LinkStatus = LinkStatus;
+exports.ListCertificateAssociationsCommand = ListCertificateAssociationsCommand;
+exports.ListLinkRoutingRulesCommand = ListLinkRoutingRulesCommand;
 exports.ListLinksCommand = ListLinksCommand;
 exports.ListRequesterGatewaysCommand = ListRequesterGatewaysCommand;
 exports.ListResponderGatewaysCommand = ListResponderGatewaysCommand;
@@ -1170,31 +1520,43 @@ exports.RequesterGatewayStatus = RequesterGatewayStatus;
 exports.ResponderErrorMaskingAction = ResponderErrorMaskingAction;
 exports.ResponderErrorMaskingLoggingType = ResponderErrorMaskingLoggingType;
 exports.ResponderGatewayStatus = ResponderGatewayStatus;
+exports.RuleStatus = RuleStatus;
 exports.TagResourceCommand = TagResourceCommand;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateLinkCommand = UpdateLinkCommand;
 exports.UpdateLinkModuleFlowCommand = UpdateLinkModuleFlowCommand;
+exports.UpdateLinkRoutingRuleCommand = UpdateLinkRoutingRuleCommand;
 exports.UpdateRequesterGatewayCommand = UpdateRequesterGatewayCommand;
 exports.UpdateResponderGatewayCommand = UpdateResponderGatewayCommand;
+exports.paginateListCertificateAssociations = paginateListCertificateAssociations;
+exports.paginateListLinkRoutingRules = paginateListLinkRoutingRules;
 exports.paginateListLinks = paginateListLinks;
 exports.paginateListRequesterGateways = paginateListRequesterGateways;
 exports.paginateListResponderGateways = paginateListResponderGateways;
+exports.waitForCertificateAssociated = waitForCertificateAssociated;
+exports.waitForCertificateDisassociated = waitForCertificateDisassociated;
 exports.waitForInboundExternalLinkActive = waitForInboundExternalLinkActive;
 exports.waitForInboundExternalLinkDeleted = waitForInboundExternalLinkDeleted;
 exports.waitForLinkAccepted = waitForLinkAccepted;
 exports.waitForLinkActive = waitForLinkActive;
 exports.waitForLinkDeleted = waitForLinkDeleted;
+exports.waitForLinkRoutingRuleActive = waitForLinkRoutingRuleActive;
+exports.waitForLinkRoutingRuleDeleted = waitForLinkRoutingRuleDeleted;
 exports.waitForOutboundExternalLinkActive = waitForOutboundExternalLinkActive;
 exports.waitForOutboundExternalLinkDeleted = waitForOutboundExternalLinkDeleted;
 exports.waitForRequesterGatewayActive = waitForRequesterGatewayActive;
 exports.waitForRequesterGatewayDeleted = waitForRequesterGatewayDeleted;
 exports.waitForResponderGatewayActive = waitForResponderGatewayActive;
 exports.waitForResponderGatewayDeleted = waitForResponderGatewayDeleted;
+exports.waitUntilCertificateAssociated = waitUntilCertificateAssociated;
+exports.waitUntilCertificateDisassociated = waitUntilCertificateDisassociated;
 exports.waitUntilInboundExternalLinkActive = waitUntilInboundExternalLinkActive;
 exports.waitUntilInboundExternalLinkDeleted = waitUntilInboundExternalLinkDeleted;
 exports.waitUntilLinkAccepted = waitUntilLinkAccepted;
 exports.waitUntilLinkActive = waitUntilLinkActive;
 exports.waitUntilLinkDeleted = waitUntilLinkDeleted;
+exports.waitUntilLinkRoutingRuleActive = waitUntilLinkRoutingRuleActive;
+exports.waitUntilLinkRoutingRuleDeleted = waitUntilLinkRoutingRuleDeleted;
 exports.waitUntilOutboundExternalLinkActive = waitUntilOutboundExternalLinkActive;
 exports.waitUntilOutboundExternalLinkDeleted = waitUntilOutboundExternalLinkDeleted;
 exports.waitUntilRequesterGatewayActive = waitUntilRequesterGatewayActive;