@aws-sdk/client-xray 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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