@aws-sdk/client-schemas 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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