@aws-sdk/client-iottwinmaker 3.44.0

package/dist-es/commands/CreateEntityCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateEntityRequest, CreateEntityResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateEntityCommand, serializeAws_restJson1CreateEntityCommand, } from "../protocols/Aws_restJson1";
+var CreateEntityCommand = (function (_super) {
+    __extends(CreateEntityCommand, _super);
+    function CreateEntityCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateEntityCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "CreateEntityCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateEntityRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateEntityResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateEntityCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateEntityCommand(input, context);
+    };
+    CreateEntityCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateEntityCommand(output, context);
+    };
+    return CreateEntityCommand;
+}($Command));
+export { CreateEntityCommand };

package/dist-es/commands/CreateSceneCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateSceneRequest, CreateSceneResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateSceneCommand, serializeAws_restJson1CreateSceneCommand, } from "../protocols/Aws_restJson1";
+var CreateSceneCommand = (function (_super) {
+    __extends(CreateSceneCommand, _super);
+    function CreateSceneCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateSceneCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "CreateSceneCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateSceneRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateSceneResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateSceneCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateSceneCommand(input, context);
+    };
+    CreateSceneCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateSceneCommand(output, context);
+    };
+    return CreateSceneCommand;
+}($Command));
+export { CreateSceneCommand };

package/dist-es/commands/CreateWorkspaceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateWorkspaceRequest, CreateWorkspaceResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateWorkspaceCommand, serializeAws_restJson1CreateWorkspaceCommand, } from "../protocols/Aws_restJson1";
+var CreateWorkspaceCommand = (function (_super) {
+    __extends(CreateWorkspaceCommand, _super);
+    function CreateWorkspaceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateWorkspaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "CreateWorkspaceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateWorkspaceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateWorkspaceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateWorkspaceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateWorkspaceCommand(input, context);
+    };
+    CreateWorkspaceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateWorkspaceCommand(output, context);
+    };
+    return CreateWorkspaceCommand;
+}($Command));
+export { CreateWorkspaceCommand };

package/dist-es/commands/DeleteComponentTypeCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteComponentTypeRequest, DeleteComponentTypeResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteComponentTypeCommand, serializeAws_restJson1DeleteComponentTypeCommand, } from "../protocols/Aws_restJson1";
+var DeleteComponentTypeCommand = (function (_super) {
+    __extends(DeleteComponentTypeCommand, _super);
+    function DeleteComponentTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteComponentTypeCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "DeleteComponentTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteComponentTypeRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteComponentTypeResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteComponentTypeCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteComponentTypeCommand(input, context);
+    };
+    DeleteComponentTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteComponentTypeCommand(output, context);
+    };
+    return DeleteComponentTypeCommand;
+}($Command));
+export { DeleteComponentTypeCommand };

package/dist-es/commands/DeleteEntityCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteEntityRequest, DeleteEntityResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteEntityCommand, serializeAws_restJson1DeleteEntityCommand, } from "../protocols/Aws_restJson1";
+var DeleteEntityCommand = (function (_super) {
+    __extends(DeleteEntityCommand, _super);
+    function DeleteEntityCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteEntityCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "DeleteEntityCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteEntityRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteEntityResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteEntityCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteEntityCommand(input, context);
+    };
+    DeleteEntityCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteEntityCommand(output, context);
+    };
+    return DeleteEntityCommand;
+}($Command));
+export { DeleteEntityCommand };

package/dist-es/commands/DeleteSceneCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteSceneRequest, DeleteSceneResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteSceneCommand, serializeAws_restJson1DeleteSceneCommand, } from "../protocols/Aws_restJson1";
+var DeleteSceneCommand = (function (_super) {
+    __extends(DeleteSceneCommand, _super);
+    function DeleteSceneCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteSceneCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "DeleteSceneCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteSceneRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteSceneResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteSceneCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteSceneCommand(input, context);
+    };
+    DeleteSceneCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteSceneCommand(output, context);
+    };
+    return DeleteSceneCommand;
+}($Command));
+export { DeleteSceneCommand };

package/dist-es/commands/DeleteWorkspaceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteWorkspaceRequest, DeleteWorkspaceResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteWorkspaceCommand, serializeAws_restJson1DeleteWorkspaceCommand, } from "../protocols/Aws_restJson1";
+var DeleteWorkspaceCommand = (function (_super) {
+    __extends(DeleteWorkspaceCommand, _super);
+    function DeleteWorkspaceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteWorkspaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "DeleteWorkspaceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteWorkspaceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteWorkspaceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteWorkspaceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteWorkspaceCommand(input, context);
+    };
+    DeleteWorkspaceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteWorkspaceCommand(output, context);
+    };
+    return DeleteWorkspaceCommand;
+}($Command));
+export { DeleteWorkspaceCommand };

package/dist-es/commands/GetComponentTypeCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetComponentTypeRequest, GetComponentTypeResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetComponentTypeCommand, serializeAws_restJson1GetComponentTypeCommand, } from "../protocols/Aws_restJson1";
+var GetComponentTypeCommand = (function (_super) {
+    __extends(GetComponentTypeCommand, _super);
+    function GetComponentTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetComponentTypeCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "GetComponentTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetComponentTypeRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetComponentTypeResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetComponentTypeCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetComponentTypeCommand(input, context);
+    };
+    GetComponentTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetComponentTypeCommand(output, context);
+    };
+    return GetComponentTypeCommand;
+}($Command));
+export { GetComponentTypeCommand };

package/dist-es/commands/GetEntityCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetEntityRequest, GetEntityResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetEntityCommand, serializeAws_restJson1GetEntityCommand, } from "../protocols/Aws_restJson1";
+var GetEntityCommand = (function (_super) {
+    __extends(GetEntityCommand, _super);
+    function GetEntityCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetEntityCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "GetEntityCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetEntityRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetEntityResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetEntityCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetEntityCommand(input, context);
+    };
+    GetEntityCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetEntityCommand(output, context);
+    };
+    return GetEntityCommand;
+}($Command));
+export { GetEntityCommand };

package/dist-es/commands/GetPropertyValueCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetPropertyValueRequest, GetPropertyValueResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetPropertyValueCommand, serializeAws_restJson1GetPropertyValueCommand, } from "../protocols/Aws_restJson1";
+var GetPropertyValueCommand = (function (_super) {
+    __extends(GetPropertyValueCommand, _super);
+    function GetPropertyValueCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetPropertyValueCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "GetPropertyValueCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetPropertyValueRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetPropertyValueResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetPropertyValueCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetPropertyValueCommand(input, context);
+    };
+    GetPropertyValueCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetPropertyValueCommand(output, context);
+    };
+    return GetPropertyValueCommand;
+}($Command));
+export { GetPropertyValueCommand };

package/dist-es/commands/GetPropertyValueHistoryCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetPropertyValueHistoryRequest, GetPropertyValueHistoryResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetPropertyValueHistoryCommand, serializeAws_restJson1GetPropertyValueHistoryCommand, } from "../protocols/Aws_restJson1";
+var GetPropertyValueHistoryCommand = (function (_super) {
+    __extends(GetPropertyValueHistoryCommand, _super);
+    function GetPropertyValueHistoryCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetPropertyValueHistoryCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "GetPropertyValueHistoryCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetPropertyValueHistoryRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetPropertyValueHistoryResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetPropertyValueHistoryCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetPropertyValueHistoryCommand(input, context);
+    };
+    GetPropertyValueHistoryCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetPropertyValueHistoryCommand(output, context);
+    };
+    return GetPropertyValueHistoryCommand;
+}($Command));
+export { GetPropertyValueHistoryCommand };

package/dist-es/commands/GetSceneCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetSceneRequest, GetSceneResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetSceneCommand, serializeAws_restJson1GetSceneCommand, } from "../protocols/Aws_restJson1";
+var GetSceneCommand = (function (_super) {
+    __extends(GetSceneCommand, _super);
+    function GetSceneCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetSceneCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "GetSceneCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetSceneRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetSceneResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetSceneCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetSceneCommand(input, context);
+    };
+    GetSceneCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetSceneCommand(output, context);
+    };
+    return GetSceneCommand;
+}($Command));
+export { GetSceneCommand };

package/dist-es/commands/GetWorkspaceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetWorkspaceRequest, GetWorkspaceResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetWorkspaceCommand, serializeAws_restJson1GetWorkspaceCommand, } from "../protocols/Aws_restJson1";
+var GetWorkspaceCommand = (function (_super) {
+    __extends(GetWorkspaceCommand, _super);
+    function GetWorkspaceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetWorkspaceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "GetWorkspaceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetWorkspaceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetWorkspaceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetWorkspaceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetWorkspaceCommand(input, context);
+    };
+    GetWorkspaceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetWorkspaceCommand(output, context);
+    };
+    return GetWorkspaceCommand;
+}($Command));
+export { GetWorkspaceCommand };

package/dist-es/commands/ListComponentTypesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListComponentTypesRequest, ListComponentTypesResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListComponentTypesCommand, serializeAws_restJson1ListComponentTypesCommand, } from "../protocols/Aws_restJson1";
+var ListComponentTypesCommand = (function (_super) {
+    __extends(ListComponentTypesCommand, _super);
+    function ListComponentTypesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListComponentTypesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "ListComponentTypesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListComponentTypesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListComponentTypesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListComponentTypesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListComponentTypesCommand(input, context);
+    };
+    ListComponentTypesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListComponentTypesCommand(output, context);
+    };
+    return ListComponentTypesCommand;
+}($Command));
+export { ListComponentTypesCommand };

package/dist-es/commands/ListEntitiesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListEntitiesRequest, ListEntitiesResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListEntitiesCommand, serializeAws_restJson1ListEntitiesCommand, } from "../protocols/Aws_restJson1";
+var ListEntitiesCommand = (function (_super) {
+    __extends(ListEntitiesCommand, _super);
+    function ListEntitiesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListEntitiesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "ListEntitiesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListEntitiesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListEntitiesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListEntitiesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListEntitiesCommand(input, context);
+    };
+    ListEntitiesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListEntitiesCommand(output, context);
+    };
+    return ListEntitiesCommand;
+}($Command));
+export { ListEntitiesCommand };

package/dist-es/commands/ListScenesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListScenesRequest, ListScenesResponse } from "../models/models_0";
+import { deserializeAws_restJson1ListScenesCommand, serializeAws_restJson1ListScenesCommand, } from "../protocols/Aws_restJson1";
+var ListScenesCommand = (function (_super) {
+    __extends(ListScenesCommand, _super);
+    function ListScenesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListScenesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "IoTTwinMakerClient";
+        var commandName = "ListScenesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListScenesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListScenesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListScenesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListScenesCommand(input, context);
+    };
+    ListScenesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListScenesCommand(output, context);
+    };
+    return ListScenesCommand;
+}($Command));
+export { ListScenesCommand };