@aws-sdk/client-redshift-serverless 3.107.0

package/dist-es/models/models_0.js

@@ -0,0 +1,523 @@
+import { __assign, __extends } from "tslib";
+import { SENSITIVE_STRING } from "@aws-sdk/smithy-client";
+import { RedshiftServerlessServiceException as __BaseException } from "./RedshiftServerlessServiceException";
+var AccessDeniedException = (function (_super) {
+    __extends(AccessDeniedException, _super);
+    function AccessDeniedException(opts) {
+        var _this = _super.call(this, __assign({ name: "AccessDeniedException", $fault: "client" }, opts)) || this;
+        _this.name = "AccessDeniedException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, AccessDeniedException.prototype);
+        _this.code = opts.code;
+        return _this;
+    }
+    return AccessDeniedException;
+}(__BaseException));
+export { AccessDeniedException };
+export var ConfigParameter;
+(function (ConfigParameter) {
+    ConfigParameter.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ConfigParameter || (ConfigParameter = {}));
+var ConflictException = (function (_super) {
+    __extends(ConflictException, _super);
+    function ConflictException(opts) {
+        var _this = _super.call(this, __assign({ name: "ConflictException", $fault: "client" }, opts)) || this;
+        _this.name = "ConflictException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ConflictException.prototype);
+        return _this;
+    }
+    return ConflictException;
+}(__BaseException));
+export { ConflictException };
+export var ConvertRecoveryPointToSnapshotRequest;
+(function (ConvertRecoveryPointToSnapshotRequest) {
+    ConvertRecoveryPointToSnapshotRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ConvertRecoveryPointToSnapshotRequest || (ConvertRecoveryPointToSnapshotRequest = {}));
+export var SnapshotStatus;
+(function (SnapshotStatus) {
+    SnapshotStatus["AVAILABLE"] = "AVAILABLE";
+    SnapshotStatus["CANCELLED"] = "CANCELLED";
+    SnapshotStatus["COPYING"] = "COPYING";
+    SnapshotStatus["CREATING"] = "CREATING";
+    SnapshotStatus["DELETED"] = "DELETED";
+    SnapshotStatus["FAILED"] = "FAILED";
+})(SnapshotStatus || (SnapshotStatus = {}));
+export var Snapshot;
+(function (Snapshot) {
+    Snapshot.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Snapshot || (Snapshot = {}));
+export var ConvertRecoveryPointToSnapshotResponse;
+(function (ConvertRecoveryPointToSnapshotResponse) {
+    ConvertRecoveryPointToSnapshotResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ConvertRecoveryPointToSnapshotResponse || (ConvertRecoveryPointToSnapshotResponse = {}));
+var InternalServerException = (function (_super) {
+    __extends(InternalServerException, _super);
+    function InternalServerException(opts) {
+        var _this = _super.call(this, __assign({ name: "InternalServerException", $fault: "server" }, opts)) || this;
+        _this.name = "InternalServerException";
+        _this.$fault = "server";
+        _this.$retryable = {};
+        Object.setPrototypeOf(_this, InternalServerException.prototype);
+        return _this;
+    }
+    return InternalServerException;
+}(__BaseException));
+export { InternalServerException };
+var ResourceNotFoundException = (function (_super) {
+    __extends(ResourceNotFoundException, _super);
+    function ResourceNotFoundException(opts) {
+        var _this = _super.call(this, __assign({ name: "ResourceNotFoundException", $fault: "client" }, opts)) || this;
+        _this.name = "ResourceNotFoundException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ResourceNotFoundException.prototype);
+        _this.resourceName = opts.resourceName;
+        return _this;
+    }
+    return ResourceNotFoundException;
+}(__BaseException));
+export { ResourceNotFoundException };
+var ServiceQuotaExceededException = (function (_super) {
+    __extends(ServiceQuotaExceededException, _super);
+    function ServiceQuotaExceededException(opts) {
+        var _this = _super.call(this, __assign({ name: "ServiceQuotaExceededException", $fault: "client" }, opts)) || this;
+        _this.name = "ServiceQuotaExceededException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ServiceQuotaExceededException.prototype);
+        return _this;
+    }
+    return ServiceQuotaExceededException;
+}(__BaseException));
+export { ServiceQuotaExceededException };
+var ValidationException = (function (_super) {
+    __extends(ValidationException, _super);
+    function ValidationException(opts) {
+        var _this = _super.call(this, __assign({ name: "ValidationException", $fault: "client" }, opts)) || this;
+        _this.name = "ValidationException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ValidationException.prototype);
+        return _this;
+    }
+    return ValidationException;
+}(__BaseException));
+export { ValidationException };
+export var CreateEndpointAccessRequest;
+(function (CreateEndpointAccessRequest) {
+    CreateEndpointAccessRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateEndpointAccessRequest || (CreateEndpointAccessRequest = {}));
+export var NetworkInterface;
+(function (NetworkInterface) {
+    NetworkInterface.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(NetworkInterface || (NetworkInterface = {}));
+export var VpcEndpoint;
+(function (VpcEndpoint) {
+    VpcEndpoint.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(VpcEndpoint || (VpcEndpoint = {}));
+export var VpcSecurityGroupMembership;
+(function (VpcSecurityGroupMembership) {
+    VpcSecurityGroupMembership.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(VpcSecurityGroupMembership || (VpcSecurityGroupMembership = {}));
+export var EndpointAccess;
+(function (EndpointAccess) {
+    EndpointAccess.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(EndpointAccess || (EndpointAccess = {}));
+export var CreateEndpointAccessResponse;
+(function (CreateEndpointAccessResponse) {
+    CreateEndpointAccessResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateEndpointAccessResponse || (CreateEndpointAccessResponse = {}));
+export var LogExport;
+(function (LogExport) {
+    LogExport["CONNECTION_LOG"] = "connectionlog";
+    LogExport["USER_ACTIVITY_LOG"] = "useractivitylog";
+    LogExport["USER_LOG"] = "userlog";
+})(LogExport || (LogExport = {}));
+export var Tag;
+(function (Tag) {
+    Tag.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Tag || (Tag = {}));
+export var CreateNamespaceRequest;
+(function (CreateNamespaceRequest) {
+    CreateNamespaceRequest.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.adminUsername && { adminUsername: SENSITIVE_STRING })), (obj.adminUserPassword && { adminUserPassword: SENSITIVE_STRING }))); };
+})(CreateNamespaceRequest || (CreateNamespaceRequest = {}));
+export var NamespaceStatus;
+(function (NamespaceStatus) {
+    NamespaceStatus["AVAILABLE"] = "AVAILABLE";
+    NamespaceStatus["DELETING"] = "DELETING";
+    NamespaceStatus["MODIFYING"] = "MODIFYING";
+})(NamespaceStatus || (NamespaceStatus = {}));
+export var Namespace;
+(function (Namespace) {
+    Namespace.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.adminUsername && { adminUsername: SENSITIVE_STRING }))); };
+})(Namespace || (Namespace = {}));
+export var CreateNamespaceResponse;
+(function (CreateNamespaceResponse) {
+    CreateNamespaceResponse.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.namespace && { namespace: Namespace.filterSensitiveLog(obj.namespace) }))); };
+})(CreateNamespaceResponse || (CreateNamespaceResponse = {}));
+var TooManyTagsException = (function (_super) {
+    __extends(TooManyTagsException, _super);
+    function TooManyTagsException(opts) {
+        var _this = _super.call(this, __assign({ name: "TooManyTagsException", $fault: "client" }, opts)) || this;
+        _this.name = "TooManyTagsException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, TooManyTagsException.prototype);
+        _this.resourceName = opts.resourceName;
+        return _this;
+    }
+    return TooManyTagsException;
+}(__BaseException));
+export { TooManyTagsException };
+export var CreateSnapshotRequest;
+(function (CreateSnapshotRequest) {
+    CreateSnapshotRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateSnapshotRequest || (CreateSnapshotRequest = {}));
+export var CreateSnapshotResponse;
+(function (CreateSnapshotResponse) {
+    CreateSnapshotResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateSnapshotResponse || (CreateSnapshotResponse = {}));
+export var UsageLimitBreachAction;
+(function (UsageLimitBreachAction) {
+    UsageLimitBreachAction["DEACTIVATE"] = "deactivate";
+    UsageLimitBreachAction["EMIT_METRIC"] = "emit-metric";
+    UsageLimitBreachAction["LOG"] = "log";
+})(UsageLimitBreachAction || (UsageLimitBreachAction = {}));
+export var UsageLimitPeriod;
+(function (UsageLimitPeriod) {
+    UsageLimitPeriod["DAILY"] = "daily";
+    UsageLimitPeriod["MONTHLY"] = "monthly";
+    UsageLimitPeriod["WEEKLY"] = "weekly";
+})(UsageLimitPeriod || (UsageLimitPeriod = {}));
+export var UsageLimitUsageType;
+(function (UsageLimitUsageType) {
+    UsageLimitUsageType["CROSS_REGION_DATASHARING"] = "cross-region-datasharing";
+    UsageLimitUsageType["SERVERLESS_COMPUTE"] = "serverless-compute";
+})(UsageLimitUsageType || (UsageLimitUsageType = {}));
+export var CreateUsageLimitRequest;
+(function (CreateUsageLimitRequest) {
+    CreateUsageLimitRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateUsageLimitRequest || (CreateUsageLimitRequest = {}));
+export var UsageLimit;
+(function (UsageLimit) {
+    UsageLimit.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UsageLimit || (UsageLimit = {}));
+export var CreateUsageLimitResponse;
+(function (CreateUsageLimitResponse) {
+    CreateUsageLimitResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateUsageLimitResponse || (CreateUsageLimitResponse = {}));
+export var CreateWorkgroupRequest;
+(function (CreateWorkgroupRequest) {
+    CreateWorkgroupRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateWorkgroupRequest || (CreateWorkgroupRequest = {}));
+export var Endpoint;
+(function (Endpoint) {
+    Endpoint.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Endpoint || (Endpoint = {}));
+export var WorkgroupStatus;
+(function (WorkgroupStatus) {
+    WorkgroupStatus["AVAILABLE"] = "AVAILABLE";
+    WorkgroupStatus["CREATING"] = "CREATING";
+    WorkgroupStatus["DELETING"] = "DELETING";
+    WorkgroupStatus["MODIFYING"] = "MODIFYING";
+})(WorkgroupStatus || (WorkgroupStatus = {}));
+export var Workgroup;
+(function (Workgroup) {
+    Workgroup.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Workgroup || (Workgroup = {}));
+export var CreateWorkgroupResponse;
+(function (CreateWorkgroupResponse) {
+    CreateWorkgroupResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateWorkgroupResponse || (CreateWorkgroupResponse = {}));
+var InsufficientCapacityException = (function (_super) {
+    __extends(InsufficientCapacityException, _super);
+    function InsufficientCapacityException(opts) {
+        var _this = _super.call(this, __assign({ name: "InsufficientCapacityException", $fault: "client" }, opts)) || this;
+        _this.name = "InsufficientCapacityException";
+        _this.$fault = "client";
+        _this.$retryable = {};
+        Object.setPrototypeOf(_this, InsufficientCapacityException.prototype);
+        return _this;
+    }
+    return InsufficientCapacityException;
+}(__BaseException));
+export { InsufficientCapacityException };
+export var DeleteEndpointAccessRequest;
+(function (DeleteEndpointAccessRequest) {
+    DeleteEndpointAccessRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteEndpointAccessRequest || (DeleteEndpointAccessRequest = {}));
+export var DeleteEndpointAccessResponse;
+(function (DeleteEndpointAccessResponse) {
+    DeleteEndpointAccessResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteEndpointAccessResponse || (DeleteEndpointAccessResponse = {}));
+export var GetEndpointAccessRequest;
+(function (GetEndpointAccessRequest) {
+    GetEndpointAccessRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetEndpointAccessRequest || (GetEndpointAccessRequest = {}));
+export var GetEndpointAccessResponse;
+(function (GetEndpointAccessResponse) {
+    GetEndpointAccessResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetEndpointAccessResponse || (GetEndpointAccessResponse = {}));
+export var ListEndpointAccessRequest;
+(function (ListEndpointAccessRequest) {
+    ListEndpointAccessRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListEndpointAccessRequest || (ListEndpointAccessRequest = {}));
+export var ListEndpointAccessResponse;
+(function (ListEndpointAccessResponse) {
+    ListEndpointAccessResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListEndpointAccessResponse || (ListEndpointAccessResponse = {}));
+export var UpdateEndpointAccessRequest;
+(function (UpdateEndpointAccessRequest) {
+    UpdateEndpointAccessRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateEndpointAccessRequest || (UpdateEndpointAccessRequest = {}));
+export var UpdateEndpointAccessResponse;
+(function (UpdateEndpointAccessResponse) {
+    UpdateEndpointAccessResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateEndpointAccessResponse || (UpdateEndpointAccessResponse = {}));
+export var DeleteNamespaceRequest;
+(function (DeleteNamespaceRequest) {
+    DeleteNamespaceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteNamespaceRequest || (DeleteNamespaceRequest = {}));
+export var DeleteNamespaceResponse;
+(function (DeleteNamespaceResponse) {
+    DeleteNamespaceResponse.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.namespace && { namespace: Namespace.filterSensitiveLog(obj.namespace) }))); };
+})(DeleteNamespaceResponse || (DeleteNamespaceResponse = {}));
+export var DeleteResourcePolicyRequest;
+(function (DeleteResourcePolicyRequest) {
+    DeleteResourcePolicyRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteResourcePolicyRequest || (DeleteResourcePolicyRequest = {}));
+export var DeleteResourcePolicyResponse;
+(function (DeleteResourcePolicyResponse) {
+    DeleteResourcePolicyResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteResourcePolicyResponse || (DeleteResourcePolicyResponse = {}));
+export var DeleteSnapshotRequest;
+(function (DeleteSnapshotRequest) {
+    DeleteSnapshotRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteSnapshotRequest || (DeleteSnapshotRequest = {}));
+export var DeleteSnapshotResponse;
+(function (DeleteSnapshotResponse) {
+    DeleteSnapshotResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteSnapshotResponse || (DeleteSnapshotResponse = {}));
+export var DeleteUsageLimitRequest;
+(function (DeleteUsageLimitRequest) {
+    DeleteUsageLimitRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteUsageLimitRequest || (DeleteUsageLimitRequest = {}));
+export var DeleteUsageLimitResponse;
+(function (DeleteUsageLimitResponse) {
+    DeleteUsageLimitResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteUsageLimitResponse || (DeleteUsageLimitResponse = {}));
+export var DeleteWorkgroupRequest;
+(function (DeleteWorkgroupRequest) {
+    DeleteWorkgroupRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteWorkgroupRequest || (DeleteWorkgroupRequest = {}));
+export var DeleteWorkgroupResponse;
+(function (DeleteWorkgroupResponse) {
+    DeleteWorkgroupResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteWorkgroupResponse || (DeleteWorkgroupResponse = {}));
+export var GetCredentialsRequest;
+(function (GetCredentialsRequest) {
+    GetCredentialsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetCredentialsRequest || (GetCredentialsRequest = {}));
+export var GetCredentialsResponse;
+(function (GetCredentialsResponse) {
+    GetCredentialsResponse.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.dbUser && { dbUser: SENSITIVE_STRING })), (obj.dbPassword && { dbPassword: SENSITIVE_STRING }))); };
+})(GetCredentialsResponse || (GetCredentialsResponse = {}));
+export var GetNamespaceRequest;
+(function (GetNamespaceRequest) {
+    GetNamespaceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetNamespaceRequest || (GetNamespaceRequest = {}));
+export var GetNamespaceResponse;
+(function (GetNamespaceResponse) {
+    GetNamespaceResponse.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.namespace && { namespace: Namespace.filterSensitiveLog(obj.namespace) }))); };
+})(GetNamespaceResponse || (GetNamespaceResponse = {}));
+export var GetRecoveryPointRequest;
+(function (GetRecoveryPointRequest) {
+    GetRecoveryPointRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetRecoveryPointRequest || (GetRecoveryPointRequest = {}));
+export var RecoveryPoint;
+(function (RecoveryPoint) {
+    RecoveryPoint.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RecoveryPoint || (RecoveryPoint = {}));
+export var GetRecoveryPointResponse;
+(function (GetRecoveryPointResponse) {
+    GetRecoveryPointResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetRecoveryPointResponse || (GetRecoveryPointResponse = {}));
+export var GetResourcePolicyRequest;
+(function (GetResourcePolicyRequest) {
+    GetResourcePolicyRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetResourcePolicyRequest || (GetResourcePolicyRequest = {}));
+export var ResourcePolicy;
+(function (ResourcePolicy) {
+    ResourcePolicy.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ResourcePolicy || (ResourcePolicy = {}));
+export var GetResourcePolicyResponse;
+(function (GetResourcePolicyResponse) {
+    GetResourcePolicyResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetResourcePolicyResponse || (GetResourcePolicyResponse = {}));
+export var GetSnapshotRequest;
+(function (GetSnapshotRequest) {
+    GetSnapshotRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetSnapshotRequest || (GetSnapshotRequest = {}));
+export var GetSnapshotResponse;
+(function (GetSnapshotResponse) {
+    GetSnapshotResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetSnapshotResponse || (GetSnapshotResponse = {}));
+export var GetUsageLimitRequest;
+(function (GetUsageLimitRequest) {
+    GetUsageLimitRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetUsageLimitRequest || (GetUsageLimitRequest = {}));
+export var GetUsageLimitResponse;
+(function (GetUsageLimitResponse) {
+    GetUsageLimitResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetUsageLimitResponse || (GetUsageLimitResponse = {}));
+export var GetWorkgroupRequest;
+(function (GetWorkgroupRequest) {
+    GetWorkgroupRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetWorkgroupRequest || (GetWorkgroupRequest = {}));
+export var GetWorkgroupResponse;
+(function (GetWorkgroupResponse) {
+    GetWorkgroupResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetWorkgroupResponse || (GetWorkgroupResponse = {}));
+var InvalidPaginationException = (function (_super) {
+    __extends(InvalidPaginationException, _super);
+    function InvalidPaginationException(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidPaginationException", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidPaginationException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidPaginationException.prototype);
+        return _this;
+    }
+    return InvalidPaginationException;
+}(__BaseException));
+export { InvalidPaginationException };
+export var ListNamespacesRequest;
+(function (ListNamespacesRequest) {
+    ListNamespacesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListNamespacesRequest || (ListNamespacesRequest = {}));
+export var ListNamespacesResponse;
+(function (ListNamespacesResponse) {
+    ListNamespacesResponse.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.namespaces && { namespaces: obj.namespaces.map(function (item) { return Namespace.filterSensitiveLog(item); }) }))); };
+})(ListNamespacesResponse || (ListNamespacesResponse = {}));
+export var ListRecoveryPointsRequest;
+(function (ListRecoveryPointsRequest) {
+    ListRecoveryPointsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListRecoveryPointsRequest || (ListRecoveryPointsRequest = {}));
+export var ListRecoveryPointsResponse;
+(function (ListRecoveryPointsResponse) {
+    ListRecoveryPointsResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListRecoveryPointsResponse || (ListRecoveryPointsResponse = {}));
+export var ListSnapshotsRequest;
+(function (ListSnapshotsRequest) {
+    ListSnapshotsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListSnapshotsRequest || (ListSnapshotsRequest = {}));
+export var ListSnapshotsResponse;
+(function (ListSnapshotsResponse) {
+    ListSnapshotsResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListSnapshotsResponse || (ListSnapshotsResponse = {}));
+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 = {}));
+var ThrottlingException = (function (_super) {
+    __extends(ThrottlingException, _super);
+    function ThrottlingException(opts) {
+        var _this = _super.call(this, __assign({ name: "ThrottlingException", $fault: "client" }, opts)) || this;
+        _this.name = "ThrottlingException";
+        _this.$fault = "client";
+        _this.$retryable = {};
+        Object.setPrototypeOf(_this, ThrottlingException.prototype);
+        _this.code = opts.code;
+        return _this;
+    }
+    return ThrottlingException;
+}(__BaseException));
+export { ThrottlingException };
+export var ListUsageLimitsRequest;
+(function (ListUsageLimitsRequest) {
+    ListUsageLimitsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListUsageLimitsRequest || (ListUsageLimitsRequest = {}));
+export var ListUsageLimitsResponse;
+(function (ListUsageLimitsResponse) {
+    ListUsageLimitsResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListUsageLimitsResponse || (ListUsageLimitsResponse = {}));
+export var ListWorkgroupsRequest;
+(function (ListWorkgroupsRequest) {
+    ListWorkgroupsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListWorkgroupsRequest || (ListWorkgroupsRequest = {}));
+export var ListWorkgroupsResponse;
+(function (ListWorkgroupsResponse) {
+    ListWorkgroupsResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListWorkgroupsResponse || (ListWorkgroupsResponse = {}));
+export var UpdateNamespaceRequest;
+(function (UpdateNamespaceRequest) {
+    UpdateNamespaceRequest.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.adminUserPassword && { adminUserPassword: SENSITIVE_STRING })), (obj.adminUsername && { adminUsername: SENSITIVE_STRING }))); };
+})(UpdateNamespaceRequest || (UpdateNamespaceRequest = {}));
+export var UpdateNamespaceResponse;
+(function (UpdateNamespaceResponse) {
+    UpdateNamespaceResponse.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.namespace && { namespace: Namespace.filterSensitiveLog(obj.namespace) }))); };
+})(UpdateNamespaceResponse || (UpdateNamespaceResponse = {}));
+export var PutResourcePolicyRequest;
+(function (PutResourcePolicyRequest) {
+    PutResourcePolicyRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PutResourcePolicyRequest || (PutResourcePolicyRequest = {}));
+export var PutResourcePolicyResponse;
+(function (PutResourcePolicyResponse) {
+    PutResourcePolicyResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PutResourcePolicyResponse || (PutResourcePolicyResponse = {}));
+export var RestoreFromRecoveryPointRequest;
+(function (RestoreFromRecoveryPointRequest) {
+    RestoreFromRecoveryPointRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RestoreFromRecoveryPointRequest || (RestoreFromRecoveryPointRequest = {}));
+export var RestoreFromRecoveryPointResponse;
+(function (RestoreFromRecoveryPointResponse) {
+    RestoreFromRecoveryPointResponse.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.namespace && { namespace: Namespace.filterSensitiveLog(obj.namespace) }))); };
+})(RestoreFromRecoveryPointResponse || (RestoreFromRecoveryPointResponse = {}));
+export var RestoreFromSnapshotRequest;
+(function (RestoreFromSnapshotRequest) {
+    RestoreFromSnapshotRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RestoreFromSnapshotRequest || (RestoreFromSnapshotRequest = {}));
+export var RestoreFromSnapshotResponse;
+(function (RestoreFromSnapshotResponse) {
+    RestoreFromSnapshotResponse.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.namespace && { namespace: Namespace.filterSensitiveLog(obj.namespace) }))); };
+})(RestoreFromSnapshotResponse || (RestoreFromSnapshotResponse = {}));
+export var UpdateSnapshotRequest;
+(function (UpdateSnapshotRequest) {
+    UpdateSnapshotRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateSnapshotRequest || (UpdateSnapshotRequest = {}));
+export var UpdateSnapshotResponse;
+(function (UpdateSnapshotResponse) {
+    UpdateSnapshotResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateSnapshotResponse || (UpdateSnapshotResponse = {}));
+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 UpdateUsageLimitRequest;
+(function (UpdateUsageLimitRequest) {
+    UpdateUsageLimitRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateUsageLimitRequest || (UpdateUsageLimitRequest = {}));
+export var UpdateUsageLimitResponse;
+(function (UpdateUsageLimitResponse) {
+    UpdateUsageLimitResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateUsageLimitResponse || (UpdateUsageLimitResponse = {}));
+export var UpdateWorkgroupRequest;
+(function (UpdateWorkgroupRequest) {
+    UpdateWorkgroupRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateWorkgroupRequest || (UpdateWorkgroupRequest = {}));
+export var UpdateWorkgroupResponse;
+(function (UpdateWorkgroupResponse) {
+    UpdateWorkgroupResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateWorkgroupResponse || (UpdateWorkgroupResponse = {}));

package/dist-es/pagination/Interfaces.js

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

package/dist-es/pagination/ListEndpointAccessPaginator.js

@@ -0,0 +1,75 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListEndpointAccessCommand, } from "../commands/ListEndpointAccessCommand";
+import { RedshiftServerless } from "../RedshiftServerless";
+import { RedshiftServerlessClient } from "../RedshiftServerlessClient";
+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 ListEndpointAccessCommand(input)], __read(args), false))];
+                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.listEndpointAccess.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListEndpointAccess(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListEndpointAccess_1() {
+        var token, hasNext, page, prevToken;
+        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 RedshiftServerless)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof RedshiftServerlessClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected RedshiftServerless | RedshiftServerlessClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    prevToken = token;
+                    token = page.nextToken;
+                    hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/ListNamespacesPaginator.js

@@ -0,0 +1,75 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListNamespacesCommand, } from "../commands/ListNamespacesCommand";
+import { RedshiftServerless } from "../RedshiftServerless";
+import { RedshiftServerlessClient } from "../RedshiftServerlessClient";
+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 ListNamespacesCommand(input)], __read(args), false))];
+                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.listNamespaces.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListNamespaces(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListNamespaces_1() {
+        var token, hasNext, page, prevToken;
+        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 RedshiftServerless)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof RedshiftServerlessClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected RedshiftServerless | RedshiftServerlessClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    prevToken = token;
+                    token = page.nextToken;
+                    hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}