@aws-sdk/client-route53resolver 3.281.0 → 3.287.0

package/dist-cjs/protocols/Aws_json1_1.js

@@ -1881,6 +1881,9 @@ const deserializeAws_json1_1GetResolverConfigCommandError = async (output, conte
         case "ThrottlingException":
         case "com.amazonaws.route53resolver#ThrottlingException":
             throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.route53resolver#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -2234,6 +2237,9 @@ const deserializeAws_json1_1GetResolverRulePolicyCommandError = async (output, c
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.route53resolver#AccessDeniedException":
+            throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
         case "InternalServiceErrorException":
         case "com.amazonaws.route53resolver#InternalServiceErrorException":
             throw await deserializeAws_json1_1InternalServiceErrorExceptionResponse(parsedOutput, context);
@@ -2608,6 +2614,9 @@ const deserializeAws_json1_1ListResolverConfigsCommandError = async (output, con
         case "ThrottlingException":
         case "com.amazonaws.route53resolver#ThrottlingException":
             throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.route53resolver#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -3114,6 +3123,9 @@ const deserializeAws_json1_1PutResolverRulePolicyCommandError = async (output, c
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.route53resolver#AccessDeniedException":
+            throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
         case "InternalServiceErrorException":
         case "com.amazonaws.route53resolver#InternalServiceErrorException":
             throw await deserializeAws_json1_1InternalServiceErrorExceptionResponse(parsedOutput, context);
@@ -3475,6 +3487,9 @@ const deserializeAws_json1_1UpdateResolverConfigCommandError = async (output, co
         case "ThrottlingException":
         case "com.amazonaws.route53resolver#ThrottlingException":
             throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.route53resolver#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -3842,6 +3857,7 @@ const serializeAws_json1_1CreateResolverEndpointRequest = (input, context) => {
             IpAddresses: serializeAws_json1_1IpAddressesRequest(input.IpAddresses, context),
         }),
         ...(input.Name != null && { Name: input.Name }),
+        ...(input.ResolverEndpointType != null && { ResolverEndpointType: input.ResolverEndpointType }),
         ...(input.SecurityGroupIds != null && {
             SecurityGroupIds: serializeAws_json1_1SecurityGroupIds(input.SecurityGroupIds, context),
         }),
@@ -4041,6 +4057,7 @@ const serializeAws_json1_1IpAddressesRequest = (input, context) => {
 const serializeAws_json1_1IpAddressRequest = (input, context) => {
     return {
         ...(input.Ip != null && { Ip: input.Ip }),
+        ...(input.Ipv6 != null && { Ipv6: input.Ipv6 }),
         ...(input.SubnetId != null && { SubnetId: input.SubnetId }),
     };
 };
@@ -4048,6 +4065,7 @@ const serializeAws_json1_1IpAddressUpdate = (input, context) => {
     return {
         ...(input.Ip != null && { Ip: input.Ip }),
         ...(input.IpId != null && { IpId: input.IpId }),
+        ...(input.Ipv6 != null && { Ipv6: input.Ipv6 }),
         ...(input.SubnetId != null && { SubnetId: input.SubnetId }),
     };
 };
@@ -4224,6 +4242,7 @@ const serializeAws_json1_1TagResourceRequest = (input, context) => {
 const serializeAws_json1_1TargetAddress = (input, context) => {
     return {
         ...(input.Ip != null && { Ip: input.Ip }),
+        ...(input.Ipv6 != null && { Ipv6: input.Ipv6 }),
         ...(input.Port != null && { Port: input.Port }),
     };
 };
@@ -4276,6 +4295,19 @@ const serializeAws_json1_1UpdateFirewallRuleRequest = (input, context) => {
         ...(input.Priority != null && { Priority: input.Priority }),
     };
 };
+const serializeAws_json1_1UpdateIpAddress = (input, context) => {
+    return {
+        ...(input.IpId != null && { IpId: input.IpId }),
+        ...(input.Ipv6 != null && { Ipv6: input.Ipv6 }),
+    };
+};
+const serializeAws_json1_1UpdateIpAddresses = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_json1_1UpdateIpAddress(entry, context);
+    });
+};
 const serializeAws_json1_1UpdateResolverConfigRequest = (input, context) => {
     return {
         ...(input.AutodefinedReverseFlag != null && { AutodefinedReverseFlag: input.AutodefinedReverseFlag }),
@@ -4292,6 +4324,10 @@ const serializeAws_json1_1UpdateResolverEndpointRequest = (input, context) => {
     return {
         ...(input.Name != null && { Name: input.Name }),
         ...(input.ResolverEndpointId != null && { ResolverEndpointId: input.ResolverEndpointId }),
+        ...(input.ResolverEndpointType != null && { ResolverEndpointType: input.ResolverEndpointType }),
+        ...(input.UpdateIpAddresses != null && {
+            UpdateIpAddresses: serializeAws_json1_1UpdateIpAddresses(input.UpdateIpAddresses, context),
+        }),
     };
 };
 const serializeAws_json1_1UpdateResolverRuleRequest = (input, context) => {
@@ -4738,6 +4774,7 @@ const deserializeAws_json1_1IpAddressResponse = (output, context) => {
         CreationTime: (0, smithy_client_1.expectString)(output.CreationTime),
         Ip: (0, smithy_client_1.expectString)(output.Ip),
         IpId: (0, smithy_client_1.expectString)(output.IpId),
+        Ipv6: (0, smithy_client_1.expectString)(output.Ipv6),
         ModificationTime: (0, smithy_client_1.expectString)(output.ModificationTime),
         Status: (0, smithy_client_1.expectString)(output.Status),
         StatusMessage: (0, smithy_client_1.expectString)(output.StatusMessage),
@@ -4932,6 +4969,7 @@ const deserializeAws_json1_1ResolverEndpoint = (output, context) => {
         IpAddressCount: (0, smithy_client_1.expectInt32)(output.IpAddressCount),
         ModificationTime: (0, smithy_client_1.expectString)(output.ModificationTime),
         Name: (0, smithy_client_1.expectString)(output.Name),
+        ResolverEndpointType: (0, smithy_client_1.expectString)(output.ResolverEndpointType),
         SecurityGroupIds: output.SecurityGroupIds != null
             ? deserializeAws_json1_1SecurityGroupIds(output.SecurityGroupIds, context)
             : undefined,
@@ -5105,6 +5143,7 @@ const deserializeAws_json1_1TagResourceResponse = (output, context) => {
 const deserializeAws_json1_1TargetAddress = (output, context) => {
     return {
         Ip: (0, smithy_client_1.expectString)(output.Ip),
+        Ipv6: (0, smithy_client_1.expectString)(output.Ipv6),
         Port: (0, smithy_client_1.expectInt32)(output.Port),
     };
 };

package/dist-es/endpoint/ruleset.js

@@ -1,4 +1,4 @@
-const p = "required", q = "fn", r = "argv", s = "ref";
-const a = "PartitionResult", b = "tree", c = "error", d = "endpoint", e = { [p]: false, "type": "String" }, f = { [p]: true, "default": false, "type": "Boolean" }, g = { [s]: "Endpoint" }, h = { [q]: "booleanEquals", [r]: [{ [s]: "UseFIPS" }, true] }, i = { [q]: "booleanEquals", [r]: [{ [s]: "UseDualStack" }, true] }, j = {}, k = { [q]: "booleanEquals", [r]: [true, { [q]: "getAttr", [r]: [{ [s]: a }, "supportsFIPS"] }] }, l = { [q]: "booleanEquals", [r]: [true, { [q]: "getAttr", [r]: [{ [s]: a }, "supportsDualStack"] }] }, m = [g], n = [h], o = [i];
-const _data = { version: "1.0", parameters: { Region: e, UseDualStack: f, UseFIPS: f, Endpoint: e }, rules: [{ conditions: [{ [q]: "aws.partition", [r]: [{ [s]: "Region" }], assign: a }], type: b, rules: [{ conditions: [{ [q]: "isSet", [r]: m }, { [q]: "parseURL", [r]: m, assign: "url" }], type: b, rules: [{ conditions: n, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: o, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: g, properties: j, headers: j }, type: d }] }] }, { conditions: [h, i], type: b, rules: [{ conditions: [k, l], type: b, rules: [{ endpoint: { url: "https://route53resolver-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: j, headers: j }, type: d }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: n, type: b, rules: [{ conditions: [k], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://route53resolver-fips.{Region}.{PartitionResult#dnsSuffix}", properties: j, headers: j }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: o, type: b, rules: [{ conditions: [l], type: b, rules: [{ endpoint: { url: "https://route53resolver.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: j, headers: j }, type: d }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { endpoint: { url: "https://route53resolver.{Region}.{PartitionResult#dnsSuffix}", properties: j, headers: j }, type: d }] }] };
+const q = "required", r = "fn", s = "argv", t = "ref";
+const a = "isSet", b = "tree", c = "error", d = "endpoint", e = "PartitionResult", f = { [q]: false, "type": "String" }, g = { [q]: true, "default": false, "type": "Boolean" }, h = { [t]: "Endpoint" }, i = { [r]: "booleanEquals", [s]: [{ [t]: "UseFIPS" }, true] }, j = { [r]: "booleanEquals", [s]: [{ [t]: "UseDualStack" }, true] }, k = {}, l = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsFIPS"] }] }, m = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsDualStack"] }] }, n = [i], o = [j], p = [{ [t]: "Region" }];
+const _data = { version: "1.0", parameters: { Region: f, UseDualStack: g, UseFIPS: g, Endpoint: f }, rules: [{ conditions: [{ [r]: a, [s]: [h] }], type: b, rules: [{ conditions: n, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: o, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: h, properties: k, headers: k }, type: d }] }] }, { type: b, rules: [{ conditions: [{ [r]: a, [s]: p }], type: b, rules: [{ conditions: [{ [r]: "aws.partition", [s]: p, assign: e }], type: b, rules: [{ conditions: [i, j], type: b, rules: [{ conditions: [l, m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://route53resolver-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: n, type: b, rules: [{ conditions: [l], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://route53resolver-fips.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: o, type: b, rules: [{ conditions: [m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://route53resolver.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { type: b, rules: [{ endpoint: { url: "https://route53resolver.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }] }, { error: "Invalid Configuration: Missing Region", type: c }] }] };
 export const ruleSet = _data;

package/dist-es/models/models_0.js

@@ -114,6 +114,12 @@ export var ResolverEndpointDirection;
     ResolverEndpointDirection["Inbound"] = "INBOUND";
     ResolverEndpointDirection["Outbound"] = "OUTBOUND";
 })(ResolverEndpointDirection || (ResolverEndpointDirection = {}));
+export var ResolverEndpointType;
+(function (ResolverEndpointType) {
+    ResolverEndpointType["DUALSTACK"] = "DUALSTACK";
+    ResolverEndpointType["IPV4"] = "IPV4";
+    ResolverEndpointType["IPV6"] = "IPV6";
+})(ResolverEndpointType || (ResolverEndpointType = {}));
 export var ResolverEndpointStatus;
 (function (ResolverEndpointStatus) {
     ResolverEndpointStatus["ActionNeeded"] = "ACTION_NEEDED";
@@ -205,6 +211,7 @@ export var AutodefinedReverseFlag;
 (function (AutodefinedReverseFlag) {
     AutodefinedReverseFlag["DISABLE"] = "DISABLE";
     AutodefinedReverseFlag["ENABLE"] = "ENABLE";
+    AutodefinedReverseFlag["USE_LOCAL_RESOURCE_SETTING"] = "USE_LOCAL_RESOURCE_SETTING";
 })(AutodefinedReverseFlag || (AutodefinedReverseFlag = {}));
 export var BlockOverrideDnsType;
 (function (BlockOverrideDnsType) {
@@ -274,6 +281,7 @@ export var FirewallFailOpenStatus;
 (function (FirewallFailOpenStatus) {
     FirewallFailOpenStatus["DISABLED"] = "DISABLED";
     FirewallFailOpenStatus["ENABLED"] = "ENABLED";
+    FirewallFailOpenStatus["USE_LOCAL_RESOURCE_SETTING"] = "USE_LOCAL_RESOURCE_SETTING";
 })(FirewallFailOpenStatus || (FirewallFailOpenStatus = {}));
 export var FirewallDomainImportOperation;
 (function (FirewallDomainImportOperation) {
@@ -291,6 +299,8 @@ export var ResolverAutodefinedReverseStatus;
     ResolverAutodefinedReverseStatus["Disabling"] = "DISABLING";
     ResolverAutodefinedReverseStatus["Enabled"] = "ENABLED";
     ResolverAutodefinedReverseStatus["Enabling"] = "ENABLING";
+    ResolverAutodefinedReverseStatus["UpdatingToUseLocalResourceSetting"] = "UPDATING_TO_USE_LOCAL_RESOURCE_SETTING";
+    ResolverAutodefinedReverseStatus["UseLocalResourceSetting"] = "USE_LOCAL_RESOURCE_SETTING";
 })(ResolverAutodefinedReverseStatus || (ResolverAutodefinedReverseStatus = {}));
 export var ResolverDNSSECValidationStatus;
 (function (ResolverDNSSECValidationStatus) {
@@ -298,6 +308,8 @@ export var ResolverDNSSECValidationStatus;
     ResolverDNSSECValidationStatus["Disabling"] = "DISABLING";
     ResolverDNSSECValidationStatus["Enabled"] = "ENABLED";
     ResolverDNSSECValidationStatus["Enabling"] = "ENABLING";
+    ResolverDNSSECValidationStatus["UpdateToUseLocalResourceSetting"] = "UPDATING_TO_USE_LOCAL_RESOURCE_SETTING";
+    ResolverDNSSECValidationStatus["UseLocalResourceSetting"] = "USE_LOCAL_RESOURCE_SETTING";
 })(ResolverDNSSECValidationStatus || (ResolverDNSSECValidationStatus = {}));
 export class UnknownResourceException extends __BaseException {
     constructor(opts) {
@@ -363,6 +375,7 @@ export var IpAddressStatus;
     IpAddressStatus["FailedResourceGone"] = "FAILED_RESOURCE_GONE";
     IpAddressStatus["RemapAttaching"] = "REMAP_ATTACHING";
     IpAddressStatus["RemapDetaching"] = "REMAP_DETACHING";
+    IpAddressStatus["Updating"] = "UPDATING";
 })(IpAddressStatus || (IpAddressStatus = {}));
 export var SortOrder;
 (function (SortOrder) {
@@ -373,6 +386,7 @@ export var Validation;
 (function (Validation) {
     Validation["DISABLE"] = "DISABLE";
     Validation["ENABLE"] = "ENABLE";
+    Validation["USE_LOCAL_RESOURCE_SETTING"] = "USE_LOCAL_RESOURCE_SETTING";
 })(Validation || (Validation = {}));
 export const TagFilterSensitiveLog = (obj) => ({
     ...obj,
@@ -803,6 +817,9 @@ export const UpdateResolverDnssecConfigRequestFilterSensitiveLog = (obj) => ({
 export const UpdateResolverDnssecConfigResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const UpdateIpAddressFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const UpdateResolverEndpointRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });

package/dist-es/pagination/ListFirewallConfigsPaginator.js

@@ -1,12 +1,8 @@
 import { ListFirewallConfigsCommand, } from "../commands/ListFirewallConfigsCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListFirewallConfigsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listFirewallConfigs(input, ...args);
-};
 export async function* paginateListFirewallConfigs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListFirewallConfigs(config, input, ...additionalA
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListFirewallDomainListsPaginator.js

@@ -1,12 +1,8 @@
 import { ListFirewallDomainListsCommand, } from "../commands/ListFirewallDomainListsCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListFirewallDomainListsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listFirewallDomainLists(input, ...args);
-};
 export async function* paginateListFirewallDomainLists(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListFirewallDomainLists(config, input, ...additio
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListFirewallDomainsPaginator.js

@@ -1,12 +1,8 @@
 import { ListFirewallDomainsCommand, } from "../commands/ListFirewallDomainsCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListFirewallDomainsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listFirewallDomains(input, ...args);
-};
 export async function* paginateListFirewallDomains(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListFirewallDomains(config, input, ...additionalA
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListFirewallRuleGroupAssociationsPaginator.js

@@ -1,12 +1,8 @@
 import { ListFirewallRuleGroupAssociationsCommand, } from "../commands/ListFirewallRuleGroupAssociationsCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListFirewallRuleGroupAssociationsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listFirewallRuleGroupAssociations(input, ...args);
-};
 export async function* paginateListFirewallRuleGroupAssociations(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListFirewallRuleGroupAssociations(config, input,
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListFirewallRuleGroupsPaginator.js

@@ -1,12 +1,8 @@
 import { ListFirewallRuleGroupsCommand, } from "../commands/ListFirewallRuleGroupsCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListFirewallRuleGroupsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listFirewallRuleGroups(input, ...args);
-};
 export async function* paginateListFirewallRuleGroups(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListFirewallRuleGroups(config, input, ...addition
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListFirewallRulesPaginator.js

@@ -1,12 +1,8 @@
 import { ListFirewallRulesCommand, } from "../commands/ListFirewallRulesCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListFirewallRulesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listFirewallRules(input, ...args);
-};
 export async function* paginateListFirewallRules(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListFirewallRules(config, input, ...additionalArg
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListResolverConfigsPaginator.js

@@ -1,12 +1,8 @@
 import { ListResolverConfigsCommand, } from "../commands/ListResolverConfigsCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListResolverConfigsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listResolverConfigs(input, ...args);
-};
 export async function* paginateListResolverConfigs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListResolverConfigs(config, input, ...additionalA
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListResolverDnssecConfigsPaginator.js

@@ -1,12 +1,8 @@
 import { ListResolverDnssecConfigsCommand, } from "../commands/ListResolverDnssecConfigsCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListResolverDnssecConfigsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listResolverDnssecConfigs(input, ...args);
-};
 export async function* paginateListResolverDnssecConfigs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListResolverDnssecConfigs(config, input, ...addit
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListResolverEndpointIpAddressesPaginator.js

@@ -1,12 +1,8 @@
 import { ListResolverEndpointIpAddressesCommand, } from "../commands/ListResolverEndpointIpAddressesCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListResolverEndpointIpAddressesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listResolverEndpointIpAddresses(input, ...args);
-};
 export async function* paginateListResolverEndpointIpAddresses(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListResolverEndpointIpAddresses(config, input, ..
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListResolverEndpointsPaginator.js

@@ -1,12 +1,8 @@
 import { ListResolverEndpointsCommand, } from "../commands/ListResolverEndpointsCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListResolverEndpointsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listResolverEndpoints(input, ...args);
-};
 export async function* paginateListResolverEndpoints(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListResolverEndpoints(config, input, ...additiona
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListResolverQueryLogConfigAssociationsPaginator.js

@@ -1,12 +1,8 @@
 import { ListResolverQueryLogConfigAssociationsCommand, } from "../commands/ListResolverQueryLogConfigAssociationsCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListResolverQueryLogConfigAssociationsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listResolverQueryLogConfigAssociations(input, ...args);
-};
 export async function* paginateListResolverQueryLogConfigAssociations(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListResolverQueryLogConfigAssociations(config, in
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListResolverQueryLogConfigsPaginator.js

@@ -1,12 +1,8 @@
 import { ListResolverQueryLogConfigsCommand, } from "../commands/ListResolverQueryLogConfigsCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListResolverQueryLogConfigsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listResolverQueryLogConfigs(input, ...args);
-};
 export async function* paginateListResolverQueryLogConfigs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListResolverQueryLogConfigs(config, input, ...add
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListResolverRuleAssociationsPaginator.js

@@ -1,12 +1,8 @@
 import { ListResolverRuleAssociationsCommand, } from "../commands/ListResolverRuleAssociationsCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListResolverRuleAssociationsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listResolverRuleAssociations(input, ...args);
-};
 export async function* paginateListResolverRuleAssociations(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListResolverRuleAssociations(config, input, ...ad
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListResolverRulesPaginator.js

@@ -1,12 +1,8 @@
 import { ListResolverRulesCommand, } from "../commands/ListResolverRulesCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListResolverRulesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listResolverRules(input, ...args);
-};
 export async function* paginateListResolverRules(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListResolverRules(config, input, ...additionalArg
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListTagsForResourcePaginator.js

@@ -1,12 +1,8 @@
 import { ListTagsForResourceCommand, } from "../commands/ListTagsForResourceCommand";
-import { Route53Resolver } from "../Route53Resolver";
 import { Route53ResolverClient } from "../Route53ResolverClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListTagsForResourceCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listTagsForResource(input, ...args);
-};
 export async function* paginateListTagsForResource(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListTagsForResource(config, input, ...additionalA
     while (hasNext) {
         input.NextToken = token;
         input["MaxResults"] = config.pageSize;
-        if (config.client instanceof Route53Resolver) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof Route53ResolverClient) {
+        if (config.client instanceof Route53ResolverClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {