@aws-sdk/client-rds 3.282.0 → 3.288.0

package/dist-cjs/pagination/DescribeEventsPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateDescribeEvents = void 0;
 const DescribeEventsCommand_1 = require("../commands/DescribeEventsCommand");
-const RDS_1 = require("../RDS");
 const RDSClient_1 = require("../RDSClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeEventsCommand_1.DescribeEventsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeEvents(input, ...args);
-};
 async function* paginateDescribeEvents(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateDescribeEvents(config, input, ...additionalArguments) {
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS_1.RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient_1.RDSClient) {
+        if (config.client instanceof RDSClient_1.RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/DescribeExportTasksPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateDescribeExportTasks = void 0;
 const DescribeExportTasksCommand_1 = require("../commands/DescribeExportTasksCommand");
-const RDS_1 = require("../RDS");
 const RDSClient_1 = require("../RDSClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeExportTasksCommand_1.DescribeExportTasksCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeExportTasks(input, ...args);
-};
 async function* paginateDescribeExportTasks(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateDescribeExportTasks(config, input, ...additionalArgument
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS_1.RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient_1.RDSClient) {
+        if (config.client instanceof RDSClient_1.RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/DescribeGlobalClustersPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateDescribeGlobalClusters = void 0;
 const DescribeGlobalClustersCommand_1 = require("../commands/DescribeGlobalClustersCommand");
-const RDS_1 = require("../RDS");
 const RDSClient_1 = require("../RDSClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeGlobalClustersCommand_1.DescribeGlobalClustersCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeGlobalClusters(input, ...args);
-};
 async function* paginateDescribeGlobalClusters(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateDescribeGlobalClusters(config, input, ...additionalArgum
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS_1.RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient_1.RDSClient) {
+        if (config.client instanceof RDSClient_1.RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/DescribeOptionGroupOptionsPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateDescribeOptionGroupOptions = void 0;
 const DescribeOptionGroupOptionsCommand_1 = require("../commands/DescribeOptionGroupOptionsCommand");
-const RDS_1 = require("../RDS");
 const RDSClient_1 = require("../RDSClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeOptionGroupOptionsCommand_1.DescribeOptionGroupOptionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeOptionGroupOptions(input, ...args);
-};
 async function* paginateDescribeOptionGroupOptions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateDescribeOptionGroupOptions(config, input, ...additionalA
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS_1.RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient_1.RDSClient) {
+        if (config.client instanceof RDSClient_1.RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/DescribeOptionGroupsPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateDescribeOptionGroups = void 0;
 const DescribeOptionGroupsCommand_1 = require("../commands/DescribeOptionGroupsCommand");
-const RDS_1 = require("../RDS");
 const RDSClient_1 = require("../RDSClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeOptionGroupsCommand_1.DescribeOptionGroupsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeOptionGroups(input, ...args);
-};
 async function* paginateDescribeOptionGroups(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateDescribeOptionGroups(config, input, ...additionalArgumen
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS_1.RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient_1.RDSClient) {
+        if (config.client instanceof RDSClient_1.RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/DescribeOrderableDBInstanceOptionsPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateDescribeOrderableDBInstanceOptions = void 0;
 const DescribeOrderableDBInstanceOptionsCommand_1 = require("../commands/DescribeOrderableDBInstanceOptionsCommand");
-const RDS_1 = require("../RDS");
 const RDSClient_1 = require("../RDSClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeOrderableDBInstanceOptionsCommand_1.DescribeOrderableDBInstanceOptionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeOrderableDBInstanceOptions(input, ...args);
-};
 async function* paginateDescribeOrderableDBInstanceOptions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateDescribeOrderableDBInstanceOptions(config, input, ...add
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS_1.RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient_1.RDSClient) {
+        if (config.client instanceof RDSClient_1.RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/DescribePendingMaintenanceActionsPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateDescribePendingMaintenanceActions = void 0;
 const DescribePendingMaintenanceActionsCommand_1 = require("../commands/DescribePendingMaintenanceActionsCommand");
-const RDS_1 = require("../RDS");
 const RDSClient_1 = require("../RDSClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribePendingMaintenanceActionsCommand_1.DescribePendingMaintenanceActionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describePendingMaintenanceActions(input, ...args);
-};
 async function* paginateDescribePendingMaintenanceActions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateDescribePendingMaintenanceActions(config, input, ...addi
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS_1.RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient_1.RDSClient) {
+        if (config.client instanceof RDSClient_1.RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/DescribeReservedDBInstancesOfferingsPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateDescribeReservedDBInstancesOfferings = void 0;
 const DescribeReservedDBInstancesOfferingsCommand_1 = require("../commands/DescribeReservedDBInstancesOfferingsCommand");
-const RDS_1 = require("../RDS");
 const RDSClient_1 = require("../RDSClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeReservedDBInstancesOfferingsCommand_1.DescribeReservedDBInstancesOfferingsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeReservedDBInstancesOfferings(input, ...args);
-};
 async function* paginateDescribeReservedDBInstancesOfferings(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateDescribeReservedDBInstancesOfferings(config, input, ...a
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS_1.RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient_1.RDSClient) {
+        if (config.client instanceof RDSClient_1.RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/DescribeReservedDBInstancesPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateDescribeReservedDBInstances = void 0;
 const DescribeReservedDBInstancesCommand_1 = require("../commands/DescribeReservedDBInstancesCommand");
-const RDS_1 = require("../RDS");
 const RDSClient_1 = require("../RDSClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeReservedDBInstancesCommand_1.DescribeReservedDBInstancesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeReservedDBInstances(input, ...args);
-};
 async function* paginateDescribeReservedDBInstances(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateDescribeReservedDBInstances(config, input, ...additional
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS_1.RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient_1.RDSClient) {
+        if (config.client instanceof RDSClient_1.RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/DescribeSourceRegionsPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateDescribeSourceRegions = void 0;
 const DescribeSourceRegionsCommand_1 = require("../commands/DescribeSourceRegionsCommand");
-const RDS_1 = require("../RDS");
 const RDSClient_1 = require("../RDSClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeSourceRegionsCommand_1.DescribeSourceRegionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeSourceRegions(input, ...args);
-};
 async function* paginateDescribeSourceRegions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateDescribeSourceRegions(config, input, ...additionalArgume
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS_1.RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient_1.RDSClient) {
+        if (config.client instanceof RDSClient_1.RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/DownloadDBLogFilePortionPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateDownloadDBLogFilePortion = void 0;
 const DownloadDBLogFilePortionCommand_1 = require("../commands/DownloadDBLogFilePortionCommand");
-const RDS_1 = require("../RDS");
 const RDSClient_1 = require("../RDSClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DownloadDBLogFilePortionCommand_1.DownloadDBLogFilePortionCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.downloadDBLogFilePortion(input, ...args);
-};
 async function* paginateDownloadDBLogFilePortion(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateDownloadDBLogFilePortion(config, input, ...additionalArg
     while (hasNext) {
         input.Marker = token;
         input["NumberOfLines"] = config.pageSize;
-        if (config.client instanceof RDS_1.RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient_1.RDSClient) {
+        if (config.client instanceof RDSClient_1.RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeBlueGreenDeploymentsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeBlueGreenDeploymentsCommand, } from "../commands/DescribeBlueGreenDeploymentsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeBlueGreenDeploymentsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeBlueGreenDeployments(input, ...args);
-};
 export async function* paginateDescribeBlueGreenDeployments(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeBlueGreenDeployments(config, input, ...ad
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient) {
+        if (config.client instanceof RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeCertificatesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeCertificatesCommand, } from "../commands/DescribeCertificatesCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeCertificatesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeCertificates(input, ...args);
-};
 export async function* paginateDescribeCertificates(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeCertificates(config, input, ...additional
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient) {
+        if (config.client instanceof RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeDBClusterBacktracksPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBClusterBacktracksCommand, } from "../commands/DescribeDBClusterBacktracksCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBClusterBacktracksCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBClusterBacktracks(input, ...args);
-};
 export async function* paginateDescribeDBClusterBacktracks(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBClusterBacktracks(config, input, ...add
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient) {
+        if (config.client instanceof RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeDBClusterEndpointsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBClusterEndpointsCommand, } from "../commands/DescribeDBClusterEndpointsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBClusterEndpointsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBClusterEndpoints(input, ...args);
-};
 export async function* paginateDescribeDBClusterEndpoints(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBClusterEndpoints(config, input, ...addi
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient) {
+        if (config.client instanceof RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeDBClusterParameterGroupsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBClusterParameterGroupsCommand, } from "../commands/DescribeDBClusterParameterGroupsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBClusterParameterGroupsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBClusterParameterGroups(input, ...args);
-};
 export async function* paginateDescribeDBClusterParameterGroups(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBClusterParameterGroups(config, input, .
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient) {
+        if (config.client instanceof RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeDBClusterParametersPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBClusterParametersCommand, } from "../commands/DescribeDBClusterParametersCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBClusterParametersCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBClusterParameters(input, ...args);
-};
 export async function* paginateDescribeDBClusterParameters(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBClusterParameters(config, input, ...add
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient) {
+        if (config.client instanceof RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeDBClusterSnapshotsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBClusterSnapshotsCommand, } from "../commands/DescribeDBClusterSnapshotsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBClusterSnapshotsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBClusterSnapshots(input, ...args);
-};
 export async function* paginateDescribeDBClusterSnapshots(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBClusterSnapshots(config, input, ...addi
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient) {
+        if (config.client instanceof RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeDBClustersPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBClustersCommand, } from "../commands/DescribeDBClustersCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBClustersCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBClusters(input, ...args);
-};
 export async function* paginateDescribeDBClusters(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBClusters(config, input, ...additionalAr
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient) {
+        if (config.client instanceof RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeDBEngineVersionsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBEngineVersionsCommand, } from "../commands/DescribeDBEngineVersionsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBEngineVersionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBEngineVersions(input, ...args);
-};
 export async function* paginateDescribeDBEngineVersions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBEngineVersions(config, input, ...additi
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient) {
+        if (config.client instanceof RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeDBInstanceAutomatedBackupsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBInstanceAutomatedBackupsCommand, } from "../commands/DescribeDBInstanceAutomatedBackupsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBInstanceAutomatedBackupsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBInstanceAutomatedBackups(input, ...args);
-};
 export async function* paginateDescribeDBInstanceAutomatedBackups(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBInstanceAutomatedBackups(config, input,
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient) {
+        if (config.client instanceof RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeDBInstancesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBInstancesCommand, } from "../commands/DescribeDBInstancesCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBInstancesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBInstances(input, ...args);
-};
 export async function* paginateDescribeDBInstances(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBInstances(config, input, ...additionalA
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient) {
+        if (config.client instanceof RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeDBLogFilesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBLogFilesCommand, } from "../commands/DescribeDBLogFilesCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBLogFilesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBLogFiles(input, ...args);
-};
 export async function* paginateDescribeDBLogFiles(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBLogFiles(config, input, ...additionalAr
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient) {
+        if (config.client instanceof RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/DescribeDBParameterGroupsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBParameterGroupsCommand, } from "../commands/DescribeDBParameterGroupsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBParameterGroupsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBParameterGroups(input, ...args);
-};
 export async function* paginateDescribeDBParameterGroups(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBParameterGroups(config, input, ...addit
     while (hasNext) {
         input.Marker = token;
         input["MaxRecords"] = config.pageSize;
-        if (config.client instanceof RDS) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof RDSClient) {
+        if (config.client instanceof RDSClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {