@aws-sdk/client-quicksight 3.183.0 → 3.186.0

package/dist-es/commands/CreateGroupCommand.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 { CreateGroupRequestFilterSensitiveLog, CreateGroupResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateGroupCommand, serializeAws_restJson1CreateGroupCommand, } from "../protocols/Aws_restJson1";
-export class CreateGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateGroupCommand = (function (_super) {
+    __extends(CreateGroupCommand, _super);
+    function CreateGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateGroupCommand.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 = "QuickSightClient";
-        const commandName = "CreateGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "QuickSightClient";
+        var commandName = "CreateGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateGroupResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateGroupCommand(output, context);
-    }
-}
+    };
+    return CreateGroupCommand;
+}($Command));
+export { CreateGroupCommand };

package/dist-es/commands/CreateGroupMembershipCommand.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 { CreateGroupMembershipRequestFilterSensitiveLog, CreateGroupMembershipResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateGroupMembershipCommand, serializeAws_restJson1CreateGroupMembershipCommand, } from "../protocols/Aws_restJson1";
-export class CreateGroupMembershipCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateGroupMembershipCommand = (function (_super) {
+    __extends(CreateGroupMembershipCommand, _super);
+    function CreateGroupMembershipCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateGroupMembershipCommand.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 = "QuickSightClient";
-        const commandName = "CreateGroupMembershipCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "QuickSightClient";
+        var commandName = "CreateGroupMembershipCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateGroupMembershipRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateGroupMembershipResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateGroupMembershipCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateGroupMembershipCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateGroupMembershipCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateGroupMembershipCommand(output, context);
-    }
-}
+    };
+    return CreateGroupMembershipCommand;
+}($Command));
+export { CreateGroupMembershipCommand };

package/dist-es/commands/CreateIAMPolicyAssignmentCommand.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 { CreateIAMPolicyAssignmentRequestFilterSensitiveLog, CreateIAMPolicyAssignmentResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateIAMPolicyAssignmentCommand, serializeAws_restJson1CreateIAMPolicyAssignmentCommand, } from "../protocols/Aws_restJson1";
-export class CreateIAMPolicyAssignmentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateIAMPolicyAssignmentCommand = (function (_super) {
+    __extends(CreateIAMPolicyAssignmentCommand, _super);
+    function CreateIAMPolicyAssignmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateIAMPolicyAssignmentCommand.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 = "QuickSightClient";
-        const commandName = "CreateIAMPolicyAssignmentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "QuickSightClient";
+        var commandName = "CreateIAMPolicyAssignmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateIAMPolicyAssignmentRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateIAMPolicyAssignmentResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateIAMPolicyAssignmentCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateIAMPolicyAssignmentCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateIAMPolicyAssignmentCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateIAMPolicyAssignmentCommand(output, context);
-    }
-}
+    };
+    return CreateIAMPolicyAssignmentCommand;
+}($Command));
+export { CreateIAMPolicyAssignmentCommand };

package/dist-es/commands/CreateIngestionCommand.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 { CreateIngestionRequestFilterSensitiveLog, CreateIngestionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateIngestionCommand, serializeAws_restJson1CreateIngestionCommand, } from "../protocols/Aws_restJson1";
-export class CreateIngestionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateIngestionCommand = (function (_super) {
+    __extends(CreateIngestionCommand, _super);
+    function CreateIngestionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateIngestionCommand.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 = "QuickSightClient";
-        const commandName = "CreateIngestionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "QuickSightClient";
+        var commandName = "CreateIngestionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateIngestionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateIngestionResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateIngestionCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateIngestionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateIngestionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateIngestionCommand(output, context);
-    }
-}
+    };
+    return CreateIngestionCommand;
+}($Command));
+export { CreateIngestionCommand };

package/dist-es/commands/CreateNamespaceCommand.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 { CreateNamespaceRequestFilterSensitiveLog, CreateNamespaceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateNamespaceCommand, serializeAws_restJson1CreateNamespaceCommand, } from "../protocols/Aws_restJson1";
-export class CreateNamespaceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateNamespaceCommand = (function (_super) {
+    __extends(CreateNamespaceCommand, _super);
+    function CreateNamespaceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateNamespaceCommand.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 = "QuickSightClient";
-        const commandName = "CreateNamespaceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "QuickSightClient";
+        var commandName = "CreateNamespaceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateNamespaceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateNamespaceResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateNamespaceCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateNamespaceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateNamespaceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateNamespaceCommand(output, context);
-    }
-}
+    };
+    return CreateNamespaceCommand;
+}($Command));
+export { CreateNamespaceCommand };

package/dist-es/commands/CreateTemplateAliasCommand.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 { CreateTemplateAliasRequestFilterSensitiveLog, CreateTemplateAliasResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateTemplateAliasCommand, serializeAws_restJson1CreateTemplateAliasCommand, } from "../protocols/Aws_restJson1";
-export class CreateTemplateAliasCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateTemplateAliasCommand = (function (_super) {
+    __extends(CreateTemplateAliasCommand, _super);
+    function CreateTemplateAliasCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateTemplateAliasCommand.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 = "QuickSightClient";
-        const commandName = "CreateTemplateAliasCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "QuickSightClient";
+        var commandName = "CreateTemplateAliasCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateTemplateAliasRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateTemplateAliasResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateTemplateAliasCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateTemplateAliasCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateTemplateAliasCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateTemplateAliasCommand(output, context);
-    }
-}
+    };
+    return CreateTemplateAliasCommand;
+}($Command));
+export { CreateTemplateAliasCommand };

package/dist-es/commands/CreateTemplateCommand.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 { CreateTemplateRequestFilterSensitiveLog, CreateTemplateResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateTemplateCommand, serializeAws_restJson1CreateTemplateCommand, } from "../protocols/Aws_restJson1";
-export class CreateTemplateCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateTemplateCommand = (function (_super) {
+    __extends(CreateTemplateCommand, _super);
+    function CreateTemplateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateTemplateCommand.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 = "QuickSightClient";
-        const commandName = "CreateTemplateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "QuickSightClient";
+        var commandName = "CreateTemplateCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateTemplateRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateTemplateResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateTemplateCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateTemplateCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateTemplateCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateTemplateCommand(output, context);
-    }
-}
+    };
+    return CreateTemplateCommand;
+}($Command));
+export { CreateTemplateCommand };

package/dist-es/commands/CreateThemeAliasCommand.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 { CreateThemeAliasRequestFilterSensitiveLog, CreateThemeAliasResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateThemeAliasCommand, serializeAws_restJson1CreateThemeAliasCommand, } from "../protocols/Aws_restJson1";
-export class CreateThemeAliasCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateThemeAliasCommand = (function (_super) {
+    __extends(CreateThemeAliasCommand, _super);
+    function CreateThemeAliasCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateThemeAliasCommand.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 = "QuickSightClient";
-        const commandName = "CreateThemeAliasCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "QuickSightClient";
+        var commandName = "CreateThemeAliasCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateThemeAliasRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateThemeAliasResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateThemeAliasCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateThemeAliasCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateThemeAliasCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateThemeAliasCommand(output, context);
-    }
-}
+    };
+    return CreateThemeAliasCommand;
+}($Command));
+export { CreateThemeAliasCommand };

package/dist-es/commands/CreateThemeCommand.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 { CreateThemeRequestFilterSensitiveLog, CreateThemeResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateThemeCommand, serializeAws_restJson1CreateThemeCommand, } from "../protocols/Aws_restJson1";
-export class CreateThemeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateThemeCommand = (function (_super) {
+    __extends(CreateThemeCommand, _super);
+    function CreateThemeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateThemeCommand.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 = "QuickSightClient";
-        const commandName = "CreateThemeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "QuickSightClient";
+        var commandName = "CreateThemeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateThemeRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateThemeResponseFilterSensitiveLog,
         };
-        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);
+    };
+    CreateThemeCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateThemeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateThemeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateThemeCommand(output, context);
-    }
-}
+    };
+    return CreateThemeCommand;
+}($Command));
+export { CreateThemeCommand };

package/dist-es/commands/DeleteAccountCustomizationCommand.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 { DeleteAccountCustomizationRequestFilterSensitiveLog, DeleteAccountCustomizationResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeleteAccountCustomizationCommand, serializeAws_restJson1DeleteAccountCustomizationCommand, } from "../protocols/Aws_restJson1";
-export class DeleteAccountCustomizationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteAccountCustomizationCommand = (function (_super) {
+    __extends(DeleteAccountCustomizationCommand, _super);
+    function DeleteAccountCustomizationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteAccountCustomizationCommand.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 = "QuickSightClient";
-        const commandName = "DeleteAccountCustomizationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "QuickSightClient";
+        var commandName = "DeleteAccountCustomizationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteAccountCustomizationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteAccountCustomizationResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DeleteAccountCustomizationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteAccountCustomizationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteAccountCustomizationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteAccountCustomizationCommand(output, context);
-    }
-}
+    };
+    return DeleteAccountCustomizationCommand;
+}($Command));
+export { DeleteAccountCustomizationCommand };