@aws-sdk/client-appsync 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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