@aws-sdk/client-greengrass 3.35.0 → 3.38.0

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

@@ -6,29 +6,11 @@ export interface ListResourceDefinitionVersionsCommandInput extends ListResource
 }
 export interface ListResourceDefinitionVersionsCommandOutput extends ListResourceDefinitionVersionsResponse, __MetadataBearer {
 }
-/**
- * Lists the versions of a resource definition.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, ListResourceDefinitionVersionsCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, ListResourceDefinitionVersionsCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new ListResourceDefinitionVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListResourceDefinitionVersionsCommandInput} for command's `input` shape.
- * @see {@link ListResourceDefinitionVersionsCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListResourceDefinitionVersionsCommand extends $Command<ListResourceDefinitionVersionsCommandInput, ListResourceDefinitionVersionsCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: ListResourceDefinitionVersionsCommandInput;
     constructor(input: ListResourceDefinitionVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResourceDefinitionVersionsCommandInput, ListResourceDefinitionVersionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListResourceDefinitionsCommandInput extends ListResourceDefinit
 }
 export interface ListResourceDefinitionsCommandOutput extends ListResourceDefinitionsResponse, __MetadataBearer {
 }
-/**
- * Retrieves a list of resource definitions.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, ListResourceDefinitionsCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, ListResourceDefinitionsCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new ListResourceDefinitionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListResourceDefinitionsCommandInput} for command's `input` shape.
- * @see {@link ListResourceDefinitionsCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListResourceDefinitionsCommand extends $Command<ListResourceDefinitionsCommandInput, ListResourceDefinitionsCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: ListResourceDefinitionsCommandInput;
     constructor(input: ListResourceDefinitionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResourceDefinitionsCommandInput, ListResourceDefinitionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListSubscriptionDefinitionVersionsCommandInput extends ListSubs
 }
 export interface ListSubscriptionDefinitionVersionsCommandOutput extends ListSubscriptionDefinitionVersionsResponse, __MetadataBearer {
 }
-/**
- * Lists the versions of a subscription definition.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, ListSubscriptionDefinitionVersionsCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, ListSubscriptionDefinitionVersionsCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new ListSubscriptionDefinitionVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListSubscriptionDefinitionVersionsCommandInput} for command's `input` shape.
- * @see {@link ListSubscriptionDefinitionVersionsCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListSubscriptionDefinitionVersionsCommand extends $Command<ListSubscriptionDefinitionVersionsCommandInput, ListSubscriptionDefinitionVersionsCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: ListSubscriptionDefinitionVersionsCommandInput;
     constructor(input: ListSubscriptionDefinitionVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSubscriptionDefinitionVersionsCommandInput, ListSubscriptionDefinitionVersionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListSubscriptionDefinitionsCommandInput extends ListSubscriptio
 }
 export interface ListSubscriptionDefinitionsCommandOutput extends ListSubscriptionDefinitionsResponse, __MetadataBearer {
 }
-/**
- * Retrieves a list of subscription definitions.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, ListSubscriptionDefinitionsCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, ListSubscriptionDefinitionsCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new ListSubscriptionDefinitionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListSubscriptionDefinitionsCommandInput} for command's `input` shape.
- * @see {@link ListSubscriptionDefinitionsCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListSubscriptionDefinitionsCommand extends $Command<ListSubscriptionDefinitionsCommandInput, ListSubscriptionDefinitionsCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: ListSubscriptionDefinitionsCommandInput;
     constructor(input: ListSubscriptionDefinitionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSubscriptionDefinitionsCommandInput, ListSubscriptionDefinitionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * Retrieves a list of resource tags for a resource arn.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, ListTagsForResourceCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, ListTagsForResourceCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(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 GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ResetDeploymentsCommandInput extends ResetDeploymentsRequest {
 }
 export interface ResetDeploymentsCommandOutput extends ResetDeploymentsResponse, __MetadataBearer {
 }
-/**
- * Resets a group's deployments.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, ResetDeploymentsCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, ResetDeploymentsCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new ResetDeploymentsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ResetDeploymentsCommandInput} for command's `input` shape.
- * @see {@link ResetDeploymentsCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ResetDeploymentsCommand extends $Command<ResetDeploymentsCommandInput, ResetDeploymentsCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: ResetDeploymentsCommandInput;
     constructor(input: ResetDeploymentsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetDeploymentsCommandInput, ResetDeploymentsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface StartBulkDeploymentCommandInput extends StartBulkDeploymentRequ
 }
 export interface StartBulkDeploymentCommandOutput extends StartBulkDeploymentResponse, __MetadataBearer {
 }
-/**
- * Deploys multiple groups in one operation. This action starts the bulk deployment of a specified set of group versions. Each group version deployment will be triggered with an adaptive rate that has a fixed upper limit. We recommend that you include an ''X-Amzn-Client-Token'' token in every ''StartBulkDeployment'' request. These requests are idempotent with respect to the token and the request parameters.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, StartBulkDeploymentCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, StartBulkDeploymentCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new StartBulkDeploymentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartBulkDeploymentCommandInput} for command's `input` shape.
- * @see {@link StartBulkDeploymentCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartBulkDeploymentCommand extends $Command<StartBulkDeploymentCommandInput, StartBulkDeploymentCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: StartBulkDeploymentCommandInput;
     constructor(input: StartBulkDeploymentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartBulkDeploymentCommandInput, StartBulkDeploymentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface StopBulkDeploymentCommandInput extends StopBulkDeploymentReques
 }
 export interface StopBulkDeploymentCommandOutput extends StopBulkDeploymentResponse, __MetadataBearer {
 }
-/**
- * Stops the execution of a bulk deployment. This action returns a status of ''Stopping'' until the deployment is stopped. You cannot start a new bulk deployment while a previous deployment is in the ''Stopping'' state. This action doesn't rollback completed deployments or cancel pending deployments.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, StopBulkDeploymentCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, StopBulkDeploymentCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new StopBulkDeploymentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopBulkDeploymentCommandInput} for command's `input` shape.
- * @see {@link StopBulkDeploymentCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopBulkDeploymentCommand extends $Command<StopBulkDeploymentCommandInput, StopBulkDeploymentCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: StopBulkDeploymentCommandInput;
     constructor(input: StopBulkDeploymentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopBulkDeploymentCommandInput, StopBulkDeploymentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends __MetadataBearer {
 }
-/**
- * Adds tags to a Greengrass resource. Valid resources are 'Group', 'ConnectorDefinition', 'CoreDefinition', 'DeviceDefinition', 'FunctionDefinition', 'LoggerDefinition', 'SubscriptionDefinition', 'ResourceDefinition', and 'BulkDeployment'.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, TagResourceCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, TagResourceCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(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 GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UntagResourceCommandInput extends UntagResourceRequest {
 }
 export interface UntagResourceCommandOutput extends __MetadataBearer {
 }
-/**
- * Remove resource tags from a Greengrass Resource.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, UntagResourceCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, UntagResourceCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateConnectivityInfoCommandInput extends UpdateConnectivityIn
 }
 export interface UpdateConnectivityInfoCommandOutput extends UpdateConnectivityInfoResponse, __MetadataBearer {
 }
-/**
- * Updates the connectivity information for the core. Any devices that belong to the group which has this core will receive this information in order to find the location of the core and connect to it.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, UpdateConnectivityInfoCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, UpdateConnectivityInfoCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new UpdateConnectivityInfoCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateConnectivityInfoCommandInput} for command's `input` shape.
- * @see {@link UpdateConnectivityInfoCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateConnectivityInfoCommand extends $Command<UpdateConnectivityInfoCommandInput, UpdateConnectivityInfoCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: UpdateConnectivityInfoCommandInput;
     constructor(input: UpdateConnectivityInfoCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConnectivityInfoCommandInput, UpdateConnectivityInfoCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateConnectorDefinitionCommandInput extends UpdateConnectorDe
 }
 export interface UpdateConnectorDefinitionCommandOutput extends UpdateConnectorDefinitionResponse, __MetadataBearer {
 }
-/**
- * Updates a connector definition.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, UpdateConnectorDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, UpdateConnectorDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new UpdateConnectorDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateConnectorDefinitionCommandInput} for command's `input` shape.
- * @see {@link UpdateConnectorDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateConnectorDefinitionCommand extends $Command<UpdateConnectorDefinitionCommandInput, UpdateConnectorDefinitionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: UpdateConnectorDefinitionCommandInput;
     constructor(input: UpdateConnectorDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConnectorDefinitionCommandInput, UpdateConnectorDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateCoreDefinitionCommandInput extends UpdateCoreDefinitionRe
 }
 export interface UpdateCoreDefinitionCommandOutput extends UpdateCoreDefinitionResponse, __MetadataBearer {
 }
-/**
- * Updates a core definition.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, UpdateCoreDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, UpdateCoreDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new UpdateCoreDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateCoreDefinitionCommandInput} for command's `input` shape.
- * @see {@link UpdateCoreDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateCoreDefinitionCommand extends $Command<UpdateCoreDefinitionCommandInput, UpdateCoreDefinitionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: UpdateCoreDefinitionCommandInput;
     constructor(input: UpdateCoreDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateCoreDefinitionCommandInput, UpdateCoreDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateDeviceDefinitionCommandInput extends UpdateDeviceDefiniti
 }
 export interface UpdateDeviceDefinitionCommandOutput extends UpdateDeviceDefinitionResponse, __MetadataBearer {
 }
-/**
- * Updates a device definition.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, UpdateDeviceDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, UpdateDeviceDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new UpdateDeviceDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateDeviceDefinitionCommandInput} for command's `input` shape.
- * @see {@link UpdateDeviceDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateDeviceDefinitionCommand extends $Command<UpdateDeviceDefinitionCommandInput, UpdateDeviceDefinitionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: UpdateDeviceDefinitionCommandInput;
     constructor(input: UpdateDeviceDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDeviceDefinitionCommandInput, UpdateDeviceDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateFunctionDefinitionCommandInput extends UpdateFunctionDefi
 }
 export interface UpdateFunctionDefinitionCommandOutput extends UpdateFunctionDefinitionResponse, __MetadataBearer {
 }
-/**
- * Updates a Lambda function definition.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, UpdateFunctionDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, UpdateFunctionDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new UpdateFunctionDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateFunctionDefinitionCommandInput} for command's `input` shape.
- * @see {@link UpdateFunctionDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateFunctionDefinitionCommand extends $Command<UpdateFunctionDefinitionCommandInput, UpdateFunctionDefinitionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: UpdateFunctionDefinitionCommandInput;
     constructor(input: UpdateFunctionDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateFunctionDefinitionCommandInput, UpdateFunctionDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateGroupCertificateConfigurationCommandInput extends UpdateG
 }
 export interface UpdateGroupCertificateConfigurationCommandOutput extends UpdateGroupCertificateConfigurationResponse, __MetadataBearer {
 }
-/**
- * Updates the Certificate expiry time for a group.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, UpdateGroupCertificateConfigurationCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, UpdateGroupCertificateConfigurationCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new UpdateGroupCertificateConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateGroupCertificateConfigurationCommandInput} for command's `input` shape.
- * @see {@link UpdateGroupCertificateConfigurationCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateGroupCertificateConfigurationCommand extends $Command<UpdateGroupCertificateConfigurationCommandInput, UpdateGroupCertificateConfigurationCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: UpdateGroupCertificateConfigurationCommandInput;
     constructor(input: UpdateGroupCertificateConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateGroupCertificateConfigurationCommandInput, UpdateGroupCertificateConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface UpdateLoggerDefinitionCommandInput extends UpdateLoggerDefiniti
 }
 export interface UpdateLoggerDefinitionCommandOutput extends UpdateLoggerDefinitionResponse, __MetadataBearer {
 }
-/**
- * Updates a logger definition.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, UpdateLoggerDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, UpdateLoggerDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new UpdateLoggerDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateLoggerDefinitionCommandInput} for command's `input` shape.
- * @see {@link UpdateLoggerDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateLoggerDefinitionCommand extends $Command<UpdateLoggerDefinitionCommandInput, UpdateLoggerDefinitionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: UpdateLoggerDefinitionCommandInput;
     constructor(input: UpdateLoggerDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateLoggerDefinitionCommandInput, UpdateLoggerDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateResourceDefinitionCommandInput extends UpdateResourceDefi
 }
 export interface UpdateResourceDefinitionCommandOutput extends UpdateResourceDefinitionResponse, __MetadataBearer {
 }
-/**
- * Updates a resource definition.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, UpdateResourceDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, UpdateResourceDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new UpdateResourceDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateResourceDefinitionCommandInput} for command's `input` shape.
- * @see {@link UpdateResourceDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateResourceDefinitionCommand extends $Command<UpdateResourceDefinitionCommandInput, UpdateResourceDefinitionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: UpdateResourceDefinitionCommandInput;
     constructor(input: UpdateResourceDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateResourceDefinitionCommandInput, UpdateResourceDefinitionCommandOutput>;
     private serialize;
     private deserialize;