@aws-sdk/client-iottwinmaker 3.44.0

package/dist-types/commands/CreateWorkspaceCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { CreateWorkspaceRequest, CreateWorkspaceResponse } from "../models/models_0";
+export interface CreateWorkspaceCommandInput extends CreateWorkspaceRequest {
+}
+export interface CreateWorkspaceCommandOutput extends CreateWorkspaceResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a workplace.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, CreateWorkspaceCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, CreateWorkspaceCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new CreateWorkspaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateWorkspaceCommandInput} for command's `input` shape.
+ * @see {@link CreateWorkspaceCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class CreateWorkspaceCommand extends $Command<CreateWorkspaceCommandInput, CreateWorkspaceCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: CreateWorkspaceCommandInput;
+    constructor(input: CreateWorkspaceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateWorkspaceCommandInput, CreateWorkspaceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteComponentTypeCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { DeleteComponentTypeRequest, DeleteComponentTypeResponse } from "../models/models_0";
+export interface DeleteComponentTypeCommandInput extends DeleteComponentTypeRequest {
+}
+export interface DeleteComponentTypeCommandOutput extends DeleteComponentTypeResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a component type.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, DeleteComponentTypeCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, DeleteComponentTypeCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new DeleteComponentTypeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteComponentTypeCommandInput} for command's `input` shape.
+ * @see {@link DeleteComponentTypeCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class DeleteComponentTypeCommand extends $Command<DeleteComponentTypeCommandInput, DeleteComponentTypeCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: DeleteComponentTypeCommandInput;
+    constructor(input: DeleteComponentTypeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteComponentTypeCommandInput, DeleteComponentTypeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteEntityCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { DeleteEntityRequest, DeleteEntityResponse } from "../models/models_0";
+export interface DeleteEntityCommandInput extends DeleteEntityRequest {
+}
+export interface DeleteEntityCommandOutput extends DeleteEntityResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes an entity.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, DeleteEntityCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, DeleteEntityCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new DeleteEntityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteEntityCommandInput} for command's `input` shape.
+ * @see {@link DeleteEntityCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class DeleteEntityCommand extends $Command<DeleteEntityCommandInput, DeleteEntityCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: DeleteEntityCommandInput;
+    constructor(input: DeleteEntityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEntityCommandInput, DeleteEntityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteSceneCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { DeleteSceneRequest, DeleteSceneResponse } from "../models/models_0";
+export interface DeleteSceneCommandInput extends DeleteSceneRequest {
+}
+export interface DeleteSceneCommandOutput extends DeleteSceneResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a scene.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, DeleteSceneCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, DeleteSceneCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new DeleteSceneCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteSceneCommandInput} for command's `input` shape.
+ * @see {@link DeleteSceneCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class DeleteSceneCommand extends $Command<DeleteSceneCommandInput, DeleteSceneCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: DeleteSceneCommandInput;
+    constructor(input: DeleteSceneCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSceneCommandInput, DeleteSceneCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteWorkspaceCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { DeleteWorkspaceRequest, DeleteWorkspaceResponse } from "../models/models_0";
+export interface DeleteWorkspaceCommandInput extends DeleteWorkspaceRequest {
+}
+export interface DeleteWorkspaceCommandOutput extends DeleteWorkspaceResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a workspace.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, DeleteWorkspaceCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, DeleteWorkspaceCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new DeleteWorkspaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteWorkspaceCommandInput} for command's `input` shape.
+ * @see {@link DeleteWorkspaceCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class DeleteWorkspaceCommand extends $Command<DeleteWorkspaceCommandInput, DeleteWorkspaceCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: DeleteWorkspaceCommandInput;
+    constructor(input: DeleteWorkspaceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteWorkspaceCommandInput, DeleteWorkspaceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetComponentTypeCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { GetComponentTypeRequest, GetComponentTypeResponse } from "../models/models_0";
+export interface GetComponentTypeCommandInput extends GetComponentTypeRequest {
+}
+export interface GetComponentTypeCommandOutput extends GetComponentTypeResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about a component type.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, GetComponentTypeCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, GetComponentTypeCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new GetComponentTypeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetComponentTypeCommandInput} for command's `input` shape.
+ * @see {@link GetComponentTypeCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class GetComponentTypeCommand extends $Command<GetComponentTypeCommandInput, GetComponentTypeCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: GetComponentTypeCommandInput;
+    constructor(input: GetComponentTypeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetComponentTypeCommandInput, GetComponentTypeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetEntityCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { GetEntityRequest, GetEntityResponse } from "../models/models_0";
+export interface GetEntityCommandInput extends GetEntityRequest {
+}
+export interface GetEntityCommandOutput extends GetEntityResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about an entity.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, GetEntityCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, GetEntityCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new GetEntityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetEntityCommandInput} for command's `input` shape.
+ * @see {@link GetEntityCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class GetEntityCommand extends $Command<GetEntityCommandInput, GetEntityCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: GetEntityCommandInput;
+    constructor(input: GetEntityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEntityCommandInput, GetEntityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetPropertyValueCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { GetPropertyValueRequest, GetPropertyValueResponse } from "../models/models_0";
+export interface GetPropertyValueCommandInput extends GetPropertyValueRequest {
+}
+export interface GetPropertyValueCommandOutput extends GetPropertyValueResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the property values for a component, component type, entity, or workspace.</p>
+ *          <p>You must specify a value for either <code>componentName</code>, <code>componentTypeId</code>, <code>entityId</code>, or <code>workspaceId</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, GetPropertyValueCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, GetPropertyValueCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new GetPropertyValueCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetPropertyValueCommandInput} for command's `input` shape.
+ * @see {@link GetPropertyValueCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class GetPropertyValueCommand extends $Command<GetPropertyValueCommandInput, GetPropertyValueCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: GetPropertyValueCommandInput;
+    constructor(input: GetPropertyValueCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetPropertyValueCommandInput, GetPropertyValueCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetPropertyValueHistoryCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { GetPropertyValueHistoryRequest, GetPropertyValueHistoryResponse } from "../models/models_0";
+export interface GetPropertyValueHistoryCommandInput extends GetPropertyValueHistoryRequest {
+}
+export interface GetPropertyValueHistoryCommandOutput extends GetPropertyValueHistoryResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about the history of a time series property value for a component, component type, entity, or workspace.</p>
+ *          <p>You must specify a value for <code>workspaceId</code>. For entity-specific queries, specify values for <code>componentName</code> and
+ *         <code>entityId</code>. For cross-entity quries, specify a value for <code>componentTypeId</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, GetPropertyValueHistoryCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, GetPropertyValueHistoryCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new GetPropertyValueHistoryCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetPropertyValueHistoryCommandInput} for command's `input` shape.
+ * @see {@link GetPropertyValueHistoryCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class GetPropertyValueHistoryCommand extends $Command<GetPropertyValueHistoryCommandInput, GetPropertyValueHistoryCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: GetPropertyValueHistoryCommandInput;
+    constructor(input: GetPropertyValueHistoryCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetPropertyValueHistoryCommandInput, GetPropertyValueHistoryCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSceneCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { GetSceneRequest, GetSceneResponse } from "../models/models_0";
+export interface GetSceneCommandInput extends GetSceneRequest {
+}
+export interface GetSceneCommandOutput extends GetSceneResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about a scene.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, GetSceneCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, GetSceneCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new GetSceneCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSceneCommandInput} for command's `input` shape.
+ * @see {@link GetSceneCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class GetSceneCommand extends $Command<GetSceneCommandInput, GetSceneCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: GetSceneCommandInput;
+    constructor(input: GetSceneCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSceneCommandInput, GetSceneCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetWorkspaceCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { GetWorkspaceRequest, GetWorkspaceResponse } from "../models/models_0";
+export interface GetWorkspaceCommandInput extends GetWorkspaceRequest {
+}
+export interface GetWorkspaceCommandOutput extends GetWorkspaceResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about a workspace.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, GetWorkspaceCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, GetWorkspaceCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new GetWorkspaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetWorkspaceCommandInput} for command's `input` shape.
+ * @see {@link GetWorkspaceCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class GetWorkspaceCommand extends $Command<GetWorkspaceCommandInput, GetWorkspaceCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: GetWorkspaceCommandInput;
+    constructor(input: GetWorkspaceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetWorkspaceCommandInput, GetWorkspaceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListComponentTypesCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { ListComponentTypesRequest, ListComponentTypesResponse } from "../models/models_0";
+export interface ListComponentTypesCommandInput extends ListComponentTypesRequest {
+}
+export interface ListComponentTypesCommandOutput extends ListComponentTypesResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all component types in a workspace.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, ListComponentTypesCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, ListComponentTypesCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new ListComponentTypesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListComponentTypesCommandInput} for command's `input` shape.
+ * @see {@link ListComponentTypesCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class ListComponentTypesCommand extends $Command<ListComponentTypesCommandInput, ListComponentTypesCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: ListComponentTypesCommandInput;
+    constructor(input: ListComponentTypesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListComponentTypesCommandInput, ListComponentTypesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListEntitiesCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { ListEntitiesRequest, ListEntitiesResponse } from "../models/models_0";
+export interface ListEntitiesCommandInput extends ListEntitiesRequest {
+}
+export interface ListEntitiesCommandOutput extends ListEntitiesResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all entities in a workspace.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, ListEntitiesCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, ListEntitiesCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new ListEntitiesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListEntitiesCommandInput} for command's `input` shape.
+ * @see {@link ListEntitiesCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class ListEntitiesCommand extends $Command<ListEntitiesCommandInput, ListEntitiesCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: ListEntitiesCommandInput;
+    constructor(input: ListEntitiesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEntitiesCommandInput, ListEntitiesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListScenesCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { ListScenesRequest, ListScenesResponse } from "../models/models_0";
+export interface ListScenesCommandInput extends ListScenesRequest {
+}
+export interface ListScenesCommandOutput extends ListScenesResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all scenes in a workspace.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, ListScenesCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, ListScenesCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new ListScenesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListScenesCommandInput} for command's `input` shape.
+ * @see {@link ListScenesCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class ListScenesCommand extends $Command<ListScenesCommandInput, ListScenesCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: ListScenesCommandInput;
+    constructor(input: ListScenesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListScenesCommandInput, ListScenesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListTagsForResourceCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all tags associated with a resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, ListTagsForResourceCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, ListTagsForResourceCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListWorkspacesCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { ListWorkspacesRequest, ListWorkspacesResponse } from "../models/models_0";
+export interface ListWorkspacesCommandInput extends ListWorkspacesRequest {
+}
+export interface ListWorkspacesCommandOutput extends ListWorkspacesResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves information about workspaces in the current account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, ListWorkspacesCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, ListWorkspacesCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new ListWorkspacesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListWorkspacesCommandInput} for command's `input` shape.
+ * @see {@link ListWorkspacesCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class ListWorkspacesCommand extends $Command<ListWorkspacesCommandInput, ListWorkspacesCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: ListWorkspacesCommandInput;
+    constructor(input: ListWorkspacesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListWorkspacesCommandInput, ListWorkspacesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/TagResourceCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTTwinMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTTwinMakerClient";
+import { TagResourceRequest, TagResourceResponse } from "../models/models_0";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Adds tags to a resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTTwinMakerClient, TagResourceCommand } from "@aws-sdk/client-iottwinmaker"; // ES Modules import
+ * // const { IoTTwinMakerClient, TagResourceCommand } = require("@aws-sdk/client-iottwinmaker"); // CommonJS import
+ * const client = new IoTTwinMakerClient(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link IoTTwinMakerClientResolvedConfig | config} for IoTTwinMakerClient's `config` shape.
+ *
+ */
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, IoTTwinMakerClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTTwinMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}