@aws-sdk/client-finspace-data 3.40.0 → 3.45.0

package/dist-es/FinspaceData.js

@@ -1,7 +1,18 @@
 import { __extends } from "tslib";
 import { CreateChangesetCommand, } from "./commands/CreateChangesetCommand";
+import { CreateDatasetCommand, } from "./commands/CreateDatasetCommand";
+import { CreateDataViewCommand, } from "./commands/CreateDataViewCommand";
+import { DeleteDatasetCommand, } from "./commands/DeleteDatasetCommand";
+import { GetChangesetCommand, } from "./commands/GetChangesetCommand";
+import { GetDatasetCommand } from "./commands/GetDatasetCommand";
+import { GetDataViewCommand } from "./commands/GetDataViewCommand";
 import { GetProgrammaticAccessCredentialsCommand, } from "./commands/GetProgrammaticAccessCredentialsCommand";
 import { GetWorkingLocationCommand, } from "./commands/GetWorkingLocationCommand";
+import { ListChangesetsCommand, } from "./commands/ListChangesetsCommand";
+import { ListDatasetsCommand, } from "./commands/ListDatasetsCommand";
+import { ListDataViewsCommand, } from "./commands/ListDataViewsCommand";
+import { UpdateChangesetCommand, } from "./commands/UpdateChangesetCommand";
+import { UpdateDatasetCommand, } from "./commands/UpdateDatasetCommand";
 import { FinspaceDataClient } from "./FinspaceDataClient";
 var FinspaceData = (function (_super) {
     __extends(FinspaceData, _super);
@@ -22,6 +33,90 @@ var FinspaceData = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    FinspaceData.prototype.createDataset = function (args, optionsOrCb, cb) {
+        var command = new CreateDatasetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    FinspaceData.prototype.createDataView = function (args, optionsOrCb, cb) {
+        var command = new CreateDataViewCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    FinspaceData.prototype.deleteDataset = function (args, optionsOrCb, cb) {
+        var command = new DeleteDatasetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    FinspaceData.prototype.getChangeset = function (args, optionsOrCb, cb) {
+        var command = new GetChangesetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    FinspaceData.prototype.getDataset = function (args, optionsOrCb, cb) {
+        var command = new GetDatasetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    FinspaceData.prototype.getDataView = function (args, optionsOrCb, cb) {
+        var command = new GetDataViewCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     FinspaceData.prototype.getProgrammaticAccessCredentials = function (args, optionsOrCb, cb) {
         var command = new GetProgrammaticAccessCredentialsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -50,6 +145,76 @@ var FinspaceData = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    FinspaceData.prototype.listChangesets = function (args, optionsOrCb, cb) {
+        var command = new ListChangesetsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    FinspaceData.prototype.listDatasets = function (args, optionsOrCb, cb) {
+        var command = new ListDatasetsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    FinspaceData.prototype.listDataViews = function (args, optionsOrCb, cb) {
+        var command = new ListDataViewsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    FinspaceData.prototype.updateChangeset = function (args, optionsOrCb, cb) {
+        var command = new UpdateChangesetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    FinspaceData.prototype.updateDataset = function (args, optionsOrCb, cb) {
+        var command = new UpdateDatasetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     return FinspaceData;
 }(FinspaceDataClient));
 export { FinspaceData };

package/dist-es/commands/CreateDataViewCommand.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 { CreateDataViewRequest, CreateDataViewResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateDataViewCommand, serializeAws_restJson1CreateDataViewCommand, } from "../protocols/Aws_restJson1";
+var CreateDataViewCommand = (function (_super) {
+    __extends(CreateDataViewCommand, _super);
+    function CreateDataViewCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateDataViewCommand.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 = "FinspaceDataClient";
+        var commandName = "CreateDataViewCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateDataViewRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDataViewResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDataViewCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateDataViewCommand(input, context);
+    };
+    CreateDataViewCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateDataViewCommand(output, context);
+    };
+    return CreateDataViewCommand;
+}($Command));
+export { CreateDataViewCommand };

package/dist-es/commands/CreateDatasetCommand.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 { CreateDatasetRequest, CreateDatasetResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateDatasetCommand, serializeAws_restJson1CreateDatasetCommand, } from "../protocols/Aws_restJson1";
+var CreateDatasetCommand = (function (_super) {
+    __extends(CreateDatasetCommand, _super);
+    function CreateDatasetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateDatasetCommand.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 = "FinspaceDataClient";
+        var commandName = "CreateDatasetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateDatasetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDatasetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDatasetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateDatasetCommand(input, context);
+    };
+    CreateDatasetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateDatasetCommand(output, context);
+    };
+    return CreateDatasetCommand;
+}($Command));
+export { CreateDatasetCommand };

package/dist-es/commands/DeleteDatasetCommand.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 { DeleteDatasetRequest, DeleteDatasetResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteDatasetCommand, serializeAws_restJson1DeleteDatasetCommand, } from "../protocols/Aws_restJson1";
+var DeleteDatasetCommand = (function (_super) {
+    __extends(DeleteDatasetCommand, _super);
+    function DeleteDatasetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteDatasetCommand.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 = "FinspaceDataClient";
+        var commandName = "DeleteDatasetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteDatasetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteDatasetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteDatasetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteDatasetCommand(input, context);
+    };
+    DeleteDatasetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteDatasetCommand(output, context);
+    };
+    return DeleteDatasetCommand;
+}($Command));
+export { DeleteDatasetCommand };

package/dist-es/commands/GetChangesetCommand.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 { GetChangesetRequest, GetChangesetResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetChangesetCommand, serializeAws_restJson1GetChangesetCommand, } from "../protocols/Aws_restJson1";
+var GetChangesetCommand = (function (_super) {
+    __extends(GetChangesetCommand, _super);
+    function GetChangesetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetChangesetCommand.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 = "FinspaceDataClient";
+        var commandName = "GetChangesetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetChangesetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetChangesetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetChangesetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetChangesetCommand(input, context);
+    };
+    GetChangesetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetChangesetCommand(output, context);
+    };
+    return GetChangesetCommand;
+}($Command));
+export { GetChangesetCommand };

package/dist-es/commands/GetDataViewCommand.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 { GetDataViewRequest, GetDataViewResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetDataViewCommand, serializeAws_restJson1GetDataViewCommand, } from "../protocols/Aws_restJson1";
+var GetDataViewCommand = (function (_super) {
+    __extends(GetDataViewCommand, _super);
+    function GetDataViewCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetDataViewCommand.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 = "FinspaceDataClient";
+        var commandName = "GetDataViewCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetDataViewRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetDataViewResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetDataViewCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetDataViewCommand(input, context);
+    };
+    GetDataViewCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetDataViewCommand(output, context);
+    };
+    return GetDataViewCommand;
+}($Command));
+export { GetDataViewCommand };

package/dist-es/commands/GetDatasetCommand.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 { GetDatasetRequest, GetDatasetResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetDatasetCommand, serializeAws_restJson1GetDatasetCommand, } from "../protocols/Aws_restJson1";
+var GetDatasetCommand = (function (_super) {
+    __extends(GetDatasetCommand, _super);
+    function GetDatasetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetDatasetCommand.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 = "FinspaceDataClient";
+        var commandName = "GetDatasetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetDatasetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetDatasetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetDatasetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetDatasetCommand(input, context);
+    };
+    GetDatasetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetDatasetCommand(output, context);
+    };
+    return GetDatasetCommand;
+}($Command));
+export { GetDatasetCommand };

package/dist-es/commands/ListChangesetsCommand.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 { ListChangesetsRequest, ListChangesetsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListChangesetsCommand, serializeAws_restJson1ListChangesetsCommand, } from "../protocols/Aws_restJson1";
+var ListChangesetsCommand = (function (_super) {
+    __extends(ListChangesetsCommand, _super);
+    function ListChangesetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListChangesetsCommand.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 = "FinspaceDataClient";
+        var commandName = "ListChangesetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListChangesetsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListChangesetsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListChangesetsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListChangesetsCommand(input, context);
+    };
+    ListChangesetsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListChangesetsCommand(output, context);
+    };
+    return ListChangesetsCommand;
+}($Command));
+export { ListChangesetsCommand };

package/dist-es/commands/ListDataViewsCommand.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 { ListDataViewsRequest, ListDataViewsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListDataViewsCommand, serializeAws_restJson1ListDataViewsCommand, } from "../protocols/Aws_restJson1";
+var ListDataViewsCommand = (function (_super) {
+    __extends(ListDataViewsCommand, _super);
+    function ListDataViewsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListDataViewsCommand.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 = "FinspaceDataClient";
+        var commandName = "ListDataViewsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListDataViewsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListDataViewsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListDataViewsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListDataViewsCommand(input, context);
+    };
+    ListDataViewsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListDataViewsCommand(output, context);
+    };
+    return ListDataViewsCommand;
+}($Command));
+export { ListDataViewsCommand };

package/dist-es/commands/ListDatasetsCommand.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 { ListDatasetsRequest, ListDatasetsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListDatasetsCommand, serializeAws_restJson1ListDatasetsCommand, } from "../protocols/Aws_restJson1";
+var ListDatasetsCommand = (function (_super) {
+    __extends(ListDatasetsCommand, _super);
+    function ListDatasetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListDatasetsCommand.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 = "FinspaceDataClient";
+        var commandName = "ListDatasetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListDatasetsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListDatasetsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListDatasetsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListDatasetsCommand(input, context);
+    };
+    ListDatasetsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListDatasetsCommand(output, context);
+    };
+    return ListDatasetsCommand;
+}($Command));
+export { ListDatasetsCommand };

package/dist-es/commands/UpdateChangesetCommand.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 { UpdateChangesetRequest, UpdateChangesetResponse } from "../models/models_0";
+import { deserializeAws_restJson1UpdateChangesetCommand, serializeAws_restJson1UpdateChangesetCommand, } from "../protocols/Aws_restJson1";
+var UpdateChangesetCommand = (function (_super) {
+    __extends(UpdateChangesetCommand, _super);
+    function UpdateChangesetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateChangesetCommand.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 = "FinspaceDataClient";
+        var commandName = "UpdateChangesetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateChangesetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateChangesetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateChangesetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateChangesetCommand(input, context);
+    };
+    UpdateChangesetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateChangesetCommand(output, context);
+    };
+    return UpdateChangesetCommand;
+}($Command));
+export { UpdateChangesetCommand };

package/dist-es/commands/UpdateDatasetCommand.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 { UpdateDatasetRequest, UpdateDatasetResponse } from "../models/models_0";
+import { deserializeAws_restJson1UpdateDatasetCommand, serializeAws_restJson1UpdateDatasetCommand, } from "../protocols/Aws_restJson1";
+var UpdateDatasetCommand = (function (_super) {
+    __extends(UpdateDatasetCommand, _super);
+    function UpdateDatasetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateDatasetCommand.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 = "FinspaceDataClient";
+        var commandName = "UpdateDatasetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateDatasetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateDatasetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateDatasetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1UpdateDatasetCommand(input, context);
+    };
+    UpdateDatasetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1UpdateDatasetCommand(output, context);
+    };
+    return UpdateDatasetCommand;
+}($Command));
+export { UpdateDatasetCommand };

package/dist-es/commands/index.js

@@ -1,3 +1,14 @@
 export * from "./CreateChangesetCommand";
+export * from "./CreateDataViewCommand";
+export * from "./CreateDatasetCommand";
+export * from "./DeleteDatasetCommand";
+export * from "./GetChangesetCommand";
+export * from "./GetDataViewCommand";
+export * from "./GetDatasetCommand";
 export * from "./GetProgrammaticAccessCredentialsCommand";
 export * from "./GetWorkingLocationCommand";
+export * from "./ListChangesetsCommand";
+export * from "./ListDataViewsCommand";
+export * from "./ListDatasetsCommand";
+export * from "./UpdateChangesetCommand";
+export * from "./UpdateDatasetCommand";