@aws-sdk/client-wisdom 3.183.0 → 3.185.0

package/dist-es/WisdomClient.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
 import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
 import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
@@ -8,26 +9,31 @@ import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-sig
 import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
 import { Client as __Client, } from "@aws-sdk/smithy-client";
 import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
-export class WisdomClient extends __Client {
-    constructor(configuration) {
-        const _config_0 = __getRuntimeConfig(configuration);
-        const _config_1 = resolveRegionConfig(_config_0);
-        const _config_2 = resolveEndpointsConfig(_config_1);
-        const _config_3 = resolveRetryConfig(_config_2);
-        const _config_4 = resolveHostHeaderConfig(_config_3);
-        const _config_5 = resolveAwsAuthConfig(_config_4);
-        const _config_6 = resolveUserAgentConfig(_config_5);
-        super(_config_6);
-        this.config = _config_6;
-        this.middlewareStack.use(getRetryPlugin(this.config));
-        this.middlewareStack.use(getContentLengthPlugin(this.config));
-        this.middlewareStack.use(getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(getLoggerPlugin(this.config));
-        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(getAwsAuthPlugin(this.config));
-        this.middlewareStack.use(getUserAgentPlugin(this.config));
+var WisdomClient = (function (_super) {
+    __extends(WisdomClient, _super);
+    function WisdomClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getRecursionDetectionPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
     }
-    destroy() {
-        super.destroy();
-    }
-}
+    WisdomClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return WisdomClient;
+}(__Client));
+export { WisdomClient };

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

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

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

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

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

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

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

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

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