@aws-sdk/client-wisdom 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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