@aws-sdk/client-finspace-data 3.52.0 → 3.54.1

package/dist-es/FinspaceData.js

@@ -2,17 +2,28 @@ import { __extends } from "tslib";
 import { CreateChangesetCommand, } from "./commands/CreateChangesetCommand";
 import { CreateDatasetCommand, } from "./commands/CreateDatasetCommand";
 import { CreateDataViewCommand, } from "./commands/CreateDataViewCommand";
+import { CreatePermissionGroupCommand, } from "./commands/CreatePermissionGroupCommand";
+import { CreateUserCommand } from "./commands/CreateUserCommand";
 import { DeleteDatasetCommand, } from "./commands/DeleteDatasetCommand";
+import { DeletePermissionGroupCommand, } from "./commands/DeletePermissionGroupCommand";
+import { DisableUserCommand } from "./commands/DisableUserCommand";
+import { EnableUserCommand } from "./commands/EnableUserCommand";
 import { GetChangesetCommand, } from "./commands/GetChangesetCommand";
 import { GetDatasetCommand } from "./commands/GetDatasetCommand";
 import { GetDataViewCommand } from "./commands/GetDataViewCommand";
 import { GetProgrammaticAccessCredentialsCommand, } from "./commands/GetProgrammaticAccessCredentialsCommand";
+import { GetUserCommand } from "./commands/GetUserCommand";
 import { GetWorkingLocationCommand, } from "./commands/GetWorkingLocationCommand";
 import { ListChangesetsCommand, } from "./commands/ListChangesetsCommand";
 import { ListDatasetsCommand, } from "./commands/ListDatasetsCommand";
 import { ListDataViewsCommand, } from "./commands/ListDataViewsCommand";
+import { ListPermissionGroupsCommand, } from "./commands/ListPermissionGroupsCommand";
+import { ListUsersCommand } from "./commands/ListUsersCommand";
+import { ResetUserPasswordCommand, } from "./commands/ResetUserPasswordCommand";
 import { UpdateChangesetCommand, } from "./commands/UpdateChangesetCommand";
 import { UpdateDatasetCommand, } from "./commands/UpdateDatasetCommand";
+import { UpdatePermissionGroupCommand, } from "./commands/UpdatePermissionGroupCommand";
+import { UpdateUserCommand } from "./commands/UpdateUserCommand";
 import { FinspaceDataClient } from "./FinspaceDataClient";
 var FinspaceData = (function (_super) {
     __extends(FinspaceData, _super);
@@ -61,6 +72,34 @@ var FinspaceData = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    FinspaceData.prototype.createPermissionGroup = function (args, optionsOrCb, cb) {
+        var command = new CreatePermissionGroupCommand(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.createUser = function (args, optionsOrCb, cb) {
+        var command = new CreateUserCommand(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") {
@@ -75,6 +114,48 @@ var FinspaceData = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    FinspaceData.prototype.deletePermissionGroup = function (args, optionsOrCb, cb) {
+        var command = new DeletePermissionGroupCommand(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.disableUser = function (args, optionsOrCb, cb) {
+        var command = new DisableUserCommand(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.enableUser = function (args, optionsOrCb, cb) {
+        var command = new EnableUserCommand(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") {
@@ -131,6 +212,20 @@ var FinspaceData = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    FinspaceData.prototype.getUser = function (args, optionsOrCb, cb) {
+        var command = new GetUserCommand(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.getWorkingLocation = function (args, optionsOrCb, cb) {
         var command = new GetWorkingLocationCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -187,6 +282,48 @@ var FinspaceData = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    FinspaceData.prototype.listPermissionGroups = function (args, optionsOrCb, cb) {
+        var command = new ListPermissionGroupsCommand(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.listUsers = function (args, optionsOrCb, cb) {
+        var command = new ListUsersCommand(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.resetUserPassword = function (args, optionsOrCb, cb) {
+        var command = new ResetUserPasswordCommand(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") {
@@ -215,6 +352,34 @@ var FinspaceData = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    FinspaceData.prototype.updatePermissionGroup = function (args, optionsOrCb, cb) {
+        var command = new UpdatePermissionGroupCommand(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.updateUser = function (args, optionsOrCb, cb) {
+        var command = new UpdateUserCommand(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/CreatePermissionGroupCommand.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 { CreatePermissionGroupRequest, CreatePermissionGroupResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreatePermissionGroupCommand, serializeAws_restJson1CreatePermissionGroupCommand, } from "../protocols/Aws_restJson1";
+var CreatePermissionGroupCommand = (function (_super) {
+    __extends(CreatePermissionGroupCommand, _super);
+    function CreatePermissionGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreatePermissionGroupCommand.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 = "CreatePermissionGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreatePermissionGroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreatePermissionGroupResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreatePermissionGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreatePermissionGroupCommand(input, context);
+    };
+    CreatePermissionGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreatePermissionGroupCommand(output, context);
+    };
+    return CreatePermissionGroupCommand;
+}($Command));
+export { CreatePermissionGroupCommand };

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

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

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

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

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

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

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

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

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

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