@aws-sdk/client-rds 3.281.0 → 3.287.0

package/dist-es/pagination/DescribeDBParametersPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBParametersCommand, } from "../commands/DescribeDBParametersCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBParametersCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBParameters(input, ...args);
-};
 export async function* paginateDescribeDBParameters(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBParameters(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/DescribeDBProxiesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBProxiesCommand, } from "../commands/DescribeDBProxiesCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBProxiesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBProxies(input, ...args);
-};
 export async function* paginateDescribeDBProxies(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBProxies(config, input, ...additionalArg
     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/DescribeDBProxyEndpointsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBProxyEndpointsCommand, } from "../commands/DescribeDBProxyEndpointsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBProxyEndpointsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBProxyEndpoints(input, ...args);
-};
 export async function* paginateDescribeDBProxyEndpoints(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBProxyEndpoints(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/DescribeDBProxyTargetGroupsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBProxyTargetGroupsCommand, } from "../commands/DescribeDBProxyTargetGroupsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBProxyTargetGroupsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBProxyTargetGroups(input, ...args);
-};
 export async function* paginateDescribeDBProxyTargetGroups(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBProxyTargetGroups(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/DescribeDBProxyTargetsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBProxyTargetsCommand, } from "../commands/DescribeDBProxyTargetsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBProxyTargetsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBProxyTargets(input, ...args);
-};
 export async function* paginateDescribeDBProxyTargets(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBProxyTargets(config, input, ...addition
     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/DescribeDBSecurityGroupsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBSecurityGroupsCommand, } from "../commands/DescribeDBSecurityGroupsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBSecurityGroupsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBSecurityGroups(input, ...args);
-};
 export async function* paginateDescribeDBSecurityGroups(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBSecurityGroups(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/DescribeDBSnapshotsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBSnapshotsCommand, } from "../commands/DescribeDBSnapshotsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBSnapshotsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBSnapshots(input, ...args);
-};
 export async function* paginateDescribeDBSnapshots(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBSnapshots(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/DescribeDBSubnetGroupsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeDBSubnetGroupsCommand, } from "../commands/DescribeDBSubnetGroupsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeDBSubnetGroupsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeDBSubnetGroups(input, ...args);
-};
 export async function* paginateDescribeDBSubnetGroups(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeDBSubnetGroups(config, input, ...addition
     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/DescribeEngineDefaultParametersPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeEngineDefaultParametersCommand, } from "../commands/DescribeEngineDefaultParametersCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeEngineDefaultParametersCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeEngineDefaultParameters(input, ...args);
-};
 export async function* paginateDescribeEngineDefaultParameters(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeEngineDefaultParameters(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/DescribeEventSubscriptionsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeEventSubscriptionsCommand, } from "../commands/DescribeEventSubscriptionsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeEventSubscriptionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeEventSubscriptions(input, ...args);
-};
 export async function* paginateDescribeEventSubscriptions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeEventSubscriptions(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/DescribeEventsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeEventsCommand, } from "../commands/DescribeEventsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeEventsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeEvents(input, ...args);
-};
 export async function* paginateDescribeEvents(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeEvents(config, input, ...additionalArgume
     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/DescribeExportTasksPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeExportTasksCommand, } from "../commands/DescribeExportTasksCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeExportTasksCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeExportTasks(input, ...args);
-};
 export async function* paginateDescribeExportTasks(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeExportTasks(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/DescribeGlobalClustersPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeGlobalClustersCommand, } from "../commands/DescribeGlobalClustersCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeGlobalClustersCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeGlobalClusters(input, ...args);
-};
 export async function* paginateDescribeGlobalClusters(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeGlobalClusters(config, input, ...addition
     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/DescribeOptionGroupOptionsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeOptionGroupOptionsCommand, } from "../commands/DescribeOptionGroupOptionsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeOptionGroupOptionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeOptionGroupOptions(input, ...args);
-};
 export async function* paginateDescribeOptionGroupOptions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeOptionGroupOptions(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/DescribeOptionGroupsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeOptionGroupsCommand, } from "../commands/DescribeOptionGroupsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeOptionGroupsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeOptionGroups(input, ...args);
-};
 export async function* paginateDescribeOptionGroups(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeOptionGroups(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/DescribeOrderableDBInstanceOptionsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeOrderableDBInstanceOptionsCommand, } from "../commands/DescribeOrderableDBInstanceOptionsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeOrderableDBInstanceOptionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeOrderableDBInstanceOptions(input, ...args);
-};
 export async function* paginateDescribeOrderableDBInstanceOptions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeOrderableDBInstanceOptions(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/DescribePendingMaintenanceActionsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribePendingMaintenanceActionsCommand, } from "../commands/DescribePendingMaintenanceActionsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribePendingMaintenanceActionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describePendingMaintenanceActions(input, ...args);
-};
 export async function* paginateDescribePendingMaintenanceActions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribePendingMaintenanceActions(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/DescribeReservedDBInstancesOfferingsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeReservedDBInstancesOfferingsCommand, } from "../commands/DescribeReservedDBInstancesOfferingsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeReservedDBInstancesOfferingsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeReservedDBInstancesOfferings(input, ...args);
-};
 export async function* paginateDescribeReservedDBInstancesOfferings(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeReservedDBInstancesOfferings(config, inpu
     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/DescribeReservedDBInstancesPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeReservedDBInstancesCommand, } from "../commands/DescribeReservedDBInstancesCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeReservedDBInstancesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeReservedDBInstances(input, ...args);
-};
 export async function* paginateDescribeReservedDBInstances(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeReservedDBInstances(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/DescribeSourceRegionsPaginator.js

@@ -1,12 +1,8 @@
 import { DescribeSourceRegionsCommand, } from "../commands/DescribeSourceRegionsCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DescribeSourceRegionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.describeSourceRegions(input, ...args);
-};
 export async function* paginateDescribeSourceRegions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDescribeSourceRegions(config, input, ...additiona
     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/DownloadDBLogFilePortionPaginator.js

@@ -1,12 +1,8 @@
 import { DownloadDBLogFilePortionCommand, } from "../commands/DownloadDBLogFilePortionCommand";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new DownloadDBLogFilePortionCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.downloadDBLogFilePortion(input, ...args);
-};
 export async function* paginateDownloadDBLogFilePortion(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateDownloadDBLogFilePortion(config, input, ...additi
     while (hasNext) {
         input.Marker = token;
         input["NumberOfLines"] = 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-types/pagination/Interfaces.d.ts

@@ -1,6 +1,5 @@
 import { PaginationConfiguration } from "@aws-sdk/types";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 export interface RDSPaginationConfiguration extends PaginationConfiguration {
-    client: RDS | RDSClient;
+    client: RDSClient;
 }

package/dist-types/ts3.4/pagination/Interfaces.d.ts

@@ -1,6 +1,5 @@
 import { PaginationConfiguration } from "@aws-sdk/types";
-import { RDS } from "../RDS";
 import { RDSClient } from "../RDSClient";
 export interface RDSPaginationConfiguration extends PaginationConfiguration {
-  client: RDS | RDSClient;
+  client: RDSClient;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-rds",
   "description": "AWS SDK for JavaScript Rds Client for Node.js, Browser and React Native",
-  "version": "3.281.0",
+  "version": "3.287.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -20,26 +20,26 @@
   "dependencies": {
     "@aws-crypto/sha256-browser": "3.0.0",
     "@aws-crypto/sha256-js": "3.0.0",
-    "@aws-sdk/client-sts": "3.281.0",
-    "@aws-sdk/config-resolver": "3.272.0",
-    "@aws-sdk/credential-provider-node": "3.281.0",
-    "@aws-sdk/fetch-http-handler": "3.272.0",
+    "@aws-sdk/client-sts": "3.287.0",
+    "@aws-sdk/config-resolver": "3.287.0",
+    "@aws-sdk/credential-provider-node": "3.287.0",
+    "@aws-sdk/fetch-http-handler": "3.282.0",
     "@aws-sdk/hash-node": "3.272.0",
     "@aws-sdk/invalid-dependency": "3.272.0",
-    "@aws-sdk/middleware-content-length": "3.272.0",
-    "@aws-sdk/middleware-endpoint": "3.272.0",
-    "@aws-sdk/middleware-host-header": "3.278.0",
-    "@aws-sdk/middleware-logger": "3.272.0",
-    "@aws-sdk/middleware-recursion-detection": "3.272.0",
-    "@aws-sdk/middleware-retry": "3.272.0",
-    "@aws-sdk/middleware-sdk-rds": "3.272.0",
+    "@aws-sdk/middleware-content-length": "3.282.0",
+    "@aws-sdk/middleware-endpoint": "3.282.0",
+    "@aws-sdk/middleware-host-header": "3.282.0",
+    "@aws-sdk/middleware-logger": "3.287.0",
+    "@aws-sdk/middleware-recursion-detection": "3.282.0",
+    "@aws-sdk/middleware-retry": "3.287.0",
+    "@aws-sdk/middleware-sdk-rds": "3.282.0",
     "@aws-sdk/middleware-serde": "3.272.0",
-    "@aws-sdk/middleware-signing": "3.272.0",
+    "@aws-sdk/middleware-signing": "3.282.0",
     "@aws-sdk/middleware-stack": "3.272.0",
-    "@aws-sdk/middleware-user-agent": "3.272.0",
-    "@aws-sdk/node-config-provider": "3.272.0",
-    "@aws-sdk/node-http-handler": "3.272.0",
-    "@aws-sdk/protocol-http": "3.272.0",
+    "@aws-sdk/middleware-user-agent": "3.282.0",
+    "@aws-sdk/node-config-provider": "3.287.0",
+    "@aws-sdk/node-http-handler": "3.282.0",
+    "@aws-sdk/protocol-http": "3.282.0",
     "@aws-sdk/smithy-client": "3.279.0",
     "@aws-sdk/types": "3.272.0",
     "@aws-sdk/url-parser": "3.272.0",
@@ -47,11 +47,11 @@
     "@aws-sdk/util-body-length-browser": "3.188.0",
     "@aws-sdk/util-body-length-node": "3.208.0",
     "@aws-sdk/util-defaults-mode-browser": "3.279.0",
-    "@aws-sdk/util-defaults-mode-node": "3.279.0",
+    "@aws-sdk/util-defaults-mode-node": "3.287.0",
     "@aws-sdk/util-endpoints": "3.272.0",
     "@aws-sdk/util-retry": "3.272.0",
-    "@aws-sdk/util-user-agent-browser": "3.272.0",
-    "@aws-sdk/util-user-agent-node": "3.272.0",
+    "@aws-sdk/util-user-agent-browser": "3.282.0",
+    "@aws-sdk/util-user-agent-node": "3.287.0",
     "@aws-sdk/util-utf8": "3.254.0",
     "@aws-sdk/util-waiter": "3.272.0",
     "fast-xml-parser": "4.1.2",