@aws-sdk/client-iam 3.282.0 → 3.287.0

package/dist-cjs/pagination/ListUsersPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListUsers = void 0;
 const ListUsersCommand_1 = require("../commands/ListUsersCommand");
-const IAM_1 = require("../IAM");
 const IAMClient_1 = require("../IAMClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListUsersCommand_1.ListUsersCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listUsers(input, ...args);
-};
 async function* paginateListUsers(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateListUsers(config, input, ...additionalArguments) {
     while (hasNext) {
         input.Marker = token;
         input["MaxItems"] = config.pageSize;
-        if (config.client instanceof IAM_1.IAM) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IAMClient_1.IAMClient) {
+        if (config.client instanceof IAMClient_1.IAMClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListVirtualMFADevicesPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListVirtualMFADevices = void 0;
 const ListVirtualMFADevicesCommand_1 = require("../commands/ListVirtualMFADevicesCommand");
-const IAM_1 = require("../IAM");
 const IAMClient_1 = require("../IAMClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListVirtualMFADevicesCommand_1.ListVirtualMFADevicesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listVirtualMFADevices(input, ...args);
-};
 async function* paginateListVirtualMFADevices(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateListVirtualMFADevices(config, input, ...additionalArgume
     while (hasNext) {
         input.Marker = token;
         input["MaxItems"] = config.pageSize;
-        if (config.client instanceof IAM_1.IAM) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IAMClient_1.IAMClient) {
+        if (config.client instanceof IAMClient_1.IAMClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/SimulateCustomPolicyPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateSimulateCustomPolicy = void 0;
 const SimulateCustomPolicyCommand_1 = require("../commands/SimulateCustomPolicyCommand");
-const IAM_1 = require("../IAM");
 const IAMClient_1 = require("../IAMClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new SimulateCustomPolicyCommand_1.SimulateCustomPolicyCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.simulateCustomPolicy(input, ...args);
-};
 async function* paginateSimulateCustomPolicy(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateSimulateCustomPolicy(config, input, ...additionalArgumen
     while (hasNext) {
         input.Marker = token;
         input["MaxItems"] = config.pageSize;
-        if (config.client instanceof IAM_1.IAM) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IAMClient_1.IAMClient) {
+        if (config.client instanceof IAMClient_1.IAMClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/SimulatePrincipalPolicyPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateSimulatePrincipalPolicy = void 0;
 const SimulatePrincipalPolicyCommand_1 = require("../commands/SimulatePrincipalPolicyCommand");
-const IAM_1 = require("../IAM");
 const IAMClient_1 = require("../IAMClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new SimulatePrincipalPolicyCommand_1.SimulatePrincipalPolicyCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.simulatePrincipalPolicy(input, ...args);
-};
 async function* paginateSimulatePrincipalPolicy(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateSimulatePrincipalPolicy(config, input, ...additionalArgu
     while (hasNext) {
         input.Marker = token;
         input["MaxItems"] = config.pageSize;
-        if (config.client instanceof IAM_1.IAM) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof IAMClient_1.IAMClient) {
+        if (config.client instanceof IAMClient_1.IAMClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/GetAccountAuthorizationDetailsPaginator.js

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

package/dist-es/pagination/GetGroupPaginator.js

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

package/dist-es/pagination/ListAccessKeysPaginator.js

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

package/dist-es/pagination/ListAccountAliasesPaginator.js

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

package/dist-es/pagination/ListAttachedGroupPoliciesPaginator.js

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

package/dist-es/pagination/ListAttachedRolePoliciesPaginator.js

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

package/dist-es/pagination/ListAttachedUserPoliciesPaginator.js

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

package/dist-es/pagination/ListEntitiesForPolicyPaginator.js

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

package/dist-es/pagination/ListGroupPoliciesPaginator.js

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

package/dist-es/pagination/ListGroupsForUserPaginator.js

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

package/dist-es/pagination/ListGroupsPaginator.js

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

package/dist-es/pagination/ListInstanceProfilesForRolePaginator.js

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

package/dist-es/pagination/ListInstanceProfilesPaginator.js

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

package/dist-es/pagination/ListMFADevicesPaginator.js

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

package/dist-es/pagination/ListPoliciesPaginator.js

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

package/dist-es/pagination/ListPolicyVersionsPaginator.js

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

package/dist-es/pagination/ListRolePoliciesPaginator.js

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

package/dist-es/pagination/ListRolesPaginator.js

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

package/dist-es/pagination/ListSSHPublicKeysPaginator.js

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

package/dist-es/pagination/ListServerCertificatesPaginator.js

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

package/dist-es/pagination/ListSigningCertificatesPaginator.js

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