@aws-sdk/client-redshift-serverless 3.107.0

package/dist-es/commands/CreateNamespaceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateNamespaceRequest, CreateNamespaceResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateNamespaceCommand, serializeAws_json1_1CreateNamespaceCommand, } from "../protocols/Aws_json1_1";
+var CreateNamespaceCommand = (function (_super) {
+    __extends(CreateNamespaceCommand, _super);
+    function CreateNamespaceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateNamespaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "CreateNamespaceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateNamespaceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateNamespaceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateNamespaceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateNamespaceCommand(input, context);
+    };
+    CreateNamespaceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateNamespaceCommand(output, context);
+    };
+    return CreateNamespaceCommand;
+}($Command));
+export { CreateNamespaceCommand };

package/dist-es/commands/CreateSnapshotCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateSnapshotRequest, CreateSnapshotResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateSnapshotCommand, serializeAws_json1_1CreateSnapshotCommand, } from "../protocols/Aws_json1_1";
+var CreateSnapshotCommand = (function (_super) {
+    __extends(CreateSnapshotCommand, _super);
+    function CreateSnapshotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateSnapshotCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "CreateSnapshotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateSnapshotRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateSnapshotResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateSnapshotCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateSnapshotCommand(input, context);
+    };
+    CreateSnapshotCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateSnapshotCommand(output, context);
+    };
+    return CreateSnapshotCommand;
+}($Command));
+export { CreateSnapshotCommand };

package/dist-es/commands/CreateUsageLimitCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateUsageLimitRequest, CreateUsageLimitResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateUsageLimitCommand, serializeAws_json1_1CreateUsageLimitCommand, } from "../protocols/Aws_json1_1";
+var CreateUsageLimitCommand = (function (_super) {
+    __extends(CreateUsageLimitCommand, _super);
+    function CreateUsageLimitCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateUsageLimitCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "CreateUsageLimitCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateUsageLimitRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateUsageLimitResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateUsageLimitCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateUsageLimitCommand(input, context);
+    };
+    CreateUsageLimitCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateUsageLimitCommand(output, context);
+    };
+    return CreateUsageLimitCommand;
+}($Command));
+export { CreateUsageLimitCommand };

package/dist-es/commands/CreateWorkgroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateWorkgroupRequest, CreateWorkgroupResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateWorkgroupCommand, serializeAws_json1_1CreateWorkgroupCommand, } from "../protocols/Aws_json1_1";
+var CreateWorkgroupCommand = (function (_super) {
+    __extends(CreateWorkgroupCommand, _super);
+    function CreateWorkgroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateWorkgroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "CreateWorkgroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateWorkgroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateWorkgroupResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateWorkgroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateWorkgroupCommand(input, context);
+    };
+    CreateWorkgroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateWorkgroupCommand(output, context);
+    };
+    return CreateWorkgroupCommand;
+}($Command));
+export { CreateWorkgroupCommand };

package/dist-es/commands/DeleteEndpointAccessCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteEndpointAccessRequest, DeleteEndpointAccessResponse } from "../models/models_0";
+import { deserializeAws_json1_1DeleteEndpointAccessCommand, serializeAws_json1_1DeleteEndpointAccessCommand, } from "../protocols/Aws_json1_1";
+var DeleteEndpointAccessCommand = (function (_super) {
+    __extends(DeleteEndpointAccessCommand, _super);
+    function DeleteEndpointAccessCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteEndpointAccessCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "DeleteEndpointAccessCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteEndpointAccessRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteEndpointAccessResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteEndpointAccessCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteEndpointAccessCommand(input, context);
+    };
+    DeleteEndpointAccessCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteEndpointAccessCommand(output, context);
+    };
+    return DeleteEndpointAccessCommand;
+}($Command));
+export { DeleteEndpointAccessCommand };

package/dist-es/commands/DeleteNamespaceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteNamespaceRequest, DeleteNamespaceResponse } from "../models/models_0";
+import { deserializeAws_json1_1DeleteNamespaceCommand, serializeAws_json1_1DeleteNamespaceCommand, } from "../protocols/Aws_json1_1";
+var DeleteNamespaceCommand = (function (_super) {
+    __extends(DeleteNamespaceCommand, _super);
+    function DeleteNamespaceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteNamespaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "DeleteNamespaceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteNamespaceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteNamespaceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteNamespaceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteNamespaceCommand(input, context);
+    };
+    DeleteNamespaceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteNamespaceCommand(output, context);
+    };
+    return DeleteNamespaceCommand;
+}($Command));
+export { DeleteNamespaceCommand };

package/dist-es/commands/DeleteResourcePolicyCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteResourcePolicyRequest, DeleteResourcePolicyResponse } from "../models/models_0";
+import { deserializeAws_json1_1DeleteResourcePolicyCommand, serializeAws_json1_1DeleteResourcePolicyCommand, } from "../protocols/Aws_json1_1";
+var DeleteResourcePolicyCommand = (function (_super) {
+    __extends(DeleteResourcePolicyCommand, _super);
+    function DeleteResourcePolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteResourcePolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "DeleteResourcePolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteResourcePolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteResourcePolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteResourcePolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteResourcePolicyCommand(input, context);
+    };
+    DeleteResourcePolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteResourcePolicyCommand(output, context);
+    };
+    return DeleteResourcePolicyCommand;
+}($Command));
+export { DeleteResourcePolicyCommand };

package/dist-es/commands/DeleteSnapshotCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteSnapshotRequest, DeleteSnapshotResponse } from "../models/models_0";
+import { deserializeAws_json1_1DeleteSnapshotCommand, serializeAws_json1_1DeleteSnapshotCommand, } from "../protocols/Aws_json1_1";
+var DeleteSnapshotCommand = (function (_super) {
+    __extends(DeleteSnapshotCommand, _super);
+    function DeleteSnapshotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteSnapshotCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "DeleteSnapshotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteSnapshotRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteSnapshotResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteSnapshotCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteSnapshotCommand(input, context);
+    };
+    DeleteSnapshotCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteSnapshotCommand(output, context);
+    };
+    return DeleteSnapshotCommand;
+}($Command));
+export { DeleteSnapshotCommand };

package/dist-es/commands/DeleteUsageLimitCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteUsageLimitRequest, DeleteUsageLimitResponse } from "../models/models_0";
+import { deserializeAws_json1_1DeleteUsageLimitCommand, serializeAws_json1_1DeleteUsageLimitCommand, } from "../protocols/Aws_json1_1";
+var DeleteUsageLimitCommand = (function (_super) {
+    __extends(DeleteUsageLimitCommand, _super);
+    function DeleteUsageLimitCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteUsageLimitCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "DeleteUsageLimitCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteUsageLimitRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteUsageLimitResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteUsageLimitCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteUsageLimitCommand(input, context);
+    };
+    DeleteUsageLimitCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteUsageLimitCommand(output, context);
+    };
+    return DeleteUsageLimitCommand;
+}($Command));
+export { DeleteUsageLimitCommand };

package/dist-es/commands/DeleteWorkgroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteWorkgroupRequest, DeleteWorkgroupResponse } from "../models/models_0";
+import { deserializeAws_json1_1DeleteWorkgroupCommand, serializeAws_json1_1DeleteWorkgroupCommand, } from "../protocols/Aws_json1_1";
+var DeleteWorkgroupCommand = (function (_super) {
+    __extends(DeleteWorkgroupCommand, _super);
+    function DeleteWorkgroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteWorkgroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "DeleteWorkgroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteWorkgroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteWorkgroupResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteWorkgroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteWorkgroupCommand(input, context);
+    };
+    DeleteWorkgroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteWorkgroupCommand(output, context);
+    };
+    return DeleteWorkgroupCommand;
+}($Command));
+export { DeleteWorkgroupCommand };

package/dist-es/commands/GetCredentialsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetCredentialsRequest, GetCredentialsResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetCredentialsCommand, serializeAws_json1_1GetCredentialsCommand, } from "../protocols/Aws_json1_1";
+var GetCredentialsCommand = (function (_super) {
+    __extends(GetCredentialsCommand, _super);
+    function GetCredentialsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetCredentialsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "GetCredentialsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetCredentialsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetCredentialsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetCredentialsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetCredentialsCommand(input, context);
+    };
+    GetCredentialsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetCredentialsCommand(output, context);
+    };
+    return GetCredentialsCommand;
+}($Command));
+export { GetCredentialsCommand };

package/dist-es/commands/GetEndpointAccessCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetEndpointAccessRequest, GetEndpointAccessResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetEndpointAccessCommand, serializeAws_json1_1GetEndpointAccessCommand, } from "../protocols/Aws_json1_1";
+var GetEndpointAccessCommand = (function (_super) {
+    __extends(GetEndpointAccessCommand, _super);
+    function GetEndpointAccessCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetEndpointAccessCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "GetEndpointAccessCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetEndpointAccessRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetEndpointAccessResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetEndpointAccessCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetEndpointAccessCommand(input, context);
+    };
+    GetEndpointAccessCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetEndpointAccessCommand(output, context);
+    };
+    return GetEndpointAccessCommand;
+}($Command));
+export { GetEndpointAccessCommand };

package/dist-es/commands/GetNamespaceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetNamespaceRequest, GetNamespaceResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetNamespaceCommand, serializeAws_json1_1GetNamespaceCommand, } from "../protocols/Aws_json1_1";
+var GetNamespaceCommand = (function (_super) {
+    __extends(GetNamespaceCommand, _super);
+    function GetNamespaceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetNamespaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "GetNamespaceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetNamespaceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetNamespaceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetNamespaceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetNamespaceCommand(input, context);
+    };
+    GetNamespaceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetNamespaceCommand(output, context);
+    };
+    return GetNamespaceCommand;
+}($Command));
+export { GetNamespaceCommand };

package/dist-es/commands/GetRecoveryPointCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetRecoveryPointRequest, GetRecoveryPointResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetRecoveryPointCommand, serializeAws_json1_1GetRecoveryPointCommand, } from "../protocols/Aws_json1_1";
+var GetRecoveryPointCommand = (function (_super) {
+    __extends(GetRecoveryPointCommand, _super);
+    function GetRecoveryPointCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetRecoveryPointCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "GetRecoveryPointCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetRecoveryPointRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetRecoveryPointResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRecoveryPointCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetRecoveryPointCommand(input, context);
+    };
+    GetRecoveryPointCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetRecoveryPointCommand(output, context);
+    };
+    return GetRecoveryPointCommand;
+}($Command));
+export { GetRecoveryPointCommand };

package/dist-es/commands/GetResourcePolicyCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetResourcePolicyRequest, GetResourcePolicyResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetResourcePolicyCommand, serializeAws_json1_1GetResourcePolicyCommand, } from "../protocols/Aws_json1_1";
+var GetResourcePolicyCommand = (function (_super) {
+    __extends(GetResourcePolicyCommand, _super);
+    function GetResourcePolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetResourcePolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "GetResourcePolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetResourcePolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetResourcePolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetResourcePolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetResourcePolicyCommand(input, context);
+    };
+    GetResourcePolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetResourcePolicyCommand(output, context);
+    };
+    return GetResourcePolicyCommand;
+}($Command));
+export { GetResourcePolicyCommand };

package/dist-es/commands/GetSnapshotCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetSnapshotRequest, GetSnapshotResponse } from "../models/models_0";
+import { deserializeAws_json1_1GetSnapshotCommand, serializeAws_json1_1GetSnapshotCommand, } from "../protocols/Aws_json1_1";
+var GetSnapshotCommand = (function (_super) {
+    __extends(GetSnapshotCommand, _super);
+    function GetSnapshotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetSnapshotCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RedshiftServerlessClient";
+        var commandName = "GetSnapshotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetSnapshotRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetSnapshotResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetSnapshotCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1GetSnapshotCommand(input, context);
+    };
+    GetSnapshotCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1GetSnapshotCommand(output, context);
+    };
+    return GetSnapshotCommand;
+}($Command));
+export { GetSnapshotCommand };