@aws-sdk/client-proton 3.282.0 → 3.287.0

package/dist-cjs/pagination/ListComponentOutputsPaginator.js

@@ -2,24 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListComponentOutputs = void 0;
 const ListComponentOutputsCommand_1 = require("../commands/ListComponentOutputsCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListComponentOutputsCommand_1.ListComponentOutputsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listComponentOutputs(input, ...args);
-};
 async function* paginateListComponentOutputs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListComponentProvisionedResourcesPaginator.js

@@ -2,24 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListComponentProvisionedResources = void 0;
 const ListComponentProvisionedResourcesCommand_1 = require("../commands/ListComponentProvisionedResourcesCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListComponentProvisionedResourcesCommand_1.ListComponentProvisionedResourcesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listComponentProvisionedResources(input, ...args);
-};
 async function* paginateListComponentProvisionedResources(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListComponentsPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListComponents = void 0;
 const ListComponentsCommand_1 = require("../commands/ListComponentsCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListComponentsCommand_1.ListComponentsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listComponents(input, ...args);
-};
 async function* paginateListComponents(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateListComponents(config, input, ...additionalArguments) {
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListEnvironmentAccountConnectionsPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListEnvironmentAccountConnections = void 0;
 const ListEnvironmentAccountConnectionsCommand_1 = require("../commands/ListEnvironmentAccountConnectionsCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListEnvironmentAccountConnectionsCommand_1.ListEnvironmentAccountConnectionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listEnvironmentAccountConnections(input, ...args);
-};
 async function* paginateListEnvironmentAccountConnections(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateListEnvironmentAccountConnections(config, input, ...addi
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListEnvironmentOutputsPaginator.js

@@ -2,24 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListEnvironmentOutputs = void 0;
 const ListEnvironmentOutputsCommand_1 = require("../commands/ListEnvironmentOutputsCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListEnvironmentOutputsCommand_1.ListEnvironmentOutputsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listEnvironmentOutputs(input, ...args);
-};
 async function* paginateListEnvironmentOutputs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListEnvironmentProvisionedResourcesPaginator.js

@@ -2,24 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListEnvironmentProvisionedResources = void 0;
 const ListEnvironmentProvisionedResourcesCommand_1 = require("../commands/ListEnvironmentProvisionedResourcesCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListEnvironmentProvisionedResourcesCommand_1.ListEnvironmentProvisionedResourcesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listEnvironmentProvisionedResources(input, ...args);
-};
 async function* paginateListEnvironmentProvisionedResources(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListEnvironmentTemplateVersionsPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListEnvironmentTemplateVersions = void 0;
 const ListEnvironmentTemplateVersionsCommand_1 = require("../commands/ListEnvironmentTemplateVersionsCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListEnvironmentTemplateVersionsCommand_1.ListEnvironmentTemplateVersionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listEnvironmentTemplateVersions(input, ...args);
-};
 async function* paginateListEnvironmentTemplateVersions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateListEnvironmentTemplateVersions(config, input, ...additi
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListEnvironmentTemplatesPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListEnvironmentTemplates = void 0;
 const ListEnvironmentTemplatesCommand_1 = require("../commands/ListEnvironmentTemplatesCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListEnvironmentTemplatesCommand_1.ListEnvironmentTemplatesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listEnvironmentTemplates(input, ...args);
-};
 async function* paginateListEnvironmentTemplates(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateListEnvironmentTemplates(config, input, ...additionalArg
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListEnvironmentsPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListEnvironments = void 0;
 const ListEnvironmentsCommand_1 = require("../commands/ListEnvironmentsCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListEnvironmentsCommand_1.ListEnvironmentsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listEnvironments(input, ...args);
-};
 async function* paginateListEnvironments(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateListEnvironments(config, input, ...additionalArguments)
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListRepositoriesPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListRepositories = void 0;
 const ListRepositoriesCommand_1 = require("../commands/ListRepositoriesCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListRepositoriesCommand_1.ListRepositoriesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listRepositories(input, ...args);
-};
 async function* paginateListRepositories(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateListRepositories(config, input, ...additionalArguments)
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListRepositorySyncDefinitionsPaginator.js

@@ -2,24 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListRepositorySyncDefinitions = void 0;
 const ListRepositorySyncDefinitionsCommand_1 = require("../commands/ListRepositorySyncDefinitionsCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListRepositorySyncDefinitionsCommand_1.ListRepositorySyncDefinitionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listRepositorySyncDefinitions(input, ...args);
-};
 async function* paginateListRepositorySyncDefinitions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListServiceInstanceOutputsPaginator.js

@@ -2,24 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListServiceInstanceOutputs = void 0;
 const ListServiceInstanceOutputsCommand_1 = require("../commands/ListServiceInstanceOutputsCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServiceInstanceOutputsCommand_1.ListServiceInstanceOutputsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServiceInstanceOutputs(input, ...args);
-};
 async function* paginateListServiceInstanceOutputs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListServiceInstanceProvisionedResourcesPaginator.js

@@ -2,24 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListServiceInstanceProvisionedResources = void 0;
 const ListServiceInstanceProvisionedResourcesCommand_1 = require("../commands/ListServiceInstanceProvisionedResourcesCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServiceInstanceProvisionedResourcesCommand_1.ListServiceInstanceProvisionedResourcesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServiceInstanceProvisionedResources(input, ...args);
-};
 async function* paginateListServiceInstanceProvisionedResources(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListServiceInstancesPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListServiceInstances = void 0;
 const ListServiceInstancesCommand_1 = require("../commands/ListServiceInstancesCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServiceInstancesCommand_1.ListServiceInstancesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServiceInstances(input, ...args);
-};
 async function* paginateListServiceInstances(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateListServiceInstances(config, input, ...additionalArgumen
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListServicePipelineOutputsPaginator.js

@@ -2,24 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListServicePipelineOutputs = void 0;
 const ListServicePipelineOutputsCommand_1 = require("../commands/ListServicePipelineOutputsCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServicePipelineOutputsCommand_1.ListServicePipelineOutputsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServicePipelineOutputs(input, ...args);
-};
 async function* paginateListServicePipelineOutputs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListServicePipelineProvisionedResourcesPaginator.js

@@ -2,24 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListServicePipelineProvisionedResources = void 0;
 const ListServicePipelineProvisionedResourcesCommand_1 = require("../commands/ListServicePipelineProvisionedResourcesCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServicePipelineProvisionedResourcesCommand_1.ListServicePipelineProvisionedResourcesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServicePipelineProvisionedResources(input, ...args);
-};
 async function* paginateListServicePipelineProvisionedResources(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListServiceTemplateVersionsPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListServiceTemplateVersions = void 0;
 const ListServiceTemplateVersionsCommand_1 = require("../commands/ListServiceTemplateVersionsCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServiceTemplateVersionsCommand_1.ListServiceTemplateVersionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServiceTemplateVersions(input, ...args);
-};
 async function* paginateListServiceTemplateVersions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateListServiceTemplateVersions(config, input, ...additional
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListServiceTemplatesPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListServiceTemplates = void 0;
 const ListServiceTemplatesCommand_1 = require("../commands/ListServiceTemplatesCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServiceTemplatesCommand_1.ListServiceTemplatesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServiceTemplates(input, ...args);
-};
 async function* paginateListServiceTemplates(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateListServiceTemplates(config, input, ...additionalArgumen
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListServicesPaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListServices = void 0;
 const ListServicesCommand_1 = require("../commands/ListServicesCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServicesCommand_1.ListServicesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServices(input, ...args);
-};
 async function* paginateListServices(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateListServices(config, input, ...additionalArguments) {
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-cjs/pagination/ListTagsForResourcePaginator.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListTagsForResource = void 0;
 const ListTagsForResourceCommand_1 = require("../commands/ListTagsForResourceCommand");
-const Proton_1 = require("../Proton");
 const ProtonClient_1 = require("../ProtonClient");
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListTagsForResourceCommand_1.ListTagsForResourceCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listTagsForResource(input, ...args);
-};
 async function* paginateListTagsForResource(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -17,10 +13,7 @@ async function* paginateListTagsForResource(config, input, ...additionalArgument
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton_1.Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient_1.ProtonClient) {
+        if (config.client instanceof ProtonClient_1.ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListComponentOutputsPaginator.js

@@ -1,22 +1,15 @@
 import { ListComponentOutputsCommand, } from "../commands/ListComponentOutputsCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListComponentOutputsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listComponentOutputs(input, ...args);
-};
 export async function* paginateListComponentOutputs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListComponentProvisionedResourcesPaginator.js

@@ -1,22 +1,15 @@
 import { ListComponentProvisionedResourcesCommand, } from "../commands/ListComponentProvisionedResourcesCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListComponentProvisionedResourcesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listComponentProvisionedResources(input, ...args);
-};
 export async function* paginateListComponentProvisionedResources(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListComponentsPaginator.js

@@ -1,12 +1,8 @@
 import { ListComponentsCommand, } from "../commands/ListComponentsCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListComponentsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listComponents(input, ...args);
-};
 export async function* paginateListComponents(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListComponents(config, input, ...additionalArgume
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListEnvironmentAccountConnectionsPaginator.js

@@ -1,12 +1,8 @@
 import { ListEnvironmentAccountConnectionsCommand, } from "../commands/ListEnvironmentAccountConnectionsCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListEnvironmentAccountConnectionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listEnvironmentAccountConnections(input, ...args);
-};
 export async function* paginateListEnvironmentAccountConnections(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListEnvironmentAccountConnections(config, input,
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListEnvironmentOutputsPaginator.js

@@ -1,22 +1,15 @@
 import { ListEnvironmentOutputsCommand, } from "../commands/ListEnvironmentOutputsCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListEnvironmentOutputsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listEnvironmentOutputs(input, ...args);
-};
 export async function* paginateListEnvironmentOutputs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListEnvironmentProvisionedResourcesPaginator.js

@@ -1,22 +1,15 @@
 import { ListEnvironmentProvisionedResourcesCommand, } from "../commands/ListEnvironmentProvisionedResourcesCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListEnvironmentProvisionedResourcesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listEnvironmentProvisionedResources(input, ...args);
-};
 export async function* paginateListEnvironmentProvisionedResources(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListEnvironmentTemplateVersionsPaginator.js

@@ -1,12 +1,8 @@
 import { ListEnvironmentTemplateVersionsCommand, } from "../commands/ListEnvironmentTemplateVersionsCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListEnvironmentTemplateVersionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listEnvironmentTemplateVersions(input, ...args);
-};
 export async function* paginateListEnvironmentTemplateVersions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListEnvironmentTemplateVersions(config, input, ..
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListEnvironmentTemplatesPaginator.js

@@ -1,12 +1,8 @@
 import { ListEnvironmentTemplatesCommand, } from "../commands/ListEnvironmentTemplatesCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListEnvironmentTemplatesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listEnvironmentTemplates(input, ...args);
-};
 export async function* paginateListEnvironmentTemplates(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListEnvironmentTemplates(config, input, ...additi
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListEnvironmentsPaginator.js

@@ -1,12 +1,8 @@
 import { ListEnvironmentsCommand, } from "../commands/ListEnvironmentsCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListEnvironmentsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listEnvironments(input, ...args);
-};
 export async function* paginateListEnvironments(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListEnvironments(config, input, ...additionalArgu
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListRepositoriesPaginator.js

@@ -1,12 +1,8 @@
 import { ListRepositoriesCommand, } from "../commands/ListRepositoriesCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListRepositoriesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listRepositories(input, ...args);
-};
 export async function* paginateListRepositories(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListRepositories(config, input, ...additionalArgu
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListRepositorySyncDefinitionsPaginator.js

@@ -1,22 +1,15 @@
 import { ListRepositorySyncDefinitionsCommand, } from "../commands/ListRepositorySyncDefinitionsCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListRepositorySyncDefinitionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listRepositorySyncDefinitions(input, ...args);
-};
 export async function* paginateListRepositorySyncDefinitions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListServiceInstanceOutputsPaginator.js

@@ -1,22 +1,15 @@
 import { ListServiceInstanceOutputsCommand, } from "../commands/ListServiceInstanceOutputsCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServiceInstanceOutputsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServiceInstanceOutputs(input, ...args);
-};
 export async function* paginateListServiceInstanceOutputs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListServiceInstanceProvisionedResourcesPaginator.js

@@ -1,22 +1,15 @@
 import { ListServiceInstanceProvisionedResourcesCommand, } from "../commands/ListServiceInstanceProvisionedResourcesCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServiceInstanceProvisionedResourcesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServiceInstanceProvisionedResources(input, ...args);
-};
 export async function* paginateListServiceInstanceProvisionedResources(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListServiceInstancesPaginator.js

@@ -1,12 +1,8 @@
 import { ListServiceInstancesCommand, } from "../commands/ListServiceInstancesCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServiceInstancesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServiceInstances(input, ...args);
-};
 export async function* paginateListServiceInstances(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListServiceInstances(config, input, ...additional
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListServicePipelineOutputsPaginator.js

@@ -1,22 +1,15 @@
 import { ListServicePipelineOutputsCommand, } from "../commands/ListServicePipelineOutputsCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServicePipelineOutputsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServicePipelineOutputs(input, ...args);
-};
 export async function* paginateListServicePipelineOutputs(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListServicePipelineProvisionedResourcesPaginator.js

@@ -1,22 +1,15 @@
 import { ListServicePipelineProvisionedResourcesCommand, } from "../commands/ListServicePipelineProvisionedResourcesCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServicePipelineProvisionedResourcesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServicePipelineProvisionedResources(input, ...args);
-};
 export async function* paginateListServicePipelineProvisionedResources(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListServiceTemplateVersionsPaginator.js

@@ -1,12 +1,8 @@
 import { ListServiceTemplateVersionsCommand, } from "../commands/ListServiceTemplateVersionsCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServiceTemplateVersionsCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServiceTemplateVersions(input, ...args);
-};
 export async function* paginateListServiceTemplateVersions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListServiceTemplateVersions(config, input, ...add
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListServiceTemplatesPaginator.js

@@ -1,12 +1,8 @@
 import { ListServiceTemplatesCommand, } from "../commands/ListServiceTemplatesCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServiceTemplatesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServiceTemplates(input, ...args);
-};
 export async function* paginateListServiceTemplates(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListServiceTemplates(config, input, ...additional
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListServicesPaginator.js

@@ -1,12 +1,8 @@
 import { ListServicesCommand, } from "../commands/ListServicesCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListServicesCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listServices(input, ...args);
-};
 export async function* paginateListServices(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListServices(config, input, ...additionalArgument
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }
         else {

package/dist-es/pagination/ListTagsForResourcePaginator.js

@@ -1,12 +1,8 @@
 import { ListTagsForResourceCommand, } from "../commands/ListTagsForResourceCommand";
-import { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 const makePagedClientRequest = async (client, input, ...args) => {
     return await client.send(new ListTagsForResourceCommand(input), ...args);
 };
-const makePagedRequest = async (client, input, ...args) => {
-    return await client.listTagsForResource(input, ...args);
-};
 export async function* paginateListTagsForResource(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
@@ -14,10 +10,7 @@ export async function* paginateListTagsForResource(config, input, ...additionalA
     while (hasNext) {
         input.nextToken = token;
         input["maxResults"] = config.pageSize;
-        if (config.client instanceof Proton) {
-            page = await makePagedRequest(config.client, input, ...additionalArguments);
-        }
-        else if (config.client instanceof ProtonClient) {
+        if (config.client instanceof ProtonClient) {
             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 { Proton } from "../Proton";
 import { ProtonClient } from "../ProtonClient";
 export interface ProtonPaginationConfiguration extends PaginationConfiguration {
-    client: Proton | ProtonClient;
+    client: ProtonClient;
 }

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

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-proton",
   "description": "AWS SDK for JavaScript Proton Client for Node.js, Browser and React Native",
-  "version": "3.282.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,23 +20,23 @@
   "dependencies": {
     "@aws-crypto/sha256-browser": "3.0.0",
     "@aws-crypto/sha256-js": "3.0.0",
-    "@aws-sdk/client-sts": "3.282.0",
-    "@aws-sdk/config-resolver": "3.282.0",
-    "@aws-sdk/credential-provider-node": "3.282.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.282.0",
     "@aws-sdk/middleware-endpoint": "3.282.0",
     "@aws-sdk/middleware-host-header": "3.282.0",
-    "@aws-sdk/middleware-logger": "3.272.0",
+    "@aws-sdk/middleware-logger": "3.287.0",
     "@aws-sdk/middleware-recursion-detection": "3.282.0",
-    "@aws-sdk/middleware-retry": "3.282.0",
+    "@aws-sdk/middleware-retry": "3.287.0",
     "@aws-sdk/middleware-serde": "3.272.0",
     "@aws-sdk/middleware-signing": "3.282.0",
     "@aws-sdk/middleware-stack": "3.272.0",
     "@aws-sdk/middleware-user-agent": "3.282.0",
-    "@aws-sdk/node-config-provider": "3.272.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",
@@ -46,11 +46,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.282.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.282.0",
-    "@aws-sdk/util-user-agent-node": "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",
     "tslib": "^2.3.1",