@aws-sdk/client-iotthingsgraph 3.35.0 → 3.38.0

package/dist-types/ts3.4/commands/CreateSystemTemplateCommand.d.ts

@@ -6,30 +6,11 @@ export interface CreateSystemTemplateCommandInput extends CreateSystemTemplateRe
 }
 export interface CreateSystemTemplateCommandOutput extends CreateSystemTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a system. The system is validated against the entities in the
- *          latest version of the user's namespace unless another namespace version is specified in the request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, CreateSystemTemplateCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, CreateSystemTemplateCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new CreateSystemTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSystemTemplateCommandInput} for command's `input` shape.
- * @see {@link CreateSystemTemplateCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSystemTemplateCommand extends $Command<CreateSystemTemplateCommandInput, CreateSystemTemplateCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: CreateSystemTemplateCommandInput;
     constructor(input: CreateSystemTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSystemTemplateCommandInput, CreateSystemTemplateCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteFlowTemplateCommand.d.ts

@@ -6,30 +6,11 @@ export interface DeleteFlowTemplateCommandInput extends DeleteFlowTemplateReques
 }
 export interface DeleteFlowTemplateCommandOutput extends DeleteFlowTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a workflow. Any new system or deployment that contains this workflow will fail to update or deploy.
- *          Existing deployments that contain the workflow will continue to run (since they use a snapshot of the workflow taken at the time of deployment).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, DeleteFlowTemplateCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, DeleteFlowTemplateCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new DeleteFlowTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteFlowTemplateCommandInput} for command's `input` shape.
- * @see {@link DeleteFlowTemplateCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteFlowTemplateCommand extends $Command<DeleteFlowTemplateCommandInput, DeleteFlowTemplateCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: DeleteFlowTemplateCommandInput;
     constructor(input: DeleteFlowTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFlowTemplateCommandInput, DeleteFlowTemplateCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteNamespaceCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeleteNamespaceCommandInput extends DeleteNamespaceRequest {
 }
 export interface DeleteNamespaceCommandOutput extends DeleteNamespaceResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified namespace. This action deletes all of the entities in the namespace. Delete the systems and flows that use entities in the namespace before performing this action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, DeleteNamespaceCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, DeleteNamespaceCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new DeleteNamespaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteNamespaceCommandInput} for command's `input` shape.
- * @see {@link DeleteNamespaceCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteNamespaceCommand extends $Command<DeleteNamespaceCommandInput, DeleteNamespaceCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: DeleteNamespaceCommandInput;
     constructor(input: DeleteNamespaceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteNamespaceCommandInput, DeleteNamespaceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteSystemInstanceCommand.d.ts

@@ -6,31 +6,11 @@ export interface DeleteSystemInstanceCommandInput extends DeleteSystemInstanceRe
 }
 export interface DeleteSystemInstanceCommandOutput extends DeleteSystemInstanceResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a system instance.
- *          Only system instances that have never been deployed, or that have been undeployed can be deleted.</p>
- *          <p>Users can create a new system instance that has the same ID as a deleted system instance.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, DeleteSystemInstanceCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, DeleteSystemInstanceCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new DeleteSystemInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteSystemInstanceCommandInput} for command's `input` shape.
- * @see {@link DeleteSystemInstanceCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteSystemInstanceCommand extends $Command<DeleteSystemInstanceCommandInput, DeleteSystemInstanceCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: DeleteSystemInstanceCommandInput;
     constructor(input: DeleteSystemInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSystemInstanceCommandInput, DeleteSystemInstanceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteSystemTemplateCommand.d.ts

@@ -6,30 +6,11 @@ export interface DeleteSystemTemplateCommandInput extends DeleteSystemTemplateRe
 }
 export interface DeleteSystemTemplateCommandOutput extends DeleteSystemTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a system. New deployments can't contain the system after its deletion.
- *       Existing deployments that contain the system will continue to work because they use a snapshot of the system that is taken when it is deployed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, DeleteSystemTemplateCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, DeleteSystemTemplateCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new DeleteSystemTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteSystemTemplateCommandInput} for command's `input` shape.
- * @see {@link DeleteSystemTemplateCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteSystemTemplateCommand extends $Command<DeleteSystemTemplateCommandInput, DeleteSystemTemplateCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: DeleteSystemTemplateCommandInput;
     constructor(input: DeleteSystemTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSystemTemplateCommandInput, DeleteSystemTemplateCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeploySystemInstanceCommand.d.ts

@@ -6,40 +6,11 @@ export interface DeploySystemInstanceCommandInput extends DeploySystemInstanceRe
 }
 export interface DeploySystemInstanceCommandOutput extends DeploySystemInstanceResponse, __MetadataBearer {
 }
-/**
- * <p>
- *             <b>Greengrass and Cloud Deployments</b>
- *          </p>
- *          <p>Deploys the system instance to the target specified in <code>CreateSystemInstance</code>. </p>
- *          <p>
- *             <b>Greengrass Deployments</b>
- *          </p>
- *          <p>If the system or any workflows and entities have been updated before this action is called, then the deployment will create a new Amazon Simple Storage Service
- *          resource file and then deploy it.</p>
- *          <p>Since this action creates a Greengrass deployment on the caller's behalf, the calling identity must have write permissions
- *          to the specified Greengrass group. Otherwise, the call will fail with an authorization error.</p>
- *          <p>For information about the artifacts that get added to your Greengrass core device when you use this API, see <a href="https://docs.aws.amazon.com/thingsgraph/latest/ug/iot-tg-greengrass.html">AWS IoT Things Graph and AWS IoT Greengrass</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, DeploySystemInstanceCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, DeploySystemInstanceCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new DeploySystemInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeploySystemInstanceCommandInput} for command's `input` shape.
- * @see {@link DeploySystemInstanceCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeploySystemInstanceCommand extends $Command<DeploySystemInstanceCommandInput, DeploySystemInstanceCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: DeploySystemInstanceCommandInput;
     constructor(input: DeploySystemInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeploySystemInstanceCommandInput, DeploySystemInstanceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeprecateFlowTemplateCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeprecateFlowTemplateCommandInput extends DeprecateFlowTemplate
 }
 export interface DeprecateFlowTemplateCommandOutput extends DeprecateFlowTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Deprecates the specified workflow. This action marks the workflow for deletion. Deprecated flows can't be deployed, but existing deployments will continue to run.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, DeprecateFlowTemplateCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, DeprecateFlowTemplateCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new DeprecateFlowTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeprecateFlowTemplateCommandInput} for command's `input` shape.
- * @see {@link DeprecateFlowTemplateCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeprecateFlowTemplateCommand extends $Command<DeprecateFlowTemplateCommandInput, DeprecateFlowTemplateCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: DeprecateFlowTemplateCommandInput;
     constructor(input: DeprecateFlowTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeprecateFlowTemplateCommandInput, DeprecateFlowTemplateCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeprecateSystemTemplateCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeprecateSystemTemplateCommandInput extends DeprecateSystemTemp
 }
 export interface DeprecateSystemTemplateCommandOutput extends DeprecateSystemTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Deprecates the specified system.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, DeprecateSystemTemplateCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, DeprecateSystemTemplateCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new DeprecateSystemTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeprecateSystemTemplateCommandInput} for command's `input` shape.
- * @see {@link DeprecateSystemTemplateCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeprecateSystemTemplateCommand extends $Command<DeprecateSystemTemplateCommandInput, DeprecateSystemTemplateCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: DeprecateSystemTemplateCommandInput;
     constructor(input: DeprecateSystemTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeprecateSystemTemplateCommandInput, DeprecateSystemTemplateCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeNamespaceCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeNamespaceCommandInput extends DescribeNamespaceRequest
 }
 export interface DescribeNamespaceCommandOutput extends DescribeNamespaceResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the latest version of the user's namespace and the public version that it is tracking.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, DescribeNamespaceCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, DescribeNamespaceCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new DescribeNamespaceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeNamespaceCommandInput} for command's `input` shape.
- * @see {@link DescribeNamespaceCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeNamespaceCommand extends $Command<DescribeNamespaceCommandInput, DescribeNamespaceCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: DescribeNamespaceCommandInput;
     constructor(input: DescribeNamespaceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeNamespaceCommandInput, DescribeNamespaceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DissociateEntityFromThingCommand.d.ts

@@ -6,30 +6,11 @@ export interface DissociateEntityFromThingCommandInput extends DissociateEntityF
 }
 export interface DissociateEntityFromThingCommandOutput extends DissociateEntityFromThingResponse, __MetadataBearer {
 }
-/**
- * <p>Dissociates a device entity from a concrete thing. The action takes only the type of the entity that you need to dissociate because only
- *          one entity of a particular type can be associated with a thing.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, DissociateEntityFromThingCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, DissociateEntityFromThingCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new DissociateEntityFromThingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DissociateEntityFromThingCommandInput} for command's `input` shape.
- * @see {@link DissociateEntityFromThingCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DissociateEntityFromThingCommand extends $Command<DissociateEntityFromThingCommandInput, DissociateEntityFromThingCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: DissociateEntityFromThingCommandInput;
     constructor(input: DissociateEntityFromThingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DissociateEntityFromThingCommandInput, DissociateEntityFromThingCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetEntitiesCommand.d.ts

@@ -6,60 +6,11 @@ export interface GetEntitiesCommandInput extends GetEntitiesRequest {
 }
 export interface GetEntitiesCommandOutput extends GetEntitiesResponse, __MetadataBearer {
 }
-/**
- * <p>Gets definitions of the specified entities. Uses the latest version of the user's namespace by default. This API returns the
- *       following TDM entities.</p>
- *          <ul>
- *             <li>
- *                <p>Properties</p>
- *             </li>
- *             <li>
- *                <p>States</p>
- *             </li>
- *             <li>
- *                <p>Events</p>
- *             </li>
- *             <li>
- *                <p>Actions</p>
- *             </li>
- *             <li>
- *                <p>Capabilities</p>
- *             </li>
- *             <li>
- *                <p>Mappings</p>
- *             </li>
- *             <li>
- *                <p>Devices</p>
- *             </li>
- *             <li>
- *                <p>Device Models</p>
- *             </li>
- *             <li>
- *                <p>Services</p>
- *             </li>
- *          </ul>
- *          <p>This action doesn't return definitions for systems, flows, and deployments.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, GetEntitiesCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, GetEntitiesCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new GetEntitiesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEntitiesCommandInput} for command's `input` shape.
- * @see {@link GetEntitiesCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEntitiesCommand extends $Command<GetEntitiesCommandInput, GetEntitiesCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: GetEntitiesCommandInput;
     constructor(input: GetEntitiesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEntitiesCommandInput, GetEntitiesCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetFlowTemplateCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetFlowTemplateCommandInput extends GetFlowTemplateRequest {
 }
 export interface GetFlowTemplateCommandOutput extends GetFlowTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the latest version of the <code>DefinitionDocument</code> and <code>FlowTemplateSummary</code> for the specified workflow.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, GetFlowTemplateCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, GetFlowTemplateCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new GetFlowTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFlowTemplateCommandInput} for command's `input` shape.
- * @see {@link GetFlowTemplateCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetFlowTemplateCommand extends $Command<GetFlowTemplateCommandInput, GetFlowTemplateCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: GetFlowTemplateCommandInput;
     constructor(input: GetFlowTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFlowTemplateCommandInput, GetFlowTemplateCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetFlowTemplateRevisionsCommand.d.ts

@@ -6,30 +6,11 @@ export interface GetFlowTemplateRevisionsCommandInput extends GetFlowTemplateRev
 }
 export interface GetFlowTemplateRevisionsCommandOutput extends GetFlowTemplateRevisionsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets revisions of the specified workflow. Only the last 100 revisions are stored. If the workflow has been deprecated,
- *       this action will return revisions that occurred before the deprecation. This action won't work for workflows that have been deleted.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, GetFlowTemplateRevisionsCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, GetFlowTemplateRevisionsCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new GetFlowTemplateRevisionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFlowTemplateRevisionsCommandInput} for command's `input` shape.
- * @see {@link GetFlowTemplateRevisionsCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetFlowTemplateRevisionsCommand extends $Command<GetFlowTemplateRevisionsCommandInput, GetFlowTemplateRevisionsCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: GetFlowTemplateRevisionsCommandInput;
     constructor(input: GetFlowTemplateRevisionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFlowTemplateRevisionsCommandInput, GetFlowTemplateRevisionsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetNamespaceDeletionStatusCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetNamespaceDeletionStatusCommandInput extends GetNamespaceDele
 }
 export interface GetNamespaceDeletionStatusCommandOutput extends GetNamespaceDeletionStatusResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the status of a namespace deletion task.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, GetNamespaceDeletionStatusCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, GetNamespaceDeletionStatusCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new GetNamespaceDeletionStatusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetNamespaceDeletionStatusCommandInput} for command's `input` shape.
- * @see {@link GetNamespaceDeletionStatusCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetNamespaceDeletionStatusCommand extends $Command<GetNamespaceDeletionStatusCommandInput, GetNamespaceDeletionStatusCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: GetNamespaceDeletionStatusCommandInput;
     constructor(input: GetNamespaceDeletionStatusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetNamespaceDeletionStatusCommandInput, GetNamespaceDeletionStatusCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetSystemInstanceCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetSystemInstanceCommandInput extends GetSystemInstanceRequest
 }
 export interface GetSystemInstanceCommandOutput extends GetSystemInstanceResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a system instance.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, GetSystemInstanceCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, GetSystemInstanceCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new GetSystemInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSystemInstanceCommandInput} for command's `input` shape.
- * @see {@link GetSystemInstanceCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetSystemInstanceCommand extends $Command<GetSystemInstanceCommandInput, GetSystemInstanceCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: GetSystemInstanceCommandInput;
     constructor(input: GetSystemInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSystemInstanceCommandInput, GetSystemInstanceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetSystemTemplateCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetSystemTemplateCommandInput extends GetSystemTemplateRequest
 }
 export interface GetSystemTemplateCommandOutput extends GetSystemTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a system.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, GetSystemTemplateCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, GetSystemTemplateCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new GetSystemTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSystemTemplateCommandInput} for command's `input` shape.
- * @see {@link GetSystemTemplateCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetSystemTemplateCommand extends $Command<GetSystemTemplateCommandInput, GetSystemTemplateCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: GetSystemTemplateCommandInput;
     constructor(input: GetSystemTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSystemTemplateCommandInput, GetSystemTemplateCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetSystemTemplateRevisionsCommand.d.ts

@@ -6,30 +6,11 @@ export interface GetSystemTemplateRevisionsCommandInput extends GetSystemTemplat
 }
 export interface GetSystemTemplateRevisionsCommandOutput extends GetSystemTemplateRevisionsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets revisions made to the specified system template. Only the previous 100 revisions are stored. If the system has been deprecated, this action will return
- *       the revisions that occurred before its deprecation. This action won't work with systems that have been deleted.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, GetSystemTemplateRevisionsCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, GetSystemTemplateRevisionsCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new GetSystemTemplateRevisionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSystemTemplateRevisionsCommandInput} for command's `input` shape.
- * @see {@link GetSystemTemplateRevisionsCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetSystemTemplateRevisionsCommand extends $Command<GetSystemTemplateRevisionsCommandInput, GetSystemTemplateRevisionsCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: GetSystemTemplateRevisionsCommandInput;
     constructor(input: GetSystemTemplateRevisionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSystemTemplateRevisionsCommandInput, GetSystemTemplateRevisionsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetUploadStatusCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetUploadStatusCommandInput extends GetUploadStatusRequest {
 }
 export interface GetUploadStatusCommandOutput extends GetUploadStatusResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the status of the specified upload.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { IoTThingsGraphClient, GetUploadStatusCommand } from "@aws-sdk/client-iotthingsgraph"; // ES Modules import
- * // const { IoTThingsGraphClient, GetUploadStatusCommand } = require("@aws-sdk/client-iotthingsgraph"); // CommonJS import
- * const client = new IoTThingsGraphClient(config);
- * const command = new GetUploadStatusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetUploadStatusCommandInput} for command's `input` shape.
- * @see {@link GetUploadStatusCommandOutput} for command's `response` shape.
- * @see {@link IoTThingsGraphClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetUploadStatusCommand extends $Command<GetUploadStatusCommandInput, GetUploadStatusCommandOutput, IoTThingsGraphClientResolvedConfig> {
     readonly input: GetUploadStatusCommandInput;
     constructor(input: GetUploadStatusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTThingsGraphClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUploadStatusCommandInput, GetUploadStatusCommandOutput>;
     private serialize;
     private deserialize;