@aws-sdk/client-proton 3.40.0 → 3.45.0

package/dist-es/models/models_0.js

@@ -42,6 +42,16 @@ export var ValidationException;
 (function (ValidationException) {
     ValidationException.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.message && { message: SENSITIVE_STRING }))); };
 })(ValidationException || (ValidationException = {}));
+export var RepositoryProvider;
+(function (RepositoryProvider) {
+    RepositoryProvider["BITBUCKET"] = "BITBUCKET";
+    RepositoryProvider["GITHUB"] = "GITHUB";
+    RepositoryProvider["GITHUB_ENTERPRISE"] = "GITHUB_ENTERPRISE";
+})(RepositoryProvider || (RepositoryProvider = {}));
+export var RepositoryBranch;
+(function (RepositoryBranch) {
+    RepositoryBranch.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RepositoryBranch || (RepositoryBranch = {}));
 export var AccountSettings;
 (function (AccountSettings) {
     AccountSettings.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -54,6 +64,10 @@ export var GetAccountSettingsOutput;
 (function (GetAccountSettingsOutput) {
     GetAccountSettingsOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetAccountSettingsOutput || (GetAccountSettingsOutput = {}));
+export var RepositoryBranchInput;
+(function (RepositoryBranchInput) {
+    RepositoryBranchInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RepositoryBranchInput || (RepositoryBranchInput = {}));
 export var UpdateAccountSettingsInput;
 (function (UpdateAccountSettingsInput) {
     UpdateAccountSettingsInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -113,6 +127,10 @@ export var CancelServicePipelineDeploymentOutput;
 (function (CancelServicePipelineDeploymentOutput) {
     CancelServicePipelineDeploymentOutput.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.pipeline && { pipeline: ServicePipeline.filterSensitiveLog(obj.pipeline) }))); };
 })(CancelServicePipelineDeploymentOutput || (CancelServicePipelineDeploymentOutput = {}));
+export var Tag;
+(function (Tag) {
+    Tag.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Tag || (Tag = {}));
 export var CreateEnvironmentAccountConnectionInput;
 (function (CreateEnvironmentAccountConnectionInput) {
     CreateEnvironmentAccountConnectionInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -174,10 +192,35 @@ export var UpdateEnvironmentAccountConnectionOutput;
 (function (UpdateEnvironmentAccountConnectionOutput) {
     UpdateEnvironmentAccountConnectionOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(UpdateEnvironmentAccountConnectionOutput || (UpdateEnvironmentAccountConnectionOutput = {}));
-export var Tag;
-(function (Tag) {
-    Tag.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-})(Tag || (Tag = {}));
+export var ListEnvironmentOutputsInput;
+(function (ListEnvironmentOutputsInput) {
+    ListEnvironmentOutputsInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListEnvironmentOutputsInput || (ListEnvironmentOutputsInput = {}));
+export var Output;
+(function (Output) {
+    Output.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Output || (Output = {}));
+export var ListEnvironmentOutputsOutput;
+(function (ListEnvironmentOutputsOutput) {
+    ListEnvironmentOutputsOutput.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.outputs && { outputs: SENSITIVE_STRING }))); };
+})(ListEnvironmentOutputsOutput || (ListEnvironmentOutputsOutput = {}));
+export var ListEnvironmentProvisionedResourcesInput;
+(function (ListEnvironmentProvisionedResourcesInput) {
+    ListEnvironmentProvisionedResourcesInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListEnvironmentProvisionedResourcesInput || (ListEnvironmentProvisionedResourcesInput = {}));
+export var ProvisionedResourceEngine;
+(function (ProvisionedResourceEngine) {
+    ProvisionedResourceEngine["CLOUDFORMATION"] = "CLOUDFORMATION";
+    ProvisionedResourceEngine["TERRAFORM"] = "TERRAFORM";
+})(ProvisionedResourceEngine || (ProvisionedResourceEngine = {}));
+export var ProvisionedResource;
+(function (ProvisionedResource) {
+    ProvisionedResource.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ProvisionedResource || (ProvisionedResource = {}));
+export var ListEnvironmentProvisionedResourcesOutput;
+(function (ListEnvironmentProvisionedResourcesOutput) {
+    ListEnvironmentProvisionedResourcesOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListEnvironmentProvisionedResourcesOutput || (ListEnvironmentProvisionedResourcesOutput = {}));
 export var CreateEnvironmentInput;
 (function (CreateEnvironmentInput) {
     CreateEnvironmentInput.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.description && { description: SENSITIVE_STRING })), (obj.spec && { spec: SENSITIVE_STRING }))); };
@@ -377,6 +420,78 @@ export var UpdateEnvironmentTemplateVersionOutput;
         environmentTemplateVersion: EnvironmentTemplateVersion.filterSensitiveLog(obj.environmentTemplateVersion),
     }))); };
 })(UpdateEnvironmentTemplateVersionOutput || (UpdateEnvironmentTemplateVersionOutput = {}));
+export var SyncType;
+(function (SyncType) {
+    SyncType["TEMPLATE_SYNC"] = "TEMPLATE_SYNC";
+})(SyncType || (SyncType = {}));
+export var GetRepositorySyncStatusInput;
+(function (GetRepositorySyncStatusInput) {
+    GetRepositorySyncStatusInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetRepositorySyncStatusInput || (GetRepositorySyncStatusInput = {}));
+export var RepositorySyncEvent;
+(function (RepositorySyncEvent) {
+    RepositorySyncEvent.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RepositorySyncEvent || (RepositorySyncEvent = {}));
+export var RepositorySyncStatus;
+(function (RepositorySyncStatus) {
+    RepositorySyncStatus["FAILED"] = "FAILED";
+    RepositorySyncStatus["INITIATED"] = "INITIATED";
+    RepositorySyncStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    RepositorySyncStatus["QUEUED"] = "QUEUED";
+    RepositorySyncStatus["SUCCEEDED"] = "SUCCEEDED";
+})(RepositorySyncStatus || (RepositorySyncStatus = {}));
+export var RepositorySyncAttempt;
+(function (RepositorySyncAttempt) {
+    RepositorySyncAttempt.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RepositorySyncAttempt || (RepositorySyncAttempt = {}));
+export var GetRepositorySyncStatusOutput;
+(function (GetRepositorySyncStatusOutput) {
+    GetRepositorySyncStatusOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetRepositorySyncStatusOutput || (GetRepositorySyncStatusOutput = {}));
+export var TemplateType;
+(function (TemplateType) {
+    TemplateType["ENVIRONMENT"] = "ENVIRONMENT";
+    TemplateType["SERVICE"] = "SERVICE";
+})(TemplateType || (TemplateType = {}));
+export var GetTemplateSyncStatusInput;
+(function (GetTemplateSyncStatusInput) {
+    GetTemplateSyncStatusInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetTemplateSyncStatusInput || (GetTemplateSyncStatusInput = {}));
+export var Revision;
+(function (Revision) {
+    Revision.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Revision || (Revision = {}));
+export var ResourceSyncEvent;
+(function (ResourceSyncEvent) {
+    ResourceSyncEvent.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ResourceSyncEvent || (ResourceSyncEvent = {}));
+export var ResourceSyncStatus;
+(function (ResourceSyncStatus) {
+    ResourceSyncStatus["FAILED"] = "FAILED";
+    ResourceSyncStatus["INITIATED"] = "INITIATED";
+    ResourceSyncStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    ResourceSyncStatus["SUCCEEDED"] = "SUCCEEDED";
+})(ResourceSyncStatus || (ResourceSyncStatus = {}));
+export var ResourceSyncAttempt;
+(function (ResourceSyncAttempt) {
+    ResourceSyncAttempt.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ResourceSyncAttempt || (ResourceSyncAttempt = {}));
+export var GetTemplateSyncStatusOutput;
+(function (GetTemplateSyncStatusOutput) {
+    GetTemplateSyncStatusOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetTemplateSyncStatusOutput || (GetTemplateSyncStatusOutput = {}));
+export var ListRepositorySyncDefinitionsInput;
+(function (ListRepositorySyncDefinitionsInput) {
+    ListRepositorySyncDefinitionsInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListRepositorySyncDefinitionsInput || (ListRepositorySyncDefinitionsInput = {}));
+export var RepositorySyncDefinition;
+(function (RepositorySyncDefinition) {
+    RepositorySyncDefinition.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RepositorySyncDefinition || (RepositorySyncDefinition = {}));
+export var ListRepositorySyncDefinitionsOutput;
+(function (ListRepositorySyncDefinitionsOutput) {
+    ListRepositorySyncDefinitionsOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListRepositorySyncDefinitionsOutput || (ListRepositorySyncDefinitionsOutput = {}));
 export var ListTagsForResourceInput;
 (function (ListTagsForResourceInput) {
     ListTagsForResourceInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -385,6 +500,76 @@ export var ListTagsForResourceOutput;
 (function (ListTagsForResourceOutput) {
     ListTagsForResourceOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(ListTagsForResourceOutput || (ListTagsForResourceOutput = {}));
+export var ResourceDeploymentStatus;
+(function (ResourceDeploymentStatus) {
+    ResourceDeploymentStatus["FAILED"] = "FAILED";
+    ResourceDeploymentStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    ResourceDeploymentStatus["SUCCEEDED"] = "SUCCEEDED";
+})(ResourceDeploymentStatus || (ResourceDeploymentStatus = {}));
+export var NotifyResourceDeploymentStatusChangeInput;
+(function (NotifyResourceDeploymentStatusChangeInput) {
+    NotifyResourceDeploymentStatusChangeInput.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.outputs && { outputs: SENSITIVE_STRING })), (obj.statusMessage && { statusMessage: SENSITIVE_STRING }))); };
+})(NotifyResourceDeploymentStatusChangeInput || (NotifyResourceDeploymentStatusChangeInput = {}));
+export var NotifyResourceDeploymentStatusChangeOutput;
+(function (NotifyResourceDeploymentStatusChangeOutput) {
+    NotifyResourceDeploymentStatusChangeOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(NotifyResourceDeploymentStatusChangeOutput || (NotifyResourceDeploymentStatusChangeOutput = {}));
+export var CreateRepositoryInput;
+(function (CreateRepositoryInput) {
+    CreateRepositoryInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateRepositoryInput || (CreateRepositoryInput = {}));
+export var Repository;
+(function (Repository) {
+    Repository.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Repository || (Repository = {}));
+export var CreateRepositoryOutput;
+(function (CreateRepositoryOutput) {
+    CreateRepositoryOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateRepositoryOutput || (CreateRepositoryOutput = {}));
+export var DeleteRepositoryInput;
+(function (DeleteRepositoryInput) {
+    DeleteRepositoryInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteRepositoryInput || (DeleteRepositoryInput = {}));
+export var DeleteRepositoryOutput;
+(function (DeleteRepositoryOutput) {
+    DeleteRepositoryOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteRepositoryOutput || (DeleteRepositoryOutput = {}));
+export var GetRepositoryInput;
+(function (GetRepositoryInput) {
+    GetRepositoryInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetRepositoryInput || (GetRepositoryInput = {}));
+export var GetRepositoryOutput;
+(function (GetRepositoryOutput) {
+    GetRepositoryOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetRepositoryOutput || (GetRepositoryOutput = {}));
+export var ListRepositoriesInput;
+(function (ListRepositoriesInput) {
+    ListRepositoriesInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListRepositoriesInput || (ListRepositoriesInput = {}));
+export var RepositorySummary;
+(function (RepositorySummary) {
+    RepositorySummary.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RepositorySummary || (RepositorySummary = {}));
+export var ListRepositoriesOutput;
+(function (ListRepositoriesOutput) {
+    ListRepositoriesOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListRepositoriesOutput || (ListRepositoriesOutput = {}));
+export var ListServiceInstanceOutputsInput;
+(function (ListServiceInstanceOutputsInput) {
+    ListServiceInstanceOutputsInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListServiceInstanceOutputsInput || (ListServiceInstanceOutputsInput = {}));
+export var ListServiceInstanceOutputsOutput;
+(function (ListServiceInstanceOutputsOutput) {
+    ListServiceInstanceOutputsOutput.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.outputs && { outputs: SENSITIVE_STRING }))); };
+})(ListServiceInstanceOutputsOutput || (ListServiceInstanceOutputsOutput = {}));
+export var ListServiceInstanceProvisionedResourcesInput;
+(function (ListServiceInstanceProvisionedResourcesInput) {
+    ListServiceInstanceProvisionedResourcesInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListServiceInstanceProvisionedResourcesInput || (ListServiceInstanceProvisionedResourcesInput = {}));
+export var ListServiceInstanceProvisionedResourcesOutput;
+(function (ListServiceInstanceProvisionedResourcesOutput) {
+    ListServiceInstanceProvisionedResourcesOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListServiceInstanceProvisionedResourcesOutput || (ListServiceInstanceProvisionedResourcesOutput = {}));
 export var GetServiceInstanceInput;
 (function (GetServiceInstanceInput) {
     GetServiceInstanceInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -415,6 +600,22 @@ export var UpdateServiceInstanceOutput;
 (function (UpdateServiceInstanceOutput) {
     UpdateServiceInstanceOutput.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.serviceInstance && { serviceInstance: ServiceInstance.filterSensitiveLog(obj.serviceInstance) }))); };
 })(UpdateServiceInstanceOutput || (UpdateServiceInstanceOutput = {}));
+export var ListServicePipelineOutputsInput;
+(function (ListServicePipelineOutputsInput) {
+    ListServicePipelineOutputsInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListServicePipelineOutputsInput || (ListServicePipelineOutputsInput = {}));
+export var ListServicePipelineOutputsOutput;
+(function (ListServicePipelineOutputsOutput) {
+    ListServicePipelineOutputsOutput.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.outputs && { outputs: SENSITIVE_STRING }))); };
+})(ListServicePipelineOutputsOutput || (ListServicePipelineOutputsOutput = {}));
+export var ListServicePipelineProvisionedResourcesInput;
+(function (ListServicePipelineProvisionedResourcesInput) {
+    ListServicePipelineProvisionedResourcesInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListServicePipelineProvisionedResourcesInput || (ListServicePipelineProvisionedResourcesInput = {}));
+export var ListServicePipelineProvisionedResourcesOutput;
+(function (ListServicePipelineProvisionedResourcesOutput) {
+    ListServicePipelineProvisionedResourcesOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListServicePipelineProvisionedResourcesOutput || (ListServicePipelineProvisionedResourcesOutput = {}));
 export var UpdateServicePipelineInput;
 (function (UpdateServicePipelineInput) {
     UpdateServicePipelineInput.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.spec && { spec: SENSITIVE_STRING }))); };
@@ -610,6 +811,42 @@ export var TagResourceOutput;
 (function (TagResourceOutput) {
     TagResourceOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(TagResourceOutput || (TagResourceOutput = {}));
+export var CreateTemplateSyncConfigInput;
+(function (CreateTemplateSyncConfigInput) {
+    CreateTemplateSyncConfigInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateTemplateSyncConfigInput || (CreateTemplateSyncConfigInput = {}));
+export var TemplateSyncConfig;
+(function (TemplateSyncConfig) {
+    TemplateSyncConfig.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(TemplateSyncConfig || (TemplateSyncConfig = {}));
+export var CreateTemplateSyncConfigOutput;
+(function (CreateTemplateSyncConfigOutput) {
+    CreateTemplateSyncConfigOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateTemplateSyncConfigOutput || (CreateTemplateSyncConfigOutput = {}));
+export var DeleteTemplateSyncConfigInput;
+(function (DeleteTemplateSyncConfigInput) {
+    DeleteTemplateSyncConfigInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteTemplateSyncConfigInput || (DeleteTemplateSyncConfigInput = {}));
+export var DeleteTemplateSyncConfigOutput;
+(function (DeleteTemplateSyncConfigOutput) {
+    DeleteTemplateSyncConfigOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteTemplateSyncConfigOutput || (DeleteTemplateSyncConfigOutput = {}));
+export var GetTemplateSyncConfigInput;
+(function (GetTemplateSyncConfigInput) {
+    GetTemplateSyncConfigInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetTemplateSyncConfigInput || (GetTemplateSyncConfigInput = {}));
+export var GetTemplateSyncConfigOutput;
+(function (GetTemplateSyncConfigOutput) {
+    GetTemplateSyncConfigOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetTemplateSyncConfigOutput || (GetTemplateSyncConfigOutput = {}));
+export var UpdateTemplateSyncConfigInput;
+(function (UpdateTemplateSyncConfigInput) {
+    UpdateTemplateSyncConfigInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateTemplateSyncConfigInput || (UpdateTemplateSyncConfigInput = {}));
+export var UpdateTemplateSyncConfigOutput;
+(function (UpdateTemplateSyncConfigOutput) {
+    UpdateTemplateSyncConfigOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateTemplateSyncConfigOutput || (UpdateTemplateSyncConfigOutput = {}));
 export var UntagResourceInput;
 (function (UntagResourceInput) {
     UntagResourceInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };

package/dist-es/pagination/ListEnvironmentOutputsPaginator.js

@@ -0,0 +1,73 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListEnvironmentOutputsCommand, } from "../commands/ListEnvironmentOutputsCommand";
+import { Proton } from "../Proton";
+import { ProtonClient } from "../ProtonClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListEnvironmentOutputsCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.listEnvironmentOutputs.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListEnvironmentOutputs(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListEnvironmentOutputs_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.nextToken = token;
+                    if (!(config.client instanceof Proton)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof ProtonClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected Proton | ProtonClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.nextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/ListEnvironmentProvisionedResourcesPaginator.js

@@ -0,0 +1,73 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListEnvironmentProvisionedResourcesCommand, } from "../commands/ListEnvironmentProvisionedResourcesCommand";
+import { Proton } from "../Proton";
+import { ProtonClient } from "../ProtonClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListEnvironmentProvisionedResourcesCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.listEnvironmentProvisionedResources.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListEnvironmentProvisionedResources(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListEnvironmentProvisionedResources_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.nextToken = token;
+                    if (!(config.client instanceof Proton)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof ProtonClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected Proton | ProtonClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.nextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/ListRepositoriesPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListRepositoriesCommand, } from "../commands/ListRepositoriesCommand";
+import { Proton } from "../Proton";
+import { ProtonClient } from "../ProtonClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListRepositoriesCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.listRepositories.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListRepositories(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListRepositories_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.nextToken = token;
+                    input["maxResults"] = config.pageSize;
+                    if (!(config.client instanceof Proton)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof ProtonClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected Proton | ProtonClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.nextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/ListRepositorySyncDefinitionsPaginator.js

@@ -0,0 +1,73 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListRepositorySyncDefinitionsCommand, } from "../commands/ListRepositorySyncDefinitionsCommand";
+import { Proton } from "../Proton";
+import { ProtonClient } from "../ProtonClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListRepositorySyncDefinitionsCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.listRepositorySyncDefinitions.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListRepositorySyncDefinitions(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListRepositorySyncDefinitions_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.nextToken = token;
+                    if (!(config.client instanceof Proton)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof ProtonClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected Proton | ProtonClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.nextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/ListServiceInstanceOutputsPaginator.js

@@ -0,0 +1,73 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListServiceInstanceOutputsCommand, } from "../commands/ListServiceInstanceOutputsCommand";
+import { Proton } from "../Proton";
+import { ProtonClient } from "../ProtonClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListServiceInstanceOutputsCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.listServiceInstanceOutputs.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListServiceInstanceOutputs(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListServiceInstanceOutputs_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.nextToken = token;
+                    if (!(config.client instanceof Proton)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof ProtonClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected Proton | ProtonClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.nextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}