@aws-sdk/client-cloudsearch 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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