@aws-sdk/client-finspace-data 3.183.0 → 3.186.0

package/dist-es/commands/ListChangesetsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListChangesetsRequestFilterSensitiveLog, ListChangesetsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListChangesetsCommand, serializeAws_restJson1ListChangesetsCommand, } from "../protocols/Aws_restJson1";
-export class ListChangesetsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListChangesetsCommand = (function (_super) {
+    __extends(ListChangesetsCommand, _super);
+    function ListChangesetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListChangesetsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FinspaceDataClient";
-        const commandName = "ListChangesetsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListChangesetsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListChangesetsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListChangesetsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListChangesetsCommand(output, context);
-    }
-}
+    };
+    return ListChangesetsCommand;
+}($Command));
+export { ListChangesetsCommand };

package/dist-es/commands/ListDataViewsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListDataViewsRequestFilterSensitiveLog, ListDataViewsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListDataViewsCommand, serializeAws_restJson1ListDataViewsCommand, } from "../protocols/Aws_restJson1";
-export class ListDataViewsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListDataViewsCommand = (function (_super) {
+    __extends(ListDataViewsCommand, _super);
+    function ListDataViewsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListDataViewsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FinspaceDataClient";
-        const commandName = "ListDataViewsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListDataViewsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListDataViewsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListDataViewsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListDataViewsCommand(output, context);
-    }
-}
+    };
+    return ListDataViewsCommand;
+}($Command));
+export { ListDataViewsCommand };

package/dist-es/commands/ListDatasetsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListDatasetsRequestFilterSensitiveLog, ListDatasetsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListDatasetsCommand, serializeAws_restJson1ListDatasetsCommand, } from "../protocols/Aws_restJson1";
-export class ListDatasetsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListDatasetsCommand = (function (_super) {
+    __extends(ListDatasetsCommand, _super);
+    function ListDatasetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListDatasetsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FinspaceDataClient";
-        const commandName = "ListDatasetsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListDatasetsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListDatasetsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListDatasetsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListDatasetsCommand(output, context);
-    }
-}
+    };
+    return ListDatasetsCommand;
+}($Command));
+export { ListDatasetsCommand };

package/dist-es/commands/ListPermissionGroupsByUserCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListPermissionGroupsByUserRequestFilterSensitiveLog, ListPermissionGroupsByUserResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListPermissionGroupsByUserCommand, serializeAws_restJson1ListPermissionGroupsByUserCommand, } from "../protocols/Aws_restJson1";
-export class ListPermissionGroupsByUserCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListPermissionGroupsByUserCommand = (function (_super) {
+    __extends(ListPermissionGroupsByUserCommand, _super);
+    function ListPermissionGroupsByUserCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListPermissionGroupsByUserCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FinspaceDataClient";
-        const commandName = "ListPermissionGroupsByUserCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FinspaceDataClient";
+        var commandName = "ListPermissionGroupsByUserCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListPermissionGroupsByUserRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListPermissionGroupsByUserResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListPermissionGroupsByUserCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListPermissionGroupsByUserCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListPermissionGroupsByUserCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListPermissionGroupsByUserCommand(output, context);
-    }
-}
+    };
+    return ListPermissionGroupsByUserCommand;
+}($Command));
+export { ListPermissionGroupsByUserCommand };

package/dist-es/commands/ListPermissionGroupsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListPermissionGroupsRequestFilterSensitiveLog, ListPermissionGroupsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListPermissionGroupsCommand, serializeAws_restJson1ListPermissionGroupsCommand, } from "../protocols/Aws_restJson1";
-export class ListPermissionGroupsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListPermissionGroupsCommand = (function (_super) {
+    __extends(ListPermissionGroupsCommand, _super);
+    function ListPermissionGroupsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListPermissionGroupsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FinspaceDataClient";
-        const commandName = "ListPermissionGroupsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListPermissionGroupsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListPermissionGroupsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListPermissionGroupsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListPermissionGroupsCommand(output, context);
-    }
-}
+    };
+    return ListPermissionGroupsCommand;
+}($Command));
+export { ListPermissionGroupsCommand };

package/dist-es/commands/ListUsersByPermissionGroupCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListUsersByPermissionGroupRequestFilterSensitiveLog, ListUsersByPermissionGroupResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListUsersByPermissionGroupCommand, serializeAws_restJson1ListUsersByPermissionGroupCommand, } from "../protocols/Aws_restJson1";
-export class ListUsersByPermissionGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListUsersByPermissionGroupCommand = (function (_super) {
+    __extends(ListUsersByPermissionGroupCommand, _super);
+    function ListUsersByPermissionGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListUsersByPermissionGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FinspaceDataClient";
-        const commandName = "ListUsersByPermissionGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "FinspaceDataClient";
+        var commandName = "ListUsersByPermissionGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListUsersByPermissionGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListUsersByPermissionGroupResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListUsersByPermissionGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListUsersByPermissionGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListUsersByPermissionGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListUsersByPermissionGroupCommand(output, context);
-    }
-}
+    };
+    return ListUsersByPermissionGroupCommand;
+}($Command));
+export { ListUsersByPermissionGroupCommand };

package/dist-es/commands/ListUsersCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListUsersRequestFilterSensitiveLog, ListUsersResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListUsersCommand, serializeAws_restJson1ListUsersCommand, } from "../protocols/Aws_restJson1";
-export class ListUsersCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListUsersCommand = (function (_super) {
+    __extends(ListUsersCommand, _super);
+    function ListUsersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListUsersCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FinspaceDataClient";
-        const commandName = "ListUsersCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListUsersRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListUsersResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListUsersCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListUsersCommand(output, context);
-    }
-}
+    };
+    return ListUsersCommand;
+}($Command));
+export { ListUsersCommand };

package/dist-es/commands/ResetUserPasswordCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ResetUserPasswordRequestFilterSensitiveLog, ResetUserPasswordResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ResetUserPasswordCommand, serializeAws_restJson1ResetUserPasswordCommand, } from "../protocols/Aws_restJson1";
-export class ResetUserPasswordCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ResetUserPasswordCommand = (function (_super) {
+    __extends(ResetUserPasswordCommand, _super);
+    function ResetUserPasswordCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ResetUserPasswordCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FinspaceDataClient";
-        const commandName = "ResetUserPasswordCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ResetUserPasswordRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ResetUserPasswordResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ResetUserPasswordCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ResetUserPasswordCommand(output, context);
-    }
-}
+    };
+    return ResetUserPasswordCommand;
+}($Command));
+export { ResetUserPasswordCommand };

package/dist-es/commands/UpdateChangesetCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateChangesetRequestFilterSensitiveLog, UpdateChangesetResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateChangesetCommand, serializeAws_restJson1UpdateChangesetCommand, } from "../protocols/Aws_restJson1";
-export class UpdateChangesetCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateChangesetCommand = (function (_super) {
+    __extends(UpdateChangesetCommand, _super);
+    function UpdateChangesetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateChangesetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FinspaceDataClient";
-        const commandName = "UpdateChangesetCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: UpdateChangesetRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateChangesetResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    UpdateChangesetCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateChangesetCommand(output, context);
-    }
-}
+    };
+    return UpdateChangesetCommand;
+}($Command));
+export { UpdateChangesetCommand };

package/dist-es/commands/UpdateDatasetCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { UpdateDatasetRequestFilterSensitiveLog, UpdateDatasetResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1UpdateDatasetCommand, serializeAws_restJson1UpdateDatasetCommand, } from "../protocols/Aws_restJson1";
-export class UpdateDatasetCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var UpdateDatasetCommand = (function (_super) {
+    __extends(UpdateDatasetCommand, _super);
+    function UpdateDatasetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    UpdateDatasetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "FinspaceDataClient";
-        const commandName = "UpdateDatasetCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: UpdateDatasetRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UpdateDatasetResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    UpdateDatasetCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1UpdateDatasetCommand(output, context);
-    }
-}
+    };
+    return UpdateDatasetCommand;
+}($Command));
+export { UpdateDatasetCommand };