@aws-sdk/client-appsync 3.183.0 → 3.185.0

package/dist-es/AppSync.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { AppSyncClient } from "./AppSyncClient";
 import { AssociateApiCommand, } from "./commands/AssociateApiCommand";
 import { CreateApiCacheCommand, } from "./commands/CreateApiCacheCommand";
@@ -49,705 +50,711 @@ import { UpdateFunctionCommand, } from "./commands/UpdateFunctionCommand";
 import { UpdateGraphqlApiCommand, } from "./commands/UpdateGraphqlApiCommand";
 import { UpdateResolverCommand, } from "./commands/UpdateResolverCommand";
 import { UpdateTypeCommand } from "./commands/UpdateTypeCommand";
-export class AppSync extends AppSyncClient {
-    associateApi(args, optionsOrCb, cb) {
-        const command = new AssociateApiCommand(args);
+var AppSync = (function (_super) {
+    __extends(AppSync, _super);
+    function AppSync() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AppSync.prototype.associateApi = function (args, optionsOrCb, cb) {
+        var command = new AssociateApiCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createApiCache(args, optionsOrCb, cb) {
-        const command = new CreateApiCacheCommand(args);
+    };
+    AppSync.prototype.createApiCache = function (args, optionsOrCb, cb) {
+        var command = new CreateApiCacheCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createApiKey(args, optionsOrCb, cb) {
-        const command = new CreateApiKeyCommand(args);
+    };
+    AppSync.prototype.createApiKey = function (args, optionsOrCb, cb) {
+        var command = new CreateApiKeyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDataSource(args, optionsOrCb, cb) {
-        const command = new CreateDataSourceCommand(args);
+    };
+    AppSync.prototype.createDataSource = function (args, optionsOrCb, cb) {
+        var command = new CreateDataSourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDomainName(args, optionsOrCb, cb) {
-        const command = new CreateDomainNameCommand(args);
+    };
+    AppSync.prototype.createDomainName = function (args, optionsOrCb, cb) {
+        var command = new CreateDomainNameCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createFunction(args, optionsOrCb, cb) {
-        const command = new CreateFunctionCommand(args);
+    };
+    AppSync.prototype.createFunction = function (args, optionsOrCb, cb) {
+        var command = new CreateFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createGraphqlApi(args, optionsOrCb, cb) {
-        const command = new CreateGraphqlApiCommand(args);
+    };
+    AppSync.prototype.createGraphqlApi = function (args, optionsOrCb, cb) {
+        var command = new CreateGraphqlApiCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createResolver(args, optionsOrCb, cb) {
-        const command = new CreateResolverCommand(args);
+    };
+    AppSync.prototype.createResolver = function (args, optionsOrCb, cb) {
+        var command = new CreateResolverCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createType(args, optionsOrCb, cb) {
-        const command = new CreateTypeCommand(args);
+    };
+    AppSync.prototype.createType = function (args, optionsOrCb, cb) {
+        var command = new CreateTypeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteApiCache(args, optionsOrCb, cb) {
-        const command = new DeleteApiCacheCommand(args);
+    };
+    AppSync.prototype.deleteApiCache = function (args, optionsOrCb, cb) {
+        var command = new DeleteApiCacheCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteApiKey(args, optionsOrCb, cb) {
-        const command = new DeleteApiKeyCommand(args);
+    };
+    AppSync.prototype.deleteApiKey = function (args, optionsOrCb, cb) {
+        var command = new DeleteApiKeyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDataSource(args, optionsOrCb, cb) {
-        const command = new DeleteDataSourceCommand(args);
+    };
+    AppSync.prototype.deleteDataSource = function (args, optionsOrCb, cb) {
+        var command = new DeleteDataSourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDomainName(args, optionsOrCb, cb) {
-        const command = new DeleteDomainNameCommand(args);
+    };
+    AppSync.prototype.deleteDomainName = function (args, optionsOrCb, cb) {
+        var command = new DeleteDomainNameCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteFunction(args, optionsOrCb, cb) {
-        const command = new DeleteFunctionCommand(args);
+    };
+    AppSync.prototype.deleteFunction = function (args, optionsOrCb, cb) {
+        var command = new DeleteFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteGraphqlApi(args, optionsOrCb, cb) {
-        const command = new DeleteGraphqlApiCommand(args);
+    };
+    AppSync.prototype.deleteGraphqlApi = function (args, optionsOrCb, cb) {
+        var command = new DeleteGraphqlApiCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteResolver(args, optionsOrCb, cb) {
-        const command = new DeleteResolverCommand(args);
+    };
+    AppSync.prototype.deleteResolver = function (args, optionsOrCb, cb) {
+        var command = new DeleteResolverCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteType(args, optionsOrCb, cb) {
-        const command = new DeleteTypeCommand(args);
+    };
+    AppSync.prototype.deleteType = function (args, optionsOrCb, cb) {
+        var command = new DeleteTypeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    disassociateApi(args, optionsOrCb, cb) {
-        const command = new DisassociateApiCommand(args);
+    };
+    AppSync.prototype.disassociateApi = function (args, optionsOrCb, cb) {
+        var command = new DisassociateApiCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    evaluateMappingTemplate(args, optionsOrCb, cb) {
-        const command = new EvaluateMappingTemplateCommand(args);
+    };
+    AppSync.prototype.evaluateMappingTemplate = function (args, optionsOrCb, cb) {
+        var command = new EvaluateMappingTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    flushApiCache(args, optionsOrCb, cb) {
-        const command = new FlushApiCacheCommand(args);
+    };
+    AppSync.prototype.flushApiCache = function (args, optionsOrCb, cb) {
+        var command = new FlushApiCacheCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getApiAssociation(args, optionsOrCb, cb) {
-        const command = new GetApiAssociationCommand(args);
+    };
+    AppSync.prototype.getApiAssociation = function (args, optionsOrCb, cb) {
+        var command = new GetApiAssociationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getApiCache(args, optionsOrCb, cb) {
-        const command = new GetApiCacheCommand(args);
+    };
+    AppSync.prototype.getApiCache = function (args, optionsOrCb, cb) {
+        var command = new GetApiCacheCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDataSource(args, optionsOrCb, cb) {
-        const command = new GetDataSourceCommand(args);
+    };
+    AppSync.prototype.getDataSource = function (args, optionsOrCb, cb) {
+        var command = new GetDataSourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDomainName(args, optionsOrCb, cb) {
-        const command = new GetDomainNameCommand(args);
+    };
+    AppSync.prototype.getDomainName = function (args, optionsOrCb, cb) {
+        var command = new GetDomainNameCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getFunction(args, optionsOrCb, cb) {
-        const command = new GetFunctionCommand(args);
+    };
+    AppSync.prototype.getFunction = function (args, optionsOrCb, cb) {
+        var command = new GetFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getGraphqlApi(args, optionsOrCb, cb) {
-        const command = new GetGraphqlApiCommand(args);
+    };
+    AppSync.prototype.getGraphqlApi = function (args, optionsOrCb, cb) {
+        var command = new GetGraphqlApiCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getIntrospectionSchema(args, optionsOrCb, cb) {
-        const command = new GetIntrospectionSchemaCommand(args);
+    };
+    AppSync.prototype.getIntrospectionSchema = function (args, optionsOrCb, cb) {
+        var command = new GetIntrospectionSchemaCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getResolver(args, optionsOrCb, cb) {
-        const command = new GetResolverCommand(args);
+    };
+    AppSync.prototype.getResolver = function (args, optionsOrCb, cb) {
+        var command = new GetResolverCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSchemaCreationStatus(args, optionsOrCb, cb) {
-        const command = new GetSchemaCreationStatusCommand(args);
+    };
+    AppSync.prototype.getSchemaCreationStatus = function (args, optionsOrCb, cb) {
+        var command = new GetSchemaCreationStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getType(args, optionsOrCb, cb) {
-        const command = new GetTypeCommand(args);
+    };
+    AppSync.prototype.getType = function (args, optionsOrCb, cb) {
+        var command = new GetTypeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listApiKeys(args, optionsOrCb, cb) {
-        const command = new ListApiKeysCommand(args);
+    };
+    AppSync.prototype.listApiKeys = function (args, optionsOrCb, cb) {
+        var command = new ListApiKeysCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDataSources(args, optionsOrCb, cb) {
-        const command = new ListDataSourcesCommand(args);
+    };
+    AppSync.prototype.listDataSources = function (args, optionsOrCb, cb) {
+        var command = new ListDataSourcesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDomainNames(args, optionsOrCb, cb) {
-        const command = new ListDomainNamesCommand(args);
+    };
+    AppSync.prototype.listDomainNames = function (args, optionsOrCb, cb) {
+        var command = new ListDomainNamesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listFunctions(args, optionsOrCb, cb) {
-        const command = new ListFunctionsCommand(args);
+    };
+    AppSync.prototype.listFunctions = function (args, optionsOrCb, cb) {
+        var command = new ListFunctionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listGraphqlApis(args, optionsOrCb, cb) {
-        const command = new ListGraphqlApisCommand(args);
+    };
+    AppSync.prototype.listGraphqlApis = function (args, optionsOrCb, cb) {
+        var command = new ListGraphqlApisCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listResolvers(args, optionsOrCb, cb) {
-        const command = new ListResolversCommand(args);
+    };
+    AppSync.prototype.listResolvers = function (args, optionsOrCb, cb) {
+        var command = new ListResolversCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listResolversByFunction(args, optionsOrCb, cb) {
-        const command = new ListResolversByFunctionCommand(args);
+    };
+    AppSync.prototype.listResolversByFunction = function (args, optionsOrCb, cb) {
+        var command = new ListResolversByFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTagsForResource(args, optionsOrCb, cb) {
-        const command = new ListTagsForResourceCommand(args);
+    };
+    AppSync.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
+        var command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTypes(args, optionsOrCb, cb) {
-        const command = new ListTypesCommand(args);
+    };
+    AppSync.prototype.listTypes = function (args, optionsOrCb, cb) {
+        var command = new ListTypesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startSchemaCreation(args, optionsOrCb, cb) {
-        const command = new StartSchemaCreationCommand(args);
+    };
+    AppSync.prototype.startSchemaCreation = function (args, optionsOrCb, cb) {
+        var command = new StartSchemaCreationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    tagResource(args, optionsOrCb, cb) {
-        const command = new TagResourceCommand(args);
+    };
+    AppSync.prototype.tagResource = function (args, optionsOrCb, cb) {
+        var command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    untagResource(args, optionsOrCb, cb) {
-        const command = new UntagResourceCommand(args);
+    };
+    AppSync.prototype.untagResource = function (args, optionsOrCb, cb) {
+        var command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateApiCache(args, optionsOrCb, cb) {
-        const command = new UpdateApiCacheCommand(args);
+    };
+    AppSync.prototype.updateApiCache = function (args, optionsOrCb, cb) {
+        var command = new UpdateApiCacheCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateApiKey(args, optionsOrCb, cb) {
-        const command = new UpdateApiKeyCommand(args);
+    };
+    AppSync.prototype.updateApiKey = function (args, optionsOrCb, cb) {
+        var command = new UpdateApiKeyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDataSource(args, optionsOrCb, cb) {
-        const command = new UpdateDataSourceCommand(args);
+    };
+    AppSync.prototype.updateDataSource = function (args, optionsOrCb, cb) {
+        var command = new UpdateDataSourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDomainName(args, optionsOrCb, cb) {
-        const command = new UpdateDomainNameCommand(args);
+    };
+    AppSync.prototype.updateDomainName = function (args, optionsOrCb, cb) {
+        var command = new UpdateDomainNameCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateFunction(args, optionsOrCb, cb) {
-        const command = new UpdateFunctionCommand(args);
+    };
+    AppSync.prototype.updateFunction = function (args, optionsOrCb, cb) {
+        var command = new UpdateFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateGraphqlApi(args, optionsOrCb, cb) {
-        const command = new UpdateGraphqlApiCommand(args);
+    };
+    AppSync.prototype.updateGraphqlApi = function (args, optionsOrCb, cb) {
+        var command = new UpdateGraphqlApiCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateResolver(args, optionsOrCb, cb) {
-        const command = new UpdateResolverCommand(args);
+    };
+    AppSync.prototype.updateResolver = function (args, optionsOrCb, cb) {
+        var command = new UpdateResolverCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateType(args, optionsOrCb, cb) {
-        const command = new UpdateTypeCommand(args);
+    };
+    AppSync.prototype.updateType = function (args, optionsOrCb, cb) {
+        var command = new UpdateTypeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-}
+    };
+    return AppSync;
+}(AppSyncClient));
+export { AppSync };