@aws-sdk/client-greengrass 3.35.0 → 3.38.0

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

@@ -6,29 +6,11 @@ export interface CreateLoggerDefinitionCommandInput extends CreateLoggerDefiniti
 }
 export interface CreateLoggerDefinitionCommandOutput extends CreateLoggerDefinitionResponse, __MetadataBearer {
 }
-/**
- * Creates a logger definition. You may provide the initial version of the logger definition now or use ''CreateLoggerDefinitionVersion'' at a later time.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateLoggerDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateLoggerDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateLoggerDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLoggerDefinitionCommandInput} for command's `input` shape.
- * @see {@link CreateLoggerDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateLoggerDefinitionCommand extends $Command<CreateLoggerDefinitionCommandInput, CreateLoggerDefinitionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: CreateLoggerDefinitionCommandInput;
     constructor(input: CreateLoggerDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoggerDefinitionCommandInput, CreateLoggerDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface CreateResourceDefinitionCommandInput extends CreateResourceDefi
 }
 export interface CreateResourceDefinitionCommandOutput extends CreateResourceDefinitionResponse, __MetadataBearer {
 }
-/**
- * Creates a resource definition which contains a list of resources to be used in a group. You can create an initial version of the definition by providing a list of resources now, or use ''CreateResourceDefinitionVersion'' later.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateResourceDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateResourceDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateResourceDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateResourceDefinitionCommandInput} for command's `input` shape.
- * @see {@link CreateResourceDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateResourceDefinitionCommand extends $Command<CreateResourceDefinitionCommandInput, CreateResourceDefinitionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: CreateResourceDefinitionCommandInput;
     constructor(input: CreateResourceDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateResourceDefinitionCommandInput, CreateResourceDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface CreateSoftwareUpdateJobCommandInput extends CreateSoftwareUpdat
 }
 export interface CreateSoftwareUpdateJobCommandOutput extends CreateSoftwareUpdateJobResponse, __MetadataBearer {
 }
-/**
- * Creates a software update for a core or group of cores (specified as an IoT thing group.) Use this to update the OTA Agent as well as the Greengrass core software. It makes use of the IoT Jobs feature which provides additional commands to manage a Greengrass core software update job.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateSoftwareUpdateJobCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateSoftwareUpdateJobCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateSoftwareUpdateJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSoftwareUpdateJobCommandInput} for command's `input` shape.
- * @see {@link CreateSoftwareUpdateJobCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSoftwareUpdateJobCommand extends $Command<CreateSoftwareUpdateJobCommandInput, CreateSoftwareUpdateJobCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: CreateSoftwareUpdateJobCommandInput;
     constructor(input: CreateSoftwareUpdateJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSoftwareUpdateJobCommandInput, CreateSoftwareUpdateJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateSubscriptionDefinitionCommandInput extends CreateSubscrip
 }
 export interface CreateSubscriptionDefinitionCommandOutput extends CreateSubscriptionDefinitionResponse, __MetadataBearer {
 }
-/**
- * Creates a subscription definition. You may provide the initial version of the subscription definition now or use ''CreateSubscriptionDefinitionVersion'' at a later time.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateSubscriptionDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateSubscriptionDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateSubscriptionDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSubscriptionDefinitionCommandInput} for command's `input` shape.
- * @see {@link CreateSubscriptionDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSubscriptionDefinitionCommand extends $Command<CreateSubscriptionDefinitionCommandInput, CreateSubscriptionDefinitionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: CreateSubscriptionDefinitionCommandInput;
     constructor(input: CreateSubscriptionDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubscriptionDefinitionCommandInput, CreateSubscriptionDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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