@aws-sdk/client-amp 3.32.0 → 3.36.0

package/dist-es/models/models_0.js

@@ -0,0 +1,218 @@
+import { __assign } from "tslib";
+export var AccessDeniedException;
+(function (AccessDeniedException) {
+    AccessDeniedException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(AccessDeniedException || (AccessDeniedException = {}));
+export var ConflictException;
+(function (ConflictException) {
+    ConflictException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ConflictException || (ConflictException = {}));
+export var CreateAlertManagerDefinitionRequest;
+(function (CreateAlertManagerDefinitionRequest) {
+    CreateAlertManagerDefinitionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateAlertManagerDefinitionRequest || (CreateAlertManagerDefinitionRequest = {}));
+export var AlertManagerDefinitionStatusCode;
+(function (AlertManagerDefinitionStatusCode) {
+    AlertManagerDefinitionStatusCode["ACTIVE"] = "ACTIVE";
+    AlertManagerDefinitionStatusCode["CREATING"] = "CREATING";
+    AlertManagerDefinitionStatusCode["CREATION_FAILED"] = "CREATION_FAILED";
+    AlertManagerDefinitionStatusCode["DELETING"] = "DELETING";
+    AlertManagerDefinitionStatusCode["UPDATE_FAILED"] = "UPDATE_FAILED";
+    AlertManagerDefinitionStatusCode["UPDATING"] = "UPDATING";
+})(AlertManagerDefinitionStatusCode || (AlertManagerDefinitionStatusCode = {}));
+export var AlertManagerDefinitionStatus;
+(function (AlertManagerDefinitionStatus) {
+    AlertManagerDefinitionStatus.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(AlertManagerDefinitionStatus || (AlertManagerDefinitionStatus = {}));
+export var CreateAlertManagerDefinitionResponse;
+(function (CreateAlertManagerDefinitionResponse) {
+    CreateAlertManagerDefinitionResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateAlertManagerDefinitionResponse || (CreateAlertManagerDefinitionResponse = {}));
+export var InternalServerException;
+(function (InternalServerException) {
+    InternalServerException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(InternalServerException || (InternalServerException = {}));
+export var ResourceNotFoundException;
+(function (ResourceNotFoundException) {
+    ResourceNotFoundException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ResourceNotFoundException || (ResourceNotFoundException = {}));
+export var ServiceQuotaExceededException;
+(function (ServiceQuotaExceededException) {
+    ServiceQuotaExceededException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ServiceQuotaExceededException || (ServiceQuotaExceededException = {}));
+export var ThrottlingException;
+(function (ThrottlingException) {
+    ThrottlingException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ThrottlingException || (ThrottlingException = {}));
+export var ValidationExceptionField;
+(function (ValidationExceptionField) {
+    ValidationExceptionField.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ValidationExceptionField || (ValidationExceptionField = {}));
+export var ValidationExceptionReason;
+(function (ValidationExceptionReason) {
+    ValidationExceptionReason["CANNOT_PARSE"] = "CANNOT_PARSE";
+    ValidationExceptionReason["FIELD_VALIDATION_FAILED"] = "FIELD_VALIDATION_FAILED";
+    ValidationExceptionReason["OTHER"] = "OTHER";
+    ValidationExceptionReason["UNKNOWN_OPERATION"] = "UNKNOWN_OPERATION";
+})(ValidationExceptionReason || (ValidationExceptionReason = {}));
+export var ValidationException;
+(function (ValidationException) {
+    ValidationException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ValidationException || (ValidationException = {}));
+export var DeleteAlertManagerDefinitionRequest;
+(function (DeleteAlertManagerDefinitionRequest) {
+    DeleteAlertManagerDefinitionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteAlertManagerDefinitionRequest || (DeleteAlertManagerDefinitionRequest = {}));
+export var DescribeAlertManagerDefinitionRequest;
+(function (DescribeAlertManagerDefinitionRequest) {
+    DescribeAlertManagerDefinitionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeAlertManagerDefinitionRequest || (DescribeAlertManagerDefinitionRequest = {}));
+export var AlertManagerDefinitionDescription;
+(function (AlertManagerDefinitionDescription) {
+    AlertManagerDefinitionDescription.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(AlertManagerDefinitionDescription || (AlertManagerDefinitionDescription = {}));
+export var DescribeAlertManagerDefinitionResponse;
+(function (DescribeAlertManagerDefinitionResponse) {
+    DescribeAlertManagerDefinitionResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeAlertManagerDefinitionResponse || (DescribeAlertManagerDefinitionResponse = {}));
+export var PutAlertManagerDefinitionRequest;
+(function (PutAlertManagerDefinitionRequest) {
+    PutAlertManagerDefinitionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PutAlertManagerDefinitionRequest || (PutAlertManagerDefinitionRequest = {}));
+export var PutAlertManagerDefinitionResponse;
+(function (PutAlertManagerDefinitionResponse) {
+    PutAlertManagerDefinitionResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PutAlertManagerDefinitionResponse || (PutAlertManagerDefinitionResponse = {}));
+export var ListTagsForResourceRequest;
+(function (ListTagsForResourceRequest) {
+    ListTagsForResourceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListTagsForResourceRequest || (ListTagsForResourceRequest = {}));
+export var ListTagsForResourceResponse;
+(function (ListTagsForResourceResponse) {
+    ListTagsForResourceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListTagsForResourceResponse || (ListTagsForResourceResponse = {}));
+export var TagResourceRequest;
+(function (TagResourceRequest) {
+    TagResourceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(TagResourceRequest || (TagResourceRequest = {}));
+export var TagResourceResponse;
+(function (TagResourceResponse) {
+    TagResourceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(TagResourceResponse || (TagResourceResponse = {}));
+export var UntagResourceRequest;
+(function (UntagResourceRequest) {
+    UntagResourceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UntagResourceRequest || (UntagResourceRequest = {}));
+export var UntagResourceResponse;
+(function (UntagResourceResponse) {
+    UntagResourceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UntagResourceResponse || (UntagResourceResponse = {}));
+export var CreateWorkspaceRequest;
+(function (CreateWorkspaceRequest) {
+    CreateWorkspaceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateWorkspaceRequest || (CreateWorkspaceRequest = {}));
+export var WorkspaceStatusCode;
+(function (WorkspaceStatusCode) {
+    WorkspaceStatusCode["ACTIVE"] = "ACTIVE";
+    WorkspaceStatusCode["CREATING"] = "CREATING";
+    WorkspaceStatusCode["CREATION_FAILED"] = "CREATION_FAILED";
+    WorkspaceStatusCode["DELETING"] = "DELETING";
+    WorkspaceStatusCode["UPDATING"] = "UPDATING";
+})(WorkspaceStatusCode || (WorkspaceStatusCode = {}));
+export var WorkspaceStatus;
+(function (WorkspaceStatus) {
+    WorkspaceStatus.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(WorkspaceStatus || (WorkspaceStatus = {}));
+export var CreateWorkspaceResponse;
+(function (CreateWorkspaceResponse) {
+    CreateWorkspaceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateWorkspaceResponse || (CreateWorkspaceResponse = {}));
+export var DeleteWorkspaceRequest;
+(function (DeleteWorkspaceRequest) {
+    DeleteWorkspaceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteWorkspaceRequest || (DeleteWorkspaceRequest = {}));
+export var DescribeWorkspaceRequest;
+(function (DescribeWorkspaceRequest) {
+    DescribeWorkspaceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeWorkspaceRequest || (DescribeWorkspaceRequest = {}));
+export var WorkspaceDescription;
+(function (WorkspaceDescription) {
+    WorkspaceDescription.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(WorkspaceDescription || (WorkspaceDescription = {}));
+export var DescribeWorkspaceResponse;
+(function (DescribeWorkspaceResponse) {
+    DescribeWorkspaceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeWorkspaceResponse || (DescribeWorkspaceResponse = {}));
+export var ListWorkspacesRequest;
+(function (ListWorkspacesRequest) {
+    ListWorkspacesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListWorkspacesRequest || (ListWorkspacesRequest = {}));
+export var WorkspaceSummary;
+(function (WorkspaceSummary) {
+    WorkspaceSummary.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(WorkspaceSummary || (WorkspaceSummary = {}));
+export var ListWorkspacesResponse;
+(function (ListWorkspacesResponse) {
+    ListWorkspacesResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListWorkspacesResponse || (ListWorkspacesResponse = {}));
+export var CreateRuleGroupsNamespaceRequest;
+(function (CreateRuleGroupsNamespaceRequest) {
+    CreateRuleGroupsNamespaceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateRuleGroupsNamespaceRequest || (CreateRuleGroupsNamespaceRequest = {}));
+export var RuleGroupsNamespaceStatusCode;
+(function (RuleGroupsNamespaceStatusCode) {
+    RuleGroupsNamespaceStatusCode["ACTIVE"] = "ACTIVE";
+    RuleGroupsNamespaceStatusCode["CREATING"] = "CREATING";
+    RuleGroupsNamespaceStatusCode["CREATION_FAILED"] = "CREATION_FAILED";
+    RuleGroupsNamespaceStatusCode["DELETING"] = "DELETING";
+    RuleGroupsNamespaceStatusCode["UPDATE_FAILED"] = "UPDATE_FAILED";
+    RuleGroupsNamespaceStatusCode["UPDATING"] = "UPDATING";
+})(RuleGroupsNamespaceStatusCode || (RuleGroupsNamespaceStatusCode = {}));
+export var RuleGroupsNamespaceStatus;
+(function (RuleGroupsNamespaceStatus) {
+    RuleGroupsNamespaceStatus.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RuleGroupsNamespaceStatus || (RuleGroupsNamespaceStatus = {}));
+export var CreateRuleGroupsNamespaceResponse;
+(function (CreateRuleGroupsNamespaceResponse) {
+    CreateRuleGroupsNamespaceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateRuleGroupsNamespaceResponse || (CreateRuleGroupsNamespaceResponse = {}));
+export var DeleteRuleGroupsNamespaceRequest;
+(function (DeleteRuleGroupsNamespaceRequest) {
+    DeleteRuleGroupsNamespaceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteRuleGroupsNamespaceRequest || (DeleteRuleGroupsNamespaceRequest = {}));
+export var DescribeRuleGroupsNamespaceRequest;
+(function (DescribeRuleGroupsNamespaceRequest) {
+    DescribeRuleGroupsNamespaceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeRuleGroupsNamespaceRequest || (DescribeRuleGroupsNamespaceRequest = {}));
+export var RuleGroupsNamespaceDescription;
+(function (RuleGroupsNamespaceDescription) {
+    RuleGroupsNamespaceDescription.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RuleGroupsNamespaceDescription || (RuleGroupsNamespaceDescription = {}));
+export var DescribeRuleGroupsNamespaceResponse;
+(function (DescribeRuleGroupsNamespaceResponse) {
+    DescribeRuleGroupsNamespaceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeRuleGroupsNamespaceResponse || (DescribeRuleGroupsNamespaceResponse = {}));
+export var ListRuleGroupsNamespacesRequest;
+(function (ListRuleGroupsNamespacesRequest) {
+    ListRuleGroupsNamespacesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListRuleGroupsNamespacesRequest || (ListRuleGroupsNamespacesRequest = {}));
+export var RuleGroupsNamespaceSummary;
+(function (RuleGroupsNamespaceSummary) {
+    RuleGroupsNamespaceSummary.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RuleGroupsNamespaceSummary || (RuleGroupsNamespaceSummary = {}));
+export var ListRuleGroupsNamespacesResponse;
+(function (ListRuleGroupsNamespacesResponse) {
+    ListRuleGroupsNamespacesResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListRuleGroupsNamespacesResponse || (ListRuleGroupsNamespacesResponse = {}));
+export var PutRuleGroupsNamespaceRequest;
+(function (PutRuleGroupsNamespaceRequest) {
+    PutRuleGroupsNamespaceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PutRuleGroupsNamespaceRequest || (PutRuleGroupsNamespaceRequest = {}));
+export var PutRuleGroupsNamespaceResponse;
+(function (PutRuleGroupsNamespaceResponse) {
+    PutRuleGroupsNamespaceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PutRuleGroupsNamespaceResponse || (PutRuleGroupsNamespaceResponse = {}));
+export var UpdateWorkspaceAliasRequest;
+(function (UpdateWorkspaceAliasRequest) {
+    UpdateWorkspaceAliasRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateWorkspaceAliasRequest || (UpdateWorkspaceAliasRequest = {}));

package/dist-es/pagination/Interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist-es/pagination/ListRuleGroupsNamespacesPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { Amp } from "../Amp";
+import { AmpClient } from "../AmpClient";
+import { ListRuleGroupsNamespacesCommand, } from "../commands/ListRuleGroupsNamespacesCommand";
+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 ListRuleGroupsNamespacesCommand(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.listRuleGroupsNamespaces.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListRuleGroupsNamespaces(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListRuleGroupsNamespaces_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 Amp)) 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 AmpClient)) 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 Amp | AmpClient");
+                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 → dist-es}/pagination/ListWorkspacesPaginator.js

@@ -2,9 +2,6 @@ import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArra
 import { Amp } from "../Amp";
 import { AmpClient } from "../AmpClient";
 import { ListWorkspacesCommand, } from "../commands/ListWorkspacesCommand";
-/**
- * @private
- */
 var makePagedClientRequest = function (client, input) {
     var args = [];
     for (var _i = 2; _i < arguments.length; _i++) {
@@ -13,17 +10,12 @@ var makePagedClientRequest = function (client, input) {
     return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, client.send.apply(client, __spreadArray([new ListWorkspacesCommand(input)], __read(args)))];
-                case 1: 
-                // @ts-ignore
-                return [2 /*return*/, _a.sent()];
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListWorkspacesCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
             }
         });
     });
 };
-/**
- * @private
- */
 var makePagedRequest = function (client, input) {
     var args = [];
     for (var _i = 2; _i < arguments.length; _i++) {
@@ -32,10 +24,8 @@ var makePagedRequest = function (client, input) {
     return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, client.listWorkspaces.apply(client, __spreadArray([input], __read(args)))];
-                case 1: 
-                // @ts-ignore
-                return [2 /*return*/, _a.sent()];
+                case 0: return [4, client.listWorkspaces.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
             }
         });
     });
@@ -54,34 +44,31 @@ export function paginateListWorkspaces(config, input) {
                     hasNext = true;
                     _a.label = 1;
                 case 1:
-                    if (!hasNext) return [3 /*break*/, 9];
+                    if (!hasNext) return [3, 9];
                     input.nextToken = token;
                     input["maxResults"] = config.pageSize;
-                    if (!(config.client instanceof Amp)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                    if (!(config.client instanceof Amp)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
                 case 2:
                     page = _a.sent();
-                    return [3 /*break*/, 6];
+                    return [3, 6];
                 case 3:
-                    if (!(config.client instanceof AmpClient)) return [3 /*break*/, 5];
-                    return [4 /*yield*/, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                    if (!(config.client instanceof AmpClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
                 case 4:
                     page = _a.sent();
-                    return [3 /*break*/, 6];
+                    return [3, 6];
                 case 5: throw new Error("Invalid client, expected Amp | AmpClient");
-                case 6: return [4 /*yield*/, __await(page)];
-                case 7: return [4 /*yield*/, _a.sent()];
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
                 case 8:
                     _a.sent();
                     token = page.nextToken;
                     hasNext = !!token;
-                    return [3 /*break*/, 1];
-                case 9: return [4 /*yield*/, __await(undefined)];
-                case 10: 
-                // @ts-ignore
-                return [2 /*return*/, _a.sent()];
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
             }
         });
     });
 }
-//# sourceMappingURL=ListWorkspacesPaginator.js.map